nLimit\\n\\n #~ print self\\n \\n nCurrentPos = 0 # in data index (not sample)\\n nSilenceMinLenData = rSilenceMinDuration * self.nAvgBytesPerSec * 8 / self.nNbrBitsPerSample\\n while( nCurrentPos < len(self.data) ):\\n \\n # first find the beginning of a sound \\n nFirstNonSilenceIndex = findFirstTrueValue( precalcWavIsNotSilence[nCurrentPos:] )\\n #~ print( \\\"nFirstNonSilenceIndex (brut): %d\\\" % nFirstNonSilenceIndex )\\n if( nFirstNonSilenceIndex == -1 ):\\n # all remaining sound are silence!\\n break\\n nFirstNonSilenceIndex += nCurrentPos\\n nNumFirstSample = nFirstNonSilenceIndex/self.nNbrChannel\\n print( \\\"INF: sound.Wav.split: found a sound at sample %d\\\" % nNumFirstSample )\\n nCurrentPos = nFirstNonSilenceIndex # so at the end, we're stopping\\n \\n # then find end\\n nEndOfSilence = nNumFirstSample*self.nNbrChannel # init of the loop\\n while( nEndOfSilence < len(self.data) ):\\n #nFirstSilenceIndex = np.argmax( np.abs(self.data[nEndOfSilence:])<=nLimit )\\n nFirstSilenceIndex = findFirstFalseValue( precalcWavIsNotSilence[nEndOfSilence:] ) \\n #~ print( \\\"nFirstSilenceIndex (brut): %d (from %d)\\\" % (nFirstSilenceIndex, nEndOfSilence) )\\n if( nFirstSilenceIndex == -1 ):\\n break\\n nFirstSilenceIndex += nEndOfSilence\\n # ensure there's enough silence\\n nEndOfSilence = findFirstTrueValue( precalcWavIsNotSilence[nFirstSilenceIndex:] )\\n #~ print( \\\"nEndOfSilence (brut): %d (data: %d) (offset: %d)\\\" % (nEndOfSilence, self.data[nFirstSilenceIndex+nEndOfSilence],nEndOfSilence + nFirstSilenceIndex) )\\n # positionnate onto the end of the silence for next time\\n if( nEndOfSilence == -1 ):\\n nCurrentPos = len(self.data)\\n else:\\n nCurrentPos = nEndOfSilence + nFirstSilenceIndex\\n \\n if( nEndOfSilence > nSilenceMinLenData or nEndOfSilence == -1 ):\\n break\\n nEndOfSilence += nFirstSilenceIndex\\n # while - end\\n \\n # each time we're out, we've got a silence or we're at the end => new split\\n if( nFirstSilenceIndex == -1 ):\\n break\\n nNumLastSample = nFirstSilenceIndex/self.nNbrChannel\\n print( \\\"INF: sound.Wav.split: found the end of that sound at sample %d\\\" % nNumLastSample )\\n if( nNumLastSample - nNumFirstSample > 4000 ):\\n w = Wav()\\n w.copyHeader( self )\\n w.data = np.copy(self.data[nNumFirstSample*self.nNbrChannel:nNumLastSample*self.nNbrChannel])\\n nPeakMax = max( max( w.data ), -min( w.data ) )\\n if( nPeakMax > self.getSampleMaxValue() / 8 ): # remove glitch sound\\n w.updateHeaderSizeFromDataLength()\\n print( \\\"INF: sound.Wav.split: new split of %5.2fs\\\" % w.rDuration )\\n aSplitted.append( w )\\n #~ print( \\\"nCurLocalVs: %s\\\" % nCurLocalVs )\\n if( nExtractJustFirsts != -1 and nExtractJustFirsts == len(aSplitted) ):\\n print( \\\"WRN: sound.Wav.split: got enough split (%d), leaving...\\\" % len(aSplitted) )\\n break\\n # while - end\\n print( \\\"INF: sound.Wav.split: created %d wav(s)\\\" % len( aSplitted ) )\\n return aSplitted\",\n \"def silence_intervals(file_path,file_name):\\r\\n nsil_start_time=[]\\r\\n nsil_end_time=[]\\r\\n sil_start_time=[]\\r\\n sil_end_time=[]\\r\\n #read file \\r\\n audio, sample_rate = librosa.load(os.path.join(file_path,file_name))\\r\\n \\r\\n #silence extraction using librosa\\r\\n nsil_intv=librosa.effects.split(audio, top_db=30).astype('float32') / sample_rate\\r\\n \\r\\n #silence extraction using pyAudioanalysis\\r\\n # [Fs, x] = aIO.readAudioFile(os.path.join(file_path,file_name))\\r\\n # nsil_intv = np.array(aS.silenceRemoval(x, Fs, 0.020, 0.020, smoothWindow = 0.7, Weight = 0.3, plot = False))\\r\\n # print \\\"non-sil segments=\\\"+str(nsil_intv)\\r\\n\\r\\n #silence detection using webrtcvad (voice activity detection)\\r\\n #nsil_intv=np.array(vad_webrtcvad(file_path,file_name))\\r\\n\\r\\n\\r\\n dur=librosa.get_duration(y=audio, sr=sample_rate)\\r\\n print nsil_intv\\r\\n print dur\\r\\n print sample_rate\\r\\n curr_sil_start=0.0\\r\\n curr_sil_end=0.0\\r\\n for i in range(nsil_intv.shape[0]):\\r\\n nsil_start_time.append(nsil_intv[i][0])\\r\\n #sil_start_time=list(np.array(sil_start_time)/sample_rate)\\r\\n\\r\\n nsil_end_time.append(nsil_intv[i][1])\\r\\n #sil_end_time=list(np.array(sil_end_time)/sample_rate)\\r\\n\\r\\n for i in range(len(nsil_start_time)):\\r\\n curr_sil_end=nsil_start_time[i]\\r\\n sil_start_time.append(str(curr_sil_start))\\r\\n sil_end_time.append(str(curr_sil_end))\\r\\n curr_sil_start=nsil_end_time[i]\\r\\n\\r\\n print sil_start_time\\r\\n print sil_end_time\\r\\n return sil_start_time,sil_end_time\",\n \"def trim_silence(audio, noise_threshold=150):\\n start = None\\n end = None\\n\\n for idx, point in enumerate(audio):\\n if abs(point) > noise_threshold:\\n start = idx\\n break\\n\\n # Reverse the array for trimming the end\\n for idx, point in enumerate(audio[::-1]):\\n if abs(point) > noise_threshold:\\n end = len(audio) - idx\\n break\\n\\n return audio[start:end]\",\n \"def __thresholdInput(self,samples):\\n absSamples = np.abs(samples) # 1 ms\\n thresh = self.peakThresholdScale*np.mean(absSamples) # 0.2 ms\\n i = np.where(absSamples>thresh)[0] # 1e-5 s\\n samples[i] = thresh * (samples[i]/absSamples[i]) # 8e-5 s\\n # Do it again in case the spikes were really loud\\n absSamples[i] = np.abs(samples[i])\\n thresh = self.peakThresholdScale*np.mean(absSamples)\\n i = np.where(absSamples>thresh)[0]\\n self.clippedPeakIPure = i # All peaks that are clipped at first round are clipped again. Requires that the peaks in first round are not set to 0\\n samples[i] = thresh * (samples[i]/absSamples[i])\\n # Mark peaks close to each other\\n if len(self.clippedPeakIPure)>0:\\n # t = time.time()\\n # Mark peaks close to each other as continuous\\n diffPeaks = np.diff(self.clippedPeakIPure)\\n gapsAll = np.where(diffPeaks>1)[0]\\n self.peakMinGap = 100\\n gaps = np.where(diffPeaks[gapsAll] < self.peakMinGap)[0] # find gaps smaller than 100\\n gapsLen = diffPeaks[gapsAll[gaps]] # length of the gaps\\n gapsIdx = gapsAll[gaps] # Index of all gaps\\n\\n\\n # fill the gaps smaller than self.peakMinGap\\n pp = np.zeros(self.Nfft,dtype=np.int8)\\n pp[self.clippedPeakIPure] = 1\\n for i in range(len(gapsLen)):\\n pp[self.clippedPeakIPure[gapsIdx[i]]:self.clippedPeakIPure[gapsIdx[i]]+gapsLen[i]] = 1\\n\\n self.clippedPeakI = np.where(pp==1)[0]\\n else:\\n self.clippedPeakI = self.clippedPeakIPure.copy()\\n if log.level == logging.DEBUG:\\n log.debug('clipped peaks ' + str(len(self.clippedPeakIPure)))\",\n \"def silence_handler(wav, sr, fl=320, fs=80, \\n max_thres_below=30, \\n min_thres=-55, \\n shortest_len_in_ms=50,\\n flag_output=0):\\n assert fs < fl, \\\"Frame shift should be smaller than frame length\\\"\\n \\n frames = buffering(wav, fl, fl - fs, 'nodelay')\\n windowed_frames = windowing(frames)\\n \\n frame_energy = 20*np.log10(np.std(frames, axis=1)+np.finfo(np.float32).eps)\\n frame_energy_max = np.max(frame_energy)\\n \\n frame_tag = np.bitwise_and(\\n (frame_energy > (frame_energy_max - max_thres_below)),\\n frame_energy > min_thres)\\n frame_tag = np.asarray(frame_tag, dtype=np.int)\\n \\n seg_len_thres = shortest_len_in_ms * sr / 1000 / fs\\n \\n \\n def ignore_short_seg(frame_tag, seg_len_thres):\\n frame_tag_new = np.zeros_like(frame_tag) + frame_tag\\n # boundary of each segment\\n seg_bound = np.diff(np.concatenate(([0], frame_tag, [0])))\\n # start of each segment\\n seg_start = np.argwhere(seg_bound == 1)[:, 0]\\n # end of each segment\\n seg_end = np.argwhere(seg_bound == -1)[:, 0]\\n assert seg_start.shape[0] == seg_end.shape[0], \\\\\\n \\\"Fail to extract segment boundaries\\\"\\n \\n # length of segment\\n seg_len = seg_end - seg_start\\n seg_short_ids = np.argwhere(seg_len < seg_len_thres)[:, 0]\\n for idx in seg_short_ids:\\n start_frame_idx = seg_start[idx]\\n end_frame_idx = seg_end[idx]\\n frame_tag_new[start_frame_idx:end_frame_idx] = 0\\n return frame_tag_new\\n \\n # work on non-speech, 1-frame_tag indicates non-speech frames\\n frame_process_sil = ignore_short_seg(1-frame_tag, seg_len_thres)\\n # reverse the sign\\n frame_process_sil = 1 - frame_process_sil\\n \\n # work on speech\\n frame_process_all = ignore_short_seg(frame_process_sil, seg_len_thres)\\n \\n # separate non-speech and speech segments\\n # do overlap and add\\n frame_tag = frame_process_all\\n # buffer for speech segments\\n spe_buf = np.zeros([np.sum(frame_tag) * fs + fl], dtype=wav.dtype)\\n # buffer for non-speech segments\\n sil_buf = np.zeros([np.sum(1-frame_tag) * fs + fl], dtype=wav.dtype)\\n spe_fr_pt = 0\\n non_fr_pt = 0\\n for frame_idx, flag_speech in enumerate(frame_tag):\\n if flag_speech:\\n spe_buf[spe_fr_pt*fs:spe_fr_pt*fs+fl] += windowed_frames[frame_idx]\\n spe_fr_pt += 1\\n else:\\n sil_buf[non_fr_pt*fs:non_fr_pt*fs+fl] += windowed_frames[frame_idx]\\n non_fr_pt += 1\\n \\n if flag_output == 1: \\n return spe_buf\\n elif flag_output == 2:\\n return sil_buf\\n else:\\n return spe_buf, sil_buf, frame_tag\",\n \"def trim_silence(T, hz, signal):\\n N = T * hz\\n extra = len(signal) - N\\n c = np.abs(signal).cumsum()\\n c = c[-extra:] - c[:extra]\\n i = np.argmax(c)\\n print(f'Keeping {T:.2g} of {len(signal)/hz:.2g} seconds'\\n f' starting at +{i/hz:.2f} seconds')\\n return signal[i:i+N]\",\n \"def remove_silence(y, threshold=-50, nb_sample=4096): \\r\\n from scipy.ndimage.filters import maximum_filter1d \\r\\n \\r\\n if np.max(y) != 1.0:\\r\\n raise ValueError(\\\"Input signal is expected to be normalised to 1\\\")\\r\\n \\r\\n # Ignore log(0) warnings\\r\\n np.seterr(divide = 'ignore') \\r\\n y_db = 20 * np.log10(np.abs(y))\\r\\n np.seterr(divide = 'warn') \\r\\n \\r\\n y_envelope = maximum_filter1d(y_db, nb_sample) \\r\\n mask = y_envelope >= threshold\\r\\n y_out = y[mask]\\r\\n \\r\\n return(y_out)\",\n \"def remove_silence_audio() -> None:\\n # Read the wav file and get rate and list of data\\n rate, data = scipy.io.wavfile.read('Test.wav')\\n\\n # Create list for data of amended wav file\\n data2 = []\\n\\n # Loop through data of original file and add data that doesn't meed condition: values >= -10 and <= 10\\n for i in range(len(data)):\\n if data[i][0] >= -10 and data[i][0] <= 10:\\n pass\\n else:\\n data2.append(data[i])\\n\\n # Create NumPy array from revised data\\n data2 = np.asarray(data2, dtype=np.int16)\\n\\n # Write new data to wav file\\n scipy.io.wavfile.write('Test.wav', rate, data2)\\n\\n return None\",\n \"def get_silence(self, duration):\\n nsamples = int(self.sample_rate * duration)\\n return \\\"\\\".join([wave.struct.pack('h', 0) for i in range(0, nsamples)])\",\n \"def majorityVoteSilence(y_Raw, amps, silenceClassNum):\\n y_raw = y_Raw.copy()\\n silenceThreshold = 1000\\n majVotWindowLength = 2.0 #in seconds\\n windowLength = 0.032\\n frameLengthFloat = math.ceil(majVotWindowLength/windowLength)\\n\\n frameLength = int(frameLengthFloat)\\n\\n resArray = np.empty(y_raw.shape)\\n\\n n_frames = int(math.ceil(y_raw.shape[0]/frameLengthFloat))\\n\\n for i in range(n_frames):\\n\\n if ((i+1) * frameLength) < y_raw.shape[0]:\\n\\n tmpAmps = amps[(i * frameLength):(((i+1) * frameLength))]\\n \\n if tmpAmps.max() >= silenceThreshold:\\n #if True:\\n tmpArray = y_raw[(i * frameLength):(((i+1) * frameLength))]\\n \\n \\\"\\\"\\\" Get most frequent number in that frames: \\\"\\\"\\\"\\n count = np.bincount(tmpArray)\\n tmpMostFrequent = np.argmax(count)\\n\\n \\\"\\\"\\\" Fill all elements with most frequent number: \\\"\\\"\\\"\\n tmpArray.fill(tmpMostFrequent)\\n\\n \\\"\\\"\\\" Write it into our result array: \\\"\\\"\\\"\\n resArray[(i * frameLength):(((i+1) * frameLength))] = tmpArray\\n \\n else:\\n \\\"\\\"\\\"If all amplitudes are below threshold, the \\n sample is considered silent:\\\"\\\"\\\" \\n resArray[(i * frameLength):(((i+1) * frameLength))] = silenceClassNum\\n else:\\n\\n tmpAmps = amps[(i * frameLength):y_raw.shape[0]]\\n\\n\\n if tmpAmps.max() >= silenceThreshold: \\n #if True:\\n tmpArray = y_raw[(i * frameLength):y_raw.shape[0]]\\n \\\"\\\"\\\" Get most frequent number in that frames and fill \\n all elements in the frame with it: \\\"\\\"\\\"\\n count = np.bincount(tmpArray)\\n tmpMostFrequent = np.argmax(count)\\n\\n \\\"\\\"\\\" Fill all elements with most frequent number: \\\"\\\"\\\"\\n tmpArray.fill(tmpMostFrequent)\\n\\n \\\"\\\"\\\" Write it into our result array: \\\"\\\"\\\"\\n resArray[(i * frameLength):y_raw.shape[0]] = tmpArray\\n \\n else:\\n \\\"\\\"\\\"If all amplitudes are below threshold, the \\n sample is considered silent:\\\"\\\"\\\" \\n resArray[(i * frameLength):y_raw.shape[0]] = silenceClassNum\\n\\n return resArray\",\n \"def _synthesize_silence(self, duration_in_msec):\\n if duration_in_msec > 0.0:\\n sample_count = int(float(self.sample_rate) * duration_in_msec * 0.001);\\n # There are two bytes per 16-bit sample.\\n byte_count = sample_count + sample_count\\n tmp_buffer = bytearray(byte_count)\\n # Loop and create the audio samples.\\n index = 0\\n for i in range(0, byte_count):\\n tmp_buffer[i] = 0\\n return tmp_buffer\",\n \"def _compute_sampling_threshold(global_step, k):\\n return k / (k + math.exp(global_step / k))\",\n \"def detect_silences(sound, sil_threshold, sil_duration):\\n textgrid = call(sound, 'To TextGrid (silences)', 100, 0.0, sil_threshold, sil_duration, 0.1, 'silence', 'speech')\\n\\n return textgrid\",\n \"def trim_silence_file(file_path, noise_threshold=150):\\n rate, audio = scipy.io.wavfile.read(file_path)\\n trimmed_audio = trim_silence(audio, noise_threshold=noise_threshold)\\n print()\\n scipy.io.wavfile.write(file_path, rate, trimmed_audio)\",\n \"def silence(score0, score1):\\n return silence\",\n \"def split_vad(silence_probs: List[float], p_silence_threshold: float, len_threshold: int) -> List[Tuple[int, int]]:\\n segments = []\\n\\n start = None\\n i = 0\\n n = len(silence_probs)\\n\\n while i < len(silence_probs) and silence_probs[i] > p_silence_threshold:\\n i += 1\\n # supported invariants: `start` points to the frame where speech starts, i >= start\\n start = i\\n\\n while i < n:\\n # scroll until first silence frame\\n if silence_probs[i] < p_silence_threshold:\\n i += 1\\n continue\\n\\n # now i points to the first silence frame\\n # look ahead: do we have at least len_threshold silence frames?\\n all_silence = True\\n for j in range(i + 1, min(i + len_threshold, n)):\\n all_silence = all_silence and silence_probs[j] > p_silence_threshold\\n if not all_silence:\\n break\\n\\n if not all_silence:\\n # no we don't: disregard the silence, go further\\n # starting from the first non-silence frame\\n i = j\\n else:\\n # we do have enough silence for a split\\n if i - start > len_threshold:\\n segments.append((start, i))\\n\\n while i < n and silence_probs[i] > p_silence_threshold:\\n i += 1\\n start = i\\n i += 1\\n\\n if i - start > len_threshold and start < n:\\n segments.append((start, i))\\n\\n return segments\",\n \"def split_multiple_recordings(audio, min_silence_duration=0.25, noise_threshold=150, sample_rate_hz=8e3):\\n # A list of tuples (start, stop)\\n min_silence_frame = sample_rate_hz * min_silence_duration\\n silence_zones = []\\n\\n zone_start = None\\n zone_end = None\\n\\n for idx, point in enumerate(audio):\\n if abs(point) < noise_threshold and zone_start is None:\\n zone_start = idx\\n\\n if abs(point) > noise_threshold and zone_start is not None:\\n zone_end = idx\\n\\n # If we are in a silent zone and we come to the end point\\n if zone_start is not None and zone_end and abs(point) > noise_threshold:\\n if (zone_end - zone_start) > min_silence_frame:\\n silence_zones.append((zone_start, zone_end))\\n\\n zone_start = None\\n zone_end = None\\n\\n # Split the recording by the zones\\n split_recordings = []\\n for idx, zone in enumerate(silence_zones):\\n if idx == 0:\\n start = 0\\n else:\\n start = silence_zones[idx - 1][1]\\n\\n end = zone[0]\\n split_recordings.append(audio[start:end])\\n\\n return split_recordings\",\n \"def record():\\n p = pyaudio.PyAudio()\\n stream = p.open(format=FORMAT, input_device_index=0, channels=1, rate=RATE, input=True, output=True, frames_per_buffer=CHUNK_SIZE)\\n num_silent = 0\\n snd_started = False\\n\\n r = array('h')\\n while 1:\\n snd_data = array('h', stream.read(CHUNK_SIZE, exception_on_overflow = False))\\n if byteorder == 'big':\\n snd_data.byteswap()\\n r.extend(snd_data)\\n\\n silent = is_silent(snd_data)\\n if silent and snd_started:\\n num_silent += 1\\n elif not silent and not snd_started:\\n print(\\\"Sound started.\\\")\\n snd_started = True\\n\\n if snd_started and num_silent> 10:\\n break\\n\\n sample_width = p.get_sample_size(FORMAT)\\n stream.stop_stream()\\n stream.close()\\n p.terminate()\\n\\n r = normalize(r)\\n #r = trim(r)\\n #r = add_silence(r, 0.5)\\n return sample_width, r\",\n \"def loudness(chunk):\\n data = numpy.array(chunk, dtype=float) / 32768.0\\n ms = math.sqrt(numpy.sum(data ** 2.0) / len(data))\\n if ms < 10e-8: ms = 10e-8\\n return 10.0 * math.log(ms, 10.0)\",\n \"def append_silence(duration_milliseconds=500):\\r\\n num_samples = duration_milliseconds * (sample_rate / 1000.0)\\r\\n\\r\\n for x in range(int(num_samples)): \\r\\n audio.append(0.0)\\r\\n\\r\\n return\",\n \"def record():\\n p = pyaudio.PyAudio()\\n stream = p.open(format=FORMAT, channels=1, rate=RATE,\\n input=True, output=True,\\n frames_per_buffer=CHUNK_SIZE)\\n\\n num_silent = 0\\n snd_started = False\\n\\n r = array('h')\\n\\n while 1:\\n # little endian, signed short\\n snd_data = array('h', stream.read(CHUNK_SIZE))\\n if byteorder == 'big':\\n snd_data.byteswap()\\n r.extend(snd_data)\\n\\n silent = is_silent(snd_data)\\n\\n if silent and snd_started:\\n num_silent += 1\\n elif not silent and not snd_started:\\n snd_started = True\\n\\n if snd_started and num_silent > 30:\\n break\\n\\n sample_width = p.get_sample_size(FORMAT)\\n stream.stop_stream()\\n stream.close()\\n p.terminate()\\n\\n r = normalize(r)\\n r = trim(r)\\n r = add_silence(r, 0.5)\\n return sample_width, r\",\n \"def get_waveform_halfwidth(waveform, sampling_rate=30000.):\\n w = resample(waveform,200)#upsample to smooth the data\\n time = np.linspace(0,len(waveform)/sampling_rate,200)\\n trough = np.where(w==np.min(w))[0][0]\\n peak = np.where(w==np.max(w))[0][0]\\n \\n #dur = time[trough:][np.where(w[trough:]==np.max(w[trough:]))[0][0]] - time[trough]\\n if w[peak] > np.abs(w[trough]):\\n dur = time[peak:][np.where(w[peak:]>=0.5*np.min(w[peak:]))[0][0]] - time[peak] \\n else:\\n dur = time[trough:][np.where(w[trough:]<=0.5*np.max(w[trough:]))[0][0]] - time[trough] \\n if peak<trough:\\n dur=-dur\\n return dur\",\n \"def weighted_loudness(wavetable: np.ndarray, mult_freq: float = 1.):\\n ps = np.abs(np.fft.fft(wavetable))\\n\\n time_step = 1 / 44100\\n freqs = np.fft.fftfreq(wavetable.size, time_step)\\n idx = np.argsort(freqs)\\n\\n weighted_sum = 0\\n for i in idx:\\n freq = freqs[i]\\n if freq > 0:\\n weighted_sum += perceptual_amplitude_dbb(freq * mult_freq) * ps[i]\\n\\n return weighted_sum\",\n \"def record():\\n p = pyaudio.PyAudio()\\n stream = p.open(format=FORMAT, channels=1, rate=RATE,\\n input=True, output=True,\\n frames_per_buffer=CHUNK_SIZE)\\n\\n num_silent = 0\\n snd_started = False\\n\\n r = array('h')\\n\\n while 1:\\n # little endian, signed short\\n snd_data = array('h', stream.read(CHUNK_SIZE))\\n if byteorder == 'big':\\n snd_data.byteswap()\\n r.extend(snd_data)\\n\\n silent = is_silent(snd_data)\\n\\n if silent and snd_started:\\n num_silent += 1\\n elif not silent and not snd_started:\\n snd_started = True\\n\\n if snd_started and num_silent > SILENCE:\\n break\\n\\n sample_width = p.get_sample_size(FORMAT)\\n stream.stop_stream()\\n stream.close()\\n p.terminate()\\n\\n r = normalize(r)\\n r = trim(r)\\n r = add_silence(r, 0.5)\\n return sample_width, r\",\n \"def removeGlitch( self, rGlitchMaxTresholdPercent = 5., rGlitchMaxDurationSec = 0.01, rSilenceTresholdPercent = 1., rSilenceMinDurationSec = 0.020 ):\\n timeBegin = time.time()\\n nGlitchLimit = int( self.getSampleMaxValue() * rGlitchMaxTresholdPercent / 100 )\\n nSilenceLimit = int( self.getSampleMaxValue() * rSilenceTresholdPercent / 100 )\\n \\n nGlitchNumSampleMaxDuration = int( rGlitchMaxDurationSec * self.nSamplingRate )\\n nSilenceNumSampleMinDuration = int( rSilenceMinDurationSec * self.nSamplingRate )\\n \\n rMarginAroundSilenceBlanking = 0.1 # in sec\\n nSilenceAroundSilenceBlanking = int( rMarginAroundSilenceBlanking * self.nSamplingRate )\\n \\n logging.debug( \\\"nSilenceLimit: %d, nGlitchLimit: %d, nGlitchNumSampleMaxDuration: %d, nSilenceNumSampleMinDuration: %d\\\" % ( nSilenceLimit, nGlitchLimit, nGlitchNumSampleMaxDuration, nSilenceNumSampleMinDuration ) )\\n \\n aPosGlitchBegin = [0]*self.nNbrChannel # for each channel, the position of beginning glitch\\n aPosSilenceBegin = [0]*self.nNbrChannel # for each channel, the position of beginning silence\\n aPosLastSoundEnd = [0]*self.nNbrChannel # for each channel, the last time with sound\\n anState = [0]*self.nNbrChannel # for each channel: the nature of current sound: 0: real silence, 1: glitch, 2: sound, 3: short silence after glitch, 4: short silence after sound\\n\\n nNbrGlitch = 0\\n nNumSample = 0\\n nNbrSampleReplace = 0\\n while( True ):\\n for nNumChannel in range( self.nNbrChannel ):\\n val = self.data[(nNumSample*self.nNbrChannel)+nNumChannel]\\n val = abs(val)\\n nCurrentState = anState[nNumChannel]\\n newState = nCurrentState\\n \\n if( nCurrentState == 0 ):\\n if( val > nGlitchLimit ):\\n newState = 2\\n elif( val > nSilenceLimit ):\\n newState = 1\\n aPosGlitchBegin[nNumChannel] = nNumSample\\n elif( nCurrentState == 1 ):\\n if( val > nGlitchLimit ):\\n newState = 2\\n elif( val < nSilenceLimit ):\\n newState = 3\\n aPosSilenceBegin[nNumChannel] = nNumSample\\n elif( nNumSample - aPosGlitchBegin[nNumChannel] >= nGlitchNumSampleMaxDuration ):\\n # too long => sound\\n newState = 2\\n elif( nCurrentState == 2 ):\\n if( val < nSilenceLimit ):\\n newState = 4\\n aPosSilenceBegin[nNumChannel] = nNumSample\\n aPosLastSoundEnd[nNumChannel] = nNumSample\\n elif( nCurrentState == 3 ):\\n if( val > nGlitchLimit ):\\n newState = 2\\n elif( val > nSilenceLimit ):\\n newState = 1\\n elif( nNumSample - aPosSilenceBegin[nNumChannel] >= nSilenceNumSampleMinDuration ):\\n newState = 0\\n # erase this glitch\\n logging.info( \\\"Channel%d: Erasing glitch between %s (%5.3fs) and %s (%5.3fs)\\\" % (nNumChannel, aPosGlitchBegin[nNumChannel],aPosGlitchBegin[nNumChannel]/float(self.nSamplingRate), nNumSample, nNumSample/float(self.nSamplingRate) ) )\\n nNbrGlitch += 1\\n self.data[ (aPosGlitchBegin[nNumChannel]*self.nNbrChannel)+nNumChannel:(nNumSample*self.nNbrChannel)+nNumChannel:self.nNbrChannel]=[0]*(nNumSample-aPosGlitchBegin[nNumChannel])\\n elif( nCurrentState == 4 ):\\n if( val > nSilenceLimit ):\\n newState = 2\\n elif( nNumSample - aPosSilenceBegin[nNumChannel] >= nSilenceNumSampleMinDuration ):\\n newState = 0\\n # nothing to do!\\n \\n if( newState != nCurrentState ):\\n if( nNumSample < 300000 ):\\n logging.debug( \\\"Channel%d: sample: %d (%5.3fs), new state: %d, data: %d\\\" % (nNumChannel,nNumSample,nNumSample/float(self.nSamplingRate), newState,val) )\\n anState[nNumChannel] = newState\\n if( newState == 2 ):\\n # we add a small respiration to leave sound trail and attacks\\n if( aPosLastSoundEnd[nNumChannel] == 0 ):\\n nBegin = 0\\n else:\\n nBegin = aPosLastSoundEnd[nNumChannel] + nSilenceAroundSilenceBlanking\\n nEnd = nNumSample - nSilenceAroundSilenceBlanking\\n if( nBegin < nEnd ):\\n logging.debug( \\\"Channel%d: Blanking silence between %s (%5.3fs) and %s (%5.3fs)\\\" % ( nNumChannel, nBegin, nBegin/float(self.nSamplingRate), nEnd, nEnd/float(self.nSamplingRate) ) )\\n self.data[ (nBegin*self.nNbrChannel)+nNumChannel:(nEnd*self.nNbrChannel)+nNumChannel:self.nNbrChannel]=[0]*(nEnd-nBegin)\\n \\n # for each chan - end\\n nNumSample += 1\\n if( nNumSample % 10000 == 0 ):\\n #TODO: unpack to be able to modify just a bit of the chain OR look how to remove a bit of the chain without compy everything (super long)\\n logging.debug( \\\"nNumSample: %d (state[0]: %d)\\\" % (nNumSample, anState[0]) ) \\n \\n if( nNumSample >= self.nNbrSample ):\\n break\\n # while - end\\n \\n rDuration = time.time()-timeBegin\\n \\n logging.info( \\\"removeGlitch: nNbrGlitch: %d, (time taken: %5.3fs)\\\" % (nNbrGlitch, rDuration ) )\\n \\n return True\",\n \"def trackThresholdOptical(threshold, ants=0) :\\n SPEED_OF_LIGHT = 299792458.0 # m/s\\n antlist = helpers.makeList(ants)\\n if antlist[0] == 0: antlist = currentAntennaNumbers()\\n flo = lofreq()\\n t = 0\\n for ant in antlist:\\n antmp = \\\"control.antenna%d\\\" %ant\\n d = queryDouble(antmp + \\\".diameter\\\")\\n t = queryDouble(antmp + \\\".trackTolerance\\\")\\n tbw = threshold*math.pi/(180*60*60)*flo*1e9*d/SPEED_OF_LIGHT\\n #print \\\"Threshold in bw:\\\", tbw\\n trackThreshold(tbw, ant)\\n return t\",\n \"def peaks_and_thresh(self):\\n # split histograms at threshold then get mean and stdev:\\n counts = np.array(self.stats['Counts'])\\n bg = counts[counts < self.thresh] # background\\n signal = counts[counts > self.thresh] # signal above threshold\\n try:\\n 1//np.size(bg) # raises ZeroDivisionError if size == 0\\n 1//(np.size(bg)-1) # need > 1 images to get std dev\\n 1//np.size(signal)\\n 1//(np.size(signal)-1)\\n self.peak_heights = [1, 1]\\n self.peak_centre = [np.mean(bg), np.mean(signal)]\\n self.peak_widths = [np.std(bg, ddof=1), np.std(signal, ddof=1)]\\n self.thresh = self.peak_centre[0] + 5*self.peak_widths[0] # update threshold\\n except ZeroDivisionError: pass\",\n \"def filter_audio(audio):\\n\\n # Calculate voice energy for every 123 ms block\\n apower = lr.amplitude_to_db(np.abs(lr.stft(audio, n_fft=2048)), ref=np.max)\\n\\n # Summarize energy of every rate, normalize\\n apsums = np.sum(apower, axis=0) ** 2\\n apsums -= np.min(apsums)\\n apsums /= np.max(apsums)\\n\\n # Smooth the graph for saving short spaces and pauses, remove sharpness\\n apsums = np.convolve(apsums, np.ones((9,)), 'same')\\n # Normalize again\\n apsums -= np.min(apsums)\\n apsums /= np.max(apsums)\\n\\n # Set noise limit to 35% over voice\\n apsums = np.array(apsums > 0.35, dtype=bool)\\n\\n # Extend the blocks every on 125ms\\n # before separated samples (2048 at block)\\n apsums = np.repeat(apsums, np.ceil(len(audio) / len(apsums)))[:len(audio)]\\n\\n return audio[apsums]\",\n \"def fine_tune(self, duration = 2):\\n\\n with sr.Microphone() as source:\\n self.recorder.adjust_for_ambient_noise(source, duration=duration)\\n return self.recorder.energy_threshold\",\n \"def strip_silence(self):\\n start_idx = 0\\n end_idx = -1\\n # class position\\n for i, tone in enumerate(self.tone_list):\\n if not 'silence' in tone:\\n start_idx = i\\n break\\n\\n for i, tone in reversed(list(enumerate(self.tone_list))):\\n if not 'silence' in tone:\\n end_idx = i - 1\\n break\\n\\n self.tone_list = self.tone_list[start_idx:end_idx]\",\n \"def calculate_wavelength_metric(wavelength_min, wavelength_max):\\n length_max = np.log(550) * 2\\n wavelength = np.abs(wavelength_max + wavelength_min) / 2\\n log_wl = np.log(wavelength)\\n default_met = np.array(log_wl / length_max)\\n scaled_met = 1.75 * (default_met - 0.5) + 0.5\\n if wavelength == 0:\\n return 0\\n else:\\n return scaled_met.clip(min=10e-11, max=1)\",\n \"def _cache_silence_sample_data(self):\\n self.silence_4_sample_buffer = self._synthesize_silence(4.0 * self.dot_time_in_msec)\\n self.silence_2_sample_buffer = self._synthesize_silence(2.0 * self.dot_time_in_msec)\\n self.silence_1_sample_buffer = self._synthesize_silence(self.dot_time_in_msec)\",\n \"def analyzeWAV(inputFile):\\n data, fs, nbits = audiolab.wavread(inputFile)\\n samplingRate = fs\\n return [data, samplingRate]\",\n \"def custom_sound(type_of, attack, decay, cutoff, coef, time, freq):\\n dzw = np.zeros(time*44100)\\n l=0\\n for i in type_of:\\n if i==\\\"sin\\\":\\n dzw+= coef[l]*sin_custom(freq,time,attack[l],decay[l])\\n if i==\\\"sq\\\":\\n dzw+= coef[l]*sq_custom(freq,time,attack[l],decay[l])\\n if i==\\\"saw\\\":\\n dzw+= coef[l]*saw_custom(freq,time,attack[l],decay[l])\\n l+=1 \\n dzw[(1-cutoff)*time*44100 -1:]==0\\n dzw = np.repeat(dzw,2).reshape(len(dzw),2)\\n dzw = dzw/np.amax(dzw)\\n return(dzw)\",\n \"def lmin(self):\\n cond = (self.transmit / self.transmit.max()) > 1./100\\n return min(self.wavelength[cond])\",\n \"def wave_samples(self):\\n return self._quantized_subsamples\",\n \"def mask(self):\\n\\n mask = self.freqs >= self.minimum_threshold\\n mask = mask.astype(int)\\n self.freqs = self.freqs * mask\\n self.sums = self.sums * mask\",\n \"def noise(self, freq: int, /) -> None:\",\n \"def timbral_brightness(fname, threshold=0, crossover=3000, stepSize=1024, blockSize=2048, n_oct=2, minFreq=20):\\n # use pysoundfile instead\\n audio_samples, fs = sf.read(fname, always_2d=False)\\n\\n num_channels = np.shape(audio_samples)\\n if len(num_channels) > 1:\\n # take just the left channel\\n audio_samples = audio_samples[:, 0]\\n\\n # initialise default settings\\n centroid_list = []\\n crossover_idx = 0\\n mag_hi_list = []\\n mag_all_list = []\\n updated = False\\n window = np.hamming(blockSize)\\n\\n i = 0\\n # split the audio into blocks of audio (ignore last block like matlab\\n while (i + blockSize) < len(audio_samples):\\n eval_audio = audio_samples[i:i + blockSize]\\n complex_spectrum = np.fft.fft(eval_audio * window)\\n magnitude_spectrum = np.absolute(complex_spectrum[0:1 + int(len(complex_spectrum) / 2)])\\n\\n if sum(magnitude_spectrum) > 0:\\n\\n if not updated:\\n fls = calcFrequencyScale(len(magnitude_spectrum), fs, blockSize)\\n crossover_idx = calcCrossoverIDX(fls, crossover)\\n minIDX = calcMinIDX(fls, minFreq)\\n maxIDX = calcMaxIDX(fls, n_oct)\\n if n_oct > 0:\\n f_upper = calcUpperFrequencyLimit(fls, n_oct, maxIDX)\\n f_lower = calcLowFrequencyLimit(fls, n_oct, maxIDX)\\n\\n updated = True\\n\\n if n_oct > 0:\\n smoothed_spectrum = spectralSmoothing(magnitude_spectrum, f_upper, f_lower)\\n else:\\n smoothed_spectrum = magnitude_spectrum\\n\\n tpower = sum(smoothed_spectrum[minIDX:])\\n\\n # calculate the spectral centroid\\n if tpower > threshold:\\n upper_spectrum = smoothed_spectrum[crossover_idx:]\\n upper_fls = fls[crossover_idx:(crossover_idx + len(upper_spectrum))]\\n upper_power = sum(upper_spectrum)\\n centroid = sum(upper_spectrum * upper_fls) / upper_power\\n\\n centroid_list.append(centroid)\\n mag_all_list.append(tpower)\\n mag_hi_list.append(upper_power)\\n\\n else:\\n centroid_list.append(0)\\n mag_all_list.append(0)\\n mag_hi_list.append(0)\\n\\n i += stepSize\\n\\n if sum(mag_all_list) == 0:\\n return 0\\n\\n mean_centroid = np.mean(np.array(centroid_list))\\n mean_mag_hi = np.mean(np.array(mag_hi_list))\\n mean_mag_all = np.mean(np.array(mag_all_list))\\n\\n # float required for float division in Python 2.7\\n ratio = mean_mag_hi / float(mean_mag_all)\\n\\n # equation taken directly from Pearce [2016]\\n bright = -25.8699 + (64.0127 * (np.log10(ratio) + (0.44 * np.log10(mean_centroid))))\\n\\n return bright\",\n \"def pumpThreshold(self):\\n EsatL, tauL, etaP = self.EsatL, self.tauL, self.etaP\\n loss, DR = self.loss, self.DR\\n return(EsatL / tauL * (loss + DR) / etaP)\",\n \"def perfectrefl(wavelength):\\n return 1.0\",\n \"def arg_threshold(data: tensor, threshold: float = 0.8, offset: int = 50) -> (int, int):\\n\\n assert 0 < data.shape[0] <= 2, \\\"Expected mono/stereo audio data to be of form (channels, smaples).\\\"\\n\\n start = 0\\n end = len(data)\\n for start, d in enumerate(data[0]):\\n if abs(d) > threshold:\\n print(\\\"Starts at: %i with volume %d.\\\" % (start, float(d)))\\n break\\n\\n for i, d in enumerate(np.flipud(data[0])):\\n if abs(d) > threshold:\\n end = len(data[0]) - i\\n print(\\\"Ends at: %i with volume %d.\\\" % (end, float(d)))\\n break\\n\\n return start + offset, end - offset\",\n \"def _compute_sampling_threshold(global_step, k):\\n return tf.cast(k / (k + tf.exp(global_step / k)), tf.float32)\",\n \"def __determina_media_confidence(self):\\n media = 0\\n nr = 0\\n for el in self.__results['conf']:\\n media += int(el)\\n nr += 1\\n media /= nr\\n return media\",\n \"def get_fft_threshold(self) -> float:\\n return float(self.query(':measure:fft:threshold?'))\",\n \"def snip_audio(data, snip_length=4, cutoff=0.25, min_snips=None, max_snips=None,\\n num_jitters=None, jitter=0.25,\\n rate=44100, log=False):\\n if max_snips is None:\\n if min_snips is None:\\n min_snips = 1\\n max_snips = max(min_snips, int((float(len(data))/rate)/3.0))\\n # Pad data with (snip_length * rate / 2) zeros.\\n chop = np.lib.pad(data, int(snip_length*rate/2), 'constant')\\n if log:\\n logging.info(\\\"Data padded with %.1f s of zeros.\\\" %\\n (float(snip_length)/2))\\n snips = []\\n logs = []\\n max_sum = 0\\n count = 0\\n sum_ratio = 1\\n\\n while True:\\n current_sum, start_idx, end_idx = find_loudest_subset(chop, snip_length,\\n rate=rate)\\n max_sum = max(max_sum, current_sum)\\n sum_ratio = float(current_sum) / max_sum\\n if sum_ratio < cutoff:\\n break\\n collection = []\\n if num_jitters is None:\\n collection.append(np.copy(chop[start_idx : end_idx]))\\n else:\\n for j in xrange(num_jitters):\\n offset = int(jitter * rate * random.uniform(-1, 1))\\n try:\\n collection.append(np.copy(chop[start_idx+offset : end_idx+offset]))\\n except IndexError:\\n collection.append(np.copy(chop[start_idx : end_idx]))\\n logs.append((sum_ratio, max_sum, start_idx, end_idx))\\n chop[start_idx : end_idx] = 0\\n snips.append(collection)\\n count += 1\\n if count >= max_snips:\\n break\\n return snips, logs\",\n \"def band_penalty(self):\\n fc_ix = np.argmin(np.abs(self.f - self.fc)) # Index to frequency array closes to center frequency\\n # Number of indexes on each side of center frequency, not extending outside, only up to 10 kHz\\n n = min(fc_ix, self.ix10k - fc_ix)\\n if n == 0:\\n return 0.0\\n return np.mean(np.square(self.fr[fc_ix - n:fc_ix] - (self.gain - self.fr[fc_ix + n - 1:fc_ix - 1:-1])))\",\n \"def find_start_end_rests(audio_data, sr, hop_length=HOP_LENGTH, n_fft=N_FFT):\\r\\n \\r\\n # Compute the 3rd percentile of the envelope and \\r\\n # deem anything below this value as silence \\r\\n envelope = frame(audio_data, hop_length=hop_length, frame_length=n_fft).max(axis=0)\\r\\n lower_bound = np.percentile(envelope, 5.0)\\r\\n \\r\\n # Implement the search as loop, this should be faster than vectorisation\\r\\n k = 0\\r\\n while envelope[k] <= lower_bound:\\r\\n k += 1\\r\\n \\r\\n # Return 0 if there is no start rest\\r\\n if k == 0:\\r\\n time_start = 0.0\\r\\n else:\\r\\n # The first value of the output of the frame function correspond to the time of\\r\\n # n_fft, then the times are spaced according to hop_length \\r\\n time_start = ((k-1)*hop_length + n_fft)/float(sr)\\r\\n \\r\\n j = len(envelope)-1\\r\\n while envelope[j] <= lower_bound:\\r\\n j -= 1\\r\\n \\r\\n # Return the length of the track if the is no end rest\\r\\n if j == len(envelope)-1:\\r\\n time_end = len(audio_data)/float(sr)\\r\\n else:\\r\\n time_end = ((j-1)*hop_length + n_fft)/float(sr)\\r\\n \\r\\n times_start_end_rests = [time_start, time_end]\\r\\n \\r\\n return(times_start_end_rests)\",\n \"def limit(filename,threshold,makeup,wout=True,plot=False):\\n start=time.time()\\n n, data, data_dB,sr,ch=inputwav(filename)\\n dataL,dataL_bit=compress(filename,threshold,1000.0,makeup,1.0,500.0,wout=False,plot=plot)\\n if wout==True:\\n print('Exporting...')\\n sf.write(filename[0:len(filename)-4]+'_limit.wav',dataL_bit,44100,'PCM_16')\\n end=time.time()\\n elapsed=int(1000*(end-start))\\n print('Done!')\\n print('...............................')\\n print('Completed in '+str(elapsed)+' milliseconds.') \\n return dataL,dataL_bit\",\n \"def trim_silence(infile, outfile):\\n subprocess.call([\\n 'sox',\\n infile,\\n outfile,\\n 'silence',\\n '1',\\n '0.1',\\n '1%'\\n ])\\n return outfile\",\n \"def timbral_warmth(fname, dev_output=False, phase_correction=False, clip_output=False, max_FFT_frame_size=8192,\\n max_WR = 12000, fs=0):\\n '''\\n Read input\\n '''\\n audio_samples, fs = timbral_util.file_read(fname, fs, phase_correction=phase_correction)\\n\\n # get the weighted high frequency content\\n mean_wr, _, _, weighted_hf = warm_region_cal(audio_samples, fs)\\n\\n # calculate the onsets\\n envelope = timbral_util.sample_and_hold_envelope_calculation(audio_samples, fs, decay_time=0.1)\\n envelope_time = np.arange(len(envelope)) / float(fs)\\n\\n # calculate the onsets\\n nperseg = 4096\\n original_onsets = timbral_util.calculate_onsets(audio_samples, envelope, fs, nperseg=nperseg)\\n # If onsets don't exist, set it to time zero\\n if not original_onsets:\\n original_onsets = [0]\\n # set to start of file in the case where there is only one onset\\n if len(original_onsets) == 1:\\n original_onsets = [0]\\n '''\\n Initialise lists for storing features\\n '''\\n # set defaults for holding\\n all_rms = []\\n all_ratio = []\\n all_SC = []\\n all_WR_Ratio = []\\n all_decay_score = []\\n\\n\\n # calculate metrics for each onset\\n for idx, onset in enumerate(original_onsets):\\n if onset == original_onsets[-1]:\\n # this is the last onset\\n segment = audio_samples[onset:]\\n else:\\n segment = audio_samples[onset:original_onsets[idx+1]]\\n\\n segment_rms = np.sqrt(np.mean(segment * segment))\\n all_rms.append(segment_rms)\\n\\n # get FFT of signal\\n segment_length = len(segment)\\n if segment_length < max_FFT_frame_size:\\n freq, time, spec = spectrogram(segment, fs, nperseg=segment_length, nfft=max_FFT_frame_size)\\n else:\\n freq, time, spec = spectrogram(segment, fs, nperseg=max_FFT_frame_size, nfft=max_FFT_frame_size)\\n\\n # flatten the audio to 1 dimension. Catches some strange errors that cause crashes\\n if spec.shape[1] > 1:\\n spec = np.sum(spec, axis=1)\\n spec = spec.flatten()\\n\\n # normalise for this onset\\n spec = np.array(list(spec)).flatten()\\n this_shape = spec.shape\\n spec /= max(abs(spec))\\n\\n '''\\n Estimate of fundamental frequency\\n '''\\n # peak picking algorithm\\n peak_idx, peak_value, peak_x = timbral_util.detect_peaks(spec, freq=freq, fs=fs)\\n # find lowest peak\\n fundamental = np.min(peak_x)\\n fundamental_idx = np.min(peak_idx)\\n\\n '''\\n Warmth region calculation\\n '''\\n # estimate the Warmth region\\n WR_upper_f_limit = fundamental * 3.5\\n if WR_upper_f_limit > max_WR:\\n WR_upper_f_limit = 12000\\n tpower = np.sum(spec)\\n WR_upper_f_limit_idx = int(np.where(freq > WR_upper_f_limit)[0][0])\\n\\n if fundamental < 260:\\n # find frequency bin closest to 260Hz\\n top_level_idx = int(np.where(freq > 260)[0][0])\\n # sum energy up to this bin\\n low_energy = np.sum(spec[fundamental_idx:top_level_idx])\\n # sum all energy\\n tpower = np.sum(spec)\\n # take ratio\\n ratio = low_energy / float(tpower)\\n else:\\n # make exception where fundamental is greater than\\n ratio = 0\\n\\n all_ratio.append(ratio)\\n\\n '''\\n Spectral centroid of the segment\\n '''\\n # spectral centroid\\n top = np.sum(freq * spec)\\n bottom = float(np.sum(spec))\\n SC = np.sum(freq * spec) / float(np.sum(spec))\\n all_SC.append(SC)\\n\\n '''\\n HF decay\\n - linear regression of the values above the warmth region\\n '''\\n above_WR_spec = np.log10(spec[WR_upper_f_limit_idx:])\\n above_WR_freq = np.log10(freq[WR_upper_f_limit_idx:])\\n np.ones_like(above_WR_freq)\\n metrics = np.array([above_WR_freq, np.ones_like(above_WR_freq)])\\n\\n # create a linear regression model\\n model = linear_model.LinearRegression(fit_intercept=False)\\n model.fit(metrics.transpose(), above_WR_spec)\\n decay_score = model.score(metrics.transpose(), above_WR_spec)\\n all_decay_score.append(decay_score)\\n\\n\\n '''\\n get mean values\\n '''\\n mean_SC = np.log10(np.mean(all_SC))\\n mean_decay_score = np.mean(all_decay_score)\\n weighted_mean_ratio = np.average(all_ratio, weights=all_rms)\\n\\n if dev_output:\\n return mean_SC, weighted_hf, mean_wr, mean_decay_score, weighted_mean_ratio\\n else:\\n\\n '''\\n Apply regression model\\n '''\\n all_metrics = np.ones(6)\\n all_metrics[0] = mean_SC\\n all_metrics[1] = weighted_hf\\n all_metrics[2] = mean_wr\\n all_metrics[3] = mean_decay_score\\n all_metrics[4] = weighted_mean_ratio\\n\\n coefficients = np.array([-4.464258317026696,\\n -0.08819320850778556,\\n 0.29156539973575546,\\n 17.274733561081554,\\n 8.403340066029507,\\n 45.21212125085579])\\n\\n warmth = np.sum(all_metrics * coefficients)\\n\\n # clip output between 0 and 100\\n if clip_output:\\n warmth = timbral_util.output_clip(warmth)\\n\\n return warmth\",\n \"def test_signal_threshold(df_phys, signal, threshold):\\n df_signal = df_phys[df_phys[\\\"Signal\\\"] == signal][\\\"Physical Value\\\"]\\n\\n stats = df_signal.agg([\\\"count\\\", \\\"min\\\", \\\"max\\\", \\\"mean\\\", \\\"std\\\"])\\n delta = stats[\\\"max\\\"] - stats[\\\"min\\\"]\\n\\n if delta > threshold:\\n print(f\\\"{signal} exhibits a 'max - min' delta of {delta} exceeding threshold of {threshold}\\\")\",\n \"def _getWavelet(self, ch='dos1rate', thresh=0.1, maxWidth=1, SIGNIF_LEVEL=0.25):\\n # Feed the counts into the wavelet microburst finder\\n validDataIdt = np.where(self.d[ch] != -1E31)[0]\\n waveletAnalysis.WaveletDetector.__init__(self, self.d[ch][validDataIdt], \\n self.d['dateTime'][validDataIdt], 0.1, mother='DOG', siglvl=0.95)\\n self.waveletTransform() # Get wavelet space\\n self.waveletFilter(self.s0, maxWidth, SIGNIF_LEVEL=SIGNIF_LEVEL) # Do a band pass and significance filter.\\n self.degenerateInvWaveletTransform() # Inverse transform filtered data.\\n # Indicies where the error-filetered data is greater than thresh\\n self.burstIdt = np.where(self.dataFlt > thresh)[0] \\n self._getPeaks(ch, validDataIdt) # Find peaks\\n return\",\n \"def checkfrequency(inputgiven):\\n data_size = 40000\\n wav_file = wave.open(inputgiven, 'r')\\n data = wav_file.readframes(data_size)\\n wav_file.close()\\n data = struct.unpack('{n}h'.format(n=data_size), data)\\n print max(data)\",\n \"def num_samples(self):\\n with audioread.audio_open(self.path) as f:\\n return int(f.duration * f.samplerate)\",\n \"def window_step(self):\\n if self.window_samples and self.overlap_samples and self.audio_sample_rate:\\n return (\\n float(self.window_samples - self.overlap_samples)\\n / self.audio_sample_rate\\n )\\n return None\",\n \"def get_UL_bw(self,wavelength):\\n sec_before = self.wavelengths[wavelength]['sec_UL_timestamp']\\n if self.env.now > (sec_before + 2):\\n # IF its 2 seconds ahead of last timestamp, it means no more pkts arrived since then\\n return 0\\n return self.wavelengths[wavelength]['last_UL_bps']\",\n \"def wav2(bins, weis):\\n\\n mean = np.average(bins, weights=weis)\\n var = np.average((bins-mean)**2, weights=weis)\\n ##\\n sum1 = weis.sum()\\n sum2 = (weis**2).sum()\\n rms = np.sqrt(sum1*var/(sum1-sum2/sum1))\\n\\n return mean, rms\",\n \"def calculateMaxAmplitude(sampleWidth: int) -> int:\\n return 2 ** (sampleWidth * NUM_BITS_IN_A_BYTE - 1) - 1\",\n \"def get_variance_threshold(variances, whisker_percent, whisker_length):\\n low_percentiles, high_percentiles = np.percentile(variances, (whisker_percent, 100-whisker_percent))\\n threshold = high_percentiles + (high_percentiles - low_percentiles) * whisker_length\\n\\n return threshold\",\n \"def split_multiple_recordings_file(file_path, min_silence_duration=0.25, noise_threshold=150):\\n print(file_path)\\n rate, audio = scipy.io.wavfile.read(file_path)\\n split_recordings = split_multiple_recordings(audio, min_silence_duration=min_silence_duration,\\n noise_threshold=noise_threshold, sample_rate_hz=rate)\\n\\n if file_path.count('.') != 1:\\n raise Exception('File_path must contain exactly one period, usually in extension. IE: /home/test.wav')\\n\\n for idx, recording in enumerate(split_recordings):\\n print(\\\"spliting \\\" + file_path)\\n new_file_path = file_path.split('.')[0] + '_' + str(idx) + \\\".wav\\\"\\n scipy.io.wavfile.write(new_file_path, rate, recording)\",\n \"def silence_removal(signal, sampling_rate, st_win, st_step, smooth_window=0.5,\\n weight=0.5, plot=False):\\n\\n if weight >= 1:\\n weight = 0.99\\n if weight <= 0:\\n weight = 0.01\\n\\n # Step 1: feature extraction\\n signal = audioBasicIO.stereo_to_mono(signal)\\n st_feats, _ = stf.feature_extraction(signal, sampling_rate,\\n st_win * sampling_rate,\\n st_step * sampling_rate)\\n\\n # Step 2: train binary svm classifier of low vs high energy frames\\n # keep only the energy short-term sequence (2nd feature)\\n st_energy = st_feats[1, :]\\n en = np.sort(st_energy)\\n # number of 10% of the total short-term windows\\n st_windows_fraction = int(len(en) / 10)\\n\\n # compute \\\"lower\\\" 10% energy threshold\\n low_threshold = np.mean(en[0:st_windows_fraction]) + 1e-15\\n\\n # compute \\\"higher\\\" 10% energy threshold\\n high_threshold = np.mean(en[-st_windows_fraction:-1]) + 1e-15\\n\\n # get all features that correspond to low energy\\n low_energy = st_feats[:, np.where(st_energy <= low_threshold)[0]]\\n\\n # get all features that correspond to high energy\\n high_energy = st_feats[:, np.where(st_energy >= high_threshold)[0]]\\n\\n # form the binary classification task and ...\\n features = [low_energy.T, high_energy.T]\\n # normalize and train the respective svm probabilistic model\\n\\n # (ONSET vs SILENCE)\\n features_norm, mean, std = at.normalize_features(features)\\n svm = at.train_svm(features_norm, 1.0)\\n\\n # Step 3: compute onset probability based on the trained svm\\n prob_on_set = []\\n for index in range(st_feats.shape[1]):\\n # for each frame\\n cur_fv = (st_feats[:, index] - mean) / std\\n # get svm probability (that it belongs to the ONSET class)\\n prob_on_set.append(svm.predict_proba(cur_fv.reshape(1, -1))[0][1])\\n prob_on_set = np.array(prob_on_set)\\n\\n # smooth probability:\\n prob_on_set = smooth_moving_avg(prob_on_set, smooth_window / st_step)\\n\\n # Step 4A: detect onset frame indices:\\n prog_on_set_sort = np.sort(prob_on_set)\\n\\n # find probability Threshold as a weighted average\\n # of top 10% and lower 10% of the values\\n nt = int(prog_on_set_sort.shape[0] / 10)\\n threshold = (np.mean((1 - weight) * prog_on_set_sort[0:nt]) +\\n weight * np.mean(prog_on_set_sort[-nt::]))\\n\\n max_indices = np.where(prob_on_set > threshold)[0]\\n # get the indices of the frames that satisfy the thresholding\\n index = 0\\n seg_limits = []\\n time_clusters = []\\n\\n # Step 4B: group frame indices to onset segments\\n while index < len(max_indices):\\n # for each of the detected onset indices\\n cur_cluster = [max_indices[index]]\\n if index == len(max_indices)-1:\\n break\\n while max_indices[index+1] - cur_cluster[-1] <= 2:\\n cur_cluster.append(max_indices[index+1])\\n index += 1\\n if index == len(max_indices)-1:\\n break\\n index += 1\\n time_clusters.append(cur_cluster)\\n seg_limits.append([cur_cluster[0] * st_step,\\n cur_cluster[-1] * st_step])\\n\\n # Step 5: Post process: remove very small segments:\\n min_duration = 0.2\\n seg_limits_2 = []\\n for s_lim in seg_limits:\\n if s_lim[1] - s_lim[0] > min_duration:\\n seg_limits_2.append(s_lim)\\n seg_limits = seg_limits_2\\n\\n if plot:\\n time_x = np.arange(0, signal.shape[0] / float(sampling_rate), 1.0 /\\n sampling_rate)\\n\\n plt.subplot(2, 1, 1)\\n plt.plot(time_x, signal)\\n for s_lim in seg_limits:\\n plt.axvline(x=s_lim[0], color='red')\\n plt.axvline(x=s_lim[1], color='red')\\n plt.subplot(2, 1, 2)\\n plt.plot(np.arange(0, prob_on_set.shape[0] * st_step, st_step), \\n prob_on_set)\\n plt.title('Signal')\\n for s_lim in seg_limits:\\n plt.axvline(x=s_lim[0], color='red')\\n plt.axvline(x=s_lim[1], color='red')\\n plt.title('svm Probability')\\n plt.show()\\n\\n return seg_limits\",\n \"def measure_wavelength(self, t_measure):\\n overlap = self.overlap(t_measure)\\n \\n # set all overlap entries below 0.1% of the maximum overlap to zero\\n overlap[overlap<0.001*np.max(overlap)] = 0.0\\n nonzero = np.nonzero(overlap)\\n \\n # find connected section of chain with nonzero overlap\\n consecutives = np.split(nonzero, np.where(np.diff(nonzero) != 1)[0]+1)\\n if len(consecutives) != 1:\\n warnings.warn('Wavelength could not be determined unambiguously.')\\n return np.nan\\n else:\\n # add 1 since overlap involves two beads each\\n wavelength = len(consecutives[0][0]) + 1\\n return wavelength\",\n \"def threshold(self) -> float:\\n return pulumi.get(self, \\\"threshold\\\")\",\n \"def band_penalty(self):\\n fc_ix = np.argmin(np.abs(self.f - self.fc)) # Index to frequency array closes to center frequency\\n # Number of indexes on each side of center frequency, not extending outside, only up to 10 kHz\\n n = min(fc_ix, self.ix10k - fc_ix)\\n if n == 0:\\n return 0.0\\n return np.mean(np.square(self.fr[fc_ix - n:fc_ix] - self.fr[fc_ix + n - 1:fc_ix - 1:-1]))\",\n \"def get_large_audio_transcription(path):\\n # open the audio file using pydub\\n r = sr.Recognizer()\\n sound = AudioSegment.from_mp3(path)\\n sound.export(\\\"tmp.wav\\\", format=\\\"wav\\\")\\n sound = AudioSegment.from_wav('tmp.wav')\\n # split audio sound where silence is 700 miliseconds or more and get chunks\\n chunks = split_on_silence(sound,\\n # experiment with this value for your target audio file\\n min_silence_len = 500,\\n # adjust this per requirement\\n silence_thresh = sound.dBFS-14,\\n # keep the silence for 1 second, adjustable as well\\n keep_silence=500,\\n )\\n folder_name = \\\"audio-chunks\\\"\\n # create a directory to store the audio chunks\\n if not os.path.isdir(folder_name):\\n os.mkdir(folder_name)\\n whole_text = \\\"\\\"\\n\\n chapter=(str(path.split('/')[-1])).split('_')[3]\\n # if chapter == '01':\\n # target=2\\n # else:\\n # target=1\\n target=2\\n # process each chunk\\n for i, audio_chunk in enumerate(chunks, start=1):\\n # export audio chunk and save it in\\n # the `folder_name` directory.\\n if i==1:\\n chunk_filename = os.path.join(folder_name, f\\\"chunk{i}.wav\\\")\\n audio_chunk.export(chunk_filename, format=\\\"wav\\\")\\n # recognize the chunk\\n with sr.AudioFile(chunk_filename) as source:\\n audio_listened = r.record(source)\\n # try converting it to text\\n try:\\n text = r.recognize_google(audio_listened,language=\\\"en-US\\\")\\n\\n except sr.UnknownValueError as e:\\n print(\\\"Error:\\\", str(e))\\n else:\\n #text = f\\\"{text.capitalize()}. \\\"\\n #print(chunk_filename, \\\":\\\", text)\\n whole_text += text\\n # return the text for all chunks detected\\n else:\\n chunk_filename = os.path.join(folder_name, f\\\"chunk{i}.wav\\\")\\n audio_chunk.export(chunk_filename, format=\\\"wav\\\")\\n # recognize the chunk\\n with sr.AudioFile(chunk_filename) as source:\\n audio_listened = r.record(source)\\n # try converting it to text\\n try:\\n text = r.recognize_google(audio_listened, language=\\\"en-US\\\")\\n\\n except sr.UnknownValueError as e:\\n print(\\\"Error:\\\", str(e))\\n else:\\n #text = f\\\"{text.capitalize()}. \\\"\\n # print(chunk_filename, \\\":\\\", text)\\n if chapter == '01':\\n whole_text += ' ' +text\\n if str(text).isalnum():\\n if str(text).split(' ')[0]==' ':\\n whole_text += text\\n else: whole_text += ' '+text\\n # return the text for all chunks detected\\n\\n if i==target:\\n break\\n if os.path.isfile('tmp.wav') :os.remove('tmp.wav')\\n subprocess.run([\\\"rm\\\", \\\"-rf\\\", folder_name])\\n return whole_text\",\n \"def sample_interval(self):\\n\\n if self.sample_rate != 0:\\n return 1.0 / self.sample_rate\\n return 0.0\",\n \"def silencing_constraint(self, x0: devices.PrimaryWeights) -> float:\\n contrast = self.get_photoreceptor_contrasts(x0)\\n return sum(pow(contrast[self.silence].values, 2))\",\n \"def get_data(self, wave):\\n data = np.array([lfilter(self.b, self.a, wave[i]) for i in range(self.n_channels)])\\n self.min_threshold = np.min(data)\\n self.max_threshold = np.max(data)\\n return data\",\n \"def checkendsilence(inputgiven):\\n output = getlastslice(inputgiven)\\n wave_file = wave.open(output, \\\"r\\\")\\n for i in range(wave_file.getnframes()):\\n current_frame = wave_file.readframes(1)\\n unpacked_signed_value = struct.unpack(\\\"<h\\\", current_frame)\\n if abs(unpacked_signed_value[0]) > 500:\\n return False\\n return True\",\n \"def listen_for_speech(threshold=THRESHOLD):\\n\\n #Open stream\\n p = pyaudio.PyAudio()\\n\\n stream = p.open(format=FORMAT,\\n channels=CHANNELS,\\n rate=RATE,\\n input=True,\\n frames_per_buffer=CHUNK)\\n\\n print(\\\"* recording\\\")\\n\\n frames = []\\n\\n for i in range(0, int(RATE / CHUNK * RECORD_SECONDS)):\\n\\tdata = stream.read(CHUNK)\\n frames.append(data)\\n\\n print(\\\"* done recording\\\")\\n\\n stream.stop_stream()\\n stream.close()\\n p.terminate()\\n\\n wf = wave.open(WAVE_OUTPUT_FILENAME, 'wb')\\n wf.setnchannels(CHANNELS)\\n wf.setsampwidth(p.get_sample_size(FORMAT))\\n wf.setframerate(RATE)\\n wf.writeframes(b''.join(frames))\\n wf.close()\\n \\n response = stt_google_wav(WAVE_OUTPUT_FILENAME)\\n\\n return response\",\n \"def micsample(listentime):\\n frames, sampling_rate = record_audio(listentime)\\n samples = np.hstack([np.frombuffer(i, np.int16) for i in frames])\\n times = np.arange(samples.size) / sampling_rate\\n return samples, times\",\n \"def separate_silence_and_speech(signal, sample_rate, time_segments):\\n\\n silence = signal\\n speech = signal\\n\\n for segment in reversed(time_segments):\\n\\n start = int(segment['start'] * sample_rate)\\n stop = int(segment['stop'] * sample_rate)\\n\\n if segment['is_speech']:\\n silence = np.delete(silence, np.s_[start:stop], axis=0)\\n else:\\n speech = np.delete(speech, np.s_[start:stop], axis=0)\\n\\n return silence, speech\",\n \"def detect_freqs(self):\\n n_fft_bins = self._config[\\\"audio_config\\\"][\\\"N_FFT_BINS\\\"]\\n channel_avgs = []\\n differences = []\\n \\n for i in range(n_fft_bins):\\n channel_avgs.append(sum(self.freq_channels[i])/len(self.freq_channels[i]))\\n differences.append(((self.freq_channels[i][0]-channel_avgs[i])*100)//channel_avgs[i])\\n for i in [\\\"beat\\\", \\\"low\\\", \\\"mid\\\", \\\"high\\\"]:\\n if any(differences[j] >= self.min_percent_diff[i]\\\\\\n and self.freq_channels[j][0] >= self.min_detect_amplitude[i]\\\\\\n for j in range(*self.detection_ranges[i]))\\\\\\n and (time.time() - self.prev_freq_detects[i] > 0.2)\\\\\\n and len(self.freq_channels[0]) == self.freq_channel_history:\\n self.prev_freq_detects[i] = time.time()\\n self.current_freq_detects[i] = True\\n else:\\n self.current_freq_detects[i] = False\",\n \"def check_audio_pre_trial(data, audio=None, **_):\\n if audio is None:\\n _log.warning(\\\"No BNC2 input in function call, retuning None\\\")\\n return None\\n s = audio[\\\"times\\\"][~np.isnan(audio[\\\"times\\\"])] # Audio TTLs with NaNs removed\\n metric = np.array([], dtype=np.int8)\\n for i, c in zip(data[\\\"intervals\\\"][:, 0], data[\\\"goCue_times\\\"]):\\n metric = np.append(metric, sum(s[s > i] < (c - 0.02)))\\n passed = metric == 0\\n assert data[\\\"intervals\\\"].shape[0] == len(metric) == len(passed)\\n return metric, passed\",\n \"def set_new_threshold(wavform, thr, n_pre=N_PRE_PT, rng=SEARCH_RNG, i_chg=20):\\n wav = np.array(wavform)\\n sgn = np.sign(thr)\\n if np.max(wav[rng[0]:rng[1]] * sgn) < np.abs(thr): return None # reject\\n\\n \\\"\\\"\\\" NOT USED -- GIVES IMPRECISE RESULT\\n # -- align: find the steepest point having the same sign as `sgn`\\n df = np.diff(wav)\\n si = np.argsort(-sgn * df) # reverse sorted\\n for i in si:\\n if np.sign(wav[i]) == sgn: break\\n \\\"\\\"\\\"\\n # -- align: find the point where waveform crosses `thr`\\n n = len(wav)\\n for i in range(n - 1):\\n if sgn * wav[i] <= sgn * thr and sgn * thr <= sgn * wav[i + 1]:\\n break\\n if i == n - 2:\\n # although i could be n - 2, it's highly likely an artifact\\n return None\\n n_shift = n_pre - i - 1 # > 0: right shift, < 0: left shift\\n if n_shift == 0:\\n return wav\\n\\n wavnew = np.empty(wav.shape)\\n wavnew[n_shift:] = wav[:-n_shift] # PBC shifting\\n wavnew[:n_shift] = wav[-n_shift:]\\n\\n # -- done: but if the spike doesn't change its sign\\n # within `i_chg`, reject.\\n if np.max(-sgn * wavnew[n_pre:i_chg]) < 0:\\n return None\\n\\n \\\"\\\"\\\" DEBUG\\n if np.abs(n_shift) > 3:\\n print '!!!', n_shift, '/', i, '/', n\\n print '---', np.max(-sgn * wavnew[n_pre:i_chg])\\n print list(wav)\\n print list(wavnew)\\n \\\"\\\"\\\"\\n\\n return wavnew\",\n \"def lmax(self):\\n cond = (self.transmit / self.transmit.max()) > 1./100\\n return max(self.wavelength[cond])\",\n \"def audioEpochFeats(cur,uid,timestamp):\\n\\tuidA = uid +'audio'\\n\\n\\tvar_stats = []\\n\\tstd_stats = []\\n\\tnoise = []\\n\\tvoiceToSilenceRatio = []\\n\\n\\tfor i in range(1,24):\\n\\t\\ths_timestamp = timestamp-86400+(i-1)*hour\\n\\t\\the_timestamp = timestamp-86400+i*hour\\n\\t\\t# Determining if start/end time of given hour is in the night\\n\\t\\t# If yes, proceed with feature calculation, if not skip\\n\\t\\ts_epoch = epochCalc(hs_timestamp)\\n\\t\\te_epoch = epochCalc(he_timestamp)\\n\\n\\t\\tif s_epoch[0][0]=='night' or e_epoch[0][0]=='night':\\n\\t\\t\\tcur.execute('SELECT audio FROM {0} WHERE time_stamp >= {1} AND time_stamp<= {2}'\\n\\t\\t\\t\\t.format(uidA,timestamp-86400+(i-1)*hour,timestamp-86400+i*hour))\\n\\t\\t\\trecords = cur.fetchall()\\n\\n\\t\\t\\tvar_stats.append(np.var(records))\\n\\t\\t\\tstd_stats.append(np.std(records))\\n\\n\\t\\t\\t# Calculating number of silence and voice/noise occurences\\n\\t\\t\\tsilence = len([item for item in records if item==0])\\n\\t\\t\\tvoice = len([item for item in records if item==1 or item==2])\\n\\t\\t\\tnoise.append(len([item for item in records if item==3]))\\n\\t\\t\\tif silence>0:\\n\\t\\t\\t\\tvoiceToSilenceRatio.append(float(voice) / silence)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tvoiceToSilenceRatio.append(0)\\n\\treturn(np.nan_to_num(np.hstack((voiceToSilenceRatio,var_stats,std_stats,noise))))\\n\\t\\\"\\\"\\\"\\ndef main():\\n\\tcon = psycopg2.connect(database='dataset', user='tabrianos')\\n\\tcur = con.cursor()\\n\\t#warnings.simplefilter(\\\"error\\\")\\n\\t#centers = np.load('visualizations/clustercenters.npy')\\n\\n# ------------TEST CASE-----------------------------\\n\\tfor loso in uids1:\\n\\t\\tytest=[]\\n\\t\\taccuracies =[]\\n\\t\\tacc=0\\n\\t\\tmaxminAcc =[]\\n\\t\\tXbig = np.zeros([1,132])\\t\\n\\t\\tYbig = np.zeros([1])\\n\\t\\tlabels=[]\\n\\t\\tlabels.append(19)\\n\\t\\t# loso means leave one student out: forest is trained on other users data\\n\\t\\t# then tests are run on 'loso' student \\n\\t\\tuids2.remove(loso)\\n\\t\\tuids2.append(loso)\\n\\t\\tprint('LOSO: {0}'.format(loso))\\n\\t\\tfor testUser in uids2:\\n\\t\\t\\tprint(testUser)\\n\\t\\t\\t# lists that temporary store features before concatenation\\n\\t\\t\\t\\n\\t\\t\\tcolocationList =[]\\n\\t\\t\\tconversationList =[]\\n\\t\\t\\tactivityList=[]\\n\\t\\t\\taudioList = []\\n\\n\\t\\t\\t# loading stress labels from database (currently on 0-5 scale)\\n\\t\\t\\trecords = loadSleepLabels(cur,testUser) \\n\\t\\t\\n\\n\\t\\t\\t\\n\\t\\t\\t#X,Y store initially the dataset and the labels accordingly\\n\\t\\t\\tY = np.zeros(len(records))\\n\\t\\t\\tX = np.array(records)\\n\\n\\t\\n\\n\\n\\t\\t\\tfor i in range(0,len(records)):\\n\\t\\t\\t\\tcolocationList.append( colocationEpochFeats(cur,testUser,X[i][0]))\\n\\t\\t\\t\\tconversationList.append( convEpochFeats(cur,testUser,X[i][0]))\\n\\t\\t\\t\\tactivityList.append(activityEpochFeats(cur,testUser,X[i][0]))\\n\\t\\t\\t#\\tScreenList.append( screenStatFeatures(cur,testUser,X[i][0],day) )\\n\\t\\t\\t\\taudioList.append(audioEpochFeats(cur,testUser,X[i][0]))\\n\\t\\t\\n\\t\\t\\t\\tif testUser==loso:\\n\\t\\t\\t\\t\\tytest.append(X[i][1])\\n\\t\\t\\t\\t#labels list holds user ids to be used in LeaveOneOut pipeline\\n\\t\\t\\t\\tlabels.append(testUser[-2:])\\n\\t\\t\\t\\tY[i] = X[i][2]\\n\\n\\t\\t\\t\\n\\t\\t\\t#concatenating features in one array \\n\\n\\t\\t\\tXtt = np.concatenate((np.array(activityList),np.array(conversationList),np.array(colocationList),np.array(audioList)),axis=1)\\n\\t\\t\\tprint(Xtt.shape)\\n\\n\\t\\t\\t#initiating and training forest, n_jobs indicates threads, -1 means all available\\n\\t\\t\\t# while the test student is not reached, training data are merged into one big matrix\\n\\t\\t\\tXbig = np.concatenate((Xbig,Xtt),axis=0)\\n\\t\\t\\tYbig = np.concatenate((Ybig,Y),axis=0)\\n\\n\\t\\t\\tdel colocationList[:]\\n\\t\\t\\tdel conversationList[:]\\n\\t\\t\\tdel activityList[:]\\n\\t\\t\\tdel audioList[:]\\n\\n\\n\\n\\t\\t\\tif testUser!=loso:\\n\\t\\t\\t\\tXbig = Xbig.astype(np.float64)\\n\\t\\t\\t\\tprint(Xbig.dtype)\\n\\t\\t\\t\\t\\n\\n\\t\\t\\t# when loso, tests are run\\n\\t\\t\\telif testUser==loso:\\n\\t\\t\\t\\t#Xbig = preprocessing.scale(Xbig)\\n\\t\\t\\t\\tnp.save('numdata/withgps/sleephourlyX.npy',Xbig)\\n\\t\\t\\t\\tnp.save('numdata/withgps/sleephourlyY.npy',Ybig)\\n\\t\\t\\t\\tnp.save('numdata/withgps/sleephourlyLOO.npy',np.array(labels))\\n\\t\\t\\t\\tprint(Xbig.shape[0],Ybig.shape[0],len(labels))\\n\\t\\t\\t\\tprint('train matrix saved')\\n\\t\\t\\t\\ta = raw_input()\\n\\t\\t\\t\\tforest = RandomForestClassifier(n_estimators=100, n_jobs = -1)\\n\\t\\t\\t\\tforest.fit(Xbig,Ybig)\\n\\t\\t\\t\\tef = forest.score(Xtt,ytest)\\n\\t\\t\\t\\tprint(ef*100)\\n\\n\\t\\t\\t\\toutput = np.array(forest.predict(Xtt))\\n\\t\\t\\t\\tscored = output - np.array(ytest)\\n\\n\\t\\t\\t\\t# Counting as correct predictions the ones which fall in +/-1, not only exact\\n\\t\\t\\t\\t# I call it the 'Tolerance technique'\\n\\t\\t\\t\\tcorrect=0\\n\\t\\t\\t\\tc = Counter(scored)\\n\\t\\t\\t\\tfor k in c.keys():\\n\\t\\t\\t\\t\\tif k<2 and k>-2:\\n\\t\\t\\t\\t\\t\\tcorrect += c[k]\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tscore = float(correct)/len(scored)\\n\\t\\t\\t\\tprint(score*100)\\n\\n\\n\\n\\t\\tprint(Xbig.shape)\\n\\t\\n\\t\\t\\n\\n\\n\\nif __name__ == '__main__':\\n\\tmain()\\n\\n\\n\\n\\t\\\"\\\"\\\"\",\n \"def get_wavelength(self):\\n E = -self.E0*(1.0/self.n_low**2 - 1.0/self.n_high**2)\\n return SI['hc']*1e12/(E*SI['keV'])\",\n \"def _compute_noise_level(self, data):\\n noise = max(data)\\n noise_min = 2600\\n noise_max = 4095\\n ratio = (noise - noise_min)/(noise_max - noise_min)\\n return int(ratio*100)\",\n \"def get_sampled_timesteps(self) -> int:\\n return self.sampled_timesteps\",\n \"def speedx(self, sound_array, factor): # http://zulko.github.io/blog/2014/03/29/soundstretching-and-pitch-shifting-in-python/\\n indices = np.round(np.arange(0, len(sound_array), factor))\\n indices = indices[indices < len(sound_array)].astype(int)\\n return sound_array[indices.astype(int)]\",\n \"def calc_spectra(stream, data_type):\\n \\n import numpy as np\\n from mtspec import mtspec\\n from scipy import interpolate\\n from scipy.stats import binned_statistic \\n\\n # Read in file \\n tr = stream[0]\\n data = tr.data\\n delta = tr.stats.delta\\n samprate = tr.stats.sampling_rate\\n npts = tr.stats.npts\\n \\n # Determine nyquist frequency\\n nyquist = 0.5 * samprate\\n \\n\\n # Calc spectra amplitudes and frequencies \\n # Switched number of tapers from 7 to 5. Decreases computation time and\\n # results are similar\\n amp_squared, freq = mtspec(data, delta=delta, time_bandwidth=4, \\n number_of_tapers=5, nfft=npts, quadratic=True)\\n \\n # Convert from power spectra to amplitude spectra\\n amp = np.sqrt(amp_squared)\\n \\n # Use scipy interpolate function to fill in data in missing bins\\n f = interpolate.interp1d(freq, amp)\\n freq_new = np.arange(np.min(freq), np.max(freq), 0.0001)\\n amp_new = f(freq_new)\\n\\n # Remove certain frequencies that are too low or high. \\n indexes = []\\n \\n for i, val in enumerate(freq_new):\\n \\n # Remove frequencies below 1/2 length of record\\n if val <= 1/(delta*npts*0.5) :\\n indexes.append(i)\\n \\n # Remove frequencies above 10 Hz for sm data because of the way it was processed \\n elif val > 10 and data_type == 'sm':\\n indexes.append(i)\\n\\n # Remove frequencies above nyquist frequency for disp data\\n # (it's already removed in the previous step for sm data)\\n elif val > nyquist and data_type == 'disp': \\n indexes.append(i)\\n \\n # Remove any duplicate indexes\\n indexes = np.unique(indexes)\\n freq_new = np.delete(freq_new,indexes)\\n amp_new = np.delete(amp_new,indexes) \\n \\n # Set up bins\\n if data_type == 'sm':\\n # Starting bins at 0.004 Hz (that is about equal to half the length\\n # of the record for the synthetic and observed data) and ending at\\n # 10 Hz because after that the sm data is unusable due to how it was\\n # processed. \\n bins = np.logspace(np.log10(0.004), np.log10(10), num=21)\\n \\n elif data_type == 'disp':\\n # Starting bins at 0.004 Hz (that is about equal to half the length\\n # of the record for the synthetic and observed data) and ending at\\n # 0.5 Hz because that is the nyquist frequency .\\n bins = np.logspace(np.log10(0.004), np.log10(0.5), num=21)\\n \\n bin_means, bin_edges, binnumber = binned_statistic(freq_new,\\n amp_new,\\n statistic='mean',\\n bins=bins)\\n \\n # for i in range(len(bin_means)):\\n # bin_means[i] = 10**bin_means[i]\\n \\n \\n return(bin_means, freq, amp)\",\n \"def _frequency_to_wavelength(freq):\\n return ifc.SPEED_OF_LIGHT_METRES_PER_SECOND / freq\",\n \"def standardize_samples_for_speakers(source_df, speakers_duration, n_samples_min, verbose=True):\\n speakers_duration = speakers_duration.loc[speakers_duration.n_samples >= n_samples_min]\\n if verbose:\\n print(f\\\"{len(speakers_duration)} speakers remain\\\")\\n\\n # get the samples > n_seconds for the remaining speakers\\n samples_remaining_speakers = pd.merge(source_df, speakers_duration, on=\\\"speaker_id\\\")\\n # sort the samples by speakers and duration\\n samples_remaining_speakers = samples_remaining_speakers.sort_values(['speaker_id', 'seconds_x'], ascending=[True, True])\\n if verbose:\\n print(f\\\"{len(samples_remaining_speakers.loc[samples_remaining_speakers['dataset_name_x'] == 'LibriSpeech'])} samples remain in LibriSpeech\\\")\\n print(f\\\"{len(samples_remaining_speakers.loc[samples_remaining_speakers['dataset_name_x'] == 'sitw'])} samples remain in sitw\\\")\\n print(f\\\"{len(samples_remaining_speakers.loc[samples_remaining_speakers['dataset_name_x'] == 'CommonVoice'])} samples remain in CommonVoice\\\")\\n print(f\\\"{len(samples_remaining_speakers.loc[samples_remaining_speakers['dataset_name_x'] == 'TCOF'])} samples remain in TCOF\\\")\\n return samples_remaining_speakers, speakers_duration\",\n \"def audio_resample(self, data):\\n\\n data = np.asarray(data)\\n if data.ndim <= 1:\\n logging.log_first_n(logging.INFO,\\n 'Converting %s sound from shape %s to 2-D' %\\n (self._name, data.shape), 5)\\n data = np.reshape(data, (-1, 1))\\n if data.shape[1] > data.shape[0]:\\n logging.log_first_n(logging.INFO,\\n 'Transposing %s sound from shape %s' %\\n (self._name, data.shape), 5)\\n data = np.transpose(data)\\n\\n # Get half window size in seconds.\\n half_window_size = 0.5 * self._window / self._fs_out\\n\\n # Concatenate and update buffer.\\n if self._buff is not None:\\n data = np.concatenate((self._buff, data), axis=0)\\n tau = self._buff.shape[0]\\n else:\\n tau = 0\\n self._buff = data[-int(self._fs_in * half_window_size):, :]\\n\\n # Get i/o data dimensions.\\n frames_in = data.shape[0]\\n frames_out = int(round((frames_in - tau) / self._fs_in * self._fs_out))\\n\\n # Resample data via moving average.\\n data_out = np.zeros((frames_out, data.shape[1]))\\n if self._fs_out < self._fs_in or self._window > 1:\\n for i in range(frames_out):\\n t = float(i) / self._fs_out # center of window in seconds\\n t1 = int(max(0, round(self._fs_in * (t - half_window_size)) + tau))\\n t2 = int(min(frames_in,\\n round(self._fs_in * (t + half_window_size)) + tau))\\n data_out[i, :] = np.mean(data[t1:t2, :], axis=0)\\n\\n else:\\n\\n data_out = data\\n\\n return data_out\",\n \"def warm_region_cal(audio_samples, fs):\\n #window the audio\\n windowed_samples = timbral_util.window_audio(audio_samples)\\n\\n # need to define a function for the roughness stimuli, emphasising the 20 - 40 region (of the bark scale)\\n min_bark_band = 10\\n max_bark_band = 40\\n mean_bark_band = (min_bark_band + max_bark_band) / 2.0\\n array = np.arange(min_bark_band, max_bark_band)\\n x = timbral_util.normal_dist(array, theta=0.01, mean=mean_bark_band)\\n x -= np.min(x)\\n x /= np.max(x)\\n\\n wr_array = np.zeros(240)\\n wr_array[min_bark_band:max_bark_band] = x\\n\\n # need to define a second array emphasising the 20 - 40 region (of the bark scale)\\n min_bark_band = 80\\n max_bark_band = 240\\n mean_bark_band = (min_bark_band + max_bark_band) / 2.0\\n array = np.arange(min_bark_band, max_bark_band)\\n x = timbral_util.normal_dist(array, theta=0.01, mean=mean_bark_band)\\n x -= np.min(x)\\n x /= np.max(x)\\n\\n hf_array = np.zeros(240)\\n hf_array[min_bark_band:max_bark_band] = x\\n\\n windowed_loud_spec = []\\n windowed_rms = []\\n\\n wr_vals = []\\n hf_vals = []\\n\\n for i in range(windowed_samples.shape[0]):\\n samples = windowed_samples[i, :]\\n N_entire, N_single = timbral_util.specific_loudness(samples, Pref=100.0, fs=fs, Mod=0)\\n\\n # append the loudness spec\\n windowed_loud_spec.append(N_single)\\n windowed_rms.append(np.sqrt(np.mean(samples * samples)))\\n\\n wr_vals.append(np.sum(wr_array * N_single))\\n hf_vals.append(np.sum(hf_array * N_single))\\n\\n mean_wr = np.mean(wr_vals)\\n mean_hf = np.mean(hf_vals)\\n weighted_wr = np.average(wr_vals, weights=windowed_rms)\\n weighted_hf = np.average(hf_vals, weights=windowed_rms)\\n\\n return mean_wr, weighted_wr, mean_hf, weighted_hf\",\n \"def filesample(filename):\\n sampling_rate, samples = wavfile.read(filename)\\n times = np.arange(len(samples)) / sampling_rate\\n return samples, sampling_rate\",\n \"def measure_wavelength_avg(self, from_time, to_time, print_n=False):\\n from_idx = self._find_index_for_time(from_time)\\n to_idx = self._find_index_for_time(to_time)\\n \\n # print number of measurements\\n if print_n:\\n n_measurements = to_idx - from_idx + 1\\n print 'n measurements:', n_measurements\\n \\n # calculate overlap\\n overlap = self.overlap()[from_idx:to_idx+1,:]\\n \\n # intitialize wavelength storage\\n wavelengths = np.zeros(overlap.shape[0])\\n \\n for i in range(overlap.shape[0]):\\n this_overlap = overlap[i,:]\\n \\n # set all overlap entries below 0.1% of the maximum overlap to zero\\n this_overlap[this_overlap<0.001*np.max(this_overlap)] = 0.0\\n \\n nonzero = np.nonzero(this_overlap)\\n \\n # find connected section of chain with nonzero overlap\\n consecutives = np.split(nonzero, np.where(np.diff(nonzero) != 1)[0]+1)\\n \\n if len(consecutives) != 1:\\n warnings.warn('Wavelength could not be determined unambiguously.')\\n return np.nan\\n else:\\n # add 1 since overlap involves two beads each\\n wavelengths[i] = float( len(consecutives[0][0]) ) + 1\\n \\n return np.mean( wavelengths )\",\n \"def get_samples_per_signal(self):\\n return np.array([self.samples_in_file(chn) for chn in range(self.signals_in_file)])\",\n \"def silence(self):\\n return self._replace(velocity=0.)\",\n \"def peakRecognition(y, sg_window, threshold):\\n\\n corrected_sg2 = savgol_filter(\\n y, window_length=sg_window, polyorder=3, deriv=2)\\n\\n peaks_all = []\\n\\n for row in corrected_sg2:\\n peaks = argrelmin(row)[0]\\n peaks = [peak for peak in peaks if row[peak] < -threshold] # Remove peaks below threshold\\n\\n # Combine peaks w/o positive 2nd derivative between them\\n peak_condensing = []\\n peaks_condensed = []\\n for j in range(len(row)):\\n if j in peaks:\\n peak_condensing.append(j)\\n if row[j] > 0 and len(peak_condensing) > 0:\\n peaks_condensed.append(int(np.mean(peak_condensing)))\\n peak_condensing = []\\n if len(peak_condensing) > 0:\\n peaks_condensed.append(int(np.mean(peak_condensing)))\\n\\n peaks_all.append(peaks_condensed)\\n bar3.update(bar3.value + 1)\\n\\n return peaks_all\",\n \"def calc_dur(mld, threshold):\\n dur = 0\\n durmax = 0\\n for i in range(len(mld)):\\n if np.abs(mld[i]) < threshold:\\n dur+=1\\n else:\\n if dur>durmax:\\n durmax=dur \\n dur=0\\n return np.max([dur,durmax])\",\n \"def clip(wavelength, spectra, threshold, substitute=None):\\n\\n if substitute == None: # remove threshold violations\\n mask = np.any(spectra > threshold, axis=1)\\n spectra = spectra[~mask, :]\\n wavelength = wavelength[~mask]\\n else: # substitute threshold violations with a value\\n spectra[spectra > threshold] = substitute\\n return wavelength, spectra\\n\\n return wavelength, spectra\",\n \"def duration(self):\\n return self.sound.nframes\",\n \"def estimate_pulse_time(self, f=0.75):\\n idxs = np.abs(self.flux) > f * self.max_flux\\n return np.mean(self.time[idxs])\",\n \"def sp_audio_pipeline(wav):\\n sig = sb.dataio.dataio.read_audio(wav)\\n sig = sig.unsqueeze(0)\\n sig = hparams[\\\"speed_perturb\\\"](sig)\\n sig = sig.squeeze(0)\\n return sig\",\n \"def mix_in_audio_sample(track_data, track_offset, sample_data, sample_offset,\\n clip_duration, sample_volume, ramp_in, ramp_out):\\n ramp_out_index = clip_duration - ramp_out\\n track_end = min(track_offset + clip_duration, track_data.shape[0])\\n track_end = min(track_end,\\n track_offset + (sample_data.shape[0] - sample_offset))\\n sample_range = track_end - track_offset\\n for i in range(sample_range):\\n if i < ramp_in:\\n envelope_scale = i / ramp_in\\n elif i > ramp_out_index:\\n envelope_scale = (clip_duration - i) / ramp_out\\n else:\\n envelope_scale = 1\\n sample_input = sample_data[sample_offset + i]\\n track_data[track_offset\\n + i] += sample_input * envelope_scale * sample_volume\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7811607","0.7448463","0.6895357","0.6664065","0.6417837","0.6375742","0.6263973","0.61554515","0.6127289","0.60519105","0.60171616","0.5937067","0.5910318","0.5892728","0.58905584","0.5843424","0.58425045","0.5808453","0.57665783","0.5759342","0.57378775","0.5722452","0.56557935","0.56487143","0.56326514","0.5627053","0.5608545","0.5589628","0.55816114","0.55515337","0.5523653","0.5475721","0.547328","0.54496133","0.54458165","0.5423756","0.54192334","0.54108334","0.54083383","0.536651","0.5366032","0.5354383","0.5347404","0.53341174","0.5330366","0.532764","0.53185964","0.5312305","0.530155","0.5290813","0.52704334","0.5266224","0.52633613","0.5260763","0.52565277","0.5253922","0.52490526","0.52474356","0.523403","0.5226085","0.5218949","0.52038807","0.5199998","0.51988626","0.5190761","0.5183309","0.51816547","0.51796705","0.51718724","0.51641685","0.5163859","0.5160769","0.51586246","0.5149331","0.51469415","0.51443344","0.51400673","0.5135204","0.51339835","0.5133169","0.5123317","0.5106125","0.51058215","0.5105051","0.510151","0.5094277","0.5087108","0.5086567","0.50858825","0.50837976","0.50825393","0.50751734","0.5060701","0.50599056","0.50523597","0.5051391","0.50512284","0.50410557","0.5038423","0.5034951"],"string":"[\n \"0.7811607\",\n \"0.7448463\",\n \"0.6895357\",\n \"0.6664065\",\n \"0.6417837\",\n \"0.6375742\",\n \"0.6263973\",\n \"0.61554515\",\n \"0.6127289\",\n \"0.60519105\",\n \"0.60171616\",\n \"0.5937067\",\n \"0.5910318\",\n \"0.5892728\",\n \"0.58905584\",\n \"0.5843424\",\n \"0.58425045\",\n \"0.5808453\",\n \"0.57665783\",\n \"0.5759342\",\n \"0.57378775\",\n \"0.5722452\",\n \"0.56557935\",\n \"0.56487143\",\n \"0.56326514\",\n \"0.5627053\",\n \"0.5608545\",\n \"0.5589628\",\n \"0.55816114\",\n \"0.55515337\",\n \"0.5523653\",\n \"0.5475721\",\n \"0.547328\",\n \"0.54496133\",\n \"0.54458165\",\n \"0.5423756\",\n \"0.54192334\",\n \"0.54108334\",\n \"0.54083383\",\n \"0.536651\",\n \"0.5366032\",\n \"0.5354383\",\n \"0.5347404\",\n \"0.53341174\",\n \"0.5330366\",\n \"0.532764\",\n \"0.53185964\",\n \"0.5312305\",\n \"0.530155\",\n \"0.5290813\",\n \"0.52704334\",\n \"0.5266224\",\n \"0.52633613\",\n \"0.5260763\",\n \"0.52565277\",\n \"0.5253922\",\n \"0.52490526\",\n \"0.52474356\",\n \"0.523403\",\n \"0.5226085\",\n \"0.5218949\",\n \"0.52038807\",\n \"0.5199998\",\n \"0.51988626\",\n \"0.5190761\",\n \"0.5183309\",\n \"0.51816547\",\n \"0.51796705\",\n \"0.51718724\",\n \"0.51641685\",\n \"0.5163859\",\n \"0.5160769\",\n \"0.51586246\",\n \"0.5149331\",\n \"0.51469415\",\n \"0.51443344\",\n \"0.51400673\",\n \"0.5135204\",\n \"0.51339835\",\n \"0.5133169\",\n \"0.5123317\",\n \"0.5106125\",\n \"0.51058215\",\n \"0.5105051\",\n \"0.510151\",\n \"0.5094277\",\n \"0.5087108\",\n \"0.5086567\",\n \"0.50858825\",\n \"0.50837976\",\n \"0.50825393\",\n \"0.50751734\",\n \"0.5060701\",\n \"0.50599056\",\n \"0.50523597\",\n \"0.5051391\",\n \"0.50512284\",\n \"0.50410557\",\n \"0.5038423\",\n \"0.5034951\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6908193"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":8777,"cells":{"query":{"kind":"string","value":"Wrapper to run Praat 'To Textgrid (silences)' function."},"document":{"kind":"string","value":"def detect_silences(sound, sil_threshold, sil_duration):\n textgrid = call(sound, 'To TextGrid (silences)', 100, 0.0, sil_threshold, sil_duration, 0.1, 'silence', 'speech')\n\n return textgrid"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def __init__ (self,win,text='Press a key to continue',**kwargs):\n\n self.win = win\n \n self.text = visual.TextStim(win,text=text,**kwargs)","def __init__ (self,win,text='Press a key to continue',**kwargs):\n\n self.win = win\n \n self.text = visual.TextStim(win,text=text,**kwargs)","def make_silence_phones_txt(self):\n raise NotImplementedError","def preprocess(text):\n text = remove_space(text)\n text = clean_special_punctuations(text)\n text = handle_emojis(text)\n text = clean_number(text)\n text = spacing_punctuation(text)\n text = clean_repeat_words(text)\n text = remove_space(text)\n #text = stop(text)# if changing this, then chnage the dims \n #(not to be done yet as its effecting the embeddings..,we might be\n #loosing words)...\n return text","def wrapper(scr, text: list):\n\n display = Display(scr, text)\n display.run()","async def translate(context, arguments, style):\n large_font_spaces = 5\n small_font_spaces = int(27 / 40 * large_font_spaces)\n large_font = True\n\n text = arguments[0]\n runes = \"\"\n\n rune_count = 0\n for i, char in enumerate(text.lower()):\n if char in default_values.RUNES[style]:\n runes += default_values.RUNES[style][char]\n rune_count += 1\n elif char in default_values.RUNES[\"archaic\"]:\n runes += default_values.RUNES[\"archaic\"][char]\n rune_count += 1\n else:\n runes += text[i]\n if char != \" \":\n large_font = False\n\n if not context.desktop_ui or not large_font or rune_count > 27:\n runes = runes.replace(\" \", \" \" * small_font_spaces)\n else:\n runes = runes.replace(\" \", \" \" * large_font_spaces)\n\n await context.message.channel.send(runes)\n return True","def do(text):\n return freeling_stemming(text)","def cut_item_texts(self, arrays=None):\n if not arrays: arrays = self.masks()\n for a in arrays:\n for item in self.sources(a):\n i = self._meta['columns'][item]\n for tk in self.valid_tks:\n text = self.text(item, True, tk)\n if text: i['text'][tk] = text\n for ed in ['x', 'y']:\n if i['text'].get('{} edits'.format(ed)):\n for tk in self.valid_tks:\n text = self.text(item, True, tk, ed)\n if text: i['text']['{} edits'.format(ed)][tk] = text\n return None","def apply(self, text):","def text(text = 'abcd', size = 10, justify = 'left', layer = 0, font = \"DEPLOF\"):\n t = Device('text')\n xoffset = 0\n yoffset = 0\n\n face = font\n if face == \"DEPLOF\":\n scaling = size/1000\n\n for line in text.split('\\n'):\n l = Device(name = 'textline')\n for c in line:\n ascii_val = ord(c)\n if c == ' ':\n xoffset += 500*scaling\n elif (33 <= ascii_val <= 126) or (ascii_val == 181):\n for poly in _glyph[ascii_val]:\n xpts = np.array(poly)[:, 0]*scaling\n ypts = np.array(poly)[:, 1]*scaling\n l.add_polygon([xpts + xoffset, ypts + yoffset],\n layer = layer)\n xoffset += (_width[ascii_val] + _indent[ascii_val])*scaling\n else:\n valid_chars = '!\"#$%&\\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\\\]^_`abcdefghijklmnopqrstuvwxyz{|}~µ'\n warnings.warn('[PHIDL] text(): Warning, some characters ignored, no geometry for character \"%s\" with ascii value %s. ' \\\n 'Valid characters: %s' % (chr(ascii_val), ascii_val, valid_chars))\n t.add_ref(l)\n yoffset -= 1500*scaling\n xoffset = 0\n else:\n from .font import _get_font_by_name, _get_font_by_file, _get_glyph\n\n # Load the font\n # If we've passed a valid file, try to load that, otherwise search system fonts\n font = None\n if (face.endswith(\".otf\") or face.endswith(\".ttf\")) and os.path.exists(face):\n font = _get_font_by_file(face)\n else:\n try:\n font = _get_font_by_name(face)\n except ValueError:\n pass\n if font is None:\n raise ValueError(('[PHIDL] Failed to find font: \"%s\". ' +\n 'Try specifying the exact (full) path to the .ttf or .otf file. ' +\n 'Otherwise, it might be resolved by rebuilding the matplotlib font cache') % (face))\n\n # Render each character\n for line in text.split('\\n'):\n l = Device('textline')\n xoffset = 0\n for letter in line:\n letter_dev = Device(\"letter\")\n letter_template, advance_x = _get_glyph(font, letter)\n for poly in letter_template.polygons:\n letter_dev.add_polygon(poly.polygons, layer=layer)\n ref = l.add_ref(letter_dev)\n ref.move(destination=(xoffset, 0))\n ref.magnification = size\n xoffset += size*advance_x\n\n ref = t.add_ref(l)\n ref.move(destination=(0, yoffset))\n yoffset -= size\n\n justify = justify.lower()\n for l in t.references:\n if justify == 'left': pass\n if justify == 'right': l.xmax = 0\n if justify == 'center': l.move(origin = l.center,\n destination = (0, 0), axis = 'x')\n\n t.flatten()\n return t","def obtain_text():\n pass","async def aesthetic(self, ctx, *, text):\n out = \"\"\n for char in text:\n out += utils.fullwidth_transform.get(char, char)\n await ctx.send(out)","def FlashyText(win,center,text,timing):\n winner = Text(center,text)\n winner.setFace(\"arial\")\n winner.setFill(\"black\")\n winner.setSize(30)\n for i in range(1,6):\n time.sleep(timing)\n if i % 2 == 0:\n winner.draw(win)\n else:\n winner.undraw()","async def outline_text(draw_surface, coords, draw_text, font):\n draw = partial(draw_surface.text, text=draw_text, font=font,\n fill=\"black\")\n for offset_pair in product(range(-1, 2), repeat=2):\n draw((coords[0]+offset_pair[0], coords[1]+offset_pair[1]))\n draw(coords, fill=\"white\")","def args_batch_to_text(args_batch: ArgsBatch) -> Text:\n lines = []\n for args in args_batch:\n lines.append('; '.join(str(a) for a in args))\n return '\\n'.join(lines)","def setText(*args):","def draw_text(self, text, i, j, **params):","def preprocess(self, text):\r\n return text","def rich(text):\n return full(text, False)","def mytext(x,y,s,**kwargs):\n # we take care of this one\n model = kwargs.pop('model', None)\n if model:\n th = text(x,y,model,**kwargs)\n draw()\n x0,y0,w,h = th.get_window_extent().bounds\n gca().texts.remove(th)\n x = x0\n y = y0\n kwargs['transform'] = matplotlib.transforms.IdentityTransform()\n kwargs['horizontalalignment'] = 'left'\n kwargs['verticalalignment'] = 'baseline'\n# print x,y,kwargs\n return text(x,y,s,**kwargs)","def get_text(downgrade_titles=False):","def text_grid(self, text, clear_screen=True, x=0, y=0, text_color='black', font=None):\n\n assert 0 <= x < Display.GRID_COLUMNS,\\\n \"grid columns must be between 0 and %d, %d was requested\" %\\\n ((Display.GRID_COLUMNS - 1, x))\n\n assert 0 <= y < Display.GRID_ROWS,\\\n \"grid rows must be between 0 and %d, %d was requested\" %\\\n ((Display.GRID_ROWS - 1), y)\n\n return self.text_pixels(text, clear_screen, x * Display.GRID_COLUMN_PIXELS, y * Display.GRID_ROW_PIXELS,\n text_color, font)","def format_text(text: TTextType) -> typing.Iterator[TViewLine]:\n for line in text.splitlines():\n yield [(\"text\", line)]","def preprocess_text(self, seq):\n if self.text_preprocess_fn:\n seq = list(map(self.text_preprocess_fn, seq))\n return seq","def textile(text, **kwargs):\n from django.contrib.markup.templatetags.markup import textile\n return textile(text)","def basic(text):\n lines = text.split(\"\\n\")\n result = []\n\n for line in lines:\n result.append(_inline(line))\n\n return \"\\n\".join(result)","def getKernels(indices):\n\n\t\t\ti = indices[0]\n\t\t\tj = indices[1]\n\n\t\t\th = i - self.scope\n\t\t\tk = j + self.scope\n\n\t\t\tif h < 0: h = 0\n\t\t\tif k > len(text): k = len(text)-1\n\n\t\t\treturn text[h:i].replace(\"\\n\", \"__\").replace(\"\\t\", \" \"), text[i:j].replace(\"\\n\", \"__\").replace(\"\\t\", \" \"), text[j:k].replace(\"\\n\", \"__\").replace(\"\\t\", \" \")\n\t\t\t#return \"|\"+text[h:i].replace(\"\\n\", \"__\").replace(\"\\t\", \" \")+\"|\", text[i:j].replace(\"\\n\", \"__\").replace(\"\\t\", \" \"), \"|\"+text[j:k].replace(\"\\n\", \"__\").replace(\"\\t\", \" \")+\"|\"","def textCurves(*args, font: AnyStr=\"\", name: AnyStr=\"\", object: bool=True, text: AnyStr=\"\",\n q=True, query=True, e=True, edit=True, **kwargs)->Union[List[AnyStr], Any]:\n pass","def generate(self, path, language, textgrid):\n activations = []\n self.model.eval()\n iterator = tokenize(path, language, path_like=True, train=False)\n if self.generation == 'bucket':\n # Here, we give as input the text line by line.\n for line in iterator:\n line = line.strip() # Remove trailing characters\n\n line = '[CLS] ' + line + ' [SEP]'\n tokenized_text = self.tokenizer.wordpiece_tokenizer.tokenize(line)\n indexed_tokens = self.tokenizer.convert_tokens_to_ids(tokenized_text)\n segment_ids = [1 for x in tokenized_text]\n mapping = utils.match_tokenized_to_untokenized(tokenized_text, line)\n\n # Convert inputs to PyTorch tensors\n tokens_tensor = torch.tensor([indexed_tokens])\n segments_tensors = torch.tensor([segment_ids])\n\n with torch.no_grad():\n encoded_layers = self.model(tokens_tensor, segments_tensors) # last_hidden_state, pooled_last_hidden_states, all_hidden_states\n # filtration\n encoded_layers = np.vstack(encoded_layers[2][1:]) # retrieve all the hidden states (dimension = layer_count * len(tokenized_text) * feature_count)\n encoded_layers = encoded_layers[self.loi, :, :]\n activations += utils.extract_activations_from_tokenized(encoded_layers, mapping)\n elif self.generation == 'sequential':\n # Here we give as input the sentence up to the actual word, incrementing by one at each step.\n for line in iterator:\n for index in range(1, len(line.split())):\n tmp_line = \" \".join(line.split()[:index])\n tmp_line = tmp_line.strip() # Remove trailing characters\n\n tmp_line = '[CLS] ' + tmp_line + ' [SEP]'\n tokenized_text = self.tokenizer.wordpiece_tokenizer.tokenize(tmp_line)\n indexed_tokens = self.tokenizer.convert_tokens_to_ids(tokenized_text)\n segment_ids = [1 for x in tokenized_text]\n mapping = utils.match_tokenized_to_untokenized(tokenized_text, line)\n\n # Convert inputs to PyTorch tensors\n tokens_tensor = torch.tensor([indexed_tokens])\n segments_tensors = torch.tensor([segment_ids])\n\n with torch.no_grad():\n encoded_layers = self.model(tokens_tensor, segments_tensors) # dimension = layer_count * len(tokenized_text) * feature_count\n # filtration\n encoded_layers = np.vstack(encoded_layers[2][1:])\n encoded_layers = encoded_layers[self.loi, :, :]\n activations.append(utils.extract_activations_from_tokenized(encoded_layers, mapping)[-1])\n result = pd.DataFrame(np.vstack(activations), columns=['layer-{}-{}'.format(layer, index) for layer in self.loi for index in range(self.FEATURE_COUNT)])\n return result","def tokenize(self, text, **kwargs):\n if self.opt['tracker'] == 'babi6':\n text = babi6_dirty_fix(text)\n text = text.replace('<SILENCE>', '_SILENCE_')\n\n return [t.text for t in NLP.tokenizer(text)]","def draw(text: list):\n\n curses.wrapper(wrapper, text)","def text_plot(self):\n if self.stext is not None:\n # Create text object :\n self.stextmesh = visu.Text(text=self.stext, color=self.stextcolor,\n font_size=self.stextsize, pos=self.xyz,\n bold=True, name='SourcesText')\n\n # Set text texture :\n self.stextmesh.set_gl_state('translucent', depth_test=True)\n\n # Apply a transformation to text elements to not cover sources :\n self.stextmesh.transform = vist.STTransform(\n translate=self.stextshift)\n else:\n self.stextmesh = visu.Text(name='NoneText')","def graphtextdetextor(image_path):\n img=cv2.imread(image_path)\n\n #img=image_filter.rotate_anticlockwise(img)\n\n\n custom_config_number=r'--oem 3 --psm 6 outputbase digits'\n custom_config=r'--oem 3 --psm 6'\n\n custom_config1=r'--oem 3 --psm 1'\n\n custom_config2=r'--oem 3 --psm 4'\n\n text=pytesseract.image_to_string(img,config=custom_config)\n text2=pytesseract.image_to_string(img,config=custom_config1)\n text3=pytesseract.image_to_string(img,config=custom_config2)\n\n\n\n d=pytesseract.image_to_data(img,config=custom_config,output_type=Output.DICT)\n\n #print(text3)\n return [text,text2,text3]","def Execute_text( canvas, Fill, column, line, high, wide, linebuffer ):\n global textitem # cache\n # new text over writing old\n if(column==2 and len(linebuffer)>1):\n key = \"T {}.{}\".format(3,line)\n try:\n item = textitem[key]\n canvas.delete(item)\n del textitem[key]\n # pdb.set_trace()\n except KeyError:\n pass\n \n (x00,y00) = (10,10)\n x0 = column * (6,12)[wide]\n key = \"T {}.{}\".format(column,line)\n remark=\"\"\n try:\n item = textitem[key] \n if canvas.itemcget(item,'text')==linebuffer :\n remark = \"repeat\"\n pass # ignore exact repetitions\n else:\n canvas.itemconfigure( item, text=linebuffer )\n remark = f\"at {key} old item {item} update text '{linebuffer}'\"\n except KeyError:\n textitem[key] = canvas.create_text(\n (x00+ x0)*2,\n (y00+line)*2,\n text=linebuffer,\n font=DDD_Font[(1,2)[high]],\n fill=Fill,\n anchor=\"nw\",\n tags = canvas.tag )\n remark = f\"at {key} NEW text item '{linebuffer}'\"\n if remark: print(\" \"*13 + remark )","def show_text(text, args):\n return expyriment.stimuli.TextLine(text,\n text_font=args[\"--text-font\"],\n text_size=args[\"--text-size\"],\n text_colour=args[\"stimuli_color\"],\n background_colour=args[\"bg_color\"])","def _setText(self, text):\n self.text = \"\"\n for ch in text:\n char, vertices, glyph = self._extractGlyph(ch)\n if not vertices is None and self.glyphs in (\n GlyphTypes.BASE, GlyphTypes.LAYER_COLOR):\n vertices['rgba'] = glm.vec4(self.color)\n if not self.text:\n off, kern = self._updateMetric(0, char)\n if char in self.NO_GLYPH_CHARS:\n self.colors.append([char, None])\n else:\n vertices['vtx'] += off + glyph['offset']\n self.allVertices = np.hstack(vertices)\n self.allIndices = self._baseInd\n self.colors.append([char, self.color])\n self.text += char\n else:\n pos = len(self.text)\n nonGlyph = countInSet(self.text, self.NO_GLYPH_CHARS)\n # Set the metric\n off, kern = self._updateMetric(pos, char)\n if char in self.NO_GLYPH_CHARS:\n self.colors.append([char, None])\n else:\n vertices['vtx'] += off + kern + glyph['offset']\n if self.allVertices is None:\n self.allVertices = np.hstack(vertices)\n else:\n self.allVertices = np.append(self.allVertices,\n vertices)\n if self.allIndices is None:\n self.allIndices = self._baseInd\n else:\n self.allIndices = np.vstack((self.allIndices,\n self._baseInd + (pos - nonGlyph) * 4))\n self.colors.append([char, self.color])\n self.text += char\n self.setUniforms()","def render_text_on_surface(text, surface, font, color=BLACK, top_padding=0, left_pading=0):\n rect = surface.get_rect()\n \n last_top = rect.top + top_padding\n for index, line in enumerate(text.split(\"\\n\")):\n text_surf = font.render(line, True, color)\n text_rect = text_surf.get_rect()\n text_rect.topleft = (rect.left + left_pading, last_top)\n surface.blit(text_surf, text_rect)\n \n last_top += text_rect.h","def write(self, text):\n text = open(text, 'w')\n text.write('File type = \"ooTextFile\"\\n')\n text.write('Object class = \"TextGrid\"\\n\\n')\n text.write('xmin = %f\\n' % self.__xmin)\n text.write('xmax = %f\\n' % self.__xmax)\n text.write('tiers? <exists>\\n')\n text.write('size = %d\\n' % self.__n)\n text.write('item []:\\n')\n for (tier, n) in zip(self.__tiers, range(1, self.__n + 1)):\n text.write('\\titem [%d]:\\n' % n)\n if tier.__class__ == IntervalTier: \n text.write('\\t\\tclass = \"IntervalTier\"\\n')\n text.write('\\t\\tname = \"%s\"\\n' % tier.name())\n text.write('\\t\\txmin = %f\\n' % tier.xmin())\n text.write('\\t\\txmax = %f\\n' % tier.xmax())\n text.write('\\t\\tintervals: size = %d\\n' % len(tier))\n for (interval, o) in zip(tier, range(1, len(tier) + 1)): \n text.write('\\t\\t\\tintervals [%d]:\\n' % o)\n text.write('\\t\\t\\t\\txmin = %f\\n' % interval.xmin())\n text.write('\\t\\t\\t\\txmax = %f\\n' % interval.xmax())\n text.write('\\t\\t\\t\\ttext = \"%s\"\\n' % interval.mark())\n else: # PointTier\n text.write('\\t\\tclass = \"TextTier\"\\n')\n text.write('\\t\\tname = \"%s\"\\n' % tier.name())\n text.write('\\t\\txmin = %f\\n' % tier.xmin())\n text.write('\\t\\txmax = %f\\n' % tier.xmax())\n text.write('\\t\\tpoints: size = %d\\n' % len(tier))\n for (point, o) in zip(tier, range(1, len(tier) + 1)):\n text.write('\\t\\t\\tpoints [%d]:\\n' % o)\n text.write('\\t\\t\\t\\ttime = %f\\n' % point.time())\n text.write('\\t\\t\\t\\tmark = \"%s\"\\n' % point.mark())\n text.close()","def export_textgrids(self, output_directory):\n ali_directory = self.align_directory\n convert_ali_to_textgrids(self.align_config, output_directory, ali_directory, self.dictionary,\n self.corpus, self.corpus.num_jobs, self)\n self.compile_information(ali_directory, output_directory)","def used_tex_func(val):\n return None","def imText(self, text, align=\"left\", \n textSize=None, rotate=None, bgColor=255, fontColor=0, scale=None, \n leading=0.25, txtWidth=None):\n if not textSize:\n textSize = int(self.printerConf['textSize'])\n if not txtWidth:\n txtWidth = self.printerConf['printerWidth']\n font = ImageFont.truetype(self.printerConf['fontFile'], textSize)\n\n def splitList(txtWidth, txtList, font, newlineSplitOnly=False):\n \"\"\"Each str/unicode in txtList equals one line when printet. Split at newlines and furthermore split if a line is too wide.\"\"\"\n # First of search for newlines and split the list if a newline is found\n withoutNewlines = []\n for txt in txtList:\n withoutNewlines.extend(txt.split(\"\\n\"))\n txtList = withoutNewlines\n if newlineSplitOnly:\n return txtList\n\n txtListWrapped = []\n for txt in txtList:\n # If the whole line is too wide, remove words until we are good\n if font.getsize(txt)[0] > txtWidth:\n txtLen = len(txt)\n for i in range(txtLen)[::-1]:\n if font.getsize(txt[:i+1])[0] <= txtWidth:\n whitespaceEtc = [ \" \", \"\\t\", \"-\" ]\n if txt[i] in whitespaceEtc:\n txtSplit = [ txt[:i+1].rstrip(), txt[i+1:] ]\n if font.getsize(txtSplit[1])[0] > txtWidth:\n txtSplit = splitList(txtWidth, txtSplit, font)\n break\n else:\n break\n # If there are no whitespaces etc. then split the word\n elif not any(w in txt[:i+1] for w in whitespaceEtc):\n if font.getsize(txt[:i+1]+\"-\")[0] <= txtWidth:\n txtSplit = [ txt[:i+1].rstrip()+\"-\", txt[i+1:] ]\n if font.getsize(txtSplit[1])[0] > txtWidth:\n txtSplit = splitList(txtWidth, txtSplit, font)\n break\n else:\n break\n else:\n continue\n else:\n txtSplit = [ txt ]\n txtListWrapped.extend(txtSplit)\n return txtListWrapped\n\n # If txtList is a simple string make it a list\n if type(text) is list:\n txtList = text\n else:\n txtList = [ text ]\n # Spacing between lines as a proportion of the width of a danish letter for the current text size.\n leadingDots = int(font.getsize(u\"Å\")[0]*leading)\n if rotate in [ 90, 270 ]:\n # Don't wrap lines based on width when turned 90 or 270 degrees\n txtList = splitList(txtWidth, txtList, font, newlineSplitOnly=True)\n else:\n # Do wordwrapping etc.\n txtList = splitList(txtWidth, txtList, font)\n\n # Determine the size of the resulting text image\n size = [0,0]\n lineHeight = font.getsize(\"a\")[1]\n size = [ 0, ( leadingDots + lineHeight ) * len(txtList) + leadingDots]\n # Find the width\n if rotate is 180:\n # Avoid right alignment of rotated text, if a line is less wide than the paper / printerConf['printerWidth']\n size[0] = self.printerConf['printerWidth']\n else:\n for txt in txtList:\n maxWidth = font.getsize(txt)[0]\n if maxWidth > size[0]:\n size[0] = maxWidth\n # Create the actual image containing the text\n img = Image.new(\"1\",size)\n draw = ImageDraw.Draw(img)\n draw.rectangle((0,0) + img.size,fill=bgColor)\n pointer = [0, 0]\n # For each line..\n for txt in txtList:\n txtPxWidth = font.getsize(txt)[0]\n if align == \"left\":\n pointer[0] = 0\n elif align == \"right\":\n pointer[0] = size[0] - txtPxWidth\n elif align == \"center\":\n pointer[0] = (size[0] - txtPxWidth)/2\n draw.text(pointer, txt, font=font, fill=fontColor)\n pointer[1] += lineHeight + leadingDots\n\n if rotate:\n angles = [0, 90, 180, 270]\n if rotate in angles:\n img = img.rotate(rotate, expand=True)\n else:\n raise ValueError(\"rotate must be part of %s if set \" % str(angles))\n if rotate in [90, 270]:\n if img.size[0] > self.printerConf['printerWidth'] and not scale:\n raise Exception(\"The textSize is too large to print. Use either a smaller textSize or the scale parameter\")\n else:\n if img.size[0] > self.printerConf['printerWidth']:\n raise Exception(\"Could not print the text. One or more lines are too wide. Did you choose a very large font?\")\n\n if align is not \"left\":\n imgOld = img\n img = Image.new(\"1\",(txtWidth,imgOld.size[1]))\n draw = ImageDraw.Draw(img)\n draw.rectangle((0,0) + img.size,fill=bgColor)\n pointer = [0, 0]\n if align is \"center\":\n i = 2\n else:\n i = 1\n img.paste(imgOld,((txtWidth-imgOld.size[0])/i,0))\n return img","def fn(): # fn definition # help2\r\n print(my_text)","def process_text(text):\n text = re.sub(r'<@>\\s+|<s>\\s+|</s>\\s+|<p>\\s+|</p>\\s+|\\s+\\,|\\'s|\\'|\\;|\\(|\\)|\\-\\-\\s+|\\s+\\.', '', text)\n text = re.sub(r'\\.\\,', '. ,', text)\n text = re.sub(r'\\,', '', text)\n text = re.sub(r'\\$', '$ ', text)\n text = re.sub(r'\\%', ' %', text)\n text = re.sub(r'\\s\\\"\\s', ' ', text)\n text = re.sub(r'\\.\\s+', '. ', text)\n text = text.lower()\n return text","def result(target_text):\n\n display_text(target_text)\n readability(target_text)","def text(self, text: str, xo: int, yo: int, color: int):\n for offset, letter in enumerate(text):\n template = font.get(letter)\n for x, line in enumerate(template):\n line_str = '{:08b}'.format(line).replace('0b', '')\n if self.portrait:\n line_str = reversed(line_str)\n for y, pix in enumerate(line_str):\n if pix == '1':\n self.pixel(xo + x + (offset * 8), yo + y, color)","def parse_text(self, text):\r\n MAXLEN = 100\r\n sentences = []\r\n punct = [\",\",\":\",\";\",\".\",\"–\",\"?\",\"!\",\"(\",\")\"] # Interpunctuation marks\r\n text = text.replace(\"\\r\", \" \").replace(\"\\t\", \" \") # Remove CR and tabs\r\n words = text.split(\" \") if len(text) > MAXLEN else []\r\n sentence = \"\" if len(text) > MAXLEN else text\r\n\r\n # Preprocess list for silence markers\r\n if conf.SilenceMarker in text:\r\n words_new = []\r\n if not words and sentence: # Was too short to be cut initially\r\n words = text.split(\" \")\r\n sentence = \"\"\r\n for w in filter(None, words):\r\n if conf.SilenceMarker not in w.lower():\r\n words_new.append(w)\r\n else:\r\n text_chunks = w.lower().split(conf.SilenceMarker)\r\n for i, part in enumerate(text_chunks):\r\n if part:\r\n words_new.append(part)\r\n if i < len(text_chunks) - 1:\r\n words_new.append(conf.SilenceMarker)\r\n else:\r\n if words_new and conf.SilenceMarker in words_new[-1]:\r\n words_new[-1] += conf.SilenceMarker\r\n else:\r\n words_new.append(conf.SilenceMarker)\r\n words = words_new\r\n\r\n for w in words:\r\n if conf.SilenceMarker in w:\r\n if sentence:\r\n sentences.append(sentence.strip())\r\n sentences.append(w)\r\n sentence = \"\"\r\n elif w[-1] in punct or w[0] in punct: # Encountered punctuation\r\n if w[-1] in punct and (len(sentence) + len(w) + 1 < MAXLEN):\r\n # Word ends with punct and sentence can still be added to\r\n sentences.append(sentence.strip() + \" \" + w.strip())\r\n sentence = \"\" # Save sentence and word, start new sentence\r\n elif w[0] in punct and w[-1] not in punct:\r\n # Word starts with punctuation, like '('\r\n sentences.append(sentence.strip()) # Save current sentence\r\n sentence = w # Start a new sentence with punct and word\r\n else: # word ends with punct and sentence already long enough\r\n sentences.extend([sentence.strip(), w.strip()])\r\n sentence = \"\" \r\n else:\r\n if (len(sentence) + len(w) + 1 < MAXLEN): # Sentence still\r\n sentence += \" \" + w # short enough\r\n else: # Sentence too long\r\n sentences.append(sentence.strip())\r\n sentence = w # Start a new sentence with the word\r\n if sentence:\r\n sentences.append(sentence.strip())\r\n return sentences","def run_ocr_in_chart(chart, pad=0, psm=PSM.SINGLE_LINE):\n img = chart.image\n\n # add a padding to the initial figure\n fpad = 1\n img = cv2.copyMakeBorder(img.copy(), fpad, fpad, fpad, fpad, cv2.BORDER_CONSTANT, value=(255, 255, 255))\n fh, fw, _ = img.shape\n\n api = PyTessBaseAPI(psm=psm, lang='eng')\n clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(4, 4))\n\n for tbox in chart.texts:\n # adding a pad to original image. Some case in quartz corpus, the text touch the border.\n x, y, w, h = ru.wrap_rect(u.ttoi(tbox.rect), (fh, fw), padx=pad, pady=pad)\n x, y = x + fpad, y + fpad\n\n if w * h == 0:\n tbox.text = ''\n continue\n\n # crop region of interest\n roi = img[y:y + h, x:x + w]\n # to gray scale\n roi_gray = cv2.cvtColor(roi, cv2.COLOR_BGR2GRAY)\n #\n roi_gray = cv2.resize(roi_gray, None, fx=3, fy=3, interpolation=cv2.INTER_CUBIC)\n # binarization\n _, roi_bw = cv2.threshold(roi_gray, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)\n # removing noise from borders\n roi_bw = 255 - clear_border(255-roi_bw)\n\n # roi_gray = cv2.copyMakeBorder(roi_gray, 5, 5, 5, 5, cv2.BORDER_CONSTANT, value=255)\n\n # when testing boxes from csv files\n if tbox.num_comp == 0:\n # Apply Contrast Limited Adaptive Histogram Equalization\n roi_gray2 = clahe.apply(roi_gray)\n _, roi_bw2 = cv2.threshold(roi_gray2, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)\n _, num_comp = morphology.label(roi_bw2, return_num=True, background=255)\n tbox.regions.extend(range(num_comp))\n\n pil_img = smp.toimage(roi_bw)\n if SHOW:\n pil_img.show()\n max_conf = -np.inf\n min_dist = np.inf\n correct_text = ''\n correct_angle = 0\n u.log('---------------')\n for angle in [0, -90, 90]:\n rot_img = pil_img.rotate(angle, expand=1)\n\n api.SetImage(rot_img)\n conf = api.MeanTextConf()\n text = api.GetUTF8Text().strip()\n dist = abs(len(text.replace(' ', '')) - tbox.num_comp)\n\n u.log('text: %s conf: %f dist: %d' % (text, conf, dist))\n if conf > max_conf and dist <= min_dist:\n max_conf = conf\n correct_text = text\n correct_angle = angle\n min_dist = dist\n\n tbox.text = post_process_text(lossy_unicode_to_ascii(correct_text))\n tbox.text_conf = max_conf\n tbox.text_dist = min_dist\n tbox.text_angle = correct_angle\n\n u.log('num comp %d' % tbox.num_comp)\n u.log(u'** text: {} conf: {} angle: {}'.format(correct_text, max_conf, correct_angle))\n\n api.End()\n\n # return boxes","def bert_preprocess(raw_text):\n nlp = English()\n nlp.add_pipe(nlp.create_pipe('sentencizer')) # updated\n doc = nlp(raw_text)\n sentences = [sent.string.strip() for sent in doc.sents][0:2] \n new_sentences = []\n for i, sentence in enumerate(sentences):\n if i==0:\n new_sentences.append(\"[CLS] \" + sentence + \" [SEP]\")\n else:\n new_sentences.append(sentence + \" [SEP]\")\n \n preprocessed_text = ' '.join(new_sentences)\n \n if \"[CLS]\" not in preprocessed_text:\n raise Exception(\"[CLS] not found in preprocessed text\")\n if \"[SEP]\" not in preprocessed_text:\n raise Exception(\"[SEP] not found in preprocessed text\")\n \n return","def sliptText(text):\n\treturn [char for char in text]","def edit_google_vision_text(self,text):\n s1=text\n try:\n log_info(\"Correcting google vision text to remove extra spacing\",MODULE_CONTEXT)\n i=0\n while(i<len(text)):\n s1=text\n if text[i] in [\"/\",\"।\",'।' ,':','|',\",\" ,'०',\"]\",\"-\",\")\",\"}\"] and text[i-1]==\" \": \n text=text[:i-1]+text[i:]\n if i > 0 :\n if text[i-1] in [\"-\",\"[\",\"{\",\"/\",\"(\"] and text[i]==\" \":\n text=text[:i]+text[i+1:]\n elif text[i] in [\"-\",\"[\",\"{\",\"/\",\"(\"] and text[i+1]==\" \":\n text=text[:i+1]+text[i+2:]\n i=i+1\n except Exception as e:\n log_exception(\"Exception while correcting google vision text\", MODULE_CONTEXT, e)\n return s1\n return text","def stats_text(test):\n\n stats_text_en(test) \n \n stats_text_cn(test)","def text_standardization(text_in):\n stand_text = text_in.strip()\n stand_text = ' '.join(stand_text.split())\n stand_text = stand_text.replace(u'(', u'（')\n stand_text = stand_text.replace(u')', u'）')\n stand_text = stand_text.replace(u':', u'：')\n return stand_text","def get_visible_text(_text):\n #text = _text.decode('utf-8', 'ignore').lower() # Don't get hung up on unicode chars in foreign languages\n text = _text.lower()\n text = re.compile(r'<').sub(' <',text) # These two lines keep words from getting smushed\n text = re.compile(r'>').sub('> ',text) # together when two they are only separated by tags.\n soup = BeautifulSoup(text, 'lxml')\n\n # decompose removes the tag and it's text content completely\n for s in soup(['script','code','style']):\n s.decompose()\n\n text = soup.get_text()\n # compress space to reduce footprint and fit on one line so it neatly fits in csv file\n text = re.compile(r'\\s+').sub(' ',text).strip()\n return text","def _setText(self, text):\n self.text = \"\"\n for ch in text:\n char, vertices, glyph = self._extractGlyph(ch)\n if not self.text:\n off, kern = self._updateMetric(0, char)\n if vertices is not None and not char in self.NO_GLYPH_CHARS:\n vertices['vtx'] += off + glyph['offset']\n self.allVertices = np.hstack(vertices)\n self.allIndices = self._baseInd\n self.text += char\n else:\n pos = len(self.text)\n nonGlyph = countInSet(self.text, self.NO_GLYPH_CHARS)\n # Set the metric\n off, kern = self._updateMetric(pos, char)\n if vertices is not None and not char in self.NO_GLYPH_CHARS:\n vertices['vtx'] += off + kern + glyph['offset']\n if self.allVertices is None:\n self.allVertices = np.hstack(vertices)\n else:\n self.allVertices = np.append(self.allVertices,\n vertices)\n if self.allIndices is None:\n self.allIndices = self._baseInd\n else:\n self.allIndices = np.vstack((self.allIndices,\n self._baseInd + (pos - nonGlyph) * 4))\n self.text += char\n self.setUniforms()","def initializeFeedback(win, expInfo):\n \n feedbackClock = core.Clock()\n feedbackText = visual.TextStim(win=win, ori=0, name='text',\n text='default text', font=u'Arial',\n pos=[0, 0], height=0.1, wrapWidth=None,\n color=u'white', colorSpace='rgb', opacity=1,\n depth=0.0, units=\"norm\")\n return(feedbackClock, feedbackText)","def print_banner(text):\n print(Figlet(font='smslant').renderText(text))","def adjusting_fonts(self):\n fix_x = int(0 * settings.scale)\n fix_y = int(0 * settings.scale)\n font_object = self.fontA\n box = self.box\n text_box = self.box.get_size()\n text_list = self.text.split()\n number_of_words = len(text_list)\n count = 0\n height = fix_y\n first = True\n line = \"\"\n line_break = False\n while count < number_of_words:\n line += text_list[count]\n line_size = font_object.size(line)\n line_pos = int((text_box[0] + fix_x - line_size[0]) / 2)\n if line_size[0] < text_box[0]:\n if count + 1 < number_of_words:\n temporary_line = line + \" \" + text_list[count + 1]\n if font_object.size(temporary_line)[0] >= text_box[0]:\n line_image = font_object.render(line, 1, self.color)\n height += int((line_size[1] * 0.8))\n box.blit(line_image, (line_pos, height))\n line = \"\"\n else:\n line += \" \"\n elif count + 1 == number_of_words:\n height += int((line_size[1] * 0.8))\n box.blit(\n font_object.render(line, 1, self.color), (line_pos, height)\n )\n else:\n line = text_list[count]\n height += int(\n line_size[1] * 0.8\n ) # If line height is perfect it does not seem that it is the same text\n count += 1","def scene_to_text(scenes):\n scene_text_dict = []\n scene_text_list = []\n for i, scene in enumerate(scenes):\n if len(scene['frame_data']) == 0:\n break\n scene_image = Image.fromarray(scene['frame_data'])\n str_text = pytesseract.image_to_string(scene_image)\n #list_text = list(filter(('').__ne__, re.split(\" |\\n|, ｜. |:|.\\n|\\x0c\", str_text)))\n list_text = list(filter(('').__ne__, re.split(\" |\\n\", str_text)))\n bag_of_word = collections.Counter(list_text)\n scene_text_dict.append(\n {'start': scene['start'], \n 'end': scene['end'], \n 'bag_of_word': dict(bag_of_word)\n })\n scene_text_list.append(list_text)\n return scene_text_dict, scene_text_list","def test_sentencier_en_trim_spaces():\n sentencizer = Sentencizer()\n text = ' This , text is... . Amazing !!'\n chunks = [i['text'] for i in sentencizer.segment(text, 0)]\n locs = [i['location'] for i in sentencizer.segment(text, 0)]\n assert chunks, [\"This , text is...\" == \"Amazing\"]\n assert text[locs[0][0]:locs[0][1]], ' This == text is...'\n assert text[locs[1][0]:locs[1][1]] == ' Amazing'\n\n def validate(req):\n assert req.docs[0].chunks[0].text, 'This == text is...'\n assert req.docs[0].chunks[1].text == 'Amazing'\n\n f = Flow().add(uses='!Sentencizer')\n with f:\n f.index_lines([' This , text is... . Amazing !!'], on_done=validate, callback_on_body=True, line_format='csv')","def texts(self, tft, oled, text_1, text_2, text_3=None, text_4=None, wait=0):\n text_line_1 = text_1\n text_line_2 = text_2\n text_line_3 = text_3\n text_line_4 = text_4\n self.clear(tft, oled)\n oled.text((5, 5), text_line_1, tft.WHITE, sysfont, 1)\n sleep(wait)\n self.clear(tft, oled)\n oled.text((5, 5), text_line_2, tft.WHITE, sysfont, 1)\n sleep(wait)\n if text_3:\n self.clear(tft, oled)\n oled.text((5, 5), text_line_3, tft.WHITE, sysfont, 1)\n sleep(wait)\n if text_4:\n self.clear(tft, oled)\n oled.text((5, 5), text_line_4, tft.WHITE, sysfont, 1)\n sleep(wait)\n self.clear(tft, oled)\n oled.text((5, 5), 'Press Button 1, 2 or 3!', tft.WHITE, sysfont, 1)","def render_text(grid):\r\n X = len(grid[0])\r\n Y = len(grid)\r\n#top row:\r\n for j in range(Y):\r\n for sub_j in range(3): #3 rows \r\n ROW = []\r\n for i in range(X):\r\n ROW += grid[j][i].arr[sub_j]\r\n print(ROW)","def get_formatted_text(self, n_cols):","def calculate_texts(self) -> None:\n texts = []\n for text in self.texts:\n paragraphs = list(filter(lambda x: x != \"\", text.split(\"\\n\\n\")))\n for paragraph in paragraphs:\n text = paragraph.replace(\"\\n\", \" \").strip()\n if len(text) > self.split_threshold_min:\n text_sentences = nlp(text)\n sentences = []\n for sentence in text_sentences.sents:\n current = sentence.text\n sentences.append(current.strip())\n texts.extend(sentences)\n else:\n texts.append(text)\n self.texts = list(set(texts))","def text_prepare(text):\r\n\r\n replace_by_space_re = re.compile('[/(){}\\[\\]\\|@,;]')\r\n good_symbols_re = re.compile('[^0-9a-z #+_]')\r\n stopwords_set = set(stopwords.words('english'))\r\n\r\n text = text.lower()\r\n text = replace_by_space_re.sub(' ', text)\r\n text = good_symbols_re.sub('', text)\r\n text = ' '.join([x for x in text.split() if x and x not in stopwords_set])\r\n\r\n return text.strip()","def text_draw(self, x, y, text, style={}):","def text_preprocessing_pdf(self,p):\n #remover_end_paragraphs=np.vectorize(self.remove_end_paragraphs,otypes=[str])\n cleaner=np.vectorize(self.remove_non_alpha,otypes=[str])\n cut_text=np.vectorize(self.cut_text,otypes=[str])\n cut_text_raw=np.vectorize(self.cut_text_raw,otypes=[str])\n assert len(self.parser)==len(self.parser_raw), \"Length of the treated sentence treated list does not match length of raw text list: {} / {}\".format(len(self.parser),len(self.parser_raw))\n cut_text_raw(p)\n p=cleaner(p)\n cut_text(p)\n return p","def getText():","def getText():","def getText():","def getText():","def getText():","def render_ents(\n self, text: str, spans: List[Dict[str, Any]], title: Optional[str]\n ) -> str:\n markup = \"\"\n offset = 0\n for span in spans:\n label = span[\"label\"]\n start = span[\"start\"]\n end = span[\"end\"]\n kb_id = span.get(\"kb_id\", \"\")\n kb_url = span.get(\"kb_url\", \"#\")\n kb_link = TPL_KB_LINK.format(kb_id=kb_id, kb_url=kb_url) if kb_id else \"\"\n additional_params = span.get(\"params\", {})\n entity = escape_html(text[start:end])\n fragments = text[offset:start].split(\"\\n\")\n for i, fragment in enumerate(fragments):\n markup += escape_html(fragment)\n if len(fragments) > 1 and i != len(fragments) - 1:\n markup += \"<br>\"\n if self.ents is None or label.upper() in self.ents:\n color = self.colors.get(label.upper(), self.default_color)\n ent_settings = {\n \"label\": label,\n \"text\": entity,\n \"bg\": color,\n \"kb_link\": kb_link,\n }\n ent_settings.update(additional_params)\n markup += self.ent_template.format(**ent_settings)\n else:\n markup += entity\n offset = end\n fragments = text[offset:].split(\"\\n\")\n for i, fragment in enumerate(fragments):\n markup += escape_html(fragment)\n if len(fragments) > 1 and i != len(fragments) - 1:\n markup += \"<br>\"\n markup = TPL_ENTS.format(content=markup, dir=self.direction)\n if title:\n markup = TPL_TITLE.format(title=title) + markup\n return markup","def display_text(target_text):\n\n print('Text to analyze:')\n print('')\n print('-------TEXT BELOW-------')\n print(target_text)\n print('-------TEXT ENDS-------')\n print('')","def process_text(self, text, language):","def process_text(text):\n text = text.strip()\n textList = text.split('\\n')\n newText = ''\n addNewline = True\n for line in textList:\n # Remove duplicate white space\n temp = ' '.join(line.split())\n # Trim any beginning non-alphabet letters\n temp = trim(temp)\n # Remove overly short lines, but keep ends of sentences\n # Add a newline if gap detected\n if len(temp) < 40 and not '.' in temp:\n if addNewline:\n newText += '\\n'\n addNewline = False\n continue\n # Add line to growing string\n newText += temp + ' '\n addNewline = True\n return newText","def sentences(summary, nlp):\n text = remove_spurious_words(text_of(summary))\n all_sentence = [sentence for sentence in re.split(\"[。，？！\\n]\", text) if sentence]\n all_sentence = [re.sub('[ ]+', ' ', sentence.encode('gb2312', 'ignore').decode('gb2312')).strip() for sentence in\n all_sentence]\n return [nlp.ner(sentence) for sentence in all_sentence if sentence]","async def ascii(self, ctx, *, text):\n text = text.replace(' ', '\\n')\n \n if not text:\n await ctx.send(f\"{ctx.tick(False)} You need to specify the text you want to convert!\")\n \n _fig = figlet_format(text.replace(' ', '\\n'))\n \n if len(_fig) > 1300:\n await ctx.send(f\"{ctx.tick(False)} That message is too long!\")\n await ctx.send(f\"{ctx.tick(True)} Done!\")\n await ctx.send(f\"```{_fig}```\")","def get_sentence(self):","def frontend(text):\n text = pyopenjtalk.g2p(text, kana=False)\n print(f\"Cleaned text: {text}\")\n charseq = text.split(\" \")\n idseq = []\n for c in charseq:\n if c.isspace():\n idseq += [char_to_id[\"<space>\"]]\n elif c not in char_to_id.keys():\n idseq += [char_to_id[\"<unk>\"]]\n else:\n idseq += [char_to_id[c]]\n idseq += [idim - 1] # <eos>\n return torch.LongTensor(idseq).view(-1).to(device)","def txt(input):\n output=atpic.cleaner_alex.txtclean(input)\n return output","def getExcerpts(self, text, DICECodeResults):\n\t\t\"\"\" - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - \"\"\"\n\t\t\n\t\tdef getKernels(indices):\n\t\t\t\"\"\"\n\t\t\t\tgetKernels() is a sub-method that extracts strings from a doc-\n\t\t\t\tument using indices provided by the DICECodeResults data struc-\n\t\t\t\tture passed into this sub-method's parent method, getExcerpts().\n\t\t\t\tThis sub-method returns three strings.\n\n\t\t\t\tindices --> tuple containing indices in the document with text to extract.\n\t\t\t\"\"\"\n\n\t\t\ti = indices[0]\n\t\t\tj = indices[1]\n\n\t\t\th = i - self.scope\n\t\t\tk = j + self.scope\n\n\t\t\tif h < 0: h = 0\n\t\t\tif k > len(text): k = len(text)-1\n\n\t\t\treturn text[h:i].replace(\"\\n\", \"__\").replace(\"\\t\", \" \"), text[i:j].replace(\"\\n\", \"__\").replace(\"\\t\", \" \"), text[j:k].replace(\"\\n\", \"__\").replace(\"\\t\", \" \")\n\t\t\t#return \"|\"+text[h:i].replace(\"\\n\", \"__\").replace(\"\\t\", \" \")+\"|\", text[i:j].replace(\"\\n\", \"__\").replace(\"\\t\", \" \"), \"|\"+text[j:k].replace(\"\\n\", \"__\").replace(\"\\t\", \" \")+\"|\"\n\n\t\tdef getComboTerms(tuples):\n\t\t\t\"\"\"\n\t\t\t\tgetComboTerms() is a sub-method that combines search terms and \n\t\t\t\ttheir indices provided in the tuple parameter into a string with\n\t\t\t\tthe following structure: [(variant, index)]. This sub-method re-\n\t\t\t\tturns a string of that structure.\n\n\t\t\t\ttuples --> data structure containing the search term and index of the search term in the form of: (term, index)\n\t\t\t\"\"\"\t\t\t\n\t\t\t#return \"[{0}]\".format('; '.join([\"({0})\".format(','.join([text[indices[0]:indices[1]], str(indices[0])])) for indices in tuples]))\n\t\t\treturn \"{0}\".format('; '.join((\"{0}\".format(text[indices[0]:indices[1]]) for indices in tuples)))\n\n\t\tdef getProximity(tuples):\n\t\t\t\"\"\"\n\t\t\t\tgetProximity() is a sub-method that calculates the distance of the search terms provided in the tuple parameter. \n\t\t\t\tThis sub-method returns an absolute value integer.\n\n\t\t\t\ttuples:\tdata structure containing the search term and index of the search term in the form of: (term, index)\n\t\t\t\"\"\"\n\t\t\tsortedIndices = [indices for indices in tuples]\n\t\t\t#return abs(sortedIndices[0][1] - sortedIndices[-1][0])\n\t\t\treturn sortedIndices[-1][0] - sortedIndices[0][1] \n\n\t\t\"\"\" - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - \"\"\"\n\n\t\texcerptsResults = list()\t\t# NEW list to contain the expanded data structure provided by the DICECodeResults parameter\n\n\t\t# CALL THESE JUST ONCE BEFORE LOOP(S)\n\t\tappend = excerptsResults.append\n\t\tformat = str.format\n\t\t# - - - - - - - - - - - - - - - - - -\n\n\t\tfor row in DICECodeResults:\n\n\t\t\tDICECode \t\t= row[0]\t# (1) DICE code as specified in C:\\Users\\a5rjqzz\\Desktop\\Python\\files\\Types.gd\n\t\t\tTYPECode \t\t= row[1]\t# (2) Type code as specified in C:\\Users\\a5rjqzz\\Desktop\\Python\\files\\Types.gd\n\t\t\tCombo \t\t= False\t\t# (3) Boolean status of the presence of a combo term\n\t\t\tdocumentIndex \t= 0\t\t\t# (4) Index of this search term in the document\n\t\t\tindices \t\t= row[2]\t# (5) Indices of the search term and combo term if present\n\t\t\tproximity\t\t= 0\t\t\t# (6) Distance between search term and combo terms\n\n\t\t\tif type(row[2][0]) == type(tuple()):\n\t\t\t\tCombo = True\t# If the type of search term is a combo, this is true\n\n\t\t\t\tfor tuples in row[2]:\n\t\t\t\t\tindices \t\t\t\t\t\t= tuples[0]\t\t\t\t# (1) Location(s) of the search term in the tuple\n\t\t\t\t\tdocumentIndex \t\t\t\t\t= indices[0]\t\t\t# (2) Location of the search term in the document\n\t\t\t\t\tcomboTerms \t\t\t\t\t\t= getComboTerms(tuples)\t# (3) Multiple terms assigned to variable comboTerms\n\t\t\t\t\tproximity \t\t\t\t\t\t= getProximity(tuples)\t# (4) Proximity of combo terms if present\n\t\t\t\t\tkernelLeft, kernel, kernelRight = getKernels(indices)\t# (5) Left, center, and right kernels or excerpts\n\n\t\t\t\t\tappend([DICECode, TYPECode, Combo, documentIndex, kernelLeft, kernel, kernelRight, comboTerms, proximity])\n\n\t\t\telse:\n\t\t\t\tdocumentIndex \t\t\t\t\t= indices[0]\t\t\t\t\t\t\t\t\t# (1) Location of the search term in the document\n\t\t\t\tcomboTerms \t\t\t\t\t\t= format(\"[{0}]\", text[indices[0]:indices[1]])\t# (2) Single term assigned to variable comboTerms\n\t\t\t\tkernelLeft, kernel, kernelRight = getKernels(indices)\t\t\t\t\t\t\t# (3) Left, center, and right kernels or excerpts\n\n\t\t\t\tappend([DICECode, TYPECode, Combo, documentIndex, kernelLeft, kernel, kernelRight, comboTerms, proximity])\n\n\t\treturn excerptsResults","def textManip(*args, visible: bool=True, q=True, query=True, **kwargs)->Union[None, Any]:\n pass","def main(argv):\n correct_font(*argv[1:])","def make_optional_silence_txt(self):\n raise NotImplementedError","def draw(grid):\n\n for row in grid:\n for char in row:\n if char is None:\n sys.stdout.write(\" \")\n else:\n sys.stdout.write(char)\n sys.stdout.write(\"\\n\")","def format_ocr_text(self, page):\n \n #read out of the text file that tesseract made\n ocr_text = open(self.ocr_text, 'r')\n \n # write into this file\n djvu_text = open( self.djvu_text, 'w' )\n \n text = \"(page 0 0 1 1\\n\"\n \n self.out_text.write('\\n## Page %d ###\\n\\n' % page )\n \n for line in ocr_text:\n \n #write to the human readable file\n self.out_text.write(line)\n \n # add each line of text\n # escaping \" to \\\" as we go\n text += '(line 0 0 1 1 \"%s\")\\n' % line.replace('\"', r'\\\"').strip()\n \n text += \")\\n\"\n \n djvu_text.write( text )\n \n ocr_text.close()\n djvu_text.close()","def process_text(text, args):\n if args.uppercase:\n text = convert_to_uppercase(text)\n\n if args.spaces:\n text = add_spaces(text)\n\n if not args.uppercase and not args.spaces:\n text = add_spaces(text)\n\n return text","def adjust(text, run_in_function=False):\n lines = text.split('\\n')\n if len(lines) == 1:\n return text\n\n if lines[0].strip() == '':\n lines = lines[1:]\n first_line = lines[0].lstrip()\n n_spaces = len(lines[0]) - len(first_line)\n\n final_lines = [(' ' if run_in_function else '') + line[n_spaces:] for line in lines]\n\n if run_in_function:\n final_lines = [\n \"def test_function():\",\n ] + final_lines + [\n \"test_function()\",\n ]\n\n return '\\n'.join(final_lines)","def render_text_surfaces(self):\n self.images = [] # The text surfaces.\n line_width = 0\n line = []\n space_width = self.font.size(' ')[0]\n\n # Put the words one after the other into a list if they still\n # fit on the same line, otherwise render the line and append\n # the resulting surface to the self.images list.\n for word in self.text:\n line_width += self.font.size(word)[0] + space_width\n # Render a line if the line width is greater than the rect width.\n if line_width > self.rect.w:\n surf = self.font.render(' '.join(line), True, self.text_color)\n self.images.append(surf)\n line = []\n line_width = self.font.size(word)[0] + space_width\n\n line.append(word)\n\n # Need to render the last line as well.\n surf = self.font.render(' '.join(line), True, self.text_color)\n self.images.append(surf)","def clear_text(self):\n global empty_string\n \n for r in range(1,3):\n for c in range(6):\n self.create_text_under_photo(data = empty_string,r=r,c=c)","def clear_text(self):\n global empty_string\n \n for r in range(1,3):\n for c in range(6):\n self.create_text_under_photo(data = empty_string,r=r,c=c)","def convert_chn_text(detail=True):\n p = {\n \"data_path\": \"../data/data_literature\",\n \"output_dir\": \"../data/converted_data\"\n }\n if detail:\n gen_params_info(p)\n\n os.system(\"rm -rf %s\" % p[\"output_dir\"])\n os.system(\"mkdir -p %s\" % p[\"output_dir\"])\n files = os.listdir(p[\"data_path\"])\n for file_name in files:\n if detail:\n print(\"to process %s\" % file_name)\n file_path = \"%s/%s\" % (p[\"data_path\"], file_name)\n out_file_path = \"%s/%s\" % (p[\"output_dir\"], file_name)\n fh_in = codecs.open(filename=file_path, mode=\"r\", encoding='utf8')\n fh_out = codecs.open(filename=out_file_path, mode=\"w\", encoding='utf8')\n line_idx = 1\n verb = \"\"\n for line in fh_in:\n line = line.lstrip()\n if line.find(\"\\t\") < 0:\n print(\"Please check in file %s, line: %s\\nsentence :%s\\n\"\\\n \"The above sentence has NO TAB and has been skiped!\" \\\n % (file_name, line_idx, line))\n continue\n items = line.split(\"\\t\")\n if len(items) != 4:\n print(\"Please check in file %s, line: %s\\nsentence :%s\\n\"\\\n \"The above sentence has NO 4 TAB and has been skiped!\" \\\n % (file_name, line_idx, line))\n continue\n frame_id = items[0]\n if frame_id.find(\".\") >= 0:\n frame_id = frame_id.split(\".\")[0]\n verb = items[2].strip()\n left_sent = items[1].strip()\n right_sent = items[3].strip()\n out_line = \"%s\\t%s\\t%s\\t%s\"\\\n % (frame_id, left_sent, verb, right_sent)\n print(out_line, file=fh_out)\n\n line_idx += 1\n\n fh_in.close()\n fh_out.close()","def small_text(self):\n pass","def convert_to_text(batch, lengths, dico, params):\n batch = batch.cpu().numpy()\n lengths = lengths.cpu().numpy()\n\n slen, bs = batch.shape\n assert lengths.max() == slen and lengths.shape[0] == bs\n assert (batch[0] == params.eos_index).sum() == bs\n assert (batch == params.eos_index).sum() == 2 * bs\n sentences = []\n\n for j in range(bs):\n words = []\n for k in range(1, lengths[j]):\n if batch[k, j] == params.eos_index:\n break\n words.append(dico[batch[k, j]])\n sentences.append(\" \".join(words))\n return sentences","def processText(text):\n print(type(text))\n for line in text:\n print(line)\n return text","def draw_text(\n self,\n text: str,\n transform: Matrix44,\n properties: Properties,\n cap_height: float,\n ) -> None:\n raise NotImplementedError","def text_update(self):\n if self.stext is not None:\n # Get index of non-masked sources :\n # idx = self._select_unmasked()[-1]\n\n # Set masked-sources text to '':\n text = np.array(self.stext)\n # text[np.array(~idx, dtype=bool)] = ''\n\n # Update elements :\n self.stextmesh.text = text\n self.stextmesh.color = self.stextcolor\n self.stextmesh.font_size = self.stextsize\n self.stextmesh.update()","def preprocess_training_text_with_stops(text, convert=False):\n return preprocess_training_text(text, accented_chars=True,\n convert_num=False, extra_whitespace=True, \n lemmatization=True, lowercase=True, punctuations=True,\n remove_html=True, remove_num=True, special_chars=True, \n stop_words=False)","def text_to_columns(text):\n \n dedented_txt = textwrap.dedent(text).strip()\n dedented_text = dedented_txt.splitlines()\n for line in dedented_text:\n ded_list = [textwrap.fill(line.strip(), initial_indent='', subsequent_indent='', width=20) for line in dedented_text] \n ded_list2=[]\n ded_list2.append(ded_list)\n return print(tabulate(ded_list2, tablefmt ='plain'))","def text_to_speech(entry):\n text = entry.get_text()\n if text:\n subprocess.call([\"milena_say\", text])"],"string":"[\n \"def __init__ (self,win,text='Press a key to continue',**kwargs):\\n\\n self.win = win\\n \\n self.text = visual.TextStim(win,text=text,**kwargs)\",\n \"def __init__ (self,win,text='Press a key to continue',**kwargs):\\n\\n self.win = win\\n \\n self.text = visual.TextStim(win,text=text,**kwargs)\",\n \"def make_silence_phones_txt(self):\\n raise NotImplementedError\",\n \"def preprocess(text):\\n text = remove_space(text)\\n text = clean_special_punctuations(text)\\n text = handle_emojis(text)\\n text = clean_number(text)\\n text = spacing_punctuation(text)\\n text = clean_repeat_words(text)\\n text = remove_space(text)\\n #text = stop(text)# if changing this, then chnage the dims \\n #(not to be done yet as its effecting the embeddings..,we might be\\n #loosing words)...\\n return text\",\n \"def wrapper(scr, text: list):\\n\\n display = Display(scr, text)\\n display.run()\",\n \"async def translate(context, arguments, style):\\n large_font_spaces = 5\\n small_font_spaces = int(27 / 40 * large_font_spaces)\\n large_font = True\\n\\n text = arguments[0]\\n runes = \\\"\\\"\\n\\n rune_count = 0\\n for i, char in enumerate(text.lower()):\\n if char in default_values.RUNES[style]:\\n runes += default_values.RUNES[style][char]\\n rune_count += 1\\n elif char in default_values.RUNES[\\\"archaic\\\"]:\\n runes += default_values.RUNES[\\\"archaic\\\"][char]\\n rune_count += 1\\n else:\\n runes += text[i]\\n if char != \\\" \\\":\\n large_font = False\\n\\n if not context.desktop_ui or not large_font or rune_count > 27:\\n runes = runes.replace(\\\" \\\", \\\" \\\" * small_font_spaces)\\n else:\\n runes = runes.replace(\\\" \\\", \\\" \\\" * large_font_spaces)\\n\\n await context.message.channel.send(runes)\\n return True\",\n \"def do(text):\\n return freeling_stemming(text)\",\n \"def cut_item_texts(self, arrays=None):\\n if not arrays: arrays = self.masks()\\n for a in arrays:\\n for item in self.sources(a):\\n i = self._meta['columns'][item]\\n for tk in self.valid_tks:\\n text = self.text(item, True, tk)\\n if text: i['text'][tk] = text\\n for ed in ['x', 'y']:\\n if i['text'].get('{} edits'.format(ed)):\\n for tk in self.valid_tks:\\n text = self.text(item, True, tk, ed)\\n if text: i['text']['{} edits'.format(ed)][tk] = text\\n return None\",\n \"def apply(self, text):\",\n \"def text(text = 'abcd', size = 10, justify = 'left', layer = 0, font = \\\"DEPLOF\\\"):\\n t = Device('text')\\n xoffset = 0\\n yoffset = 0\\n\\n face = font\\n if face == \\\"DEPLOF\\\":\\n scaling = size/1000\\n\\n for line in text.split('\\\\n'):\\n l = Device(name = 'textline')\\n for c in line:\\n ascii_val = ord(c)\\n if c == ' ':\\n xoffset += 500*scaling\\n elif (33 <= ascii_val <= 126) or (ascii_val == 181):\\n for poly in _glyph[ascii_val]:\\n xpts = np.array(poly)[:, 0]*scaling\\n ypts = np.array(poly)[:, 1]*scaling\\n l.add_polygon([xpts + xoffset, ypts + yoffset],\\n layer = layer)\\n xoffset += (_width[ascii_val] + _indent[ascii_val])*scaling\\n else:\\n valid_chars = '!\\\"#$%&\\\\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\\\\\\\]^_`abcdefghijklmnopqrstuvwxyz{|}~µ'\\n warnings.warn('[PHIDL] text(): Warning, some characters ignored, no geometry for character \\\"%s\\\" with ascii value %s. ' \\\\\\n 'Valid characters: %s' % (chr(ascii_val), ascii_val, valid_chars))\\n t.add_ref(l)\\n yoffset -= 1500*scaling\\n xoffset = 0\\n else:\\n from .font import _get_font_by_name, _get_font_by_file, _get_glyph\\n\\n # Load the font\\n # If we've passed a valid file, try to load that, otherwise search system fonts\\n font = None\\n if (face.endswith(\\\".otf\\\") or face.endswith(\\\".ttf\\\")) and os.path.exists(face):\\n font = _get_font_by_file(face)\\n else:\\n try:\\n font = _get_font_by_name(face)\\n except ValueError:\\n pass\\n if font is None:\\n raise ValueError(('[PHIDL] Failed to find font: \\\"%s\\\". ' +\\n 'Try specifying the exact (full) path to the .ttf or .otf file. ' +\\n 'Otherwise, it might be resolved by rebuilding the matplotlib font cache') % (face))\\n\\n # Render each character\\n for line in text.split('\\\\n'):\\n l = Device('textline')\\n xoffset = 0\\n for letter in line:\\n letter_dev = Device(\\\"letter\\\")\\n letter_template, advance_x = _get_glyph(font, letter)\\n for poly in letter_template.polygons:\\n letter_dev.add_polygon(poly.polygons, layer=layer)\\n ref = l.add_ref(letter_dev)\\n ref.move(destination=(xoffset, 0))\\n ref.magnification = size\\n xoffset += size*advance_x\\n\\n ref = t.add_ref(l)\\n ref.move(destination=(0, yoffset))\\n yoffset -= size\\n\\n justify = justify.lower()\\n for l in t.references:\\n if justify == 'left': pass\\n if justify == 'right': l.xmax = 0\\n if justify == 'center': l.move(origin = l.center,\\n destination = (0, 0), axis = 'x')\\n\\n t.flatten()\\n return t\",\n \"def obtain_text():\\n pass\",\n \"async def aesthetic(self, ctx, *, text):\\n out = \\\"\\\"\\n for char in text:\\n out += utils.fullwidth_transform.get(char, char)\\n await ctx.send(out)\",\n \"def FlashyText(win,center,text,timing):\\n winner = Text(center,text)\\n winner.setFace(\\\"arial\\\")\\n winner.setFill(\\\"black\\\")\\n winner.setSize(30)\\n for i in range(1,6):\\n time.sleep(timing)\\n if i % 2 == 0:\\n winner.draw(win)\\n else:\\n winner.undraw()\",\n \"async def outline_text(draw_surface, coords, draw_text, font):\\n draw = partial(draw_surface.text, text=draw_text, font=font,\\n fill=\\\"black\\\")\\n for offset_pair in product(range(-1, 2), repeat=2):\\n draw((coords[0]+offset_pair[0], coords[1]+offset_pair[1]))\\n draw(coords, fill=\\\"white\\\")\",\n \"def args_batch_to_text(args_batch: ArgsBatch) -> Text:\\n lines = []\\n for args in args_batch:\\n lines.append('; '.join(str(a) for a in args))\\n return '\\\\n'.join(lines)\",\n \"def setText(*args):\",\n \"def draw_text(self, text, i, j, **params):\",\n \"def preprocess(self, text):\\r\\n return text\",\n \"def rich(text):\\n return full(text, False)\",\n \"def mytext(x,y,s,**kwargs):\\n # we take care of this one\\n model = kwargs.pop('model', None)\\n if model:\\n th = text(x,y,model,**kwargs)\\n draw()\\n x0,y0,w,h = th.get_window_extent().bounds\\n gca().texts.remove(th)\\n x = x0\\n y = y0\\n kwargs['transform'] = matplotlib.transforms.IdentityTransform()\\n kwargs['horizontalalignment'] = 'left'\\n kwargs['verticalalignment'] = 'baseline'\\n# print x,y,kwargs\\n return text(x,y,s,**kwargs)\",\n \"def get_text(downgrade_titles=False):\",\n \"def text_grid(self, text, clear_screen=True, x=0, y=0, text_color='black', font=None):\\n\\n assert 0 <= x < Display.GRID_COLUMNS,\\\\\\n \\\"grid columns must be between 0 and %d, %d was requested\\\" %\\\\\\n ((Display.GRID_COLUMNS - 1, x))\\n\\n assert 0 <= y < Display.GRID_ROWS,\\\\\\n \\\"grid rows must be between 0 and %d, %d was requested\\\" %\\\\\\n ((Display.GRID_ROWS - 1), y)\\n\\n return self.text_pixels(text, clear_screen, x * Display.GRID_COLUMN_PIXELS, y * Display.GRID_ROW_PIXELS,\\n text_color, font)\",\n \"def format_text(text: TTextType) -> typing.Iterator[TViewLine]:\\n for line in text.splitlines():\\n yield [(\\\"text\\\", line)]\",\n \"def preprocess_text(self, seq):\\n if self.text_preprocess_fn:\\n seq = list(map(self.text_preprocess_fn, seq))\\n return seq\",\n \"def textile(text, **kwargs):\\n from django.contrib.markup.templatetags.markup import textile\\n return textile(text)\",\n \"def basic(text):\\n lines = text.split(\\\"\\\\n\\\")\\n result = []\\n\\n for line in lines:\\n result.append(_inline(line))\\n\\n return \\\"\\\\n\\\".join(result)\",\n \"def getKernels(indices):\\n\\n\\t\\t\\ti = indices[0]\\n\\t\\t\\tj = indices[1]\\n\\n\\t\\t\\th = i - self.scope\\n\\t\\t\\tk = j + self.scope\\n\\n\\t\\t\\tif h < 0: h = 0\\n\\t\\t\\tif k > len(text): k = len(text)-1\\n\\n\\t\\t\\treturn text[h:i].replace(\\\"\\\\n\\\", \\\"__\\\").replace(\\\"\\\\t\\\", \\\" \\\"), text[i:j].replace(\\\"\\\\n\\\", \\\"__\\\").replace(\\\"\\\\t\\\", \\\" \\\"), text[j:k].replace(\\\"\\\\n\\\", \\\"__\\\").replace(\\\"\\\\t\\\", \\\" \\\")\\n\\t\\t\\t#return \\\"|\\\"+text[h:i].replace(\\\"\\\\n\\\", \\\"__\\\").replace(\\\"\\\\t\\\", \\\" \\\")+\\\"|\\\", text[i:j].replace(\\\"\\\\n\\\", \\\"__\\\").replace(\\\"\\\\t\\\", \\\" \\\"), \\\"|\\\"+text[j:k].replace(\\\"\\\\n\\\", \\\"__\\\").replace(\\\"\\\\t\\\", \\\" \\\")+\\\"|\\\"\",\n \"def textCurves(*args, font: AnyStr=\\\"\\\", name: AnyStr=\\\"\\\", object: bool=True, text: AnyStr=\\\"\\\",\\n q=True, query=True, e=True, edit=True, **kwargs)->Union[List[AnyStr], Any]:\\n pass\",\n \"def generate(self, path, language, textgrid):\\n activations = []\\n self.model.eval()\\n iterator = tokenize(path, language, path_like=True, train=False)\\n if self.generation == 'bucket':\\n # Here, we give as input the text line by line.\\n for line in iterator:\\n line = line.strip() # Remove trailing characters\\n\\n line = '[CLS] ' + line + ' [SEP]'\\n tokenized_text = self.tokenizer.wordpiece_tokenizer.tokenize(line)\\n indexed_tokens = self.tokenizer.convert_tokens_to_ids(tokenized_text)\\n segment_ids = [1 for x in tokenized_text]\\n mapping = utils.match_tokenized_to_untokenized(tokenized_text, line)\\n\\n # Convert inputs to PyTorch tensors\\n tokens_tensor = torch.tensor([indexed_tokens])\\n segments_tensors = torch.tensor([segment_ids])\\n\\n with torch.no_grad():\\n encoded_layers = self.model(tokens_tensor, segments_tensors) # last_hidden_state, pooled_last_hidden_states, all_hidden_states\\n # filtration\\n encoded_layers = np.vstack(encoded_layers[2][1:]) # retrieve all the hidden states (dimension = layer_count * len(tokenized_text) * feature_count)\\n encoded_layers = encoded_layers[self.loi, :, :]\\n activations += utils.extract_activations_from_tokenized(encoded_layers, mapping)\\n elif self.generation == 'sequential':\\n # Here we give as input the sentence up to the actual word, incrementing by one at each step.\\n for line in iterator:\\n for index in range(1, len(line.split())):\\n tmp_line = \\\" \\\".join(line.split()[:index])\\n tmp_line = tmp_line.strip() # Remove trailing characters\\n\\n tmp_line = '[CLS] ' + tmp_line + ' [SEP]'\\n tokenized_text = self.tokenizer.wordpiece_tokenizer.tokenize(tmp_line)\\n indexed_tokens = self.tokenizer.convert_tokens_to_ids(tokenized_text)\\n segment_ids = [1 for x in tokenized_text]\\n mapping = utils.match_tokenized_to_untokenized(tokenized_text, line)\\n\\n # Convert inputs to PyTorch tensors\\n tokens_tensor = torch.tensor([indexed_tokens])\\n segments_tensors = torch.tensor([segment_ids])\\n\\n with torch.no_grad():\\n encoded_layers = self.model(tokens_tensor, segments_tensors) # dimension = layer_count * len(tokenized_text) * feature_count\\n # filtration\\n encoded_layers = np.vstack(encoded_layers[2][1:])\\n encoded_layers = encoded_layers[self.loi, :, :]\\n activations.append(utils.extract_activations_from_tokenized(encoded_layers, mapping)[-1])\\n result = pd.DataFrame(np.vstack(activations), columns=['layer-{}-{}'.format(layer, index) for layer in self.loi for index in range(self.FEATURE_COUNT)])\\n return result\",\n \"def tokenize(self, text, **kwargs):\\n if self.opt['tracker'] == 'babi6':\\n text = babi6_dirty_fix(text)\\n text = text.replace('<SILENCE>', '_SILENCE_')\\n\\n return [t.text for t in NLP.tokenizer(text)]\",\n \"def draw(text: list):\\n\\n curses.wrapper(wrapper, text)\",\n \"def text_plot(self):\\n if self.stext is not None:\\n # Create text object :\\n self.stextmesh = visu.Text(text=self.stext, color=self.stextcolor,\\n font_size=self.stextsize, pos=self.xyz,\\n bold=True, name='SourcesText')\\n\\n # Set text texture :\\n self.stextmesh.set_gl_state('translucent', depth_test=True)\\n\\n # Apply a transformation to text elements to not cover sources :\\n self.stextmesh.transform = vist.STTransform(\\n translate=self.stextshift)\\n else:\\n self.stextmesh = visu.Text(name='NoneText')\",\n \"def graphtextdetextor(image_path):\\n img=cv2.imread(image_path)\\n\\n #img=image_filter.rotate_anticlockwise(img)\\n\\n\\n custom_config_number=r'--oem 3 --psm 6 outputbase digits'\\n custom_config=r'--oem 3 --psm 6'\\n\\n custom_config1=r'--oem 3 --psm 1'\\n\\n custom_config2=r'--oem 3 --psm 4'\\n\\n text=pytesseract.image_to_string(img,config=custom_config)\\n text2=pytesseract.image_to_string(img,config=custom_config1)\\n text3=pytesseract.image_to_string(img,config=custom_config2)\\n\\n\\n\\n d=pytesseract.image_to_data(img,config=custom_config,output_type=Output.DICT)\\n\\n #print(text3)\\n return [text,text2,text3]\",\n \"def Execute_text( canvas, Fill, column, line, high, wide, linebuffer ):\\n global textitem # cache\\n # new text over writing old\\n if(column==2 and len(linebuffer)>1):\\n key = \\\"T {}.{}\\\".format(3,line)\\n try:\\n item = textitem[key]\\n canvas.delete(item)\\n del textitem[key]\\n # pdb.set_trace()\\n except KeyError:\\n pass\\n \\n (x00,y00) = (10,10)\\n x0 = column * (6,12)[wide]\\n key = \\\"T {}.{}\\\".format(column,line)\\n remark=\\\"\\\"\\n try:\\n item = textitem[key] \\n if canvas.itemcget(item,'text')==linebuffer :\\n remark = \\\"repeat\\\"\\n pass # ignore exact repetitions\\n else:\\n canvas.itemconfigure( item, text=linebuffer )\\n remark = f\\\"at {key} old item {item} update text '{linebuffer}'\\\"\\n except KeyError:\\n textitem[key] = canvas.create_text(\\n (x00+ x0)*2,\\n (y00+line)*2,\\n text=linebuffer,\\n font=DDD_Font[(1,2)[high]],\\n fill=Fill,\\n anchor=\\\"nw\\\",\\n tags = canvas.tag )\\n remark = f\\\"at {key} NEW text item '{linebuffer}'\\\"\\n if remark: print(\\\" \\\"*13 + remark )\",\n \"def show_text(text, args):\\n return expyriment.stimuli.TextLine(text,\\n text_font=args[\\\"--text-font\\\"],\\n text_size=args[\\\"--text-size\\\"],\\n text_colour=args[\\\"stimuli_color\\\"],\\n background_colour=args[\\\"bg_color\\\"])\",\n \"def _setText(self, text):\\n self.text = \\\"\\\"\\n for ch in text:\\n char, vertices, glyph = self._extractGlyph(ch)\\n if not vertices is None and self.glyphs in (\\n GlyphTypes.BASE, GlyphTypes.LAYER_COLOR):\\n vertices['rgba'] = glm.vec4(self.color)\\n if not self.text:\\n off, kern = self._updateMetric(0, char)\\n if char in self.NO_GLYPH_CHARS:\\n self.colors.append([char, None])\\n else:\\n vertices['vtx'] += off + glyph['offset']\\n self.allVertices = np.hstack(vertices)\\n self.allIndices = self._baseInd\\n self.colors.append([char, self.color])\\n self.text += char\\n else:\\n pos = len(self.text)\\n nonGlyph = countInSet(self.text, self.NO_GLYPH_CHARS)\\n # Set the metric\\n off, kern = self._updateMetric(pos, char)\\n if char in self.NO_GLYPH_CHARS:\\n self.colors.append([char, None])\\n else:\\n vertices['vtx'] += off + kern + glyph['offset']\\n if self.allVertices is None:\\n self.allVertices = np.hstack(vertices)\\n else:\\n self.allVertices = np.append(self.allVertices,\\n vertices)\\n if self.allIndices is None:\\n self.allIndices = self._baseInd\\n else:\\n self.allIndices = np.vstack((self.allIndices,\\n self._baseInd + (pos - nonGlyph) * 4))\\n self.colors.append([char, self.color])\\n self.text += char\\n self.setUniforms()\",\n \"def render_text_on_surface(text, surface, font, color=BLACK, top_padding=0, left_pading=0):\\n rect = surface.get_rect()\\n \\n last_top = rect.top + top_padding\\n for index, line in enumerate(text.split(\\\"\\\\n\\\")):\\n text_surf = font.render(line, True, color)\\n text_rect = text_surf.get_rect()\\n text_rect.topleft = (rect.left + left_pading, last_top)\\n surface.blit(text_surf, text_rect)\\n \\n last_top += text_rect.h\",\n \"def write(self, text):\\n text = open(text, 'w')\\n text.write('File type = \\\"ooTextFile\\\"\\\\n')\\n text.write('Object class = \\\"TextGrid\\\"\\\\n\\\\n')\\n text.write('xmin = %f\\\\n' % self.__xmin)\\n text.write('xmax = %f\\\\n' % self.__xmax)\\n text.write('tiers? <exists>\\\\n')\\n text.write('size = %d\\\\n' % self.__n)\\n text.write('item []:\\\\n')\\n for (tier, n) in zip(self.__tiers, range(1, self.__n + 1)):\\n text.write('\\\\titem [%d]:\\\\n' % n)\\n if tier.__class__ == IntervalTier: \\n text.write('\\\\t\\\\tclass = \\\"IntervalTier\\\"\\\\n')\\n text.write('\\\\t\\\\tname = \\\"%s\\\"\\\\n' % tier.name())\\n text.write('\\\\t\\\\txmin = %f\\\\n' % tier.xmin())\\n text.write('\\\\t\\\\txmax = %f\\\\n' % tier.xmax())\\n text.write('\\\\t\\\\tintervals: size = %d\\\\n' % len(tier))\\n for (interval, o) in zip(tier, range(1, len(tier) + 1)): \\n text.write('\\\\t\\\\t\\\\tintervals [%d]:\\\\n' % o)\\n text.write('\\\\t\\\\t\\\\t\\\\txmin = %f\\\\n' % interval.xmin())\\n text.write('\\\\t\\\\t\\\\t\\\\txmax = %f\\\\n' % interval.xmax())\\n text.write('\\\\t\\\\t\\\\t\\\\ttext = \\\"%s\\\"\\\\n' % interval.mark())\\n else: # PointTier\\n text.write('\\\\t\\\\tclass = \\\"TextTier\\\"\\\\n')\\n text.write('\\\\t\\\\tname = \\\"%s\\\"\\\\n' % tier.name())\\n text.write('\\\\t\\\\txmin = %f\\\\n' % tier.xmin())\\n text.write('\\\\t\\\\txmax = %f\\\\n' % tier.xmax())\\n text.write('\\\\t\\\\tpoints: size = %d\\\\n' % len(tier))\\n for (point, o) in zip(tier, range(1, len(tier) + 1)):\\n text.write('\\\\t\\\\t\\\\tpoints [%d]:\\\\n' % o)\\n text.write('\\\\t\\\\t\\\\t\\\\ttime = %f\\\\n' % point.time())\\n text.write('\\\\t\\\\t\\\\t\\\\tmark = \\\"%s\\\"\\\\n' % point.mark())\\n text.close()\",\n \"def export_textgrids(self, output_directory):\\n ali_directory = self.align_directory\\n convert_ali_to_textgrids(self.align_config, output_directory, ali_directory, self.dictionary,\\n self.corpus, self.corpus.num_jobs, self)\\n self.compile_information(ali_directory, output_directory)\",\n \"def used_tex_func(val):\\n return None\",\n \"def imText(self, text, align=\\\"left\\\", \\n textSize=None, rotate=None, bgColor=255, fontColor=0, scale=None, \\n leading=0.25, txtWidth=None):\\n if not textSize:\\n textSize = int(self.printerConf['textSize'])\\n if not txtWidth:\\n txtWidth = self.printerConf['printerWidth']\\n font = ImageFont.truetype(self.printerConf['fontFile'], textSize)\\n\\n def splitList(txtWidth, txtList, font, newlineSplitOnly=False):\\n \\\"\\\"\\\"Each str/unicode in txtList equals one line when printet. Split at newlines and furthermore split if a line is too wide.\\\"\\\"\\\"\\n # First of search for newlines and split the list if a newline is found\\n withoutNewlines = []\\n for txt in txtList:\\n withoutNewlines.extend(txt.split(\\\"\\\\n\\\"))\\n txtList = withoutNewlines\\n if newlineSplitOnly:\\n return txtList\\n\\n txtListWrapped = []\\n for txt in txtList:\\n # If the whole line is too wide, remove words until we are good\\n if font.getsize(txt)[0] > txtWidth:\\n txtLen = len(txt)\\n for i in range(txtLen)[::-1]:\\n if font.getsize(txt[:i+1])[0] <= txtWidth:\\n whitespaceEtc = [ \\\" \\\", \\\"\\\\t\\\", \\\"-\\\" ]\\n if txt[i] in whitespaceEtc:\\n txtSplit = [ txt[:i+1].rstrip(), txt[i+1:] ]\\n if font.getsize(txtSplit[1])[0] > txtWidth:\\n txtSplit = splitList(txtWidth, txtSplit, font)\\n break\\n else:\\n break\\n # If there are no whitespaces etc. then split the word\\n elif not any(w in txt[:i+1] for w in whitespaceEtc):\\n if font.getsize(txt[:i+1]+\\\"-\\\")[0] <= txtWidth:\\n txtSplit = [ txt[:i+1].rstrip()+\\\"-\\\", txt[i+1:] ]\\n if font.getsize(txtSplit[1])[0] > txtWidth:\\n txtSplit = splitList(txtWidth, txtSplit, font)\\n break\\n else:\\n break\\n else:\\n continue\\n else:\\n txtSplit = [ txt ]\\n txtListWrapped.extend(txtSplit)\\n return txtListWrapped\\n\\n # If txtList is a simple string make it a list\\n if type(text) is list:\\n txtList = text\\n else:\\n txtList = [ text ]\\n # Spacing between lines as a proportion of the width of a danish letter for the current text size.\\n leadingDots = int(font.getsize(u\\\"Å\\\")[0]*leading)\\n if rotate in [ 90, 270 ]:\\n # Don't wrap lines based on width when turned 90 or 270 degrees\\n txtList = splitList(txtWidth, txtList, font, newlineSplitOnly=True)\\n else:\\n # Do wordwrapping etc.\\n txtList = splitList(txtWidth, txtList, font)\\n\\n # Determine the size of the resulting text image\\n size = [0,0]\\n lineHeight = font.getsize(\\\"a\\\")[1]\\n size = [ 0, ( leadingDots + lineHeight ) * len(txtList) + leadingDots]\\n # Find the width\\n if rotate is 180:\\n # Avoid right alignment of rotated text, if a line is less wide than the paper / printerConf['printerWidth']\\n size[0] = self.printerConf['printerWidth']\\n else:\\n for txt in txtList:\\n maxWidth = font.getsize(txt)[0]\\n if maxWidth > size[0]:\\n size[0] = maxWidth\\n # Create the actual image containing the text\\n img = Image.new(\\\"1\\\",size)\\n draw = ImageDraw.Draw(img)\\n draw.rectangle((0,0) + img.size,fill=bgColor)\\n pointer = [0, 0]\\n # For each line..\\n for txt in txtList:\\n txtPxWidth = font.getsize(txt)[0]\\n if align == \\\"left\\\":\\n pointer[0] = 0\\n elif align == \\\"right\\\":\\n pointer[0] = size[0] - txtPxWidth\\n elif align == \\\"center\\\":\\n pointer[0] = (size[0] - txtPxWidth)/2\\n draw.text(pointer, txt, font=font, fill=fontColor)\\n pointer[1] += lineHeight + leadingDots\\n\\n if rotate:\\n angles = [0, 90, 180, 270]\\n if rotate in angles:\\n img = img.rotate(rotate, expand=True)\\n else:\\n raise ValueError(\\\"rotate must be part of %s if set \\\" % str(angles))\\n if rotate in [90, 270]:\\n if img.size[0] > self.printerConf['printerWidth'] and not scale:\\n raise Exception(\\\"The textSize is too large to print. Use either a smaller textSize or the scale parameter\\\")\\n else:\\n if img.size[0] > self.printerConf['printerWidth']:\\n raise Exception(\\\"Could not print the text. One or more lines are too wide. Did you choose a very large font?\\\")\\n\\n if align is not \\\"left\\\":\\n imgOld = img\\n img = Image.new(\\\"1\\\",(txtWidth,imgOld.size[1]))\\n draw = ImageDraw.Draw(img)\\n draw.rectangle((0,0) + img.size,fill=bgColor)\\n pointer = [0, 0]\\n if align is \\\"center\\\":\\n i = 2\\n else:\\n i = 1\\n img.paste(imgOld,((txtWidth-imgOld.size[0])/i,0))\\n return img\",\n \"def fn(): # fn definition # help2\\r\\n print(my_text)\",\n \"def process_text(text):\\n text = re.sub(r'<@>\\\\s+|<s>\\\\s+|</s>\\\\s+|<p>\\\\s+|</p>\\\\s+|\\\\s+\\\\,|\\\\'s|\\\\'|\\\\;|\\\\(|\\\\)|\\\\-\\\\-\\\\s+|\\\\s+\\\\.', '', text)\\n text = re.sub(r'\\\\.\\\\,', '. ,', text)\\n text = re.sub(r'\\\\,', '', text)\\n text = re.sub(r'\\\\$', '$ ', text)\\n text = re.sub(r'\\\\%', ' %', text)\\n text = re.sub(r'\\\\s\\\\\\\"\\\\s', ' ', text)\\n text = re.sub(r'\\\\.\\\\s+', '. ', text)\\n text = text.lower()\\n return text\",\n \"def result(target_text):\\n\\n display_text(target_text)\\n readability(target_text)\",\n \"def text(self, text: str, xo: int, yo: int, color: int):\\n for offset, letter in enumerate(text):\\n template = font.get(letter)\\n for x, line in enumerate(template):\\n line_str = '{:08b}'.format(line).replace('0b', '')\\n if self.portrait:\\n line_str = reversed(line_str)\\n for y, pix in enumerate(line_str):\\n if pix == '1':\\n self.pixel(xo + x + (offset * 8), yo + y, color)\",\n \"def parse_text(self, text):\\r\\n MAXLEN = 100\\r\\n sentences = []\\r\\n punct = [\\\",\\\",\\\":\\\",\\\";\\\",\\\".\\\",\\\"–\\\",\\\"?\\\",\\\"!\\\",\\\"(\\\",\\\")\\\"] # Interpunctuation marks\\r\\n text = text.replace(\\\"\\\\r\\\", \\\" \\\").replace(\\\"\\\\t\\\", \\\" \\\") # Remove CR and tabs\\r\\n words = text.split(\\\" \\\") if len(text) > MAXLEN else []\\r\\n sentence = \\\"\\\" if len(text) > MAXLEN else text\\r\\n\\r\\n # Preprocess list for silence markers\\r\\n if conf.SilenceMarker in text:\\r\\n words_new = []\\r\\n if not words and sentence: # Was too short to be cut initially\\r\\n words = text.split(\\\" \\\")\\r\\n sentence = \\\"\\\"\\r\\n for w in filter(None, words):\\r\\n if conf.SilenceMarker not in w.lower():\\r\\n words_new.append(w)\\r\\n else:\\r\\n text_chunks = w.lower().split(conf.SilenceMarker)\\r\\n for i, part in enumerate(text_chunks):\\r\\n if part:\\r\\n words_new.append(part)\\r\\n if i < len(text_chunks) - 1:\\r\\n words_new.append(conf.SilenceMarker)\\r\\n else:\\r\\n if words_new and conf.SilenceMarker in words_new[-1]:\\r\\n words_new[-1] += conf.SilenceMarker\\r\\n else:\\r\\n words_new.append(conf.SilenceMarker)\\r\\n words = words_new\\r\\n\\r\\n for w in words:\\r\\n if conf.SilenceMarker in w:\\r\\n if sentence:\\r\\n sentences.append(sentence.strip())\\r\\n sentences.append(w)\\r\\n sentence = \\\"\\\"\\r\\n elif w[-1] in punct or w[0] in punct: # Encountered punctuation\\r\\n if w[-1] in punct and (len(sentence) + len(w) + 1 < MAXLEN):\\r\\n # Word ends with punct and sentence can still be added to\\r\\n sentences.append(sentence.strip() + \\\" \\\" + w.strip())\\r\\n sentence = \\\"\\\" # Save sentence and word, start new sentence\\r\\n elif w[0] in punct and w[-1] not in punct:\\r\\n # Word starts with punctuation, like '('\\r\\n sentences.append(sentence.strip()) # Save current sentence\\r\\n sentence = w # Start a new sentence with punct and word\\r\\n else: # word ends with punct and sentence already long enough\\r\\n sentences.extend([sentence.strip(), w.strip()])\\r\\n sentence = \\\"\\\" \\r\\n else:\\r\\n if (len(sentence) + len(w) + 1 < MAXLEN): # Sentence still\\r\\n sentence += \\\" \\\" + w # short enough\\r\\n else: # Sentence too long\\r\\n sentences.append(sentence.strip())\\r\\n sentence = w # Start a new sentence with the word\\r\\n if sentence:\\r\\n sentences.append(sentence.strip())\\r\\n return sentences\",\n \"def run_ocr_in_chart(chart, pad=0, psm=PSM.SINGLE_LINE):\\n img = chart.image\\n\\n # add a padding to the initial figure\\n fpad = 1\\n img = cv2.copyMakeBorder(img.copy(), fpad, fpad, fpad, fpad, cv2.BORDER_CONSTANT, value=(255, 255, 255))\\n fh, fw, _ = img.shape\\n\\n api = PyTessBaseAPI(psm=psm, lang='eng')\\n clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(4, 4))\\n\\n for tbox in chart.texts:\\n # adding a pad to original image. Some case in quartz corpus, the text touch the border.\\n x, y, w, h = ru.wrap_rect(u.ttoi(tbox.rect), (fh, fw), padx=pad, pady=pad)\\n x, y = x + fpad, y + fpad\\n\\n if w * h == 0:\\n tbox.text = ''\\n continue\\n\\n # crop region of interest\\n roi = img[y:y + h, x:x + w]\\n # to gray scale\\n roi_gray = cv2.cvtColor(roi, cv2.COLOR_BGR2GRAY)\\n #\\n roi_gray = cv2.resize(roi_gray, None, fx=3, fy=3, interpolation=cv2.INTER_CUBIC)\\n # binarization\\n _, roi_bw = cv2.threshold(roi_gray, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)\\n # removing noise from borders\\n roi_bw = 255 - clear_border(255-roi_bw)\\n\\n # roi_gray = cv2.copyMakeBorder(roi_gray, 5, 5, 5, 5, cv2.BORDER_CONSTANT, value=255)\\n\\n # when testing boxes from csv files\\n if tbox.num_comp == 0:\\n # Apply Contrast Limited Adaptive Histogram Equalization\\n roi_gray2 = clahe.apply(roi_gray)\\n _, roi_bw2 = cv2.threshold(roi_gray2, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)\\n _, num_comp = morphology.label(roi_bw2, return_num=True, background=255)\\n tbox.regions.extend(range(num_comp))\\n\\n pil_img = smp.toimage(roi_bw)\\n if SHOW:\\n pil_img.show()\\n max_conf = -np.inf\\n min_dist = np.inf\\n correct_text = ''\\n correct_angle = 0\\n u.log('---------------')\\n for angle in [0, -90, 90]:\\n rot_img = pil_img.rotate(angle, expand=1)\\n\\n api.SetImage(rot_img)\\n conf = api.MeanTextConf()\\n text = api.GetUTF8Text().strip()\\n dist = abs(len(text.replace(' ', '')) - tbox.num_comp)\\n\\n u.log('text: %s conf: %f dist: %d' % (text, conf, dist))\\n if conf > max_conf and dist <= min_dist:\\n max_conf = conf\\n correct_text = text\\n correct_angle = angle\\n min_dist = dist\\n\\n tbox.text = post_process_text(lossy_unicode_to_ascii(correct_text))\\n tbox.text_conf = max_conf\\n tbox.text_dist = min_dist\\n tbox.text_angle = correct_angle\\n\\n u.log('num comp %d' % tbox.num_comp)\\n u.log(u'** text: {} conf: {} angle: {}'.format(correct_text, max_conf, correct_angle))\\n\\n api.End()\\n\\n # return boxes\",\n \"def bert_preprocess(raw_text):\\n nlp = English()\\n nlp.add_pipe(nlp.create_pipe('sentencizer')) # updated\\n doc = nlp(raw_text)\\n sentences = [sent.string.strip() for sent in doc.sents][0:2] \\n new_sentences = []\\n for i, sentence in enumerate(sentences):\\n if i==0:\\n new_sentences.append(\\\"[CLS] \\\" + sentence + \\\" [SEP]\\\")\\n else:\\n new_sentences.append(sentence + \\\" [SEP]\\\")\\n \\n preprocessed_text = ' '.join(new_sentences)\\n \\n if \\\"[CLS]\\\" not in preprocessed_text:\\n raise Exception(\\\"[CLS] not found in preprocessed text\\\")\\n if \\\"[SEP]\\\" not in preprocessed_text:\\n raise Exception(\\\"[SEP] not found in preprocessed text\\\")\\n \\n return\",\n \"def sliptText(text):\\n\\treturn [char for char in text]\",\n \"def edit_google_vision_text(self,text):\\n s1=text\\n try:\\n log_info(\\\"Correcting google vision text to remove extra spacing\\\",MODULE_CONTEXT)\\n i=0\\n while(i<len(text)):\\n s1=text\\n if text[i] in [\\\"/\\\",\\\"।\\\",'।' ,':','|',\\\",\\\" ,'०',\\\"]\\\",\\\"-\\\",\\\")\\\",\\\"}\\\"] and text[i-1]==\\\" \\\": \\n text=text[:i-1]+text[i:]\\n if i > 0 :\\n if text[i-1] in [\\\"-\\\",\\\"[\\\",\\\"{\\\",\\\"/\\\",\\\"(\\\"] and text[i]==\\\" \\\":\\n text=text[:i]+text[i+1:]\\n elif text[i] in [\\\"-\\\",\\\"[\\\",\\\"{\\\",\\\"/\\\",\\\"(\\\"] and text[i+1]==\\\" \\\":\\n text=text[:i+1]+text[i+2:]\\n i=i+1\\n except Exception as e:\\n log_exception(\\\"Exception while correcting google vision text\\\", MODULE_CONTEXT, e)\\n return s1\\n return text\",\n \"def stats_text(test):\\n\\n stats_text_en(test) \\n \\n stats_text_cn(test)\",\n \"def text_standardization(text_in):\\n stand_text = text_in.strip()\\n stand_text = ' '.join(stand_text.split())\\n stand_text = stand_text.replace(u'(', u'（')\\n stand_text = stand_text.replace(u')', u'）')\\n stand_text = stand_text.replace(u':', u'：')\\n return stand_text\",\n \"def get_visible_text(_text):\\n #text = _text.decode('utf-8', 'ignore').lower() # Don't get hung up on unicode chars in foreign languages\\n text = _text.lower()\\n text = re.compile(r'<').sub(' <',text) # These two lines keep words from getting smushed\\n text = re.compile(r'>').sub('> ',text) # together when two they are only separated by tags.\\n soup = BeautifulSoup(text, 'lxml')\\n\\n # decompose removes the tag and it's text content completely\\n for s in soup(['script','code','style']):\\n s.decompose()\\n\\n text = soup.get_text()\\n # compress space to reduce footprint and fit on one line so it neatly fits in csv file\\n text = re.compile(r'\\\\s+').sub(' ',text).strip()\\n return text\",\n \"def _setText(self, text):\\n self.text = \\\"\\\"\\n for ch in text:\\n char, vertices, glyph = self._extractGlyph(ch)\\n if not self.text:\\n off, kern = self._updateMetric(0, char)\\n if vertices is not None and not char in self.NO_GLYPH_CHARS:\\n vertices['vtx'] += off + glyph['offset']\\n self.allVertices = np.hstack(vertices)\\n self.allIndices = self._baseInd\\n self.text += char\\n else:\\n pos = len(self.text)\\n nonGlyph = countInSet(self.text, self.NO_GLYPH_CHARS)\\n # Set the metric\\n off, kern = self._updateMetric(pos, char)\\n if vertices is not None and not char in self.NO_GLYPH_CHARS:\\n vertices['vtx'] += off + kern + glyph['offset']\\n if self.allVertices is None:\\n self.allVertices = np.hstack(vertices)\\n else:\\n self.allVertices = np.append(self.allVertices,\\n vertices)\\n if self.allIndices is None:\\n self.allIndices = self._baseInd\\n else:\\n self.allIndices = np.vstack((self.allIndices,\\n self._baseInd + (pos - nonGlyph) * 4))\\n self.text += char\\n self.setUniforms()\",\n \"def initializeFeedback(win, expInfo):\\n \\n feedbackClock = core.Clock()\\n feedbackText = visual.TextStim(win=win, ori=0, name='text',\\n text='default text', font=u'Arial',\\n pos=[0, 0], height=0.1, wrapWidth=None,\\n color=u'white', colorSpace='rgb', opacity=1,\\n depth=0.0, units=\\\"norm\\\")\\n return(feedbackClock, feedbackText)\",\n \"def print_banner(text):\\n print(Figlet(font='smslant').renderText(text))\",\n \"def adjusting_fonts(self):\\n fix_x = int(0 * settings.scale)\\n fix_y = int(0 * settings.scale)\\n font_object = self.fontA\\n box = self.box\\n text_box = self.box.get_size()\\n text_list = self.text.split()\\n number_of_words = len(text_list)\\n count = 0\\n height = fix_y\\n first = True\\n line = \\\"\\\"\\n line_break = False\\n while count < number_of_words:\\n line += text_list[count]\\n line_size = font_object.size(line)\\n line_pos = int((text_box[0] + fix_x - line_size[0]) / 2)\\n if line_size[0] < text_box[0]:\\n if count + 1 < number_of_words:\\n temporary_line = line + \\\" \\\" + text_list[count + 1]\\n if font_object.size(temporary_line)[0] >= text_box[0]:\\n line_image = font_object.render(line, 1, self.color)\\n height += int((line_size[1] * 0.8))\\n box.blit(line_image, (line_pos, height))\\n line = \\\"\\\"\\n else:\\n line += \\\" \\\"\\n elif count + 1 == number_of_words:\\n height += int((line_size[1] * 0.8))\\n box.blit(\\n font_object.render(line, 1, self.color), (line_pos, height)\\n )\\n else:\\n line = text_list[count]\\n height += int(\\n line_size[1] * 0.8\\n ) # If line height is perfect it does not seem that it is the same text\\n count += 1\",\n \"def scene_to_text(scenes):\\n scene_text_dict = []\\n scene_text_list = []\\n for i, scene in enumerate(scenes):\\n if len(scene['frame_data']) == 0:\\n break\\n scene_image = Image.fromarray(scene['frame_data'])\\n str_text = pytesseract.image_to_string(scene_image)\\n #list_text = list(filter(('').__ne__, re.split(\\\" |\\\\n|, ｜. |:|.\\\\n|\\\\x0c\\\", str_text)))\\n list_text = list(filter(('').__ne__, re.split(\\\" |\\\\n\\\", str_text)))\\n bag_of_word = collections.Counter(list_text)\\n scene_text_dict.append(\\n {'start': scene['start'], \\n 'end': scene['end'], \\n 'bag_of_word': dict(bag_of_word)\\n })\\n scene_text_list.append(list_text)\\n return scene_text_dict, scene_text_list\",\n \"def test_sentencier_en_trim_spaces():\\n sentencizer = Sentencizer()\\n text = ' This , text is... . Amazing !!'\\n chunks = [i['text'] for i in sentencizer.segment(text, 0)]\\n locs = [i['location'] for i in sentencizer.segment(text, 0)]\\n assert chunks, [\\\"This , text is...\\\" == \\\"Amazing\\\"]\\n assert text[locs[0][0]:locs[0][1]], ' This == text is...'\\n assert text[locs[1][0]:locs[1][1]] == ' Amazing'\\n\\n def validate(req):\\n assert req.docs[0].chunks[0].text, 'This == text is...'\\n assert req.docs[0].chunks[1].text == 'Amazing'\\n\\n f = Flow().add(uses='!Sentencizer')\\n with f:\\n f.index_lines([' This , text is... . Amazing !!'], on_done=validate, callback_on_body=True, line_format='csv')\",\n \"def texts(self, tft, oled, text_1, text_2, text_3=None, text_4=None, wait=0):\\n text_line_1 = text_1\\n text_line_2 = text_2\\n text_line_3 = text_3\\n text_line_4 = text_4\\n self.clear(tft, oled)\\n oled.text((5, 5), text_line_1, tft.WHITE, sysfont, 1)\\n sleep(wait)\\n self.clear(tft, oled)\\n oled.text((5, 5), text_line_2, tft.WHITE, sysfont, 1)\\n sleep(wait)\\n if text_3:\\n self.clear(tft, oled)\\n oled.text((5, 5), text_line_3, tft.WHITE, sysfont, 1)\\n sleep(wait)\\n if text_4:\\n self.clear(tft, oled)\\n oled.text((5, 5), text_line_4, tft.WHITE, sysfont, 1)\\n sleep(wait)\\n self.clear(tft, oled)\\n oled.text((5, 5), 'Press Button 1, 2 or 3!', tft.WHITE, sysfont, 1)\",\n \"def render_text(grid):\\r\\n X = len(grid[0])\\r\\n Y = len(grid)\\r\\n#top row:\\r\\n for j in range(Y):\\r\\n for sub_j in range(3): #3 rows \\r\\n ROW = []\\r\\n for i in range(X):\\r\\n ROW += grid[j][i].arr[sub_j]\\r\\n print(ROW)\",\n \"def get_formatted_text(self, n_cols):\",\n \"def calculate_texts(self) -> None:\\n texts = []\\n for text in self.texts:\\n paragraphs = list(filter(lambda x: x != \\\"\\\", text.split(\\\"\\\\n\\\\n\\\")))\\n for paragraph in paragraphs:\\n text = paragraph.replace(\\\"\\\\n\\\", \\\" \\\").strip()\\n if len(text) > self.split_threshold_min:\\n text_sentences = nlp(text)\\n sentences = []\\n for sentence in text_sentences.sents:\\n current = sentence.text\\n sentences.append(current.strip())\\n texts.extend(sentences)\\n else:\\n texts.append(text)\\n self.texts = list(set(texts))\",\n \"def text_prepare(text):\\r\\n\\r\\n replace_by_space_re = re.compile('[/(){}\\\\[\\\\]\\\\|@,;]')\\r\\n good_symbols_re = re.compile('[^0-9a-z #+_]')\\r\\n stopwords_set = set(stopwords.words('english'))\\r\\n\\r\\n text = text.lower()\\r\\n text = replace_by_space_re.sub(' ', text)\\r\\n text = good_symbols_re.sub('', text)\\r\\n text = ' '.join([x for x in text.split() if x and x not in stopwords_set])\\r\\n\\r\\n return text.strip()\",\n \"def text_draw(self, x, y, text, style={}):\",\n \"def text_preprocessing_pdf(self,p):\\n #remover_end_paragraphs=np.vectorize(self.remove_end_paragraphs,otypes=[str])\\n cleaner=np.vectorize(self.remove_non_alpha,otypes=[str])\\n cut_text=np.vectorize(self.cut_text,otypes=[str])\\n cut_text_raw=np.vectorize(self.cut_text_raw,otypes=[str])\\n assert len(self.parser)==len(self.parser_raw), \\\"Length of the treated sentence treated list does not match length of raw text list: {} / {}\\\".format(len(self.parser),len(self.parser_raw))\\n cut_text_raw(p)\\n p=cleaner(p)\\n cut_text(p)\\n return p\",\n \"def getText():\",\n \"def getText():\",\n \"def getText():\",\n \"def getText():\",\n \"def getText():\",\n \"def render_ents(\\n self, text: str, spans: List[Dict[str, Any]], title: Optional[str]\\n ) -> str:\\n markup = \\\"\\\"\\n offset = 0\\n for span in spans:\\n label = span[\\\"label\\\"]\\n start = span[\\\"start\\\"]\\n end = span[\\\"end\\\"]\\n kb_id = span.get(\\\"kb_id\\\", \\\"\\\")\\n kb_url = span.get(\\\"kb_url\\\", \\\"#\\\")\\n kb_link = TPL_KB_LINK.format(kb_id=kb_id, kb_url=kb_url) if kb_id else \\\"\\\"\\n additional_params = span.get(\\\"params\\\", {})\\n entity = escape_html(text[start:end])\\n fragments = text[offset:start].split(\\\"\\\\n\\\")\\n for i, fragment in enumerate(fragments):\\n markup += escape_html(fragment)\\n if len(fragments) > 1 and i != len(fragments) - 1:\\n markup += \\\"<br>\\\"\\n if self.ents is None or label.upper() in self.ents:\\n color = self.colors.get(label.upper(), self.default_color)\\n ent_settings = {\\n \\\"label\\\": label,\\n \\\"text\\\": entity,\\n \\\"bg\\\": color,\\n \\\"kb_link\\\": kb_link,\\n }\\n ent_settings.update(additional_params)\\n markup += self.ent_template.format(**ent_settings)\\n else:\\n markup += entity\\n offset = end\\n fragments = text[offset:].split(\\\"\\\\n\\\")\\n for i, fragment in enumerate(fragments):\\n markup += escape_html(fragment)\\n if len(fragments) > 1 and i != len(fragments) - 1:\\n markup += \\\"<br>\\\"\\n markup = TPL_ENTS.format(content=markup, dir=self.direction)\\n if title:\\n markup = TPL_TITLE.format(title=title) + markup\\n return markup\",\n \"def display_text(target_text):\\n\\n print('Text to analyze:')\\n print('')\\n print('-------TEXT BELOW-------')\\n print(target_text)\\n print('-------TEXT ENDS-------')\\n print('')\",\n \"def process_text(self, text, language):\",\n \"def process_text(text):\\n text = text.strip()\\n textList = text.split('\\\\n')\\n newText = ''\\n addNewline = True\\n for line in textList:\\n # Remove duplicate white space\\n temp = ' '.join(line.split())\\n # Trim any beginning non-alphabet letters\\n temp = trim(temp)\\n # Remove overly short lines, but keep ends of sentences\\n # Add a newline if gap detected\\n if len(temp) < 40 and not '.' in temp:\\n if addNewline:\\n newText += '\\\\n'\\n addNewline = False\\n continue\\n # Add line to growing string\\n newText += temp + ' '\\n addNewline = True\\n return newText\",\n \"def sentences(summary, nlp):\\n text = remove_spurious_words(text_of(summary))\\n all_sentence = [sentence for sentence in re.split(\\\"[。，？！\\\\n]\\\", text) if sentence]\\n all_sentence = [re.sub('[ ]+', ' ', sentence.encode('gb2312', 'ignore').decode('gb2312')).strip() for sentence in\\n all_sentence]\\n return [nlp.ner(sentence) for sentence in all_sentence if sentence]\",\n \"async def ascii(self, ctx, *, text):\\n text = text.replace(' ', '\\\\n')\\n \\n if not text:\\n await ctx.send(f\\\"{ctx.tick(False)} You need to specify the text you want to convert!\\\")\\n \\n _fig = figlet_format(text.replace(' ', '\\\\n'))\\n \\n if len(_fig) > 1300:\\n await ctx.send(f\\\"{ctx.tick(False)} That message is too long!\\\")\\n await ctx.send(f\\\"{ctx.tick(True)} Done!\\\")\\n await ctx.send(f\\\"```{_fig}```\\\")\",\n \"def get_sentence(self):\",\n \"def frontend(text):\\n text = pyopenjtalk.g2p(text, kana=False)\\n print(f\\\"Cleaned text: {text}\\\")\\n charseq = text.split(\\\" \\\")\\n idseq = []\\n for c in charseq:\\n if c.isspace():\\n idseq += [char_to_id[\\\"<space>\\\"]]\\n elif c not in char_to_id.keys():\\n idseq += [char_to_id[\\\"<unk>\\\"]]\\n else:\\n idseq += [char_to_id[c]]\\n idseq += [idim - 1] # <eos>\\n return torch.LongTensor(idseq).view(-1).to(device)\",\n \"def txt(input):\\n output=atpic.cleaner_alex.txtclean(input)\\n return output\",\n \"def getExcerpts(self, text, DICECodeResults):\\n\\t\\t\\\"\\\"\\\" - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - \\\"\\\"\\\"\\n\\t\\t\\n\\t\\tdef getKernels(indices):\\n\\t\\t\\t\\\"\\\"\\\"\\n\\t\\t\\t\\tgetKernels() is a sub-method that extracts strings from a doc-\\n\\t\\t\\t\\tument using indices provided by the DICECodeResults data struc-\\n\\t\\t\\t\\tture passed into this sub-method's parent method, getExcerpts().\\n\\t\\t\\t\\tThis sub-method returns three strings.\\n\\n\\t\\t\\t\\tindices --> tuple containing indices in the document with text to extract.\\n\\t\\t\\t\\\"\\\"\\\"\\n\\n\\t\\t\\ti = indices[0]\\n\\t\\t\\tj = indices[1]\\n\\n\\t\\t\\th = i - self.scope\\n\\t\\t\\tk = j + self.scope\\n\\n\\t\\t\\tif h < 0: h = 0\\n\\t\\t\\tif k > len(text): k = len(text)-1\\n\\n\\t\\t\\treturn text[h:i].replace(\\\"\\\\n\\\", \\\"__\\\").replace(\\\"\\\\t\\\", \\\" \\\"), text[i:j].replace(\\\"\\\\n\\\", \\\"__\\\").replace(\\\"\\\\t\\\", \\\" \\\"), text[j:k].replace(\\\"\\\\n\\\", \\\"__\\\").replace(\\\"\\\\t\\\", \\\" \\\")\\n\\t\\t\\t#return \\\"|\\\"+text[h:i].replace(\\\"\\\\n\\\", \\\"__\\\").replace(\\\"\\\\t\\\", \\\" \\\")+\\\"|\\\", text[i:j].replace(\\\"\\\\n\\\", \\\"__\\\").replace(\\\"\\\\t\\\", \\\" \\\"), \\\"|\\\"+text[j:k].replace(\\\"\\\\n\\\", \\\"__\\\").replace(\\\"\\\\t\\\", \\\" \\\")+\\\"|\\\"\\n\\n\\t\\tdef getComboTerms(tuples):\\n\\t\\t\\t\\\"\\\"\\\"\\n\\t\\t\\t\\tgetComboTerms() is a sub-method that combines search terms and \\n\\t\\t\\t\\ttheir indices provided in the tuple parameter into a string with\\n\\t\\t\\t\\tthe following structure: [(variant, index)]. This sub-method re-\\n\\t\\t\\t\\tturns a string of that structure.\\n\\n\\t\\t\\t\\ttuples --> data structure containing the search term and index of the search term in the form of: (term, index)\\n\\t\\t\\t\\\"\\\"\\\"\\t\\t\\t\\n\\t\\t\\t#return \\\"[{0}]\\\".format('; '.join([\\\"({0})\\\".format(','.join([text[indices[0]:indices[1]], str(indices[0])])) for indices in tuples]))\\n\\t\\t\\treturn \\\"{0}\\\".format('; '.join((\\\"{0}\\\".format(text[indices[0]:indices[1]]) for indices in tuples)))\\n\\n\\t\\tdef getProximity(tuples):\\n\\t\\t\\t\\\"\\\"\\\"\\n\\t\\t\\t\\tgetProximity() is a sub-method that calculates the distance of the search terms provided in the tuple parameter. \\n\\t\\t\\t\\tThis sub-method returns an absolute value integer.\\n\\n\\t\\t\\t\\ttuples:\\tdata structure containing the search term and index of the search term in the form of: (term, index)\\n\\t\\t\\t\\\"\\\"\\\"\\n\\t\\t\\tsortedIndices = [indices for indices in tuples]\\n\\t\\t\\t#return abs(sortedIndices[0][1] - sortedIndices[-1][0])\\n\\t\\t\\treturn sortedIndices[-1][0] - sortedIndices[0][1] \\n\\n\\t\\t\\\"\\\"\\\" - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - \\\"\\\"\\\"\\n\\n\\t\\texcerptsResults = list()\\t\\t# NEW list to contain the expanded data structure provided by the DICECodeResults parameter\\n\\n\\t\\t# CALL THESE JUST ONCE BEFORE LOOP(S)\\n\\t\\tappend = excerptsResults.append\\n\\t\\tformat = str.format\\n\\t\\t# - - - - - - - - - - - - - - - - - -\\n\\n\\t\\tfor row in DICECodeResults:\\n\\n\\t\\t\\tDICECode \\t\\t= row[0]\\t# (1) DICE code as specified in C:\\\\Users\\\\a5rjqzz\\\\Desktop\\\\Python\\\\files\\\\Types.gd\\n\\t\\t\\tTYPECode \\t\\t= row[1]\\t# (2) Type code as specified in C:\\\\Users\\\\a5rjqzz\\\\Desktop\\\\Python\\\\files\\\\Types.gd\\n\\t\\t\\tCombo \\t\\t= False\\t\\t# (3) Boolean status of the presence of a combo term\\n\\t\\t\\tdocumentIndex \\t= 0\\t\\t\\t# (4) Index of this search term in the document\\n\\t\\t\\tindices \\t\\t= row[2]\\t# (5) Indices of the search term and combo term if present\\n\\t\\t\\tproximity\\t\\t= 0\\t\\t\\t# (6) Distance between search term and combo terms\\n\\n\\t\\t\\tif type(row[2][0]) == type(tuple()):\\n\\t\\t\\t\\tCombo = True\\t# If the type of search term is a combo, this is true\\n\\n\\t\\t\\t\\tfor tuples in row[2]:\\n\\t\\t\\t\\t\\tindices \\t\\t\\t\\t\\t\\t= tuples[0]\\t\\t\\t\\t# (1) Location(s) of the search term in the tuple\\n\\t\\t\\t\\t\\tdocumentIndex \\t\\t\\t\\t\\t= indices[0]\\t\\t\\t# (2) Location of the search term in the document\\n\\t\\t\\t\\t\\tcomboTerms \\t\\t\\t\\t\\t\\t= getComboTerms(tuples)\\t# (3) Multiple terms assigned to variable comboTerms\\n\\t\\t\\t\\t\\tproximity \\t\\t\\t\\t\\t\\t= getProximity(tuples)\\t# (4) Proximity of combo terms if present\\n\\t\\t\\t\\t\\tkernelLeft, kernel, kernelRight = getKernels(indices)\\t# (5) Left, center, and right kernels or excerpts\\n\\n\\t\\t\\t\\t\\tappend([DICECode, TYPECode, Combo, documentIndex, kernelLeft, kernel, kernelRight, comboTerms, proximity])\\n\\n\\t\\t\\telse:\\n\\t\\t\\t\\tdocumentIndex \\t\\t\\t\\t\\t= indices[0]\\t\\t\\t\\t\\t\\t\\t\\t\\t# (1) Location of the search term in the document\\n\\t\\t\\t\\tcomboTerms \\t\\t\\t\\t\\t\\t= format(\\\"[{0}]\\\", text[indices[0]:indices[1]])\\t# (2) Single term assigned to variable comboTerms\\n\\t\\t\\t\\tkernelLeft, kernel, kernelRight = getKernels(indices)\\t\\t\\t\\t\\t\\t\\t# (3) Left, center, and right kernels or excerpts\\n\\n\\t\\t\\t\\tappend([DICECode, TYPECode, Combo, documentIndex, kernelLeft, kernel, kernelRight, comboTerms, proximity])\\n\\n\\t\\treturn excerptsResults\",\n \"def textManip(*args, visible: bool=True, q=True, query=True, **kwargs)->Union[None, Any]:\\n pass\",\n \"def main(argv):\\n correct_font(*argv[1:])\",\n \"def make_optional_silence_txt(self):\\n raise NotImplementedError\",\n \"def draw(grid):\\n\\n for row in grid:\\n for char in row:\\n if char is None:\\n sys.stdout.write(\\\" \\\")\\n else:\\n sys.stdout.write(char)\\n sys.stdout.write(\\\"\\\\n\\\")\",\n \"def format_ocr_text(self, page):\\n \\n #read out of the text file that tesseract made\\n ocr_text = open(self.ocr_text, 'r')\\n \\n # write into this file\\n djvu_text = open( self.djvu_text, 'w' )\\n \\n text = \\\"(page 0 0 1 1\\\\n\\\"\\n \\n self.out_text.write('\\\\n## Page %d ###\\\\n\\\\n' % page )\\n \\n for line in ocr_text:\\n \\n #write to the human readable file\\n self.out_text.write(line)\\n \\n # add each line of text\\n # escaping \\\" to \\\\\\\" as we go\\n text += '(line 0 0 1 1 \\\"%s\\\")\\\\n' % line.replace('\\\"', r'\\\\\\\"').strip()\\n \\n text += \\\")\\\\n\\\"\\n \\n djvu_text.write( text )\\n \\n ocr_text.close()\\n djvu_text.close()\",\n \"def process_text(text, args):\\n if args.uppercase:\\n text = convert_to_uppercase(text)\\n\\n if args.spaces:\\n text = add_spaces(text)\\n\\n if not args.uppercase and not args.spaces:\\n text = add_spaces(text)\\n\\n return text\",\n \"def adjust(text, run_in_function=False):\\n lines = text.split('\\\\n')\\n if len(lines) == 1:\\n return text\\n\\n if lines[0].strip() == '':\\n lines = lines[1:]\\n first_line = lines[0].lstrip()\\n n_spaces = len(lines[0]) - len(first_line)\\n\\n final_lines = [(' ' if run_in_function else '') + line[n_spaces:] for line in lines]\\n\\n if run_in_function:\\n final_lines = [\\n \\\"def test_function():\\\",\\n ] + final_lines + [\\n \\\"test_function()\\\",\\n ]\\n\\n return '\\\\n'.join(final_lines)\",\n \"def render_text_surfaces(self):\\n self.images = [] # The text surfaces.\\n line_width = 0\\n line = []\\n space_width = self.font.size(' ')[0]\\n\\n # Put the words one after the other into a list if they still\\n # fit on the same line, otherwise render the line and append\\n # the resulting surface to the self.images list.\\n for word in self.text:\\n line_width += self.font.size(word)[0] + space_width\\n # Render a line if the line width is greater than the rect width.\\n if line_width > self.rect.w:\\n surf = self.font.render(' '.join(line), True, self.text_color)\\n self.images.append(surf)\\n line = []\\n line_width = self.font.size(word)[0] + space_width\\n\\n line.append(word)\\n\\n # Need to render the last line as well.\\n surf = self.font.render(' '.join(line), True, self.text_color)\\n self.images.append(surf)\",\n \"def clear_text(self):\\n global empty_string\\n \\n for r in range(1,3):\\n for c in range(6):\\n self.create_text_under_photo(data = empty_string,r=r,c=c)\",\n \"def clear_text(self):\\n global empty_string\\n \\n for r in range(1,3):\\n for c in range(6):\\n self.create_text_under_photo(data = empty_string,r=r,c=c)\",\n \"def convert_chn_text(detail=True):\\n p = {\\n \\\"data_path\\\": \\\"../data/data_literature\\\",\\n \\\"output_dir\\\": \\\"../data/converted_data\\\"\\n }\\n if detail:\\n gen_params_info(p)\\n\\n os.system(\\\"rm -rf %s\\\" % p[\\\"output_dir\\\"])\\n os.system(\\\"mkdir -p %s\\\" % p[\\\"output_dir\\\"])\\n files = os.listdir(p[\\\"data_path\\\"])\\n for file_name in files:\\n if detail:\\n print(\\\"to process %s\\\" % file_name)\\n file_path = \\\"%s/%s\\\" % (p[\\\"data_path\\\"], file_name)\\n out_file_path = \\\"%s/%s\\\" % (p[\\\"output_dir\\\"], file_name)\\n fh_in = codecs.open(filename=file_path, mode=\\\"r\\\", encoding='utf8')\\n fh_out = codecs.open(filename=out_file_path, mode=\\\"w\\\", encoding='utf8')\\n line_idx = 1\\n verb = \\\"\\\"\\n for line in fh_in:\\n line = line.lstrip()\\n if line.find(\\\"\\\\t\\\") < 0:\\n print(\\\"Please check in file %s, line: %s\\\\nsentence :%s\\\\n\\\"\\\\\\n \\\"The above sentence has NO TAB and has been skiped!\\\" \\\\\\n % (file_name, line_idx, line))\\n continue\\n items = line.split(\\\"\\\\t\\\")\\n if len(items) != 4:\\n print(\\\"Please check in file %s, line: %s\\\\nsentence :%s\\\\n\\\"\\\\\\n \\\"The above sentence has NO 4 TAB and has been skiped!\\\" \\\\\\n % (file_name, line_idx, line))\\n continue\\n frame_id = items[0]\\n if frame_id.find(\\\".\\\") >= 0:\\n frame_id = frame_id.split(\\\".\\\")[0]\\n verb = items[2].strip()\\n left_sent = items[1].strip()\\n right_sent = items[3].strip()\\n out_line = \\\"%s\\\\t%s\\\\t%s\\\\t%s\\\"\\\\\\n % (frame_id, left_sent, verb, right_sent)\\n print(out_line, file=fh_out)\\n\\n line_idx += 1\\n\\n fh_in.close()\\n fh_out.close()\",\n \"def small_text(self):\\n pass\",\n \"def convert_to_text(batch, lengths, dico, params):\\n batch = batch.cpu().numpy()\\n lengths = lengths.cpu().numpy()\\n\\n slen, bs = batch.shape\\n assert lengths.max() == slen and lengths.shape[0] == bs\\n assert (batch[0] == params.eos_index).sum() == bs\\n assert (batch == params.eos_index).sum() == 2 * bs\\n sentences = []\\n\\n for j in range(bs):\\n words = []\\n for k in range(1, lengths[j]):\\n if batch[k, j] == params.eos_index:\\n break\\n words.append(dico[batch[k, j]])\\n sentences.append(\\\" \\\".join(words))\\n return sentences\",\n \"def processText(text):\\n print(type(text))\\n for line in text:\\n print(line)\\n return text\",\n \"def draw_text(\\n self,\\n text: str,\\n transform: Matrix44,\\n properties: Properties,\\n cap_height: float,\\n ) -> None:\\n raise NotImplementedError\",\n \"def text_update(self):\\n if self.stext is not None:\\n # Get index of non-masked sources :\\n # idx = self._select_unmasked()[-1]\\n\\n # Set masked-sources text to '':\\n text = np.array(self.stext)\\n # text[np.array(~idx, dtype=bool)] = ''\\n\\n # Update elements :\\n self.stextmesh.text = text\\n self.stextmesh.color = self.stextcolor\\n self.stextmesh.font_size = self.stextsize\\n self.stextmesh.update()\",\n \"def preprocess_training_text_with_stops(text, convert=False):\\n return preprocess_training_text(text, accented_chars=True,\\n convert_num=False, extra_whitespace=True, \\n lemmatization=True, lowercase=True, punctuations=True,\\n remove_html=True, remove_num=True, special_chars=True, \\n stop_words=False)\",\n \"def text_to_columns(text):\\n \\n dedented_txt = textwrap.dedent(text).strip()\\n dedented_text = dedented_txt.splitlines()\\n for line in dedented_text:\\n ded_list = [textwrap.fill(line.strip(), initial_indent='', subsequent_indent='', width=20) for line in dedented_text] \\n ded_list2=[]\\n ded_list2.append(ded_list)\\n return print(tabulate(ded_list2, tablefmt ='plain'))\",\n \"def text_to_speech(entry):\\n text = entry.get_text()\\n if text:\\n subprocess.call([\\\"milena_say\\\", text])\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5339875","0.5339875","0.52565366","0.5225016","0.5224651","0.52221847","0.52040446","0.5149263","0.50935054","0.509346","0.50882745","0.50577587","0.50410724","0.50378585","0.5034093","0.5024333","0.5018697","0.50046563","0.4991087","0.49812207","0.49809837","0.49805796","0.49801278","0.49495757","0.49275097","0.4912974","0.49064887","0.48921722","0.4890334","0.48809183","0.4877972","0.4876322","0.4858871","0.4855568","0.48357993","0.48342806","0.48279387","0.48185685","0.48101938","0.48063084","0.47938663","0.47929645","0.4747644","0.47426447","0.47422916","0.474015","0.4737755","0.47338927","0.47299847","0.47261256","0.47242594","0.4721024","0.47210225","0.47191656","0.47144884","0.47099337","0.47098053","0.47086412","0.4703541","0.4702951","0.4697118","0.4695288","0.46925586","0.46904412","0.4682169","0.46792045","0.46771646","0.46771646","0.46771646","0.46771646","0.46771646","0.46718454","0.46705294","0.46695283","0.46686673","0.46679652","0.4666158","0.46600655","0.4659671","0.46546715","0.46506232","0.46491417","0.46484506","0.46456665","0.464041","0.46394974","0.4627992","0.46162754","0.46110514","0.4610035","0.4610035","0.46094075","0.4609097","0.46023232","0.46008855","0.4592708","0.4589503","0.45869377","0.4586473","0.45854598"],"string":"[\n \"0.5339875\",\n \"0.5339875\",\n \"0.52565366\",\n \"0.5225016\",\n \"0.5224651\",\n \"0.52221847\",\n \"0.52040446\",\n \"0.5149263\",\n \"0.50935054\",\n \"0.509346\",\n \"0.50882745\",\n \"0.50577587\",\n \"0.50410724\",\n \"0.50378585\",\n \"0.5034093\",\n \"0.5024333\",\n \"0.5018697\",\n \"0.50046563\",\n \"0.4991087\",\n \"0.49812207\",\n \"0.49809837\",\n \"0.49805796\",\n \"0.49801278\",\n \"0.49495757\",\n \"0.49275097\",\n \"0.4912974\",\n \"0.49064887\",\n \"0.48921722\",\n \"0.4890334\",\n \"0.48809183\",\n \"0.4877972\",\n \"0.4876322\",\n \"0.4858871\",\n \"0.4855568\",\n \"0.48357993\",\n \"0.48342806\",\n \"0.48279387\",\n \"0.48185685\",\n \"0.48101938\",\n \"0.48063084\",\n \"0.47938663\",\n \"0.47929645\",\n \"0.4747644\",\n \"0.47426447\",\n \"0.47422916\",\n \"0.474015\",\n \"0.4737755\",\n \"0.47338927\",\n \"0.47299847\",\n \"0.47261256\",\n \"0.47242594\",\n \"0.4721024\",\n \"0.47210225\",\n \"0.47191656\",\n \"0.47144884\",\n \"0.47099337\",\n \"0.47098053\",\n \"0.47086412\",\n \"0.4703541\",\n \"0.4702951\",\n \"0.4697118\",\n \"0.4695288\",\n \"0.46925586\",\n \"0.46904412\",\n \"0.4682169\",\n \"0.46792045\",\n \"0.46771646\",\n \"0.46771646\",\n \"0.46771646\",\n \"0.46771646\",\n \"0.46771646\",\n \"0.46718454\",\n \"0.46705294\",\n \"0.46695283\",\n \"0.46686673\",\n \"0.46679652\",\n \"0.4666158\",\n \"0.46600655\",\n \"0.4659671\",\n \"0.46546715\",\n \"0.46506232\",\n \"0.46491417\",\n \"0.46484506\",\n \"0.46456665\",\n \"0.464041\",\n \"0.46394974\",\n \"0.4627992\",\n \"0.46162754\",\n \"0.46110514\",\n \"0.4610035\",\n \"0.4610035\",\n \"0.46094075\",\n \"0.4609097\",\n \"0.46023232\",\n \"0.46008855\",\n \"0.4592708\",\n \"0.4589503\",\n \"0.45869377\",\n \"0.4586473\",\n \"0.45854598\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.59195006"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":8778,"cells":{"query":{"kind":"string","value":"Saves chunked speech intervals as WAV file."},"document":{"kind":"string","value":"def save_chunks(chunk_sound, out_path, video_id):\n chunk_start_ms = int(chunk_sound.get_start_time()*1000)\n chunk_end_ms = int(chunk_sound.get_end_time()*1000)\n chunk_duration = chunk_end_ms - chunk_start_ms\n\n chunk_fn = '{0}_{1}_{2}.wav'.format(video_id, chunk_start_ms, chunk_end_ms)\n chunk_file_path = path.join(out_path, chunk_fn)\n chunk_sound.save(chunk_file_path, 'WAV')\n\n return {'filename': chunk_fn, 'video_id': video_id, 'start_time': chunk_start_ms, 'end_time': chunk_end_ms, 'duration': chunk_duration}"},"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 save_wav(file_name, signal, fs):\n wavfile.write(file_name, fs, np.int16(signal/np.max(np.abs(signal)) * (2**(16)/2-1)))","def save_audio(self, name=DEFAULT_OUT_NAME):\n print(\"Saving...\")\n wf = wave.open(name+'.wav', 'wb')\n wf.setnchannels(DEFAULT_CHANNELS)\n wf.setsampwidth(self.audio.get_sample_size(DEFAULT_FORMAT))\n wf.setframerate(DEFAULT_RATE)\n wf.writeframes(b''.join(self.frames))\n wf.close()\n print('Saved')","def __save(self,audio):\n self.__openSampleFile()\n self.__sampleFile.writeframes(audio)","def save_frames_to_wav_file(frames: np.ndarray, sample_rate: int, file_path: str):\n wavfile.write(file_path, sample_rate, np.hstack(frames))","def write_wav(fname, samps, sampling_rate=16000, normalize=True):\n\t# for multi-channel, accept ndarray [Nsamples, Nchannels]\n\tif samps.ndim != 1 and samps.shape[0] < samps.shape[1]:\n\t\tsamps = np.transpose(samps)\n\t\tsamps = np.squeeze(samps)\n\t# same as MATLAB and kaldi\n\tif normalize:\n\t\tsamps = samps * MAX_INT16\n\t\tsamps = samps.astype(np.int16)\n\tfdir = os.path.dirname(fname)\n\tif fdir and not os.path.exists(fdir):\n\t\tos.makedirs(fdir)\n\t# NOTE: librosa 0.6.0 seems could not write non-float narray\n\t# so use scipy.io.wavfile instead\n\twavfile.write(fname, sampling_rate, samps)","def save(self, fname, master_volume=1.):\n \n # first pass - find max amplitude value to normalise output\n vmax = 0.\n for c in range(len(self.out_channels)):\n vmax = max(\n abs(self.out_channels[str(c)].values.max()),\n abs(self.out_channels[str(c)].values.min()),\n vmax\n )\n\n # normalisation for conversion to int32 bitdepth wav\n norm = master_volume * (pow(2, 31)-1) / vmax\n\n # setup array to house wav stream data \n chans = np.zeros((self.out_channels['0'].values.size,\n len(self.out_channels)), dtype=\"int32\")\n \n # normalise and collect channels into a list\n for c in range(len(self.out_channels)):\n vals = self.out_channels[str(c)].values\n chans[:,c] = (vals*norm).astype(\"int32\")\n \n # finally combine and write out wav file\n wavfile.write(fname, self.samprate, chans)\n print(f\"Saved {fname}\")","def _save_wav(buff, data, rate) -> None:\n # Code inspired from `IPython.display.Audio`\n data = np.array(data, dtype=float)\n\n bit_depth = 16\n max_sample_value = int(2**(bit_depth - 1)) - 1\n\n num_channels = data.shape[1] if len(data.shape) > 1 else 1\n scaled = np.int16(data / np.max(np.abs(data)) * max_sample_value)\n # The WAVE spec expects little-endian integers of \"sampwidth\" bytes each.\n # Numpy's `astype` accepts array-protocol type strings, so we specify:\n # - '<' to indicate little endian\n # - 'i' to specify signed integer\n # - the number of bytes used to represent each integer\n # See: https://numpy.org/doc/stable/reference/arrays.dtypes.html\n encoded_wav = scaled.astype(f'<i{bit_depth // 8}', copy=False).tobytes()\n\n with wave.open(buff, mode='wb') as waveobj:\n waveobj.setnchannels(num_channels)\n waveobj.setframerate(rate)\n waveobj.setsampwidth(bit_depth // 8)\n waveobj.setcomptype('NONE', 'NONE')\n waveobj.writeframes(encoded_wav)","def write_wav(self, full_out_file = None):\n\n if full_out_file is None:\n \n (out_file, out_dir) = misc.save_file(FilterSpec='*.wav', DialogTitle='Write sound to ...', \n DefaultName='')\n full_out_file = os.path.join(out_dir, out_file)\n if full_out_file is None:\n print('Output discarded.')\n return 0\n else:\n full_out_file = os.path.abspath(full_out_file)\n (out_dir , out_file) = os.path.split(full_out_file)\n\n write(str(full_out_file), int(self.rate), self.data)\n print('Sounddata written to ' + out_file + ', with a sample rate of ' + str(self.rate))\n print('OutDir: ' + out_dir)\n \n return full_out_file","def save_sound(filename,sound,sample_freq,num_channels):\n #open a wave file in write ('w') mode, this will create the file\n file=wave.open(filename,'w')\n #set the framerate aka sample frequency\n file.setframerate(sample_freq)\n #set the number of the channels\n file.setnchannels(num_channels)\n #the size of the one sample in bytes\n file.setsampwidth(2)\n #write the actual sound to the file, notice the call to get_raw\n file.writeframesraw(sound.get_raw())\n file.close()","def create_wav_file(self, ):\n\n f_out = open(self.wav_file, 'w')\n u_utt2spk = open(self.utt2spk, 'w')\n for file in glob.glob(self.wav_folder+'/*.wav'):\n base = os.path.basename(file).split('.')[0]\n # write to scp file\n f_out.write(base + '\\t' + file + '\\n')\n u_utt2spk.write(base + '\\t' + 'tts' + '\\n')","def save_wav(filename, samples, rate=16000, width=2, channels=1):\n wav = wave.open(filename, 'wb')\n wav.setnchannels(channels)\n wav.setsampwidth(width)\n wav.setframerate(rate)\n wav.writeframes(samples)\n wav.close()","def split_on_silence_threshold(wav_file, dest_dir):\n # Read the file\n audioSegment = AudioSegment.from_wav(wav_file)\n # Calculating the silence threshold\n # Normalizing the audio file belfore finding the threshold\n full_audio_wav = normalize(audioSegment)\n loudness_ms_list = [] # Save the audio levels of all the chunks\n for ms_chunk in full_audio_wav:\n loudness_ms_list.append(round(ms_chunk.dBFS))\n print(\"Audio levels are recorded\", file=sys.stderr)\n # Using pandas df for easier manipulation\n df = pd.DataFrame(loudness_ms_list)\n df[0] = df[df[0] != float(\"-inf\")] # Remove the very low levels\n st = df[0].mean()\n st = st if st < -16 else -16 # Because -16db is default\n # Splits the audio if silence duration is MSL long\n MSL = 500 # minimum silence length in ms\n chunks = split_on_silence(\n full_audio_wav, \n # split on silences longer than 500ms (500ms)\n min_silence_len=MSL, \n # anything under -16 dBFS is considered silence\n silence_thresh=st, \n # keep 200 ms of leading/trailing silence\n keep_silence=200, \n )\n # Saving all the chunks\n print(\"Writing all the files, this may take some time!\", file=sys.stderr)\n for index, chunk in enumerate(chunks):\n chunk_file_name = os.path.join(dest_dir, \"sample_{}.wav\".format(str(index).zfill(10)))\n print(\"Saving the file to \" + chunk_file_name, file=sys.stderr)\n # You can export as mp3 etc, note that it has dependency on ffmpeg\n chunk.export(chunk_file_name, format=\"wav\")","def save_sample(file_path, sampling_rate, audio):\n audio = (audio.numpy() * 32768).astype(\"int16\")\n write(file_path, sampling_rate, audio)","def write_data_to_wav(self, file_name: str, data):\r\n # apply scale and convert to int16\r\n data = np.int16(data/np.max(np.abs(data)) * self.wav_scale)\r\n # write to file\r\n write(file_name, self.audio_sample_rate, data)\r\n print('Sound ', file_name, ' has been saved')","def save_stereo(self, fname, master_volume=1.):\n\n if len(self.out_channels) > 2:\n print(\"Warning: sonification has > 2 channels, only first 2 will be used. See 'save_combined' method.\")\n \n # first pass - find max amplitude value to normalise output\n # and concatenate channels to list\n vmax = 0.\n channels = []\n for c in range(min(len(self.out_channels), 2)):\n vmax = max(\n abs(self.out_channels[str(c)].values.max()),\n abs(self.out_channels[str(c)].values.min()),\n vmax\n ) / master_volume\n channels.append(self.out_channels[str(c)].values)\n \n wav.write(fname, \n np.column_stack(channels),\n self.samprate, \n scale = (-vmax,vmax),\n sampwidth=3)\n \n print(\"Saved.\")","def export_wav(self, folder, name_fmt=\"{:02d}.wav\", dtype=np.int16):\n data = np.atleast_2d(self.in_time)\n\n assert data.ndim == 2\n assert np.all(np.abs(data) <= 1.0)\n\n # convert and scale to new output datatype\n if dtype in [np.uint8, np.int16, np.int32]:\n lim_orig = (-1.0, 1.0)\n lim_new = (np.iinfo(dtype).min, np.iinfo(dtype).max)\n data = _rescale(data, lim_orig, lim_new).astype(dtype)\n elif dtype != np.float32:\n raise TypeError(f\"dtype {dtype} is not supported by scipy.wavfile.write.\")\n\n path = Path(folder)\n if not path.is_dir():\n path.mkdir(parents=True, exist_ok=False)\n\n for i in range(data.shape[0]):\n wavfile.write(path / name_fmt.format(i + 1), self.fs, data[i])","def write(f, sr, x, normalized=False):\n channels = 2 if (x.ndim == 2 and x.shape[1] == 2) else 1\n if normalized: # normalized array - each item should be a float in [-1, 1)\n y = np.int16(x * 2 ** 15)\n else:\n y = np.int16(x)\n song = pydub.AudioSegment(y.tobytes(), frame_rate=sr, sample_width=2, channels=channels)\n song.export(f, format=\"mp3\", bitrate=\"64k\")","def write_timeline_to_wav(output_path, data, sample_rate):\n\n scipy.io.wavfile.write(output_path, sample_rate, data.T)","def save_combined(self, fname, ffmpeg_output=False, master_volume=1.):\n # setup list to house wav stream data \n inputs = [None]*len(self.out_channels)\n\n # first pass - find max amplitude value to normalise output\n vmax = 0.\n for c in range(len(self.out_channels)):\n vmax = max(\n abs(self.out_channels[str(c)].values.max()),\n abs(self.out_channels[str(c)].values.min()),\n vmax\n ) / master_volume\n \n print(\"Creating temporary .wav files...\")\n \n for c in range(len(self.out_channels)):\n tempfname = f\"./.TEMP_{c}.wav\"\n wav.write(tempfname, \n self.out_channels[str(c)].values,\n self.samprate, \n scale = (-vmax,vmax),\n sampwidth=3)\n inputs[self.channels.forder[c]] = ff.input(tempfname)\n \n print(\"Joning temporary .wav files...\")\n (\n ff.filter(inputs, 'join', inputs=len(inputs), channel_layout=self.channels.setup)\n .output(fname)\n .overwrite_output()\n .run(quiet=~ffmpeg_output)\n )\n \n print(\"Cleaning up...\")\n for c in range(len(self.out_channels)):\n os.remove(f\"./.TEMP_{c}.wav\")\n \n print(\"Saved.\")","def save_wavetables(self, path: str, filename_prefix: str = '') -> None:\n for i in range(len(self.wavetables)):\n if not os.path.exists(path):\n os.mkdir(path)\n location = os.path.join(path, filename_prefix + f'{i:02d}.wav')\n wav_file = WavFile(location)\n wav_file.write_samples(self.wavetables[i])","def all_wav_to_mp3(self):\n for each_file, artist in self.past_songs_db_data:\n self.convert_wav_to_mp3(each_file)","def save(self, name):\n try:\n os.mkdir(os.path.join(self.dbpath, name))\n except:\n pass\n\n wf = wave.open(os.path.join(self.dbpath, name, str(uuid.uuid4()) + \".wav\"), 'wb')\n wf.setnchannels(self.CHANNELS)\n wf.setsampwidth(self.p.get_sample_size(self.FORMAT))\n wf.setframerate(self.RATE)\n wf.writeframes(b''.join(list(self.frames)))\n wf.close()","def export_wav(\n filename_wav: Path,\n tradb: vae.io.TraDatabase,\n channel: int,\n time_start: Optional[float] = None,\n time_stop: Optional[float] = None,\n decimation_factor: int = 1,\n):\n y, fs = tradb.read_continuous_wave(\n channel=channel,\n time_start=time_start,\n time_stop=time_stop,\n time_axis=False,\n show_progress=False,\n raw=True, # read as ADC values (int16)\n )\n\n if decimation_factor > 1:\n y = signal.decimate(y, decimation_factor).astype(np.int16)\n fs //= decimation_factor\n\n wavfile.write(filename_wav, fs, y)","def save_secured_song_to_wave(self, file_location):\n protected_wav = wave.open(os.path.abspath(file_location), 'wb')\n protected_wav.setnchannels(self.original_song.getnchannels())\n protected_wav.setsampwidth(self.original_song.getsampwidth())\n protected_wav.setframerate(self.original_song.getframerate())\n protected_wav.writeframes(self.metadata)\n\n for val in self.full_song:\n protected_wav_val = struct.pack('<h', val)\n protected_wav.writeframesraw(protected_wav_val)\n\n protected_wav.close()","def wavwrite(y, fs, filename):\n \n x = copy.deepcopy(y) # copy array\n x *= INT16_FAC # scaling floating point -1 to 1 range signal to int16 range\n x = np.int16(x) # converting to int16 type\n wavfile.write(filename, fs, x)","def save_separated_audio(self, audios, filename):\n\n # Create folder with mixture name\n folder_path = os.path.join(self.config[\"separated_audio_folder\"], os.path.splitext(filename)[0])\n os.makedirs(folder_path)\n # Save each separated source\n for class_idx, audio in enumerate(audios):\n librosa.output.write_wav(os.path.join(folder_path, self.data_set.classes[class_idx]) + '.wav',\n audio.T,\n sr=self.data_set.config[\"sampling_rate\"])\n # Also copy the mixture in the folder\n copyfile(self.data_set.audio_full_filename(filename), os.path.join(folder_path, \"original_mix.wav\"))","def wavwrite(y, fs, filename):\n\n\tx = copy.deepcopy(y) # copy array\n\tx *= INT16_FAC # scaling floating point -1 to 1 range signal to int16 range\n\tx = np.int16(x) # converting to int16 type\n\twrite(filename, fs, x)","def save_to_file(\n sources,\n codec='wav', audio_adapter=ffmpeg.FFMPEGProcessAudioAdapter(),\n bitrate='128k', synchronous=True):\n\n # filename = \"chengdu.mp3\"\n pool = Pool()\n tasks = []\n for instrument, data in sources.items():\n path = \"./out/\"+instrument + \".\" + codec\n\n if pool:\n task = pool.apply_async(audio_adapter.save, (\n path,\n data,\n 44100,\n codec,\n bitrate))\n tasks.append(task)\n else:\n audio_adapter.save(path, data, 44100, codec, bitrate)\n if synchronous and pool:\n while len(tasks) > 0:\n task = tasks.pop()\n task.get()\n task.wait(timeout=200)","def output_beat_to_file(file_name, e):\n print(\"Writing to file:\", file_name)\n routine = gp.compile(e,pset)\n with open(file_name+\".raw\",'w') as f:\n for t in range(200000):\n f.write(chr(int(routine(t+1))%256))\n # Now convert to wav\n subprocess.call(SOX_COMMAND + \" \" + file_name + \".raw\" + \" \" + file_name + \".wav\", shell=True)\n subprocess.call(LAME_COMMAND + \" \" + file_name + \".wav\", shell=True)","def wavwrite(fname, Fs, xt):\n # convert to np.int16 data type\n xt = np.array((2**15-1)*xt, np.int16)\n sio_wav.write(fname, Fs, xt)","def save_wfm(self, source, dest):\n self.bus.write('SAV:WAVE %s,%s' % (source, dest))","def write_wav(filename, data, rate = 44100):\r\n \r\n # Compress the data (the input format is likely to be float64)\r\n # Make sure that the format is readable by Librosa\r\n maxv = np.iinfo(np.int16).max\r\n lb_write_wav(filename, (data * maxv).astype(np.int16), rate) \r\n \r\n return(None)","def write_wave(path, audio, sample_rate):\n with contextlib.closing(wave.open(path, 'wb')) as wf:\n wf.setnchannels(1)\n wf.setsampwidth(2)\n wf.setframerate(sample_rate)\n wf.writeframes(audio)","def _create_wave_file(self):\n is_wave_open = False\n try:\n wv = wave.open(self.audio_file_name, mode='wb')\n is_wave_open = True\n wv.setparams((1, # 1 channel (mono)\n 2, # 2 bytes per sample * 1 channel\n self.sample_rate,\n 0, # Initial number of samples.\n 'NONE',\n 'not compressed'))\n wv.writeframes(self.sample_buffer)\n except:\n print('Error creating audio file')\n if is_wave_open:\n wv.close()","def write_sound(file, snds: Property, pack_list, snd_prefix='*'):\n if snds.has_children():\n file.write('\"rndwave\"\\n\\t{\\n')\n for snd in snds:\n file.write(\n '\\t\"wave\" \"{sndchar}{file}\"\\n'.format(\n file=snd.value.lstrip(SOUND_CHARS),\n sndchar=snd_prefix,\n )\n )\n pack_list.add('sound/' + snd.value.casefold())\n file.write('\\t}\\n')\n else:\n file.write(\n '\"wave\" \"{sndchar}{file}\"\\n'.format(\n file=snds.value.lstrip(SOUND_CHARS),\n sndchar=snd_prefix,\n )\n )\n pack_list.add('sound/' + snds.value.casefold())","def save_wav(data, file_path, sample_rate):\n if np.issubdtype(data.dtype, np.floating):\n data = data.astype(np.float32)\n elif data.dtype not in [np.int32, np.int16, np.uint8]:\n raise ValueError(f'wavfile data must be np.float*, np.int32, np.int16, or np.uint8, got {data.dtype}')\n\n wavfile.write(file_path, sample_rate, data)","def writesilence(self, duration):\n samples = int(self.sample_rate * duration)\n values = []\n for i in range(0, samples):\n signal = wave.struct.pack('h', 0)\n values.append(signal)\n # Buffer values every 5 seconds (22050 samples)\n if len(values) >= 220500:\n value_string = \"\".join(values)\n self.file.writeframes(value_string)\n # Clear values array\n del values[0:len(values)]\n value_string = \"\".join(values)\n self.file.writeframes(value_string)","def raw_to_wav(data, path, rate=44100):\n wavfile.write(path, rate, data)","def write_audio_segment(self, data):\n cache_name = self.CACHE_FILE_NAME + str(time.time()) + '.wav'\n file = open(cache_name, \"wb\")\n file.write(data)\n file.close()\n return cache_name","def record_audio_to_file(self, time, file_name):\n sample_width, frames = self.record_audio(time)\n wf = wave.open(file_name, 'wb')\n wf.setnchannels(self.channels)\n wf.setsampwidth(sample_width)\n wf.setframerate(self.rate)\n wf.writeframes(frames)\n wf.close()","def make_waves(wave_array, filename: str, num_cycle=1):\n sampleRate = 44100.0 # hertz\n duration = 1.0 # seconds\n frequency = 440.0 # hertz\n obj = wave.open(filename, 'w')\n obj.setnchannels(1) # mono\n obj.setsampwidth(2)\n obj.setframerate(sampleRate)\n waves = list(wave_array)\n for w in range(num_cycle):\n for i in waves:\n value = i\n data = struct.pack('<h', int(value))\n obj.writeframesraw(data)\n obj.close()","def save_to_file(samps, filename, save_as_numpy):\n with open(filename, 'wb') as out_file:\n if save_as_numpy:\n np.save(out_file, samps, allow_pickle=False, fix_imports=False)\n else:\n samps.tofile(out_file)","def test_wav_multiple_channels(self, dtype, sample_rate, num_channels):\n duration = 1\n path = self.get_temp_path(\"data.wav\")\n data = get_wav_data(dtype, num_channels, normalize=False, num_frames=duration * sample_rate)\n save_wav(path, data, sample_rate)\n info = self._info(path)\n assert info.sample_rate == sample_rate\n assert info.num_frames == sample_rate * duration\n assert info.num_channels == num_channels\n assert info.bits_per_sample == sox_utils.get_bit_depth(dtype)\n assert info.encoding == get_encoding(\"wav\", dtype)","def play(sampler, name=\"/Users/Jxie0755/Documents/DXcodings/Learning_Python/CS_61A/week03/mario.wav\", seconds=2):\n out = open(name, \"wb\")\n out.setnchannels(1)\n out.setsampwidth(2)\n out.setframerate(frame_rate)\n t = 0\n while t < seconds * frame_rate:\n sample = sampler(t)\n out.writeframes(encode(sample))\n t = t + 1\n out.close()","def _to_wav(self):\n self._status = 0\n fname = fm.file2wav(self.get_filename()) \n if fname != self.get_filename(): # can change the name\n self._set_filename(fname) # in case of wave transcoding\n self._status = 1","def saveSong(song, filename, append = 1):\n if append:\n mode = \"w+\"\n else:\n mode = \"w\"\n fp = open(filename, mode) # will append it if it exists\n if type(song) in [list]:\n for tup in song:\n if len(tup) == 2:\n f, d = tup\n fp.write(\"%s %s\\n\" % (_getNoteFromFrequency(f), d))\n elif len(tup) == 3:\n f1, f2, d = tup\n fp.write(\"%s %s %s\\n\" % (_getNoteFromFrequency(f),\n _getNoteFromFrequency(f), d))\n else: # string\n song = song.replace(\"\\n\", \";\")\n lines = song.split(\";\")\n for line in lines:\n fp.write(line + \"\\n\")\n fp.close()","def write_audio_to_file(audio: torch.Tensor, sample_id: str = ''):\n global FS_HZ\n assert FS_HZ is not None\n audio_extension = '.wav'\n audio_path = upload_directory + 'sample' + sample_id + audio_extension\n audio_np = audio.cpu().numpy()\n with open(audio_path, 'wb') as f:\n soundfile.write(f,\n audio_np,\n samplerate=FS_HZ)\n return audio_path","def save_mp3(ndarray, sr, feature_name, out_path, x, y, new_labels, mp3_filename=None):\n import soundfile as sf\n\n def _save_mp3(source_path, out_path):\n cmd = [\n 'lame',\n '--preset',\n 'insane',\n str(source_path),\n str(out_path)\n ]\n errno = subprocess.call(cmd)\n if errno:\n print('{} encoding failed with code'.format(source_path), end=' ')\n print(errno)\n print('skipping...')\n return errno\n os.remove(source_path)\n return 0\n\n # this is kind-of standard\n if mp3_filename is None:\n mp3_filename = FeatureExtractor.get_file_name(x, feature_name, 'mp3')\n wav_filename = mp3_filename.replace('mp3', 'wav')\n sf.write(str(out_path / wav_filename), ndarray, sr) # write wav file\n errno = _save_mp3(out_path / wav_filename,\n out_path / mp3_filename) # load wav, encode as mp3 and remove wav file\n if errno:\n # if any error, then keep wav\n filename = wav_filename\n else:\n # non-error clause, then it was successfully exported to mp3\n filename = mp3_filename\n if new_labels is not None:\n new_labels.append([filename, y])\n print('info: {} transformed and saved!'.format(filename))\n return filename","def snip(filename,s,e,wout=True):\n n, data, data_dB,sr,ch=inputwav(filename)\n st=int(s*44100)\n en=int(e*44100)\n data_s=data[st:en,:]\n if wout==True:\n print('Exporting...')\n sf.write(filename[0:len(filename)-4]+'_snipped.wav',data_s,sr,'PCM_16')\n print('Done!')\n return data_s","def write_wave(data, samp_rate, file):\n if data.dtype != np.float16:\n assert(data.dtype in [np.float32, np.float64])\n if (len(data.shape) < 2 or data.shape[0] > data.shape[1] or\n not data.dtype in [np.float32, np.float64]):\n raise ValueError(\"Input audio had unexpected type or shape or dtype: {},{}\"\n .format(data.shape, data.dtype))\n max_val = data.max() * 32768.0\n min_val = data.min() * 32768.0\n\n truncation_scale = 1.0\n if max_val > 32767.0:\n # The + 0.1 below is a small offset to prevent roundoff causing\n # wrap-around errors.\n truncation_scale = 32767.0 / (max_val + 0.1)\n if min_val < -32768.0:\n s = 32768.0 / (-min_val + 0.1);\n if s > truncation_scale:\n truncation_scale = s\n scale = 32768.0 * truncation_scale\n data = np.rint(data * scale).astype(np.int16)\n data = data.swapaxes(0, 1)\n file = file_utils.open_or_fd(file, \"w\", encoding=None)\n wavio.write(file, data, samp_rate, scale='none')\n file.close()","def convert_to_wav(fin, fout):\n temp = subprocess.run([\"ffmpeg\",\n \"-i\", \n fin, \n fout], \n stdout=subprocess.PIPE, \n stderr=subprocess.PIPE)","def to_voice(item):\r\n item.seek(0)\r\n item = AudioSegment.from_file(item)\r\n m = io.BytesIO()\r\n m.name = \"voice.ogg\"\r\n item.split_to_mono()\r\n dur = len(item) / 1000\r\n item.export(m, format=\"ogg\", bitrate=\"64k\", codec=\"libopus\")\r\n m.seek(0)\r\n return m, dur","def test_wav(self, dtype, sample_rate, num_channels):\n duration = 1\n path = self.get_temp_path(\"data.wav\")\n data = get_wav_data(dtype, num_channels, normalize=False, num_frames=duration * sample_rate)\n save_wav(path, data, sample_rate)\n info = self._info(path)\n assert info.sample_rate == sample_rate\n assert info.num_frames == sample_rate * duration\n assert info.num_channels == num_channels\n assert info.bits_per_sample == sox_utils.get_bit_depth(dtype)\n assert info.encoding == get_encoding(\"wav\", dtype)","def morse_to_audio(words, playsound=None, name_file=\"output\\\\code_to_audio_output.wav\"):\n dot = wave.open(\"kropka.wav\", 'rb')\n dash = wave.open(\"kreska.wav\", 'rb')\n\n rate_dot = dot.getframerate()\n\n rate_dash = dash.getframerate()\n\n data_dot = dot.readframes(-1)\n data_dash = dash.readframes(-1)\n data_dot = np.fromstring(data_dot, 'Int16')\n data_dash = np.fromstring(data_dash, 'Int16')\n\n l2=len(data_dot)\n l1=len(data_dash)\n\n output=[]\n\n for element in words:\n # print(element)\n for i in range(0, len(element)):\n # print(element[i])\n if element[i] == '1':\n # playsound(\"kropka.wav\")\n output.extend(data_dot)\n\n if element[i] == '0':\n # playsound(\"kreska.wav\")\n output.extend(data_dash)\n if element[i] == ' ':\n output.extend(np.zeros(int(len(data_dash)))*3)\n if i != len(element) - 1:\n # time.sleep(dl_kropka)\n output.extend(np.zeros(int(len(data_dot))))\n else:\n continue\n # time.sleep(dl_kreska)\n output.extend(np.zeros(int(len(data_dash))))\n\n # print(output)\n\n wynik=np.asarray(output)\n\n wynik=np.array(wynik).astype('int16')\n\n wav.write(name_file, rate_dash, wynik)\n\n #plik sie nie odtwarza w windowsie ale w audacity jest już wyraźnym szumem XD\n\n dot.close()\n dash.close()","def split_multiple_recordings_file(file_path, min_silence_duration=0.25, noise_threshold=150):\n print(file_path)\n rate, audio = scipy.io.wavfile.read(file_path)\n split_recordings = split_multiple_recordings(audio, min_silence_duration=min_silence_duration,\n noise_threshold=noise_threshold, sample_rate_hz=rate)\n\n if file_path.count('.') != 1:\n raise Exception('File_path must contain exactly one period, usually in extension. IE: /home/test.wav')\n\n for idx, recording in enumerate(split_recordings):\n print(\"spliting \" + file_path)\n new_file_path = file_path.split('.')[0] + '_' + str(idx) + \".wav\"\n scipy.io.wavfile.write(new_file_path, rate, recording)","def segment_audio(filename, y_value, split='train', clf='gender'):\n\n filepath = 'recordings/recordings/' + filename + '.mp3'\n audio, sr = librosa.load(filepath, sr=16000)\n audio = normalize(audio)\n\n # Add gender label to filename for later processing\n sex = y_value\n if sex == 'female':\n filename = '{}.F'.format(filename)\n else: filename = '{}.M'.format(filename)\n\n # Segment audio file\n seg_files = segment_10s(audio, sr)\n\n for key, val in seg_files.items():\n new_name = '{}.{}'.format(filename, key)\n sf.write('data/{}/{}/{}o.wav'.format(clf, split, new_name), val, sr)","def audio_file_save(folder_path, current_time, data, name_by_date):\r\n\r\n name_by_time = current_time + '.wav' #timestamp for the audio file name\r\n usage = disk_usage(folder_path)\r\n if usage.used / usage.total < args.storage_threshold:\r\n file_path = os.path.join(folder_path, name_by_time)\r\n\r\n if args.resampling:\r\n sampling_rate = args.resampling_rate\r\n audio = audio_resampling(data)\r\n else:\r\n sampling_rate = args.recording_samplerate\r\n audio = data\r\n\r\n sf.write(file_path , audio, sampling_rate)\r\n\r\n else:\r\n name = os.path.join(folder_path, name_by_date + '.txt')\r\n f = open(name, 'a')\r\n f.write(current_time + '\\t Activity Detected \\n')\r\n f.close()","def record_audio_to_file_and_get_wav(self, time, file_name):\n sample_width, frames = self.record_audio(time)\n wf = wave.open(file_name, 'wb')\n wf.setnchannels(self.channels)\n wf.setsampwidth(sample_width)\n wf.setframerate(self.rate)\n wf.writeframes(frames)\n wf.close()\n return WavFile(samples=frames, sample_width=sample_width, time=time, word=file_name)","def convert_wav(src_wav, dst_wav, subtype='PCM_16'):\n assert os.path.exists(src_wav), \"{} not exists!\".format(src_wav)\n data, sr = soundfile.read(src_wav)\n soundfile.write(dst_wav, data, sr, subtype=subtype)","def output_wave_file(predicted_mfccs, filename):\n global eng\n predicted_mfccs_transposed = np.transpose(predicted_mfccs)\n\n\n # MFCC features need to be a numpy array of shape (num_coefficients x num_frames) in order to be passed to the invmelfcc function\n inverted_wav_data = eng.invmelfcc(matlab.double(predicted_mfccs_transposed.tolist()), 16000.0, 25, 100.0, 0.005, 0.005)\n\n inverted_wav_data = np.squeeze(np.array(inverted_wav_data))\n\n # scales the waveform to be between -1 and 1\n maxVec = np.max(inverted_wav_data)\n minVec = np.min(inverted_wav_data)\n inverted_wav_data = ((inverted_wav_data - minVec) / (maxVec - minVec) - 0.5) * 2\n\n wav.write(filename + '.wav', 16000.0, inverted_wav_data)","def mp3_to_wav(show_progress=True):\n\n # Define a devnull var to supress subprocess output\n devnull = open(os.devnull, 'w')\n\n # Get a list of the filepath for each of the mp3 files in each subdirectory of data/fma_small\n file_list = glob.glob('./../data/fma_small/*/*.mp3')\n\n # Get the number of files N and initialize a counter\n N = len(file_list)\n counter = 0\n\n # For each file/filepath, convert that file to wav format and save it to data/wavs/*/*.wav (so as a wave file)\n for filepath in file_list:\n\n # Every 100 file conversions, print a progress update\n if counter % 50 == 49 and show_progress:\n progress = str(round(100 * counter / N, 2))\n print('File conversion ' + progress + '% complete.')\n\n # Get the file name from the path and define a new path for the wav file\n file_name = filepath[24:-4]\n new_path = './../data/wavs/' + file_name + '.wav'\n\n # Call the subprocess using ffmpeg to convert the file to wav format (and supress all the output)\n subprocess.call(['ffmpeg', '-i', filepath, new_path], stdout=devnull)\n\n # Increment the counter\n counter += 1","def record():\n p = pyaudio.PyAudio()\n stream = p.open(format=FORMAT, input_device_index=0, channels=1, rate=RATE, input=True, output=True, frames_per_buffer=CHUNK_SIZE)\n num_silent = 0\n snd_started = False\n\n r = array('h')\n while 1:\n snd_data = array('h', stream.read(CHUNK_SIZE, exception_on_overflow = False))\n if byteorder == 'big':\n snd_data.byteswap()\n r.extend(snd_data)\n\n silent = is_silent(snd_data)\n if silent and snd_started:\n num_silent += 1\n elif not silent and not snd_started:\n print(\"Sound started.\")\n snd_started = True\n\n if snd_started and num_silent> 10:\n break\n\n sample_width = p.get_sample_size(FORMAT)\n stream.stop_stream()\n stream.close()\n p.terminate()\n\n r = normalize(r)\n #r = trim(r)\n #r = add_silence(r, 0.5)\n return sample_width, r","def save_audio(ndarray, feature_name, out_path, x, y, new_labels, filename=None, sr=SR):\n # this is kind-of standard\n filename = filename or FeatureExtractor.get_file_name(x, feature_name, 'wav')\n librosa.output.write_wav(out_path / filename, ndarray, sr=sr, norm=True)\n new_labels.append([filename, y])\n print('info: {} transformed and saved!'.format(filename))\n return filename","def generate_waveform(self, mel, normalize=True, batched=True,\n target=8000, overlap=800, do_save_wav=True):\n wav = self.vocoder_manager.infer_waveform(mel,\n normalize=normalize,\n batched=batched,\n target=target,\n overlap=overlap,\n do_save_wav=do_save_wav\n )\n return wav","def export_sounds(names, path, base_label='Sound_'):\n\tfor filename, output in dump_sounds(names, base_label):\n\t\twith open(os.path.join(path, filename), 'w') as out:\n\t\t\tout.write(output)","def record():\n p = pyaudio.PyAudio()\n stream = p.open(format=FORMAT, channels=1, rate=RATE,\n input=True, output=True,\n frames_per_buffer=CHUNK_SIZE)\n\n num_silent = 0\n snd_started = False\n\n r = array('h')\n\n while 1:\n # little endian, signed short\n snd_data = array('h', stream.read(CHUNK_SIZE))\n if byteorder == 'big':\n snd_data.byteswap()\n r.extend(snd_data)\n\n silent = is_silent(snd_data)\n\n if silent and snd_started:\n num_silent += 1\n elif not silent and not snd_started:\n snd_started = True\n\n if snd_started and num_silent > 30:\n break\n\n sample_width = p.get_sample_size(FORMAT)\n stream.stop_stream()\n stream.close()\n p.terminate()\n\n r = normalize(r)\n r = trim(r)\n r = add_silence(r, 0.5)\n return sample_width, r","def encode_audio(in_file, out_file):\r\n # construct the encoder\r\n autoencoder = keras.models.load_model(\"audio_autoencoder.model\")\r\n in_layer = keras.layers.Input(shape=(416, 1))\r\n encode = autoencoder.layers[1](in_layer)\r\n encode = autoencoder.layers[2](encode)\r\n encode = autoencoder.layers[3](encode)\r\n encode = autoencoder.layers[4](encode)\r\n encode = autoencoder.layers[5](encode)\r\n encode = autoencoder.layers[6](encode)\r\n encode = autoencoder.layers[7](encode)\r\n encode = autoencoder.layers[8](encode)\r\n encode = autoencoder.layers[9](encode)\r\n encode = autoencoder.layers[10](encode)\r\n encode = autoencoder.layers[11](encode)\r\n encode = autoencoder.layers[12](encode)\r\n encoder = keras.models.Model(in_layer, encode)\r\n\r\n # Read the file\r\n samp_rate, data = wavfile.read(in_file)\r\n # check if the file is mono or stereo\r\n if len(data.shape) == 2:\r\n data = np.concatenate(data)\r\n chans = 2\r\n else:\r\n chans = 1\r\n\r\n # Rescale integer samples over range [-32768,32767] to floats over range [0.0,1.0]\r\n data = data.astype('float32') / float(pow(2, 15))\r\n data += 1.0\r\n data = data / 2.0\r\n\r\n # Pad the samples with zeroes, if needed, to make the last encoding frame full\r\n padded = np.pad(data, (0, 416 - (len(data) % 416)), 'constant')\r\n\r\n # Construct input layer\r\n inputs = padded.reshape(len(padded) // 416, 416, 1)\r\n\r\n # Encode the data\r\n encoded = encoder.predict(inputs)\r\n\r\n # Save the encoded data, as well as the important parameters\r\n np.savez_compressed(out_file, data=encoded, rate=samp_rate, Type=1, channels=chans)","def play_wav_on_index(audio_data, stream_object):\n\n stream_object.write(audio_data)","def save_all_chunks_with_labels(audio_dir, json_dir, csv_dir):\n for file in os.listdir(json_dir):\n file_path = os.path.join(json_dir, file)\n audio_file_path = os.path.join(audio_dir, file)[:-4] + \"wav\"\n with open(file_path) as f:\n data = json.load(f)\n save_arrays_with_labels(audio_file_path, data, csv_dir)","def save_song(self):\n if self.is_stream:\n self.save_song_from_stream()\n else:\n self.save_song_from_file()","def record():\n p = pyaudio.PyAudio()\n stream = p.open(format=FORMAT, channels=1, rate=RATE,\n input=True, output=True,\n frames_per_buffer=CHUNK_SIZE)\n\n num_silent = 0\n snd_started = False\n\n r = array('h')\n\n while 1:\n # little endian, signed short\n snd_data = array('h', stream.read(CHUNK_SIZE))\n if byteorder == 'big':\n snd_data.byteswap()\n r.extend(snd_data)\n\n silent = is_silent(snd_data)\n\n if silent and snd_started:\n num_silent += 1\n elif not silent and not snd_started:\n snd_started = True\n\n if snd_started and num_silent > SILENCE:\n break\n\n sample_width = p.get_sample_size(FORMAT)\n stream.stop_stream()\n stream.close()\n p.terminate()\n\n r = normalize(r)\n r = trim(r)\n r = add_silence(r, 0.5)\n return sample_width, r","def convert_to_wav(mp3_filename):\n\n wav_filename = mp3_filename[:-4] + \".wav\"\n complete_mp3FileName = os.path.join(MP3_FOLDER, mp3_filename)\n complete_wavFileName = os.path.join(WAV_FOLDER, wav_filename)\n\n mp3_file = AudioSegment.from_mp3(complete_mp3FileName)\n mp3_file.export(complete_wavFileName, format=\"wav\")\n\n print(f\"The mp3 file {complete_mp3FileName} was successfully converted to \" \\\n + f\"the wav file {complete_wavFileName}.\")","def _writeWiggle(trackName, trackDescription, allCounts, wigOut, win=1):\n wigFile = open(wigOut, \"w\")\n wigFile.write(\"track type=wiggle_0 name='%s' description='%s' visibility=2\\n\" % (trackName,\n trackDescription))\n for name in allCounts.keys():\n start = 0\n end = max(allCounts[name].keys())\n\n wigFile.write(\"fixedStep chrom=%s start=%s step=%s span=%s\\n\" % (name, start+1, win, win))\n\n for i in range(start, end):\n if allCounts[name].has_key(i):\n curValue = allCounts[name][i]\n else:\n curValue = 0\n wigFile.write(\"%s\\n\" % (curValue))\n\n wigFile.close()","def _record_wav(stream, N, CHUNK):\n frames = []\n for i in range(N):\n data = stream.read(CHUNK)\n frames.append(data)\n return np.fromstring(b\"\".join(frames), 'Int16')","def save_to_file(filename: str, sequence: List[Sample]):\n\n with open(get_path() + \"/sequence/\" + filename, \"ab+\") as file:\n for sample in sequence:\n pickle.dump(sample, file, pickle.HIGHEST_PROTOCOL)","def save_data(self, f): \n if not self.sampling:\n self.convert_to_array()\n np.save(f, self.reads)","def write( self, strFilename, bAsRawFile = False, bQuiet = False ):\n if( len( self.data ) < 1 ):\n logging.warning( \"Wav is empty, NOT saving it (to '%s').\" % (strFilename) ) \n return False\n timeBegin = time.time()\n file = open( strFilename, \"wb\" )\n if( not bAsRawFile ):\n self.writeHeader( file )\n self.writeData( file, bAddBeginOfDataChunk = not bAsRawFile )\n file.close()\n rDuration = time.time() - timeBegin\n if not bQuiet: logging.info( \"sound.Wav: successfully saved wav to '%s', duration: %5.3fs, datasize: %d (saving takes %5.3fs)\" % (strFilename, self.rDuration, self.nDataSize, rDuration) )\n return True","def storeWavelengths(self, nm):\n pre = \"w,0\"\n d = {\"wavelength_nm\": list(nm)}\n self._writeline(pre, str(d))","def save_bin(words,data,fname):\n\n out=open(fname,\"wb\")\n\n rows,dims=data.shape\n out.write(\"{} {}\\n\".format(rows,dims).encode(\"utf-8\"))\n counter=0\n\n for i,w in enumerate(words):\n out.write(w.encode(\"utf-8\"))\n out.write(\" \".encode(\"utf-8\"))\n out.write(struct.pack(\"{}f\".format(dims),*data[i,:]))\n counter+=1\n \n out.close()\n print(\"Model saved to\",fname,file=sys.stderr)","def do_wave(l, wave_type, r, g, b, duration, repeat):\n command = create_wave_command(\n wave_type, r, g, b, duration, repeat\n )\n l.write(command)","def cut_audio(old_path, new_path, start, end):\r\n fs, data = wavfile.read(old_path)\r\n indx_start = int(start*fs)\r\n indx_end = int(end*fs)+1\r\n wavfile.write(new_path,fs,data[indx_start:indx_end])\r\n\r\n return True","def write_data(infbfile,begin_N,dur_N,outfbfile):\n infbfile.seek_to_sample(begin_N)\n for i in range(begin_N,(begin_N+dur_N)):\n data = infbfile.read_sample()\n data.tofile(outfbfile)","def fillSongsArray():\r\n counter = 1\r\n notealt = 0.0\r\n frequenz = 0\r\n notencounter = 0\r\n\r\n file2write.write(\"\\n{\")\r\n for instrument in midi_data.instruments:\r\n while counter == 1:#first line of the instrument e.g piano it will only save the treble clef and NOT the bass clef\r\n for note in instrument.notes:\r\n if note.start - notealt >= 0.15: #If the note is a break it will save it as such\r\n value = dauer/((note.start - notealt)*1000)\r\n y = round(value)\r\n file2write.write(\"{0,\")\r\n file2write.write(str(y+1))\r\n file2write.write(\"},\")\r\n\r\n else:\r\n frequenz = int(pretty_midi.note_number_to_hz(note.pitch)) #convert the midi-note-number to a frequency with function of the library\r\n value = dauer/((note.end - note.start)*1000) #calculates the duration of the note\r\n x = round(value)\r\n file2write.write(\"{\")\r\n file2write.write(str(frequenz))\r\n file2write.write(\",\")\r\n file2write.write(str(x))\r\n file2write.write(\"},\")\r\n notealt = note.end\r\n counter += 1\r\n file2write.write(\"},\")\r\n #file2write.write(\"};\\n\")\r","def on_stop(self):\n self.songs.save_songs(FILE_NAME)","def create_audio_file():\n # Get the response from boto3\n raw_audio = generate_audio()\n # pull the Audiostream object from the response from boto3\n raw_audio = raw_audio[\"AudioStream\"]\n # create output location\n # process the whole block\n with closing(raw_audio) as audio:\n with open(\"output_audio.mp3\", \"wb\") as file:\n file.write(raw_audio.read())","def GenerateSinewav(self, dut_file_path, channel, wav_duration):\n with file_utils.UnopenedTemporaryFile(suffix='.wav') as file_path:\n cmd = audio_utils.GetGenerateSineWavArgs(file_path, channel,\n _DEFAULT_FREQ_HZ, wav_duration)\n process_utils.Spawn(cmd.split(' '), log=True, check_call=True)\n self._dut.link.Push(file_path, dut_file_path)","def split_diphones(wav_path, outdir=None):\n tg = ml.parsing.textgrid_reader.read(textgrid_path(wav_path))\n word = os.path.splitext(os.path.basename(wav_path))[0]\n\n wav_dir = os.path.dirname(wav_path)\n diphones_dir = os.path.join(wav_dir, \"diphones\")\n\n if not os.path.exists(diphones_dir):\n os.mkdir(diphones_dir)\n\n wav = AudioSegment.from_file(wav_path)\n for (begin, end, diphone) in tg[u'phones']:\n diphone = diphone.strip().replace(\"-\", \"_\")\n if len(diphone) > 0 and diphone[0] != \".\":\n diphone_file = \"{}_{}.wav\".format(diphone, word)\n diphone_path = os.path.join(diphones_dir, diphone_file)\n\n # Works in milliseconds\n segment = wav[(begin * 1000):(end * 1000)]\n print(\"Saving {} ({} - {})\".format(diphone_path, begin, end))\n segment.export(diphone_path, format=\"wav\")\n elif diphone[0] == \".\":\n print(\"skipping {}\".format(diphone))","def set_audio_sink(core, filenameOrHandle):\n\tres = wave.open(filenameOrHandle, \"wb\")\n\tres.setnchannels(2)\n\tres.setsampwidth(2)\n\tres.setframerate(SNES_OUTPUT_FREQUENCY)\n\tres.setcomptype('NONE', 'not compressed')\n\n\tdef audio_sample(left, right):\n\t\t# We can safely use .writeframesraw() here because the header will be\n\t\t# corrected once we call .close()\n\t\tres.writeframesraw(sndstruct.pack(left, right))\n\n\tcore.set_audio_sample_cb(audio_sample)\n\n\treturn res","def record_audio(self):\n stream = self.audio.open(format=DEFAULT_FORMAT,\n channels=DEFAULT_CHANNELS,\n rate=DEFAULT_RATE,\n input=True,\n frames_per_buffer=DEFAULT_CHUNK_SIZE)\n\n print(\"Recording...\")\n\n for i in range(0, int(DEFAULT_RATE / DEFAULT_CHUNK_SIZE * RECORD_SECONDS)):\n data = stream.read(DEFAULT_CHUNK_SIZE)\n self.frames.append(data)\n\n print(\"Done.\")\n\n stream.stop_stream()\n stream.close()","def convert_to_wav (filename, name, origpath, wavpath, mono):\n print(\"Converting {0} to .wav...\".format(filename))\n if not re.match(r\".*_\\d+$\",name):\n # If filenames do include video titles\n name = name.rsplit('_',1)[0]\n\n channel, vid_num = name.rsplit('_', 1)\n channel = re.sub(r'[^A-Za-z1-9]', '', channel)\n newname = '_'.join([channel, vid_num])\n\n exportname = newname + \".wav\"\n filepath = path.join(origpath, filename)\n\n if not path.exists(wavpath):\n makedirs(wavpath)\n exportPath = path.join(wavpath, exportname)\n sound = AudioSegment.from_file(filepath,\"mp4\")\n if mono == True:\n sound = sound.set_channels(1)\n sound.export(exportPath, format=\"wav\")","def write_WFs(folder, filename_prefix='', indices=None, WFs=None, extension=settings.HEAVY_AUDIO_WRITE_EXTENSION, sample_rate=settings.DEFAULT_SAMPLE_RATE):\n if WFs is None:\n raise ValueError('save_WFs expects either a WF list or 2-D np array')\n\n is_array = isinstance(WFs, np.ndarray)\n if is_array:\n n_WFs = WFs.shape[0]\n else:\n n_WFs = len(WFs)\n\n if indices is None:\n indices = range(n_WFs)\n if len(indices) != n_WFs:\n raise ValueError('save_WFs expects as many indices as there are WFs')\n\n file_names = []\n file_paths = []\n for i in indices:\n file_name = '{0}_{1}.{2}'.format(filename_prefix, rank_4_audacity(i), extension)\n file_path = '{0}/{1}'.format(folder, file_name)\n if is_array:\n sf.write(file_path, WFs[i, :], sample_rate)\n else:\n sf.write(file_path, WFs[i], sample_rate)\n file_names.append(file_name)\n file_paths.append(file_path)\n\n return file_paths, file_names","def wavPlayer(data, rate, scale=False, autoplay=False):\r\n #if np.max(abs(data)) > 1 or scale:\r\n # data = data/np.max(abs(data))\r\n #data = (2**13*data).astype(np.int16)\r\n \r\n buffer = BytesIO()\r\n buffer.write(b'RIFF')\r\n buffer.write(b'\\x00\\x00\\x00\\x00')\r\n buffer.write(b'WAVE')\r\n \r\n buffer.write(b'fmt ')\r\n if data.ndim == 1:\r\n noc = 1\r\n else:\r\n noc = data.shape[1]\r\n \r\n bits = data.dtype.itemsize * 8\r\n sbytes = rate*(bits // 8)*noc\r\n ba = noc * (bits // 8)\r\n buffer.write(struct.pack('<ihHIIHH', 16, 1, noc, rate, sbytes, ba, bits))\r\n\r\n # data chunk\r\n buffer.write(b'data')\r\n buffer.write(struct.pack('<i', data.nbytes))\r\n\r\n if data.dtype.byteorder == '>' or (data.dtype.byteorder == '=' and sys.byteorder == 'big'):\r\n data = data.byteswap()\r\n\r\n buffer.write(data.astype(np.int16).tostring())\r\n\r\n # Determine file size and place it in correct position at start of the file.\r\n size = buffer.tell()\r\n buffer.seek(4)\r\n buffer.write(struct.pack('<i', size-8))\r\n \r\n val = buffer.getvalue()\r\n autoplay = \" autoplay=\\\"autoplay\\\"\"*autoplay + \"\"\r\n \r\n src = \"\"\"<audio controls=\"controls\" style=\"width:600px\"{autoplay}>\r\n <source controls src=\"data:audio/wav;base64,{base64}\" type=\"audio/wav\" />\r\n Your browser does not support the audio element.\r\n </audio>\"\"\".format(base64=base64.b64encode(val).decode(\"ascii\"), autoplay=autoplay)\r\n display(HTML(src))","def rec_one_shot(self, sec, file_name=None):\n self.__open_noncallback_stream()\n frames = []\n for i in range(int(self.RATE / self.CHUNK * sec)):\n data = self.stream.read(self.CHUNK)\n data = np.fromstring(data, dtype=np.int16)\n frames.append(data)\n self.stream.stop_stream()\n if file_name is not None:\n with wave.open(file_name, 'wb') as wav_file:\n wav_file.setnchannels(self.CHANNELS)\n wav_file.setsampwidth(self.recorder.get_sample_size(self.FORMAT))\n wav_file.setframerate(self.RATE)\n wav_file.writeframes(b''.join(frames))\n frame = np.concatenate(frames, 0)\n self.stop_streaming()\n return frame","def save_waveform(self, chan=None):\n t, y, pre = self.device.retrieve_current_waveform()\n meta = self.create_meta()\n if chan != None:\n meta['Channel'] = chan\n for name in pre:\n meta[name] = pre[name]\n data = {'meta' : meta,\n 't' : t,\n 'y' : y}\n rsp = daq.Rsp('save', data, meta)\n self.shot += 1\n self.r_queue.put(rsp)","def save_timit_pitch():\n timit_names = []\n pitch_intensity_tables = []\n\n wav_txt_file_names = glob.glob(os.path.join(timit_pitch_data_path, '*.wav.txt'))\n for wav_txt_file in wav_txt_file_names:\n pitch_intensity = pd.read_csv(wav_txt_file, delimiter='\\t', dtype=np.float64, na_values=['?'])\n pitch_intensity = pitch_intensity.dropna()\n pitch_intensity.loc[pitch_intensity.pitch == 0, 'pitch'] = np.NaN\n pitch_intensity.loc[pitch_intensity.intensity == 0, 'intensity'] = np.NaN\n pitch_intensity['log_hz'] = np.log(pitch_intensity['pitch'])\n pitch_intensity['erb_rate'] = convert_hz(pitch_intensity['pitch'], \"erb\")\n pitch = pitch_intensity['log_hz']\n pitch_intensity['rel_pitch_global'] = (pitch - np.mean(pitch))/np.std(pitch)\n pitch = pitch_intensity['erb_rate']\n pitch_intensity['rel_pitch_global_erb'] = (pitch - np.mean(pitch))/np.std(pitch)\n\n timit_name = wav_txt_file.split(os.sep)[-1][:-8]\n\n timit_names.append(timit_name)\n pitch_intensity_tables.append(pitch_intensity)\n\n timit_pitch = pd.concat(pitch_intensity_tables, keys=timit_names)\n #print(np.mean(timit_pitch['log_hz'])) # -> 4.9406, (no log: 147.0387)\n #print(np.std(timit_pitch['log_hz'])) # -> 0.3112, (no log: 48.59846)\n timit_pitch['abs_pitch'] = (timit_pitch['log_hz'] - np.mean(timit_pitch['log_hz']))/np.std(timit_pitch['log_hz'])\n timit_pitch['abs_pitch_erb'] = (timit_pitch['erb_rate'] - np.mean(timit_pitch['erb_rate']))/np.std(timit_pitch['erb_rate'])\n timit_pitch['abs_pitch_change'] = timit_pitch['abs_pitch'].diff()\n timit_pitch['abs_pitch_erb_change'] = timit_pitch['abs_pitch_erb'].diff()\n #print(np.mean(timit_pitch.intensity)) # -> 63.000\n #print(np.std(timit_pitch.intensity)) # -> 15.537\n timit_pitch['zscore_intensity'] = (timit_pitch.intensity - np.mean(timit_pitch.intensity))/np.std(timit_pitch.intensity)\n\n filename = os.path.join(processed_timit_data_path, 'timit_pitch.h5')\n timit_pitch.to_hdf(filename, 'timit_pitch')\n return timit_pitch","def writeMIDI(filepath,data):\n\n\n\twith open(filepath,\"wb\") as f:\n\n\t\t## Writing the MIDI file header\n\t\tf.write(\"MThd\")\n\t\tf.write(struct.pack(\">ihhh\",6,1,len(d[\"tracks\"]),1000)) # Length of the header, MIDI type 1, number of track, 1000 ticks per quarter\n\n\t\tfor x in data[\"tracks\"]:\n\t\t\t# Reordering all the sound events by increasing time\n\t\t\ttrackdata = [[y[\"type\"],y[\"note\"],y[\"velocity\"],y[\"time\"]] for y in x]\n\t\t\ttrackdata = sorted(trackdata, key=lambda x:x[3])\n\t\t\t\n\t\t\t# MIDI files deal with time differences, which we calculate here\n\t\t\ttrackdata_diff = [[trackdata[0][0],trackdata[0][1],trackdata[0][2],trackdata[0][3]]]\n\t\t\tfor i in range(1,len(trackdata)):\n\t\t\t\ttrackdata_diff.append([trackdata[i][0],trackdata[i][1],trackdata[i][2],trackdata[i][3]-trackdata[i-1][3]])\n\t\t\ttrackdata_diff = [[x[0],x[1],x[2],encodeVL(int(2000.*x[3]))] for x in trackdata_diff] ## 2000= 1000 ticks per quarter * 2 (because 120 bpm = 2 quarters per seconds)\n\t\t\t\n\t\t\t# Number of bytes of the track chunk: 15 for standard info (120bpm, fake notes, etc.), 4 for the tail, the rest depends on the data\n\t\t\ttrackdata_numbytes = 15+4+3*len(trackdata_diff)+sum([len(x[3]) for x in trackdata_diff])\n\t\t\t# If sustain is used\n\t\t\t#trackdata_numbytes += 4 \n\t\t\t\n\t\t\t## Writing the track chunk to the MIDI file\n\t\t\tf.write(\"MTrk\")\n\t\t\tf.write(struct.pack(\">i\",trackdata_numbytes)) # Length of the track chunk\n\n\t\t\t# 120 bpm\n\t\t\tf.write(struct.pack(\">BBBB\",0,0xFF,0x51,0x03))\n\t\t\tf.write(struct.pack(\">BBB\",0x07,0xA1,0x20))\n\t\t\t\n\n\t\t\t# Fake note at the beginning to mark 0 time\n\t\t\tf.write(struct.pack(\">BBBB\",0,0x90,0,40))\n\t\t\tf.write(struct.pack(\">BBBB\",1,0x80,0,40))\n\t\t\t\n\t\t\t#Sustain pedal on\n\t\t\t#f.write(struct.pack(\">BBBB\",2,0xB0,0x40,0x41))\n\n\t\t\t# Writing one note\n\t\t\tfor x in trackdata_diff:\n\t\t\t\tfor y in x[3]:\n\t\t\t\t\tf.write(struct.pack(\">B\",y))\n\t\t\t\tif x[0]==\"ON\":\n\t\t\t\t\tf.write(struct.pack(\">BBB\",0x90,x[1],x[2]))\n\t\t\t\tif x[0]==\"OFF\":\n\t\t\t\t\tf.write(struct.pack(\">BBB\",0x80,x[1],x[2]))\n\t\t\t\n\t\t\t## End of the track chunk\n\t\t\tf.write(struct.pack(\">BBBB\",0,0xFF,0x2F,0))","def generate_wavplot(song_name):\n\n filepath = features[features.inferred_name.str.title() == song_name].feature_file.values[0]\n rate, wave = wavfile.read(filepath)\n mono = np.mean(wave, axis=1)\n mono.shape\n plt.figure(figsize=(20,6))\n plt.axis('off')\n plt.plot(mono[::mono.shape[0]//6000], color='white')\n plt.tight_layout;\n friendly_song_name = '_'.join(song_name.split()).lower()\n output_filepath = './static/wavplots/' + friendly_song_name + '.png'\n plt.savefig(output_filepath, bbox_inches='tight', pad_inches=0, transparent=True)\n return output_filepath","def webm_to_wav(webm_file: str):\n wav_file = webm_file.replace(\".webm\", \".wav\")\n wav = AudioSegment.from_file(webm_file)\n wav.export(wav_file, format=\"wav\")\n return wav_file","def _writeWiggleVar(trackName, trackDescription, allCounts, wigOut):\n wigFile = open(wigOut, \"w\")\n wigFile.write(\"track type=wiggle_0 name='%s' description='%s' visibility=2\\n\" % (trackName,\n trackDescription))\n\n for name in allCounts.keys():\n start = 0\n end = max(allCounts[name].keys())\n\n wigFile.write(\"variableStep chrom=%s span=1\\n\" % (name))\n\n for pos in sorted(allCounts[name].keys()):\n wigFile.write(\"%s\\t%s\\n\" % (pos,allCounts[name][pos]))\n\n\n wigFile.close()","def load_audio(file_path):\n # load the audio file in its original sampling rate\n audio_data, sr = librosa.load(file_path, sr=sampling_rate)\n\n # get the common file name\n file_name = file_path.split(\"/\")[-1]\n file_name = file_name.split(\".wav\")[0]\n\n # calculate number of samples in the time duration needed\n num_samples = int(sr*time_duration)\n\n # get the cut-off audio signals and save them\n for i in np.arange(num_audio_files):\n audio_cut_data = cut_sample(audio_data, num_samples)\n file_path=dir_to_save + file_name + \"_\" + str(i+1) + \".wav\"\n save_sample(audio_cut_data, file_path, sr)\n print(f\"generating signal {str(i)}, its length {len(audio_cut_data)} by cutting the original signal\")"],"string":"[\n \"def save_wav(file_name, signal, fs):\\n wavfile.write(file_name, fs, np.int16(signal/np.max(np.abs(signal)) * (2**(16)/2-1)))\",\n \"def save_audio(self, name=DEFAULT_OUT_NAME):\\n print(\\\"Saving...\\\")\\n wf = wave.open(name+'.wav', 'wb')\\n wf.setnchannels(DEFAULT_CHANNELS)\\n wf.setsampwidth(self.audio.get_sample_size(DEFAULT_FORMAT))\\n wf.setframerate(DEFAULT_RATE)\\n wf.writeframes(b''.join(self.frames))\\n wf.close()\\n print('Saved')\",\n \"def __save(self,audio):\\n self.__openSampleFile()\\n self.__sampleFile.writeframes(audio)\",\n \"def save_frames_to_wav_file(frames: np.ndarray, sample_rate: int, file_path: str):\\n wavfile.write(file_path, sample_rate, np.hstack(frames))\",\n \"def write_wav(fname, samps, sampling_rate=16000, normalize=True):\\n\\t# for multi-channel, accept ndarray [Nsamples, Nchannels]\\n\\tif samps.ndim != 1 and samps.shape[0] < samps.shape[1]:\\n\\t\\tsamps = np.transpose(samps)\\n\\t\\tsamps = np.squeeze(samps)\\n\\t# same as MATLAB and kaldi\\n\\tif normalize:\\n\\t\\tsamps = samps * MAX_INT16\\n\\t\\tsamps = samps.astype(np.int16)\\n\\tfdir = os.path.dirname(fname)\\n\\tif fdir and not os.path.exists(fdir):\\n\\t\\tos.makedirs(fdir)\\n\\t# NOTE: librosa 0.6.0 seems could not write non-float narray\\n\\t# so use scipy.io.wavfile instead\\n\\twavfile.write(fname, sampling_rate, samps)\",\n \"def save(self, fname, master_volume=1.):\\n \\n # first pass - find max amplitude value to normalise output\\n vmax = 0.\\n for c in range(len(self.out_channels)):\\n vmax = max(\\n abs(self.out_channels[str(c)].values.max()),\\n abs(self.out_channels[str(c)].values.min()),\\n vmax\\n )\\n\\n # normalisation for conversion to int32 bitdepth wav\\n norm = master_volume * (pow(2, 31)-1) / vmax\\n\\n # setup array to house wav stream data \\n chans = np.zeros((self.out_channels['0'].values.size,\\n len(self.out_channels)), dtype=\\\"int32\\\")\\n \\n # normalise and collect channels into a list\\n for c in range(len(self.out_channels)):\\n vals = self.out_channels[str(c)].values\\n chans[:,c] = (vals*norm).astype(\\\"int32\\\")\\n \\n # finally combine and write out wav file\\n wavfile.write(fname, self.samprate, chans)\\n print(f\\\"Saved {fname}\\\")\",\n \"def _save_wav(buff, data, rate) -> None:\\n # Code inspired from `IPython.display.Audio`\\n data = np.array(data, dtype=float)\\n\\n bit_depth = 16\\n max_sample_value = int(2**(bit_depth - 1)) - 1\\n\\n num_channels = data.shape[1] if len(data.shape) > 1 else 1\\n scaled = np.int16(data / np.max(np.abs(data)) * max_sample_value)\\n # The WAVE spec expects little-endian integers of \\\"sampwidth\\\" bytes each.\\n # Numpy's `astype` accepts array-protocol type strings, so we specify:\\n # - '<' to indicate little endian\\n # - 'i' to specify signed integer\\n # - the number of bytes used to represent each integer\\n # See: https://numpy.org/doc/stable/reference/arrays.dtypes.html\\n encoded_wav = scaled.astype(f'<i{bit_depth // 8}', copy=False).tobytes()\\n\\n with wave.open(buff, mode='wb') as waveobj:\\n waveobj.setnchannels(num_channels)\\n waveobj.setframerate(rate)\\n waveobj.setsampwidth(bit_depth // 8)\\n waveobj.setcomptype('NONE', 'NONE')\\n waveobj.writeframes(encoded_wav)\",\n \"def write_wav(self, full_out_file = None):\\n\\n if full_out_file is None:\\n \\n (out_file, out_dir) = misc.save_file(FilterSpec='*.wav', DialogTitle='Write sound to ...', \\n DefaultName='')\\n full_out_file = os.path.join(out_dir, out_file)\\n if full_out_file is None:\\n print('Output discarded.')\\n return 0\\n else:\\n full_out_file = os.path.abspath(full_out_file)\\n (out_dir , out_file) = os.path.split(full_out_file)\\n\\n write(str(full_out_file), int(self.rate), self.data)\\n print('Sounddata written to ' + out_file + ', with a sample rate of ' + str(self.rate))\\n print('OutDir: ' + out_dir)\\n \\n return full_out_file\",\n \"def save_sound(filename,sound,sample_freq,num_channels):\\n #open a wave file in write ('w') mode, this will create the file\\n file=wave.open(filename,'w')\\n #set the framerate aka sample frequency\\n file.setframerate(sample_freq)\\n #set the number of the channels\\n file.setnchannels(num_channels)\\n #the size of the one sample in bytes\\n file.setsampwidth(2)\\n #write the actual sound to the file, notice the call to get_raw\\n file.writeframesraw(sound.get_raw())\\n file.close()\",\n \"def create_wav_file(self, ):\\n\\n f_out = open(self.wav_file, 'w')\\n u_utt2spk = open(self.utt2spk, 'w')\\n for file in glob.glob(self.wav_folder+'/*.wav'):\\n base = os.path.basename(file).split('.')[0]\\n # write to scp file\\n f_out.write(base + '\\\\t' + file + '\\\\n')\\n u_utt2spk.write(base + '\\\\t' + 'tts' + '\\\\n')\",\n \"def save_wav(filename, samples, rate=16000, width=2, channels=1):\\n wav = wave.open(filename, 'wb')\\n wav.setnchannels(channels)\\n wav.setsampwidth(width)\\n wav.setframerate(rate)\\n wav.writeframes(samples)\\n wav.close()\",\n \"def split_on_silence_threshold(wav_file, dest_dir):\\n # Read the file\\n audioSegment = AudioSegment.from_wav(wav_file)\\n # Calculating the silence threshold\\n # Normalizing the audio file belfore finding the threshold\\n full_audio_wav = normalize(audioSegment)\\n loudness_ms_list = [] # Save the audio levels of all the chunks\\n for ms_chunk in full_audio_wav:\\n loudness_ms_list.append(round(ms_chunk.dBFS))\\n print(\\\"Audio levels are recorded\\\", file=sys.stderr)\\n # Using pandas df for easier manipulation\\n df = pd.DataFrame(loudness_ms_list)\\n df[0] = df[df[0] != float(\\\"-inf\\\")] # Remove the very low levels\\n st = df[0].mean()\\n st = st if st < -16 else -16 # Because -16db is default\\n # Splits the audio if silence duration is MSL long\\n MSL = 500 # minimum silence length in ms\\n chunks = split_on_silence(\\n full_audio_wav, \\n # split on silences longer than 500ms (500ms)\\n min_silence_len=MSL, \\n # anything under -16 dBFS is considered silence\\n silence_thresh=st, \\n # keep 200 ms of leading/trailing silence\\n keep_silence=200, \\n )\\n # Saving all the chunks\\n print(\\\"Writing all the files, this may take some time!\\\", file=sys.stderr)\\n for index, chunk in enumerate(chunks):\\n chunk_file_name = os.path.join(dest_dir, \\\"sample_{}.wav\\\".format(str(index).zfill(10)))\\n print(\\\"Saving the file to \\\" + chunk_file_name, file=sys.stderr)\\n # You can export as mp3 etc, note that it has dependency on ffmpeg\\n chunk.export(chunk_file_name, format=\\\"wav\\\")\",\n \"def save_sample(file_path, sampling_rate, audio):\\n audio = (audio.numpy() * 32768).astype(\\\"int16\\\")\\n write(file_path, sampling_rate, audio)\",\n \"def write_data_to_wav(self, file_name: str, data):\\r\\n # apply scale and convert to int16\\r\\n data = np.int16(data/np.max(np.abs(data)) * self.wav_scale)\\r\\n # write to file\\r\\n write(file_name, self.audio_sample_rate, data)\\r\\n print('Sound ', file_name, ' has been saved')\",\n \"def save_stereo(self, fname, master_volume=1.):\\n\\n if len(self.out_channels) > 2:\\n print(\\\"Warning: sonification has > 2 channels, only first 2 will be used. See 'save_combined' method.\\\")\\n \\n # first pass - find max amplitude value to normalise output\\n # and concatenate channels to list\\n vmax = 0.\\n channels = []\\n for c in range(min(len(self.out_channels), 2)):\\n vmax = max(\\n abs(self.out_channels[str(c)].values.max()),\\n abs(self.out_channels[str(c)].values.min()),\\n vmax\\n ) / master_volume\\n channels.append(self.out_channels[str(c)].values)\\n \\n wav.write(fname, \\n np.column_stack(channels),\\n self.samprate, \\n scale = (-vmax,vmax),\\n sampwidth=3)\\n \\n print(\\\"Saved.\\\")\",\n \"def export_wav(self, folder, name_fmt=\\\"{:02d}.wav\\\", dtype=np.int16):\\n data = np.atleast_2d(self.in_time)\\n\\n assert data.ndim == 2\\n assert np.all(np.abs(data) <= 1.0)\\n\\n # convert and scale to new output datatype\\n if dtype in [np.uint8, np.int16, np.int32]:\\n lim_orig = (-1.0, 1.0)\\n lim_new = (np.iinfo(dtype).min, np.iinfo(dtype).max)\\n data = _rescale(data, lim_orig, lim_new).astype(dtype)\\n elif dtype != np.float32:\\n raise TypeError(f\\\"dtype {dtype} is not supported by scipy.wavfile.write.\\\")\\n\\n path = Path(folder)\\n if not path.is_dir():\\n path.mkdir(parents=True, exist_ok=False)\\n\\n for i in range(data.shape[0]):\\n wavfile.write(path / name_fmt.format(i + 1), self.fs, data[i])\",\n \"def write(f, sr, x, normalized=False):\\n channels = 2 if (x.ndim == 2 and x.shape[1] == 2) else 1\\n if normalized: # normalized array - each item should be a float in [-1, 1)\\n y = np.int16(x * 2 ** 15)\\n else:\\n y = np.int16(x)\\n song = pydub.AudioSegment(y.tobytes(), frame_rate=sr, sample_width=2, channels=channels)\\n song.export(f, format=\\\"mp3\\\", bitrate=\\\"64k\\\")\",\n \"def write_timeline_to_wav(output_path, data, sample_rate):\\n\\n scipy.io.wavfile.write(output_path, sample_rate, data.T)\",\n \"def save_combined(self, fname, ffmpeg_output=False, master_volume=1.):\\n # setup list to house wav stream data \\n inputs = [None]*len(self.out_channels)\\n\\n # first pass - find max amplitude value to normalise output\\n vmax = 0.\\n for c in range(len(self.out_channels)):\\n vmax = max(\\n abs(self.out_channels[str(c)].values.max()),\\n abs(self.out_channels[str(c)].values.min()),\\n vmax\\n ) / master_volume\\n \\n print(\\\"Creating temporary .wav files...\\\")\\n \\n for c in range(len(self.out_channels)):\\n tempfname = f\\\"./.TEMP_{c}.wav\\\"\\n wav.write(tempfname, \\n self.out_channels[str(c)].values,\\n self.samprate, \\n scale = (-vmax,vmax),\\n sampwidth=3)\\n inputs[self.channels.forder[c]] = ff.input(tempfname)\\n \\n print(\\\"Joning temporary .wav files...\\\")\\n (\\n ff.filter(inputs, 'join', inputs=len(inputs), channel_layout=self.channels.setup)\\n .output(fname)\\n .overwrite_output()\\n .run(quiet=~ffmpeg_output)\\n )\\n \\n print(\\\"Cleaning up...\\\")\\n for c in range(len(self.out_channels)):\\n os.remove(f\\\"./.TEMP_{c}.wav\\\")\\n \\n print(\\\"Saved.\\\")\",\n \"def save_wavetables(self, path: str, filename_prefix: str = '') -> None:\\n for i in range(len(self.wavetables)):\\n if not os.path.exists(path):\\n os.mkdir(path)\\n location = os.path.join(path, filename_prefix + f'{i:02d}.wav')\\n wav_file = WavFile(location)\\n wav_file.write_samples(self.wavetables[i])\",\n \"def all_wav_to_mp3(self):\\n for each_file, artist in self.past_songs_db_data:\\n self.convert_wav_to_mp3(each_file)\",\n \"def save(self, name):\\n try:\\n os.mkdir(os.path.join(self.dbpath, name))\\n except:\\n pass\\n\\n wf = wave.open(os.path.join(self.dbpath, name, str(uuid.uuid4()) + \\\".wav\\\"), 'wb')\\n wf.setnchannels(self.CHANNELS)\\n wf.setsampwidth(self.p.get_sample_size(self.FORMAT))\\n wf.setframerate(self.RATE)\\n wf.writeframes(b''.join(list(self.frames)))\\n wf.close()\",\n \"def export_wav(\\n filename_wav: Path,\\n tradb: vae.io.TraDatabase,\\n channel: int,\\n time_start: Optional[float] = None,\\n time_stop: Optional[float] = None,\\n decimation_factor: int = 1,\\n):\\n y, fs = tradb.read_continuous_wave(\\n channel=channel,\\n time_start=time_start,\\n time_stop=time_stop,\\n time_axis=False,\\n show_progress=False,\\n raw=True, # read as ADC values (int16)\\n )\\n\\n if decimation_factor > 1:\\n y = signal.decimate(y, decimation_factor).astype(np.int16)\\n fs //= decimation_factor\\n\\n wavfile.write(filename_wav, fs, y)\",\n \"def save_secured_song_to_wave(self, file_location):\\n protected_wav = wave.open(os.path.abspath(file_location), 'wb')\\n protected_wav.setnchannels(self.original_song.getnchannels())\\n protected_wav.setsampwidth(self.original_song.getsampwidth())\\n protected_wav.setframerate(self.original_song.getframerate())\\n protected_wav.writeframes(self.metadata)\\n\\n for val in self.full_song:\\n protected_wav_val = struct.pack('<h', val)\\n protected_wav.writeframesraw(protected_wav_val)\\n\\n protected_wav.close()\",\n \"def wavwrite(y, fs, filename):\\n \\n x = copy.deepcopy(y) # copy array\\n x *= INT16_FAC # scaling floating point -1 to 1 range signal to int16 range\\n x = np.int16(x) # converting to int16 type\\n wavfile.write(filename, fs, x)\",\n \"def save_separated_audio(self, audios, filename):\\n\\n # Create folder with mixture name\\n folder_path = os.path.join(self.config[\\\"separated_audio_folder\\\"], os.path.splitext(filename)[0])\\n os.makedirs(folder_path)\\n # Save each separated source\\n for class_idx, audio in enumerate(audios):\\n librosa.output.write_wav(os.path.join(folder_path, self.data_set.classes[class_idx]) + '.wav',\\n audio.T,\\n sr=self.data_set.config[\\\"sampling_rate\\\"])\\n # Also copy the mixture in the folder\\n copyfile(self.data_set.audio_full_filename(filename), os.path.join(folder_path, \\\"original_mix.wav\\\"))\",\n \"def wavwrite(y, fs, filename):\\n\\n\\tx = copy.deepcopy(y) # copy array\\n\\tx *= INT16_FAC # scaling floating point -1 to 1 range signal to int16 range\\n\\tx = np.int16(x) # converting to int16 type\\n\\twrite(filename, fs, x)\",\n \"def save_to_file(\\n sources,\\n codec='wav', audio_adapter=ffmpeg.FFMPEGProcessAudioAdapter(),\\n bitrate='128k', synchronous=True):\\n\\n # filename = \\\"chengdu.mp3\\\"\\n pool = Pool()\\n tasks = []\\n for instrument, data in sources.items():\\n path = \\\"./out/\\\"+instrument + \\\".\\\" + codec\\n\\n if pool:\\n task = pool.apply_async(audio_adapter.save, (\\n path,\\n data,\\n 44100,\\n codec,\\n bitrate))\\n tasks.append(task)\\n else:\\n audio_adapter.save(path, data, 44100, codec, bitrate)\\n if synchronous and pool:\\n while len(tasks) > 0:\\n task = tasks.pop()\\n task.get()\\n task.wait(timeout=200)\",\n \"def output_beat_to_file(file_name, e):\\n print(\\\"Writing to file:\\\", file_name)\\n routine = gp.compile(e,pset)\\n with open(file_name+\\\".raw\\\",'w') as f:\\n for t in range(200000):\\n f.write(chr(int(routine(t+1))%256))\\n # Now convert to wav\\n subprocess.call(SOX_COMMAND + \\\" \\\" + file_name + \\\".raw\\\" + \\\" \\\" + file_name + \\\".wav\\\", shell=True)\\n subprocess.call(LAME_COMMAND + \\\" \\\" + file_name + \\\".wav\\\", shell=True)\",\n \"def wavwrite(fname, Fs, xt):\\n # convert to np.int16 data type\\n xt = np.array((2**15-1)*xt, np.int16)\\n sio_wav.write(fname, Fs, xt)\",\n \"def save_wfm(self, source, dest):\\n self.bus.write('SAV:WAVE %s,%s' % (source, dest))\",\n \"def write_wav(filename, data, rate = 44100):\\r\\n \\r\\n # Compress the data (the input format is likely to be float64)\\r\\n # Make sure that the format is readable by Librosa\\r\\n maxv = np.iinfo(np.int16).max\\r\\n lb_write_wav(filename, (data * maxv).astype(np.int16), rate) \\r\\n \\r\\n return(None)\",\n \"def write_wave(path, audio, sample_rate):\\n with contextlib.closing(wave.open(path, 'wb')) as wf:\\n wf.setnchannels(1)\\n wf.setsampwidth(2)\\n wf.setframerate(sample_rate)\\n wf.writeframes(audio)\",\n \"def _create_wave_file(self):\\n is_wave_open = False\\n try:\\n wv = wave.open(self.audio_file_name, mode='wb')\\n is_wave_open = True\\n wv.setparams((1, # 1 channel (mono)\\n 2, # 2 bytes per sample * 1 channel\\n self.sample_rate,\\n 0, # Initial number of samples.\\n 'NONE',\\n 'not compressed'))\\n wv.writeframes(self.sample_buffer)\\n except:\\n print('Error creating audio file')\\n if is_wave_open:\\n wv.close()\",\n \"def write_sound(file, snds: Property, pack_list, snd_prefix='*'):\\n if snds.has_children():\\n file.write('\\\"rndwave\\\"\\\\n\\\\t{\\\\n')\\n for snd in snds:\\n file.write(\\n '\\\\t\\\"wave\\\" \\\"{sndchar}{file}\\\"\\\\n'.format(\\n file=snd.value.lstrip(SOUND_CHARS),\\n sndchar=snd_prefix,\\n )\\n )\\n pack_list.add('sound/' + snd.value.casefold())\\n file.write('\\\\t}\\\\n')\\n else:\\n file.write(\\n '\\\"wave\\\" \\\"{sndchar}{file}\\\"\\\\n'.format(\\n file=snds.value.lstrip(SOUND_CHARS),\\n sndchar=snd_prefix,\\n )\\n )\\n pack_list.add('sound/' + snds.value.casefold())\",\n \"def save_wav(data, file_path, sample_rate):\\n if np.issubdtype(data.dtype, np.floating):\\n data = data.astype(np.float32)\\n elif data.dtype not in [np.int32, np.int16, np.uint8]:\\n raise ValueError(f'wavfile data must be np.float*, np.int32, np.int16, or np.uint8, got {data.dtype}')\\n\\n wavfile.write(file_path, sample_rate, data)\",\n \"def writesilence(self, duration):\\n samples = int(self.sample_rate * duration)\\n values = []\\n for i in range(0, samples):\\n signal = wave.struct.pack('h', 0)\\n values.append(signal)\\n # Buffer values every 5 seconds (22050 samples)\\n if len(values) >= 220500:\\n value_string = \\\"\\\".join(values)\\n self.file.writeframes(value_string)\\n # Clear values array\\n del values[0:len(values)]\\n value_string = \\\"\\\".join(values)\\n self.file.writeframes(value_string)\",\n \"def raw_to_wav(data, path, rate=44100):\\n wavfile.write(path, rate, data)\",\n \"def write_audio_segment(self, data):\\n cache_name = self.CACHE_FILE_NAME + str(time.time()) + '.wav'\\n file = open(cache_name, \\\"wb\\\")\\n file.write(data)\\n file.close()\\n return cache_name\",\n \"def record_audio_to_file(self, time, file_name):\\n sample_width, frames = self.record_audio(time)\\n wf = wave.open(file_name, 'wb')\\n wf.setnchannels(self.channels)\\n wf.setsampwidth(sample_width)\\n wf.setframerate(self.rate)\\n wf.writeframes(frames)\\n wf.close()\",\n \"def make_waves(wave_array, filename: str, num_cycle=1):\\n sampleRate = 44100.0 # hertz\\n duration = 1.0 # seconds\\n frequency = 440.0 # hertz\\n obj = wave.open(filename, 'w')\\n obj.setnchannels(1) # mono\\n obj.setsampwidth(2)\\n obj.setframerate(sampleRate)\\n waves = list(wave_array)\\n for w in range(num_cycle):\\n for i in waves:\\n value = i\\n data = struct.pack('<h', int(value))\\n obj.writeframesraw(data)\\n obj.close()\",\n \"def save_to_file(samps, filename, save_as_numpy):\\n with open(filename, 'wb') as out_file:\\n if save_as_numpy:\\n np.save(out_file, samps, allow_pickle=False, fix_imports=False)\\n else:\\n samps.tofile(out_file)\",\n \"def test_wav_multiple_channels(self, dtype, sample_rate, num_channels):\\n duration = 1\\n path = self.get_temp_path(\\\"data.wav\\\")\\n data = get_wav_data(dtype, num_channels, normalize=False, num_frames=duration * sample_rate)\\n save_wav(path, data, sample_rate)\\n info = self._info(path)\\n assert info.sample_rate == sample_rate\\n assert info.num_frames == sample_rate * duration\\n assert info.num_channels == num_channels\\n assert info.bits_per_sample == sox_utils.get_bit_depth(dtype)\\n assert info.encoding == get_encoding(\\\"wav\\\", dtype)\",\n \"def play(sampler, name=\\\"/Users/Jxie0755/Documents/DXcodings/Learning_Python/CS_61A/week03/mario.wav\\\", seconds=2):\\n out = open(name, \\\"wb\\\")\\n out.setnchannels(1)\\n out.setsampwidth(2)\\n out.setframerate(frame_rate)\\n t = 0\\n while t < seconds * frame_rate:\\n sample = sampler(t)\\n out.writeframes(encode(sample))\\n t = t + 1\\n out.close()\",\n \"def _to_wav(self):\\n self._status = 0\\n fname = fm.file2wav(self.get_filename()) \\n if fname != self.get_filename(): # can change the name\\n self._set_filename(fname) # in case of wave transcoding\\n self._status = 1\",\n \"def saveSong(song, filename, append = 1):\\n if append:\\n mode = \\\"w+\\\"\\n else:\\n mode = \\\"w\\\"\\n fp = open(filename, mode) # will append it if it exists\\n if type(song) in [list]:\\n for tup in song:\\n if len(tup) == 2:\\n f, d = tup\\n fp.write(\\\"%s %s\\\\n\\\" % (_getNoteFromFrequency(f), d))\\n elif len(tup) == 3:\\n f1, f2, d = tup\\n fp.write(\\\"%s %s %s\\\\n\\\" % (_getNoteFromFrequency(f),\\n _getNoteFromFrequency(f), d))\\n else: # string\\n song = song.replace(\\\"\\\\n\\\", \\\";\\\")\\n lines = song.split(\\\";\\\")\\n for line in lines:\\n fp.write(line + \\\"\\\\n\\\")\\n fp.close()\",\n \"def write_audio_to_file(audio: torch.Tensor, sample_id: str = ''):\\n global FS_HZ\\n assert FS_HZ is not None\\n audio_extension = '.wav'\\n audio_path = upload_directory + 'sample' + sample_id + audio_extension\\n audio_np = audio.cpu().numpy()\\n with open(audio_path, 'wb') as f:\\n soundfile.write(f,\\n audio_np,\\n samplerate=FS_HZ)\\n return audio_path\",\n \"def save_mp3(ndarray, sr, feature_name, out_path, x, y, new_labels, mp3_filename=None):\\n import soundfile as sf\\n\\n def _save_mp3(source_path, out_path):\\n cmd = [\\n 'lame',\\n '--preset',\\n 'insane',\\n str(source_path),\\n str(out_path)\\n ]\\n errno = subprocess.call(cmd)\\n if errno:\\n print('{} encoding failed with code'.format(source_path), end=' ')\\n print(errno)\\n print('skipping...')\\n return errno\\n os.remove(source_path)\\n return 0\\n\\n # this is kind-of standard\\n if mp3_filename is None:\\n mp3_filename = FeatureExtractor.get_file_name(x, feature_name, 'mp3')\\n wav_filename = mp3_filename.replace('mp3', 'wav')\\n sf.write(str(out_path / wav_filename), ndarray, sr) # write wav file\\n errno = _save_mp3(out_path / wav_filename,\\n out_path / mp3_filename) # load wav, encode as mp3 and remove wav file\\n if errno:\\n # if any error, then keep wav\\n filename = wav_filename\\n else:\\n # non-error clause, then it was successfully exported to mp3\\n filename = mp3_filename\\n if new_labels is not None:\\n new_labels.append([filename, y])\\n print('info: {} transformed and saved!'.format(filename))\\n return filename\",\n \"def snip(filename,s,e,wout=True):\\n n, data, data_dB,sr,ch=inputwav(filename)\\n st=int(s*44100)\\n en=int(e*44100)\\n data_s=data[st:en,:]\\n if wout==True:\\n print('Exporting...')\\n sf.write(filename[0:len(filename)-4]+'_snipped.wav',data_s,sr,'PCM_16')\\n print('Done!')\\n return data_s\",\n \"def write_wave(data, samp_rate, file):\\n if data.dtype != np.float16:\\n assert(data.dtype in [np.float32, np.float64])\\n if (len(data.shape) < 2 or data.shape[0] > data.shape[1] or\\n not data.dtype in [np.float32, np.float64]):\\n raise ValueError(\\\"Input audio had unexpected type or shape or dtype: {},{}\\\"\\n .format(data.shape, data.dtype))\\n max_val = data.max() * 32768.0\\n min_val = data.min() * 32768.0\\n\\n truncation_scale = 1.0\\n if max_val > 32767.0:\\n # The + 0.1 below is a small offset to prevent roundoff causing\\n # wrap-around errors.\\n truncation_scale = 32767.0 / (max_val + 0.1)\\n if min_val < -32768.0:\\n s = 32768.0 / (-min_val + 0.1);\\n if s > truncation_scale:\\n truncation_scale = s\\n scale = 32768.0 * truncation_scale\\n data = np.rint(data * scale).astype(np.int16)\\n data = data.swapaxes(0, 1)\\n file = file_utils.open_or_fd(file, \\\"w\\\", encoding=None)\\n wavio.write(file, data, samp_rate, scale='none')\\n file.close()\",\n \"def convert_to_wav(fin, fout):\\n temp = subprocess.run([\\\"ffmpeg\\\",\\n \\\"-i\\\", \\n fin, \\n fout], \\n stdout=subprocess.PIPE, \\n stderr=subprocess.PIPE)\",\n \"def to_voice(item):\\r\\n item.seek(0)\\r\\n item = AudioSegment.from_file(item)\\r\\n m = io.BytesIO()\\r\\n m.name = \\\"voice.ogg\\\"\\r\\n item.split_to_mono()\\r\\n dur = len(item) / 1000\\r\\n item.export(m, format=\\\"ogg\\\", bitrate=\\\"64k\\\", codec=\\\"libopus\\\")\\r\\n m.seek(0)\\r\\n return m, dur\",\n \"def test_wav(self, dtype, sample_rate, num_channels):\\n duration = 1\\n path = self.get_temp_path(\\\"data.wav\\\")\\n data = get_wav_data(dtype, num_channels, normalize=False, num_frames=duration * sample_rate)\\n save_wav(path, data, sample_rate)\\n info = self._info(path)\\n assert info.sample_rate == sample_rate\\n assert info.num_frames == sample_rate * duration\\n assert info.num_channels == num_channels\\n assert info.bits_per_sample == sox_utils.get_bit_depth(dtype)\\n assert info.encoding == get_encoding(\\\"wav\\\", dtype)\",\n \"def morse_to_audio(words, playsound=None, name_file=\\\"output\\\\\\\\code_to_audio_output.wav\\\"):\\n dot = wave.open(\\\"kropka.wav\\\", 'rb')\\n dash = wave.open(\\\"kreska.wav\\\", 'rb')\\n\\n rate_dot = dot.getframerate()\\n\\n rate_dash = dash.getframerate()\\n\\n data_dot = dot.readframes(-1)\\n data_dash = dash.readframes(-1)\\n data_dot = np.fromstring(data_dot, 'Int16')\\n data_dash = np.fromstring(data_dash, 'Int16')\\n\\n l2=len(data_dot)\\n l1=len(data_dash)\\n\\n output=[]\\n\\n for element in words:\\n # print(element)\\n for i in range(0, len(element)):\\n # print(element[i])\\n if element[i] == '1':\\n # playsound(\\\"kropka.wav\\\")\\n output.extend(data_dot)\\n\\n if element[i] == '0':\\n # playsound(\\\"kreska.wav\\\")\\n output.extend(data_dash)\\n if element[i] == ' ':\\n output.extend(np.zeros(int(len(data_dash)))*3)\\n if i != len(element) - 1:\\n # time.sleep(dl_kropka)\\n output.extend(np.zeros(int(len(data_dot))))\\n else:\\n continue\\n # time.sleep(dl_kreska)\\n output.extend(np.zeros(int(len(data_dash))))\\n\\n # print(output)\\n\\n wynik=np.asarray(output)\\n\\n wynik=np.array(wynik).astype('int16')\\n\\n wav.write(name_file, rate_dash, wynik)\\n\\n #plik sie nie odtwarza w windowsie ale w audacity jest już wyraźnym szumem XD\\n\\n dot.close()\\n dash.close()\",\n \"def split_multiple_recordings_file(file_path, min_silence_duration=0.25, noise_threshold=150):\\n print(file_path)\\n rate, audio = scipy.io.wavfile.read(file_path)\\n split_recordings = split_multiple_recordings(audio, min_silence_duration=min_silence_duration,\\n noise_threshold=noise_threshold, sample_rate_hz=rate)\\n\\n if file_path.count('.') != 1:\\n raise Exception('File_path must contain exactly one period, usually in extension. IE: /home/test.wav')\\n\\n for idx, recording in enumerate(split_recordings):\\n print(\\\"spliting \\\" + file_path)\\n new_file_path = file_path.split('.')[0] + '_' + str(idx) + \\\".wav\\\"\\n scipy.io.wavfile.write(new_file_path, rate, recording)\",\n \"def segment_audio(filename, y_value, split='train', clf='gender'):\\n\\n filepath = 'recordings/recordings/' + filename + '.mp3'\\n audio, sr = librosa.load(filepath, sr=16000)\\n audio = normalize(audio)\\n\\n # Add gender label to filename for later processing\\n sex = y_value\\n if sex == 'female':\\n filename = '{}.F'.format(filename)\\n else: filename = '{}.M'.format(filename)\\n\\n # Segment audio file\\n seg_files = segment_10s(audio, sr)\\n\\n for key, val in seg_files.items():\\n new_name = '{}.{}'.format(filename, key)\\n sf.write('data/{}/{}/{}o.wav'.format(clf, split, new_name), val, sr)\",\n \"def audio_file_save(folder_path, current_time, data, name_by_date):\\r\\n\\r\\n name_by_time = current_time + '.wav' #timestamp for the audio file name\\r\\n usage = disk_usage(folder_path)\\r\\n if usage.used / usage.total < args.storage_threshold:\\r\\n file_path = os.path.join(folder_path, name_by_time)\\r\\n\\r\\n if args.resampling:\\r\\n sampling_rate = args.resampling_rate\\r\\n audio = audio_resampling(data)\\r\\n else:\\r\\n sampling_rate = args.recording_samplerate\\r\\n audio = data\\r\\n\\r\\n sf.write(file_path , audio, sampling_rate)\\r\\n\\r\\n else:\\r\\n name = os.path.join(folder_path, name_by_date + '.txt')\\r\\n f = open(name, 'a')\\r\\n f.write(current_time + '\\\\t Activity Detected \\\\n')\\r\\n f.close()\",\n \"def record_audio_to_file_and_get_wav(self, time, file_name):\\n sample_width, frames = self.record_audio(time)\\n wf = wave.open(file_name, 'wb')\\n wf.setnchannels(self.channels)\\n wf.setsampwidth(sample_width)\\n wf.setframerate(self.rate)\\n wf.writeframes(frames)\\n wf.close()\\n return WavFile(samples=frames, sample_width=sample_width, time=time, word=file_name)\",\n \"def convert_wav(src_wav, dst_wav, subtype='PCM_16'):\\n assert os.path.exists(src_wav), \\\"{} not exists!\\\".format(src_wav)\\n data, sr = soundfile.read(src_wav)\\n soundfile.write(dst_wav, data, sr, subtype=subtype)\",\n \"def output_wave_file(predicted_mfccs, filename):\\n global eng\\n predicted_mfccs_transposed = np.transpose(predicted_mfccs)\\n\\n\\n # MFCC features need to be a numpy array of shape (num_coefficients x num_frames) in order to be passed to the invmelfcc function\\n inverted_wav_data = eng.invmelfcc(matlab.double(predicted_mfccs_transposed.tolist()), 16000.0, 25, 100.0, 0.005, 0.005)\\n\\n inverted_wav_data = np.squeeze(np.array(inverted_wav_data))\\n\\n # scales the waveform to be between -1 and 1\\n maxVec = np.max(inverted_wav_data)\\n minVec = np.min(inverted_wav_data)\\n inverted_wav_data = ((inverted_wav_data - minVec) / (maxVec - minVec) - 0.5) * 2\\n\\n wav.write(filename + '.wav', 16000.0, inverted_wav_data)\",\n \"def mp3_to_wav(show_progress=True):\\n\\n # Define a devnull var to supress subprocess output\\n devnull = open(os.devnull, 'w')\\n\\n # Get a list of the filepath for each of the mp3 files in each subdirectory of data/fma_small\\n file_list = glob.glob('./../data/fma_small/*/*.mp3')\\n\\n # Get the number of files N and initialize a counter\\n N = len(file_list)\\n counter = 0\\n\\n # For each file/filepath, convert that file to wav format and save it to data/wavs/*/*.wav (so as a wave file)\\n for filepath in file_list:\\n\\n # Every 100 file conversions, print a progress update\\n if counter % 50 == 49 and show_progress:\\n progress = str(round(100 * counter / N, 2))\\n print('File conversion ' + progress + '% complete.')\\n\\n # Get the file name from the path and define a new path for the wav file\\n file_name = filepath[24:-4]\\n new_path = './../data/wavs/' + file_name + '.wav'\\n\\n # Call the subprocess using ffmpeg to convert the file to wav format (and supress all the output)\\n subprocess.call(['ffmpeg', '-i', filepath, new_path], stdout=devnull)\\n\\n # Increment the counter\\n counter += 1\",\n \"def record():\\n p = pyaudio.PyAudio()\\n stream = p.open(format=FORMAT, input_device_index=0, channels=1, rate=RATE, input=True, output=True, frames_per_buffer=CHUNK_SIZE)\\n num_silent = 0\\n snd_started = False\\n\\n r = array('h')\\n while 1:\\n snd_data = array('h', stream.read(CHUNK_SIZE, exception_on_overflow = False))\\n if byteorder == 'big':\\n snd_data.byteswap()\\n r.extend(snd_data)\\n\\n silent = is_silent(snd_data)\\n if silent and snd_started:\\n num_silent += 1\\n elif not silent and not snd_started:\\n print(\\\"Sound started.\\\")\\n snd_started = True\\n\\n if snd_started and num_silent> 10:\\n break\\n\\n sample_width = p.get_sample_size(FORMAT)\\n stream.stop_stream()\\n stream.close()\\n p.terminate()\\n\\n r = normalize(r)\\n #r = trim(r)\\n #r = add_silence(r, 0.5)\\n return sample_width, r\",\n \"def save_audio(ndarray, feature_name, out_path, x, y, new_labels, filename=None, sr=SR):\\n # this is kind-of standard\\n filename = filename or FeatureExtractor.get_file_name(x, feature_name, 'wav')\\n librosa.output.write_wav(out_path / filename, ndarray, sr=sr, norm=True)\\n new_labels.append([filename, y])\\n print('info: {} transformed and saved!'.format(filename))\\n return filename\",\n \"def generate_waveform(self, mel, normalize=True, batched=True,\\n target=8000, overlap=800, do_save_wav=True):\\n wav = self.vocoder_manager.infer_waveform(mel,\\n normalize=normalize,\\n batched=batched,\\n target=target,\\n overlap=overlap,\\n do_save_wav=do_save_wav\\n )\\n return wav\",\n \"def export_sounds(names, path, base_label='Sound_'):\\n\\tfor filename, output in dump_sounds(names, base_label):\\n\\t\\twith open(os.path.join(path, filename), 'w') as out:\\n\\t\\t\\tout.write(output)\",\n \"def record():\\n p = pyaudio.PyAudio()\\n stream = p.open(format=FORMAT, channels=1, rate=RATE,\\n input=True, output=True,\\n frames_per_buffer=CHUNK_SIZE)\\n\\n num_silent = 0\\n snd_started = False\\n\\n r = array('h')\\n\\n while 1:\\n # little endian, signed short\\n snd_data = array('h', stream.read(CHUNK_SIZE))\\n if byteorder == 'big':\\n snd_data.byteswap()\\n r.extend(snd_data)\\n\\n silent = is_silent(snd_data)\\n\\n if silent and snd_started:\\n num_silent += 1\\n elif not silent and not snd_started:\\n snd_started = True\\n\\n if snd_started and num_silent > 30:\\n break\\n\\n sample_width = p.get_sample_size(FORMAT)\\n stream.stop_stream()\\n stream.close()\\n p.terminate()\\n\\n r = normalize(r)\\n r = trim(r)\\n r = add_silence(r, 0.5)\\n return sample_width, r\",\n \"def encode_audio(in_file, out_file):\\r\\n # construct the encoder\\r\\n autoencoder = keras.models.load_model(\\\"audio_autoencoder.model\\\")\\r\\n in_layer = keras.layers.Input(shape=(416, 1))\\r\\n encode = autoencoder.layers[1](in_layer)\\r\\n encode = autoencoder.layers[2](encode)\\r\\n encode = autoencoder.layers[3](encode)\\r\\n encode = autoencoder.layers[4](encode)\\r\\n encode = autoencoder.layers[5](encode)\\r\\n encode = autoencoder.layers[6](encode)\\r\\n encode = autoencoder.layers[7](encode)\\r\\n encode = autoencoder.layers[8](encode)\\r\\n encode = autoencoder.layers[9](encode)\\r\\n encode = autoencoder.layers[10](encode)\\r\\n encode = autoencoder.layers[11](encode)\\r\\n encode = autoencoder.layers[12](encode)\\r\\n encoder = keras.models.Model(in_layer, encode)\\r\\n\\r\\n # Read the file\\r\\n samp_rate, data = wavfile.read(in_file)\\r\\n # check if the file is mono or stereo\\r\\n if len(data.shape) == 2:\\r\\n data = np.concatenate(data)\\r\\n chans = 2\\r\\n else:\\r\\n chans = 1\\r\\n\\r\\n # Rescale integer samples over range [-32768,32767] to floats over range [0.0,1.0]\\r\\n data = data.astype('float32') / float(pow(2, 15))\\r\\n data += 1.0\\r\\n data = data / 2.0\\r\\n\\r\\n # Pad the samples with zeroes, if needed, to make the last encoding frame full\\r\\n padded = np.pad(data, (0, 416 - (len(data) % 416)), 'constant')\\r\\n\\r\\n # Construct input layer\\r\\n inputs = padded.reshape(len(padded) // 416, 416, 1)\\r\\n\\r\\n # Encode the data\\r\\n encoded = encoder.predict(inputs)\\r\\n\\r\\n # Save the encoded data, as well as the important parameters\\r\\n np.savez_compressed(out_file, data=encoded, rate=samp_rate, Type=1, channels=chans)\",\n \"def play_wav_on_index(audio_data, stream_object):\\n\\n stream_object.write(audio_data)\",\n \"def save_all_chunks_with_labels(audio_dir, json_dir, csv_dir):\\n for file in os.listdir(json_dir):\\n file_path = os.path.join(json_dir, file)\\n audio_file_path = os.path.join(audio_dir, file)[:-4] + \\\"wav\\\"\\n with open(file_path) as f:\\n data = json.load(f)\\n save_arrays_with_labels(audio_file_path, data, csv_dir)\",\n \"def save_song(self):\\n if self.is_stream:\\n self.save_song_from_stream()\\n else:\\n self.save_song_from_file()\",\n \"def record():\\n p = pyaudio.PyAudio()\\n stream = p.open(format=FORMAT, channels=1, rate=RATE,\\n input=True, output=True,\\n frames_per_buffer=CHUNK_SIZE)\\n\\n num_silent = 0\\n snd_started = False\\n\\n r = array('h')\\n\\n while 1:\\n # little endian, signed short\\n snd_data = array('h', stream.read(CHUNK_SIZE))\\n if byteorder == 'big':\\n snd_data.byteswap()\\n r.extend(snd_data)\\n\\n silent = is_silent(snd_data)\\n\\n if silent and snd_started:\\n num_silent += 1\\n elif not silent and not snd_started:\\n snd_started = True\\n\\n if snd_started and num_silent > SILENCE:\\n break\\n\\n sample_width = p.get_sample_size(FORMAT)\\n stream.stop_stream()\\n stream.close()\\n p.terminate()\\n\\n r = normalize(r)\\n r = trim(r)\\n r = add_silence(r, 0.5)\\n return sample_width, r\",\n \"def convert_to_wav(mp3_filename):\\n\\n wav_filename = mp3_filename[:-4] + \\\".wav\\\"\\n complete_mp3FileName = os.path.join(MP3_FOLDER, mp3_filename)\\n complete_wavFileName = os.path.join(WAV_FOLDER, wav_filename)\\n\\n mp3_file = AudioSegment.from_mp3(complete_mp3FileName)\\n mp3_file.export(complete_wavFileName, format=\\\"wav\\\")\\n\\n print(f\\\"The mp3 file {complete_mp3FileName} was successfully converted to \\\" \\\\\\n + f\\\"the wav file {complete_wavFileName}.\\\")\",\n \"def _writeWiggle(trackName, trackDescription, allCounts, wigOut, win=1):\\n wigFile = open(wigOut, \\\"w\\\")\\n wigFile.write(\\\"track type=wiggle_0 name='%s' description='%s' visibility=2\\\\n\\\" % (trackName,\\n trackDescription))\\n for name in allCounts.keys():\\n start = 0\\n end = max(allCounts[name].keys())\\n\\n wigFile.write(\\\"fixedStep chrom=%s start=%s step=%s span=%s\\\\n\\\" % (name, start+1, win, win))\\n\\n for i in range(start, end):\\n if allCounts[name].has_key(i):\\n curValue = allCounts[name][i]\\n else:\\n curValue = 0\\n wigFile.write(\\\"%s\\\\n\\\" % (curValue))\\n\\n wigFile.close()\",\n \"def _record_wav(stream, N, CHUNK):\\n frames = []\\n for i in range(N):\\n data = stream.read(CHUNK)\\n frames.append(data)\\n return np.fromstring(b\\\"\\\".join(frames), 'Int16')\",\n \"def save_to_file(filename: str, sequence: List[Sample]):\\n\\n with open(get_path() + \\\"/sequence/\\\" + filename, \\\"ab+\\\") as file:\\n for sample in sequence:\\n pickle.dump(sample, file, pickle.HIGHEST_PROTOCOL)\",\n \"def save_data(self, f): \\n if not self.sampling:\\n self.convert_to_array()\\n np.save(f, self.reads)\",\n \"def write( self, strFilename, bAsRawFile = False, bQuiet = False ):\\n if( len( self.data ) < 1 ):\\n logging.warning( \\\"Wav is empty, NOT saving it (to '%s').\\\" % (strFilename) ) \\n return False\\n timeBegin = time.time()\\n file = open( strFilename, \\\"wb\\\" )\\n if( not bAsRawFile ):\\n self.writeHeader( file )\\n self.writeData( file, bAddBeginOfDataChunk = not bAsRawFile )\\n file.close()\\n rDuration = time.time() - timeBegin\\n if not bQuiet: logging.info( \\\"sound.Wav: successfully saved wav to '%s', duration: %5.3fs, datasize: %d (saving takes %5.3fs)\\\" % (strFilename, self.rDuration, self.nDataSize, rDuration) )\\n return True\",\n \"def storeWavelengths(self, nm):\\n pre = \\\"w,0\\\"\\n d = {\\\"wavelength_nm\\\": list(nm)}\\n self._writeline(pre, str(d))\",\n \"def save_bin(words,data,fname):\\n\\n out=open(fname,\\\"wb\\\")\\n\\n rows,dims=data.shape\\n out.write(\\\"{} {}\\\\n\\\".format(rows,dims).encode(\\\"utf-8\\\"))\\n counter=0\\n\\n for i,w in enumerate(words):\\n out.write(w.encode(\\\"utf-8\\\"))\\n out.write(\\\" \\\".encode(\\\"utf-8\\\"))\\n out.write(struct.pack(\\\"{}f\\\".format(dims),*data[i,:]))\\n counter+=1\\n \\n out.close()\\n print(\\\"Model saved to\\\",fname,file=sys.stderr)\",\n \"def do_wave(l, wave_type, r, g, b, duration, repeat):\\n command = create_wave_command(\\n wave_type, r, g, b, duration, repeat\\n )\\n l.write(command)\",\n \"def cut_audio(old_path, new_path, start, end):\\r\\n fs, data = wavfile.read(old_path)\\r\\n indx_start = int(start*fs)\\r\\n indx_end = int(end*fs)+1\\r\\n wavfile.write(new_path,fs,data[indx_start:indx_end])\\r\\n\\r\\n return True\",\n \"def write_data(infbfile,begin_N,dur_N,outfbfile):\\n infbfile.seek_to_sample(begin_N)\\n for i in range(begin_N,(begin_N+dur_N)):\\n data = infbfile.read_sample()\\n data.tofile(outfbfile)\",\n \"def fillSongsArray():\\r\\n counter = 1\\r\\n notealt = 0.0\\r\\n frequenz = 0\\r\\n notencounter = 0\\r\\n\\r\\n file2write.write(\\\"\\\\n{\\\")\\r\\n for instrument in midi_data.instruments:\\r\\n while counter == 1:#first line of the instrument e.g piano it will only save the treble clef and NOT the bass clef\\r\\n for note in instrument.notes:\\r\\n if note.start - notealt >= 0.15: #If the note is a break it will save it as such\\r\\n value = dauer/((note.start - notealt)*1000)\\r\\n y = round(value)\\r\\n file2write.write(\\\"{0,\\\")\\r\\n file2write.write(str(y+1))\\r\\n file2write.write(\\\"},\\\")\\r\\n\\r\\n else:\\r\\n frequenz = int(pretty_midi.note_number_to_hz(note.pitch)) #convert the midi-note-number to a frequency with function of the library\\r\\n value = dauer/((note.end - note.start)*1000) #calculates the duration of the note\\r\\n x = round(value)\\r\\n file2write.write(\\\"{\\\")\\r\\n file2write.write(str(frequenz))\\r\\n file2write.write(\\\",\\\")\\r\\n file2write.write(str(x))\\r\\n file2write.write(\\\"},\\\")\\r\\n notealt = note.end\\r\\n counter += 1\\r\\n file2write.write(\\\"},\\\")\\r\\n #file2write.write(\\\"};\\\\n\\\")\\r\",\n \"def on_stop(self):\\n self.songs.save_songs(FILE_NAME)\",\n \"def create_audio_file():\\n # Get the response from boto3\\n raw_audio = generate_audio()\\n # pull the Audiostream object from the response from boto3\\n raw_audio = raw_audio[\\\"AudioStream\\\"]\\n # create output location\\n # process the whole block\\n with closing(raw_audio) as audio:\\n with open(\\\"output_audio.mp3\\\", \\\"wb\\\") as file:\\n file.write(raw_audio.read())\",\n \"def GenerateSinewav(self, dut_file_path, channel, wav_duration):\\n with file_utils.UnopenedTemporaryFile(suffix='.wav') as file_path:\\n cmd = audio_utils.GetGenerateSineWavArgs(file_path, channel,\\n _DEFAULT_FREQ_HZ, wav_duration)\\n process_utils.Spawn(cmd.split(' '), log=True, check_call=True)\\n self._dut.link.Push(file_path, dut_file_path)\",\n \"def split_diphones(wav_path, outdir=None):\\n tg = ml.parsing.textgrid_reader.read(textgrid_path(wav_path))\\n word = os.path.splitext(os.path.basename(wav_path))[0]\\n\\n wav_dir = os.path.dirname(wav_path)\\n diphones_dir = os.path.join(wav_dir, \\\"diphones\\\")\\n\\n if not os.path.exists(diphones_dir):\\n os.mkdir(diphones_dir)\\n\\n wav = AudioSegment.from_file(wav_path)\\n for (begin, end, diphone) in tg[u'phones']:\\n diphone = diphone.strip().replace(\\\"-\\\", \\\"_\\\")\\n if len(diphone) > 0 and diphone[0] != \\\".\\\":\\n diphone_file = \\\"{}_{}.wav\\\".format(diphone, word)\\n diphone_path = os.path.join(diphones_dir, diphone_file)\\n\\n # Works in milliseconds\\n segment = wav[(begin * 1000):(end * 1000)]\\n print(\\\"Saving {} ({} - {})\\\".format(diphone_path, begin, end))\\n segment.export(diphone_path, format=\\\"wav\\\")\\n elif diphone[0] == \\\".\\\":\\n print(\\\"skipping {}\\\".format(diphone))\",\n \"def set_audio_sink(core, filenameOrHandle):\\n\\tres = wave.open(filenameOrHandle, \\\"wb\\\")\\n\\tres.setnchannels(2)\\n\\tres.setsampwidth(2)\\n\\tres.setframerate(SNES_OUTPUT_FREQUENCY)\\n\\tres.setcomptype('NONE', 'not compressed')\\n\\n\\tdef audio_sample(left, right):\\n\\t\\t# We can safely use .writeframesraw() here because the header will be\\n\\t\\t# corrected once we call .close()\\n\\t\\tres.writeframesraw(sndstruct.pack(left, right))\\n\\n\\tcore.set_audio_sample_cb(audio_sample)\\n\\n\\treturn res\",\n \"def record_audio(self):\\n stream = self.audio.open(format=DEFAULT_FORMAT,\\n channels=DEFAULT_CHANNELS,\\n rate=DEFAULT_RATE,\\n input=True,\\n frames_per_buffer=DEFAULT_CHUNK_SIZE)\\n\\n print(\\\"Recording...\\\")\\n\\n for i in range(0, int(DEFAULT_RATE / DEFAULT_CHUNK_SIZE * RECORD_SECONDS)):\\n data = stream.read(DEFAULT_CHUNK_SIZE)\\n self.frames.append(data)\\n\\n print(\\\"Done.\\\")\\n\\n stream.stop_stream()\\n stream.close()\",\n \"def convert_to_wav (filename, name, origpath, wavpath, mono):\\n print(\\\"Converting {0} to .wav...\\\".format(filename))\\n if not re.match(r\\\".*_\\\\d+$\\\",name):\\n # If filenames do include video titles\\n name = name.rsplit('_',1)[0]\\n\\n channel, vid_num = name.rsplit('_', 1)\\n channel = re.sub(r'[^A-Za-z1-9]', '', channel)\\n newname = '_'.join([channel, vid_num])\\n\\n exportname = newname + \\\".wav\\\"\\n filepath = path.join(origpath, filename)\\n\\n if not path.exists(wavpath):\\n makedirs(wavpath)\\n exportPath = path.join(wavpath, exportname)\\n sound = AudioSegment.from_file(filepath,\\\"mp4\\\")\\n if mono == True:\\n sound = sound.set_channels(1)\\n sound.export(exportPath, format=\\\"wav\\\")\",\n \"def write_WFs(folder, filename_prefix='', indices=None, WFs=None, extension=settings.HEAVY_AUDIO_WRITE_EXTENSION, sample_rate=settings.DEFAULT_SAMPLE_RATE):\\n if WFs is None:\\n raise ValueError('save_WFs expects either a WF list or 2-D np array')\\n\\n is_array = isinstance(WFs, np.ndarray)\\n if is_array:\\n n_WFs = WFs.shape[0]\\n else:\\n n_WFs = len(WFs)\\n\\n if indices is None:\\n indices = range(n_WFs)\\n if len(indices) != n_WFs:\\n raise ValueError('save_WFs expects as many indices as there are WFs')\\n\\n file_names = []\\n file_paths = []\\n for i in indices:\\n file_name = '{0}_{1}.{2}'.format(filename_prefix, rank_4_audacity(i), extension)\\n file_path = '{0}/{1}'.format(folder, file_name)\\n if is_array:\\n sf.write(file_path, WFs[i, :], sample_rate)\\n else:\\n sf.write(file_path, WFs[i], sample_rate)\\n file_names.append(file_name)\\n file_paths.append(file_path)\\n\\n return file_paths, file_names\",\n \"def wavPlayer(data, rate, scale=False, autoplay=False):\\r\\n #if np.max(abs(data)) > 1 or scale:\\r\\n # data = data/np.max(abs(data))\\r\\n #data = (2**13*data).astype(np.int16)\\r\\n \\r\\n buffer = BytesIO()\\r\\n buffer.write(b'RIFF')\\r\\n buffer.write(b'\\\\x00\\\\x00\\\\x00\\\\x00')\\r\\n buffer.write(b'WAVE')\\r\\n \\r\\n buffer.write(b'fmt ')\\r\\n if data.ndim == 1:\\r\\n noc = 1\\r\\n else:\\r\\n noc = data.shape[1]\\r\\n \\r\\n bits = data.dtype.itemsize * 8\\r\\n sbytes = rate*(bits // 8)*noc\\r\\n ba = noc * (bits // 8)\\r\\n buffer.write(struct.pack('<ihHIIHH', 16, 1, noc, rate, sbytes, ba, bits))\\r\\n\\r\\n # data chunk\\r\\n buffer.write(b'data')\\r\\n buffer.write(struct.pack('<i', data.nbytes))\\r\\n\\r\\n if data.dtype.byteorder == '>' or (data.dtype.byteorder == '=' and sys.byteorder == 'big'):\\r\\n data = data.byteswap()\\r\\n\\r\\n buffer.write(data.astype(np.int16).tostring())\\r\\n\\r\\n # Determine file size and place it in correct position at start of the file.\\r\\n size = buffer.tell()\\r\\n buffer.seek(4)\\r\\n buffer.write(struct.pack('<i', size-8))\\r\\n \\r\\n val = buffer.getvalue()\\r\\n autoplay = \\\" autoplay=\\\\\\\"autoplay\\\\\\\"\\\"*autoplay + \\\"\\\"\\r\\n \\r\\n src = \\\"\\\"\\\"<audio controls=\\\"controls\\\" style=\\\"width:600px\\\"{autoplay}>\\r\\n <source controls src=\\\"data:audio/wav;base64,{base64}\\\" type=\\\"audio/wav\\\" />\\r\\n Your browser does not support the audio element.\\r\\n </audio>\\\"\\\"\\\".format(base64=base64.b64encode(val).decode(\\\"ascii\\\"), autoplay=autoplay)\\r\\n display(HTML(src))\",\n \"def rec_one_shot(self, sec, file_name=None):\\n self.__open_noncallback_stream()\\n frames = []\\n for i in range(int(self.RATE / self.CHUNK * sec)):\\n data = self.stream.read(self.CHUNK)\\n data = np.fromstring(data, dtype=np.int16)\\n frames.append(data)\\n self.stream.stop_stream()\\n if file_name is not None:\\n with wave.open(file_name, 'wb') as wav_file:\\n wav_file.setnchannels(self.CHANNELS)\\n wav_file.setsampwidth(self.recorder.get_sample_size(self.FORMAT))\\n wav_file.setframerate(self.RATE)\\n wav_file.writeframes(b''.join(frames))\\n frame = np.concatenate(frames, 0)\\n self.stop_streaming()\\n return frame\",\n \"def save_waveform(self, chan=None):\\n t, y, pre = self.device.retrieve_current_waveform()\\n meta = self.create_meta()\\n if chan != None:\\n meta['Channel'] = chan\\n for name in pre:\\n meta[name] = pre[name]\\n data = {'meta' : meta,\\n 't' : t,\\n 'y' : y}\\n rsp = daq.Rsp('save', data, meta)\\n self.shot += 1\\n self.r_queue.put(rsp)\",\n \"def save_timit_pitch():\\n timit_names = []\\n pitch_intensity_tables = []\\n\\n wav_txt_file_names = glob.glob(os.path.join(timit_pitch_data_path, '*.wav.txt'))\\n for wav_txt_file in wav_txt_file_names:\\n pitch_intensity = pd.read_csv(wav_txt_file, delimiter='\\\\t', dtype=np.float64, na_values=['?'])\\n pitch_intensity = pitch_intensity.dropna()\\n pitch_intensity.loc[pitch_intensity.pitch == 0, 'pitch'] = np.NaN\\n pitch_intensity.loc[pitch_intensity.intensity == 0, 'intensity'] = np.NaN\\n pitch_intensity['log_hz'] = np.log(pitch_intensity['pitch'])\\n pitch_intensity['erb_rate'] = convert_hz(pitch_intensity['pitch'], \\\"erb\\\")\\n pitch = pitch_intensity['log_hz']\\n pitch_intensity['rel_pitch_global'] = (pitch - np.mean(pitch))/np.std(pitch)\\n pitch = pitch_intensity['erb_rate']\\n pitch_intensity['rel_pitch_global_erb'] = (pitch - np.mean(pitch))/np.std(pitch)\\n\\n timit_name = wav_txt_file.split(os.sep)[-1][:-8]\\n\\n timit_names.append(timit_name)\\n pitch_intensity_tables.append(pitch_intensity)\\n\\n timit_pitch = pd.concat(pitch_intensity_tables, keys=timit_names)\\n #print(np.mean(timit_pitch['log_hz'])) # -> 4.9406, (no log: 147.0387)\\n #print(np.std(timit_pitch['log_hz'])) # -> 0.3112, (no log: 48.59846)\\n timit_pitch['abs_pitch'] = (timit_pitch['log_hz'] - np.mean(timit_pitch['log_hz']))/np.std(timit_pitch['log_hz'])\\n timit_pitch['abs_pitch_erb'] = (timit_pitch['erb_rate'] - np.mean(timit_pitch['erb_rate']))/np.std(timit_pitch['erb_rate'])\\n timit_pitch['abs_pitch_change'] = timit_pitch['abs_pitch'].diff()\\n timit_pitch['abs_pitch_erb_change'] = timit_pitch['abs_pitch_erb'].diff()\\n #print(np.mean(timit_pitch.intensity)) # -> 63.000\\n #print(np.std(timit_pitch.intensity)) # -> 15.537\\n timit_pitch['zscore_intensity'] = (timit_pitch.intensity - np.mean(timit_pitch.intensity))/np.std(timit_pitch.intensity)\\n\\n filename = os.path.join(processed_timit_data_path, 'timit_pitch.h5')\\n timit_pitch.to_hdf(filename, 'timit_pitch')\\n return timit_pitch\",\n \"def writeMIDI(filepath,data):\\n\\n\\n\\twith open(filepath,\\\"wb\\\") as f:\\n\\n\\t\\t## Writing the MIDI file header\\n\\t\\tf.write(\\\"MThd\\\")\\n\\t\\tf.write(struct.pack(\\\">ihhh\\\",6,1,len(d[\\\"tracks\\\"]),1000)) # Length of the header, MIDI type 1, number of track, 1000 ticks per quarter\\n\\n\\t\\tfor x in data[\\\"tracks\\\"]:\\n\\t\\t\\t# Reordering all the sound events by increasing time\\n\\t\\t\\ttrackdata = [[y[\\\"type\\\"],y[\\\"note\\\"],y[\\\"velocity\\\"],y[\\\"time\\\"]] for y in x]\\n\\t\\t\\ttrackdata = sorted(trackdata, key=lambda x:x[3])\\n\\t\\t\\t\\n\\t\\t\\t# MIDI files deal with time differences, which we calculate here\\n\\t\\t\\ttrackdata_diff = [[trackdata[0][0],trackdata[0][1],trackdata[0][2],trackdata[0][3]]]\\n\\t\\t\\tfor i in range(1,len(trackdata)):\\n\\t\\t\\t\\ttrackdata_diff.append([trackdata[i][0],trackdata[i][1],trackdata[i][2],trackdata[i][3]-trackdata[i-1][3]])\\n\\t\\t\\ttrackdata_diff = [[x[0],x[1],x[2],encodeVL(int(2000.*x[3]))] for x in trackdata_diff] ## 2000= 1000 ticks per quarter * 2 (because 120 bpm = 2 quarters per seconds)\\n\\t\\t\\t\\n\\t\\t\\t# Number of bytes of the track chunk: 15 for standard info (120bpm, fake notes, etc.), 4 for the tail, the rest depends on the data\\n\\t\\t\\ttrackdata_numbytes = 15+4+3*len(trackdata_diff)+sum([len(x[3]) for x in trackdata_diff])\\n\\t\\t\\t# If sustain is used\\n\\t\\t\\t#trackdata_numbytes += 4 \\n\\t\\t\\t\\n\\t\\t\\t## Writing the track chunk to the MIDI file\\n\\t\\t\\tf.write(\\\"MTrk\\\")\\n\\t\\t\\tf.write(struct.pack(\\\">i\\\",trackdata_numbytes)) # Length of the track chunk\\n\\n\\t\\t\\t# 120 bpm\\n\\t\\t\\tf.write(struct.pack(\\\">BBBB\\\",0,0xFF,0x51,0x03))\\n\\t\\t\\tf.write(struct.pack(\\\">BBB\\\",0x07,0xA1,0x20))\\n\\t\\t\\t\\n\\n\\t\\t\\t# Fake note at the beginning to mark 0 time\\n\\t\\t\\tf.write(struct.pack(\\\">BBBB\\\",0,0x90,0,40))\\n\\t\\t\\tf.write(struct.pack(\\\">BBBB\\\",1,0x80,0,40))\\n\\t\\t\\t\\n\\t\\t\\t#Sustain pedal on\\n\\t\\t\\t#f.write(struct.pack(\\\">BBBB\\\",2,0xB0,0x40,0x41))\\n\\n\\t\\t\\t# Writing one note\\n\\t\\t\\tfor x in trackdata_diff:\\n\\t\\t\\t\\tfor y in x[3]:\\n\\t\\t\\t\\t\\tf.write(struct.pack(\\\">B\\\",y))\\n\\t\\t\\t\\tif x[0]==\\\"ON\\\":\\n\\t\\t\\t\\t\\tf.write(struct.pack(\\\">BBB\\\",0x90,x[1],x[2]))\\n\\t\\t\\t\\tif x[0]==\\\"OFF\\\":\\n\\t\\t\\t\\t\\tf.write(struct.pack(\\\">BBB\\\",0x80,x[1],x[2]))\\n\\t\\t\\t\\n\\t\\t\\t## End of the track chunk\\n\\t\\t\\tf.write(struct.pack(\\\">BBBB\\\",0,0xFF,0x2F,0))\",\n \"def generate_wavplot(song_name):\\n\\n filepath = features[features.inferred_name.str.title() == song_name].feature_file.values[0]\\n rate, wave = wavfile.read(filepath)\\n mono = np.mean(wave, axis=1)\\n mono.shape\\n plt.figure(figsize=(20,6))\\n plt.axis('off')\\n plt.plot(mono[::mono.shape[0]//6000], color='white')\\n plt.tight_layout;\\n friendly_song_name = '_'.join(song_name.split()).lower()\\n output_filepath = './static/wavplots/' + friendly_song_name + '.png'\\n plt.savefig(output_filepath, bbox_inches='tight', pad_inches=0, transparent=True)\\n return output_filepath\",\n \"def webm_to_wav(webm_file: str):\\n wav_file = webm_file.replace(\\\".webm\\\", \\\".wav\\\")\\n wav = AudioSegment.from_file(webm_file)\\n wav.export(wav_file, format=\\\"wav\\\")\\n return wav_file\",\n \"def _writeWiggleVar(trackName, trackDescription, allCounts, wigOut):\\n wigFile = open(wigOut, \\\"w\\\")\\n wigFile.write(\\\"track type=wiggle_0 name='%s' description='%s' visibility=2\\\\n\\\" % (trackName,\\n trackDescription))\\n\\n for name in allCounts.keys():\\n start = 0\\n end = max(allCounts[name].keys())\\n\\n wigFile.write(\\\"variableStep chrom=%s span=1\\\\n\\\" % (name))\\n\\n for pos in sorted(allCounts[name].keys()):\\n wigFile.write(\\\"%s\\\\t%s\\\\n\\\" % (pos,allCounts[name][pos]))\\n\\n\\n wigFile.close()\",\n \"def load_audio(file_path):\\n # load the audio file in its original sampling rate\\n audio_data, sr = librosa.load(file_path, sr=sampling_rate)\\n\\n # get the common file name\\n file_name = file_path.split(\\\"/\\\")[-1]\\n file_name = file_name.split(\\\".wav\\\")[0]\\n\\n # calculate number of samples in the time duration needed\\n num_samples = int(sr*time_duration)\\n\\n # get the cut-off audio signals and save them\\n for i in np.arange(num_audio_files):\\n audio_cut_data = cut_sample(audio_data, num_samples)\\n file_path=dir_to_save + file_name + \\\"_\\\" + str(i+1) + \\\".wav\\\"\\n save_sample(audio_cut_data, file_path, sr)\\n print(f\\\"generating signal {str(i)}, its length {len(audio_cut_data)} by cutting the original signal\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6919104","0.6847627","0.672993","0.6697336","0.66271955","0.6598934","0.65593815","0.65480053","0.65218306","0.6511665","0.64606607","0.6440448","0.63984156","0.6338785","0.63294864","0.6315476","0.63118845","0.63059294","0.6304708","0.6291267","0.62757117","0.6230143","0.6198605","0.61878157","0.6102107","0.6099962","0.60927933","0.60619295","0.6056393","0.6048941","0.6047668","0.5988708","0.5978977","0.5970552","0.5914261","0.5913791","0.5910785","0.5894348","0.58427626","0.57939655","0.5757947","0.5756954","0.57461345","0.57365096","0.5732714","0.57275516","0.57220566","0.5706426","0.5699579","0.5690336","0.5682572","0.5677494","0.5662849","0.56330985","0.5630398","0.56192356","0.5605534","0.56053364","0.55982536","0.55929387","0.5591035","0.5579563","0.55716544","0.5555678","0.5525672","0.5497725","0.54900086","0.5479204","0.54781985","0.54691356","0.5458135","0.5453484","0.5444185","0.544044","0.5422919","0.54109836","0.54100686","0.539366","0.5392348","0.5378004","0.5370847","0.5363176","0.53444535","0.53306365","0.5321931","0.5317966","0.5315327","0.53147954","0.5312611","0.5299452","0.5293861","0.5287521","0.52867866","0.5285107","0.5284913","0.52809215","0.5274716","0.5272779","0.5268722","0.52671653"],"string":"[\n \"0.6919104\",\n \"0.6847627\",\n \"0.672993\",\n \"0.6697336\",\n \"0.66271955\",\n \"0.6598934\",\n \"0.65593815\",\n \"0.65480053\",\n \"0.65218306\",\n \"0.6511665\",\n \"0.64606607\",\n \"0.6440448\",\n \"0.63984156\",\n \"0.6338785\",\n \"0.63294864\",\n \"0.6315476\",\n \"0.63118845\",\n \"0.63059294\",\n \"0.6304708\",\n \"0.6291267\",\n \"0.62757117\",\n \"0.6230143\",\n \"0.6198605\",\n \"0.61878157\",\n \"0.6102107\",\n \"0.6099962\",\n \"0.60927933\",\n \"0.60619295\",\n \"0.6056393\",\n \"0.6048941\",\n \"0.6047668\",\n \"0.5988708\",\n \"0.5978977\",\n \"0.5970552\",\n \"0.5914261\",\n \"0.5913791\",\n \"0.5910785\",\n \"0.5894348\",\n \"0.58427626\",\n \"0.57939655\",\n \"0.5757947\",\n \"0.5756954\",\n \"0.57461345\",\n \"0.57365096\",\n \"0.5732714\",\n \"0.57275516\",\n \"0.57220566\",\n \"0.5706426\",\n \"0.5699579\",\n \"0.5690336\",\n \"0.5682572\",\n \"0.5677494\",\n \"0.5662849\",\n \"0.56330985\",\n \"0.5630398\",\n \"0.56192356\",\n \"0.5605534\",\n \"0.56053364\",\n \"0.55982536\",\n \"0.55929387\",\n \"0.5591035\",\n \"0.5579563\",\n \"0.55716544\",\n \"0.5555678\",\n \"0.5525672\",\n \"0.5497725\",\n \"0.54900086\",\n \"0.5479204\",\n \"0.54781985\",\n \"0.54691356\",\n \"0.5458135\",\n \"0.5453484\",\n \"0.5444185\",\n \"0.544044\",\n \"0.5422919\",\n \"0.54109836\",\n \"0.54100686\",\n \"0.539366\",\n \"0.5392348\",\n \"0.5378004\",\n \"0.5370847\",\n \"0.5363176\",\n \"0.53444535\",\n \"0.53306365\",\n \"0.5321931\",\n \"0.5317966\",\n \"0.5315327\",\n \"0.53147954\",\n \"0.5312611\",\n \"0.5299452\",\n \"0.5293861\",\n \"0.5287521\",\n \"0.52867866\",\n \"0.5285107\",\n \"0.5284913\",\n \"0.52809215\",\n \"0.5274716\",\n \"0.5272779\",\n \"0.5268722\",\n \"0.52671653\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6976282"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":8779,"cells":{"query":{"kind":"string","value":"Selects which value to return."},"document":{"kind":"string","value":"def _return(*args):\r\n to_return = ()\r\n\r\n for arg in args:\r\n cond, value = arg\r\n if cond:\r\n to_return += (value,)\r\n\r\n if len(to_return) == 1:\r\n return to_return[0]\r\n return to_return"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def getValue(name, default=None):","def get_value(self):","def getValue(self,value):\n if value in self.header.keys():\n return self.header[value]\n if value in self.subintinfo.keys():\n return self.subintinfo[value][-1]\n if self.params is None:\n return None\n return self.params.get(value) #will return None if non-existent","def get(self, index, default):\n try:\n return self[index].value\n except Exception, e:\n #if default is not None:\n return default\n #else:\n # raise e","def get_value(self):\r\n return input(\"Enter your choice :\")","def get_value(self):\n pass","def getValue(self, state):\n return self.values[state]","def get_val(self):\n return","def value(self):\n if self._check_:\n f = self.getChecked\n else:\n f = self.getSelected\n return f()","def getvalue(self):\n ...","def getvalue(self):\n ...","def get_value(self, section, option):\n raise NotImplementedError()","def get(self, node):\n if node in self.val:\n return self.val[node]\n else:\n return self.initial","def SelectValue(self, cnxn, col, default=None, where=None, **kwargs):\n row = self.SelectRow(\n cnxn, cols=[col], default=[default], where=where, **kwargs)\n return row[0]","def get_value(self):\n raise NotImplementedError","def _get_value(self):\n \n return self._value","def get_value(self):\n return self._value","def getValue(self):\n return random.choices(self.indices, weights=self.weights, k=1)[0]","def _get_value(self):\n return self.__value","def get_val(self, **kwargs):\n return self._value","def pick(self):\n\n pickerdict = {}\n current_value = 0\n\n if len(self.choices) == 0:\n return None\n\n if len(self.choices) == 1:\n return self.choices[0][0]\n\n for option in self.choices:\n pickerdict[current_value] = option[0]\n current_value += option[1]\n\n picker = random.randint(0, current_value)\n last_value = 0\n result = None\n sorted_keys = sorted(pickerdict.keys())\n\n found = False\n for key in sorted_keys:\n if key >= picker:\n result = pickerdict[last_value]\n found = True\n continue\n last_value = key\n\n if not found:\n result = pickerdict[sorted_keys[-1]]\n\n return result","def getValue(self, state):\r\n return self.values[state]","def select(self):\n\n return self.p[0], self.p[1]","def getSelected(self):\n selected = self.defaultChoice\n if self.tableSelected is not None:\n selected = self.tableSelected.getString(self.defaultChoice)\n return self.map.get(selected)","def getValue(self) -> int:\n ...","def getvalue(self, name, *default):\n try:\n return self.getattr(name).value\n except KeyError:\n if default:\n return default[0]\n raise","def get_value(self):\n if callable(self.supplier):\n return self.supplier()\n return None","def result(value):\n return None, value, None","def selected(self):\n return self._choices[self._selected][0]","def current_val(self):\n try:\n return self.listbox.get(self.listbox.curselection()[0])\n except IndexError:\n raise KeyError(\"Nothing selected\")","def select(self):\n idx, c, result_msg, op = self._choose()\n return (c, result_msg)","def get_value(self, *args, **kwargs) -> Optional[ValueType]: # pragma: no cover\n raise NotImplementedError","def _fetch_value(cursor, index=1):\n return cursor.fetchone().popitem()[index]","def getValue(self):\n return self._row[self.name]","def current_choice(self):\n\t\treturn self.choice_data_list[self.select_index]","def get(self, key, default=None):\n def find(found_item, _):\n \"\"\" This is the closer function which will be passed to find by key function , if key found than return the value \n otherwise return blanck\"\"\"\n if found_item:\n return found_item[1]\n else:\n return default\n\n return self._find_by_key(key, find)","def get_val(self, arg_idx):\n\t\tidx = arg_idx-1\n\t\tif idx >= len(self.__par_modes) or self.__par_modes[idx] == 0:\n\t\t\treturn self.memory[self.memory[self.ptr+arg_idx]]\n\t\telif self.__par_modes[idx] == 1:\n\t\t\treturn self.memory[self.ptr + arg_idx]","def get_value_by_index(self, index):\n return self['value'][index]","def getSelected(*args):","def getValue(self, state):\n return self.values[state]","def getValue(self, state):\n return self.values[state]","def getValue(self, state):\n return self.values[state]","def getValue(self, state):\n return self.values[state]","def getValue(self, state):\n return self.values[state]","def getValue(self, state):\n return self.values[state]","def getValue(self, state):\n return self.values[state]","def getValue(self, state):\n return self.values[state]","def getValue(self, state):\n return self.values[state]","def getValue(self, state):\n return self.values[state]","def getValue(self, state):\n return self.values[state]","def getValue(self, state):\n return self.values[state]","def getval(self):\r\n return self.value","def choose(self):\n\n i = bisect.bisect(self._p, random.random())\n return self._values[i]","def get_value(self):\n return None","def __getitem__(self, v):\r\n return self.unif.get(v, (v, None))[0]","def _value(self):\n return self.device.value(*self._id[1:])","def __getitem__(self, value):\n return self.d.get(value, 0)","def select(self, value) -> str:","def selected(self):\n return self.__result","def _get_value(o):\n return value(o, exception=False)","def select_function(_):\n try:\n self.update_infobox()\n except KeyError:\n pass\n # return self.current_val()","def _single_getitem(self, key):\n try:\n return self._dict[key]\n except KeyError:\n return self.default","def _get_value(self, value_column):\n pass","def returnOne(self):\n try:\n # self.checkValName()\n self.cursor.execute(self.query % self.val)\n self.results = self.conn.fetchone()\n except Exception as e:\n print \"Query failed: %s \" % e","def __getitem__(self, value):\n\n # Select the correct index\n if isinstance(value, six.integer_types):\n idx = self.by_value\n elif isinstance(value, six.string_types):\n idx = self.by_name\n else:\n raise KeyError(value)\n\n # Look up the value in that index\n return idx[value]","def select_scalar(self, *args, **kwargs):\n row = self.db_connection.execute(*args, **kwargs).fetchone()\n return None if row is None else row[0]","def __call__(self):\n return self.value","def get_selection(self, name):\n print 'hi being selected in plotdata'\n return self.selections.get(name, None)","def selected_value(self):\n option = self.selected_option\n return option.value if option else None","def get_value(self):\n if self.name in ['1','2','3','4','5','6','7','8', '9', '10']:\n return int(self.name)\n if self.name in ['J','Q','K']:\n return 10\n if self.name == 'A':\n return 1","def getValue(self):\n raise NotImplementedError(\"Define in derived class\")","def get_val(self):\n return self.value","def getValue(self):\n \n if len(self._possibilities) is 1:\n \n return self._possibilities.copy().pop()\n \n else:\n \n return None","def get(self, index):\n\n return self.values[index]","def returnOne(self):\n try:\n # self.checkValName()\n self.dbc.execute(self.query, self.val)\n self.results = self.dbc.fetchone()\n except MySQLdb.Error, e:\n print \"Query failed: %s \" % e","def get_value(default):\n output(\" [\" + default + \"]: \")\n response = read_chomped_line()\n if response == \"\":\n return default\n else:\n return response","def get_value(self, key):\n pass","def _select_single(self, disc):\n sqlstmt = \"SELECT h FROM %s WHERE d=?\" % self.VIEW\n pickup = self.cursor.execute(sqlstmt, (disc,))\n picked = pickup.fetchone()\n if picked is not None:\n # picked = (h,)\n return picked[0]\n else:\n raise KeyError(str(disc))","def get_value(self, field):\n field = self.find_first(field)\n if field is not None:\n return field.value\n return None","def find_selected(self):\r\n return None","def _selection ( self, nick ) :\n \n if not self.__selections_.has_key ( self.name() ) :\n self.__selections_[ self.name() ] = {} \n \n return self.__selections_[ self.name() ].get( nick , None )","def getValue(self, state):\n util.raiseNotDefined()","def getValue(self, state):\n util.raiseNotDefined()","def get_value(self, locator: Locator) -> Optional[str]:\n element = self.ctx.get_element(locator)\n get_value_pattern = self.get_value_pattern(element)\n\n if get_value_pattern:\n func_name = get_value_pattern.__name__\n self.logger.info(\n \"Retrieving the element value with the %r method.\", func_name\n )\n value_pattern = get_value_pattern()\n return value_pattern.Value if value_pattern else None\n\n raise ActionNotPossible(\n f\"Element found with {locator!r} doesn't support value retrieval\"\n )","def select(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"select\")","def select(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"select\")","def value(self, value: Optional[int] = None) -> Optional[int]:\n ...","def value(\n self, key: _K = 0, default: t.Optional[object] = None\n ) -> t.Any:\n try:\n index = self.index(key)\n except (IndexError, KeyError):\n return default\n else:\n return self[index]","def get(self, key, default=None):\n key = self._validate_key(key)\n sql = u\"\"\"\n SELECT `value` FROM `{table}` WHERE key = ?\n \"\"\".format(table=self.name)\n\n r = self.conn.execute(sql, (key,)).fetchone()\n\n if r:\n return self.convert_out(r['value'])\n\n return default","def get(self, index):\n if 0 <= index <= len(self.nums):\n return self.nums[index]\n return -1","def getValue(self, name):\n values = self.__get('values')\n return values[name]","def _get_value(self, value):\r\n try:\r\n return int(value)\r\n except ValueError:\r\n return self.registers[value]","def get_value(self):\n return self.value","def get_value(self):\n return self.value","def get_value(self):\n return self.value","def getValue(self):\n raise Exception(\"getValue function not defined with class {0}\".format(self.__class__.__name__))","def get_selected(self):\n return self.selected","def pick(\n self, values: Counter, default: Optional[Union[Callable, Value]] = None,\n raise_error: Optional[bool] = False\n ) -> Value:\n if len(values) == 1:\n return values.most_common(1)[0][0]\n elif not raise_error:\n return default\n raise ValueError('received set of {} values'.format(len(values)))","def get(self, state):\n return state[self.primary or self]","def getSelectedItem(*args):","def __getitem__(self, item):\r\n return self.select(item)"],"string":"[\n \"def getValue(name, default=None):\",\n \"def get_value(self):\",\n \"def getValue(self,value):\\n if value in self.header.keys():\\n return self.header[value]\\n if value in self.subintinfo.keys():\\n return self.subintinfo[value][-1]\\n if self.params is None:\\n return None\\n return self.params.get(value) #will return None if non-existent\",\n \"def get(self, index, default):\\n try:\\n return self[index].value\\n except Exception, e:\\n #if default is not None:\\n return default\\n #else:\\n # raise e\",\n \"def get_value(self):\\r\\n return input(\\\"Enter your choice :\\\")\",\n \"def get_value(self):\\n pass\",\n \"def getValue(self, state):\\n return self.values[state]\",\n \"def get_val(self):\\n return\",\n \"def value(self):\\n if self._check_:\\n f = self.getChecked\\n else:\\n f = self.getSelected\\n return f()\",\n \"def getvalue(self):\\n ...\",\n \"def getvalue(self):\\n ...\",\n \"def get_value(self, section, option):\\n raise NotImplementedError()\",\n \"def get(self, node):\\n if node in self.val:\\n return self.val[node]\\n else:\\n return self.initial\",\n \"def SelectValue(self, cnxn, col, default=None, where=None, **kwargs):\\n row = self.SelectRow(\\n cnxn, cols=[col], default=[default], where=where, **kwargs)\\n return row[0]\",\n \"def get_value(self):\\n raise NotImplementedError\",\n \"def _get_value(self):\\n \\n return self._value\",\n \"def get_value(self):\\n return self._value\",\n \"def getValue(self):\\n return random.choices(self.indices, weights=self.weights, k=1)[0]\",\n \"def _get_value(self):\\n return self.__value\",\n \"def get_val(self, **kwargs):\\n return self._value\",\n \"def pick(self):\\n\\n pickerdict = {}\\n current_value = 0\\n\\n if len(self.choices) == 0:\\n return None\\n\\n if len(self.choices) == 1:\\n return self.choices[0][0]\\n\\n for option in self.choices:\\n pickerdict[current_value] = option[0]\\n current_value += option[1]\\n\\n picker = random.randint(0, current_value)\\n last_value = 0\\n result = None\\n sorted_keys = sorted(pickerdict.keys())\\n\\n found = False\\n for key in sorted_keys:\\n if key >= picker:\\n result = pickerdict[last_value]\\n found = True\\n continue\\n last_value = key\\n\\n if not found:\\n result = pickerdict[sorted_keys[-1]]\\n\\n return result\",\n \"def getValue(self, state):\\r\\n return self.values[state]\",\n \"def select(self):\\n\\n return self.p[0], self.p[1]\",\n \"def getSelected(self):\\n selected = self.defaultChoice\\n if self.tableSelected is not None:\\n selected = self.tableSelected.getString(self.defaultChoice)\\n return self.map.get(selected)\",\n \"def getValue(self) -> int:\\n ...\",\n \"def getvalue(self, name, *default):\\n try:\\n return self.getattr(name).value\\n except KeyError:\\n if default:\\n return default[0]\\n raise\",\n \"def get_value(self):\\n if callable(self.supplier):\\n return self.supplier()\\n return None\",\n \"def result(value):\\n return None, value, None\",\n \"def selected(self):\\n return self._choices[self._selected][0]\",\n \"def current_val(self):\\n try:\\n return self.listbox.get(self.listbox.curselection()[0])\\n except IndexError:\\n raise KeyError(\\\"Nothing selected\\\")\",\n \"def select(self):\\n idx, c, result_msg, op = self._choose()\\n return (c, result_msg)\",\n \"def get_value(self, *args, **kwargs) -> Optional[ValueType]: # pragma: no cover\\n raise NotImplementedError\",\n \"def _fetch_value(cursor, index=1):\\n return cursor.fetchone().popitem()[index]\",\n \"def getValue(self):\\n return self._row[self.name]\",\n \"def current_choice(self):\\n\\t\\treturn self.choice_data_list[self.select_index]\",\n \"def get(self, key, default=None):\\n def find(found_item, _):\\n \\\"\\\"\\\" This is the closer function which will be passed to find by key function , if key found than return the value \\n otherwise return blanck\\\"\\\"\\\"\\n if found_item:\\n return found_item[1]\\n else:\\n return default\\n\\n return self._find_by_key(key, find)\",\n \"def get_val(self, arg_idx):\\n\\t\\tidx = arg_idx-1\\n\\t\\tif idx >= len(self.__par_modes) or self.__par_modes[idx] == 0:\\n\\t\\t\\treturn self.memory[self.memory[self.ptr+arg_idx]]\\n\\t\\telif self.__par_modes[idx] == 1:\\n\\t\\t\\treturn self.memory[self.ptr + arg_idx]\",\n \"def get_value_by_index(self, index):\\n return self['value'][index]\",\n \"def getSelected(*args):\",\n \"def getValue(self, state):\\n return self.values[state]\",\n \"def getValue(self, state):\\n return self.values[state]\",\n \"def getValue(self, state):\\n return self.values[state]\",\n \"def getValue(self, state):\\n return self.values[state]\",\n \"def getValue(self, state):\\n return self.values[state]\",\n \"def getValue(self, state):\\n return self.values[state]\",\n \"def getValue(self, state):\\n return self.values[state]\",\n \"def getValue(self, state):\\n return self.values[state]\",\n \"def getValue(self, state):\\n return self.values[state]\",\n \"def getValue(self, state):\\n return self.values[state]\",\n \"def getValue(self, state):\\n return self.values[state]\",\n \"def getValue(self, state):\\n return self.values[state]\",\n \"def getval(self):\\r\\n return self.value\",\n \"def choose(self):\\n\\n i = bisect.bisect(self._p, random.random())\\n return self._values[i]\",\n \"def get_value(self):\\n return None\",\n \"def __getitem__(self, v):\\r\\n return self.unif.get(v, (v, None))[0]\",\n \"def _value(self):\\n return self.device.value(*self._id[1:])\",\n \"def __getitem__(self, value):\\n return self.d.get(value, 0)\",\n \"def select(self, value) -> str:\",\n \"def selected(self):\\n return self.__result\",\n \"def _get_value(o):\\n return value(o, exception=False)\",\n \"def select_function(_):\\n try:\\n self.update_infobox()\\n except KeyError:\\n pass\\n # return self.current_val()\",\n \"def _single_getitem(self, key):\\n try:\\n return self._dict[key]\\n except KeyError:\\n return self.default\",\n \"def _get_value(self, value_column):\\n pass\",\n \"def returnOne(self):\\n try:\\n # self.checkValName()\\n self.cursor.execute(self.query % self.val)\\n self.results = self.conn.fetchone()\\n except Exception as e:\\n print \\\"Query failed: %s \\\" % e\",\n \"def __getitem__(self, value):\\n\\n # Select the correct index\\n if isinstance(value, six.integer_types):\\n idx = self.by_value\\n elif isinstance(value, six.string_types):\\n idx = self.by_name\\n else:\\n raise KeyError(value)\\n\\n # Look up the value in that index\\n return idx[value]\",\n \"def select_scalar(self, *args, **kwargs):\\n row = self.db_connection.execute(*args, **kwargs).fetchone()\\n return None if row is None else row[0]\",\n \"def __call__(self):\\n return self.value\",\n \"def get_selection(self, name):\\n print 'hi being selected in plotdata'\\n return self.selections.get(name, None)\",\n \"def selected_value(self):\\n option = self.selected_option\\n return option.value if option else None\",\n \"def get_value(self):\\n if self.name in ['1','2','3','4','5','6','7','8', '9', '10']:\\n return int(self.name)\\n if self.name in ['J','Q','K']:\\n return 10\\n if self.name == 'A':\\n return 1\",\n \"def getValue(self):\\n raise NotImplementedError(\\\"Define in derived class\\\")\",\n \"def get_val(self):\\n return self.value\",\n \"def getValue(self):\\n \\n if len(self._possibilities) is 1:\\n \\n return self._possibilities.copy().pop()\\n \\n else:\\n \\n return None\",\n \"def get(self, index):\\n\\n return self.values[index]\",\n \"def returnOne(self):\\n try:\\n # self.checkValName()\\n self.dbc.execute(self.query, self.val)\\n self.results = self.dbc.fetchone()\\n except MySQLdb.Error, e:\\n print \\\"Query failed: %s \\\" % e\",\n \"def get_value(default):\\n output(\\\" [\\\" + default + \\\"]: \\\")\\n response = read_chomped_line()\\n if response == \\\"\\\":\\n return default\\n else:\\n return response\",\n \"def get_value(self, key):\\n pass\",\n \"def _select_single(self, disc):\\n sqlstmt = \\\"SELECT h FROM %s WHERE d=?\\\" % self.VIEW\\n pickup = self.cursor.execute(sqlstmt, (disc,))\\n picked = pickup.fetchone()\\n if picked is not None:\\n # picked = (h,)\\n return picked[0]\\n else:\\n raise KeyError(str(disc))\",\n \"def get_value(self, field):\\n field = self.find_first(field)\\n if field is not None:\\n return field.value\\n return None\",\n \"def find_selected(self):\\r\\n return None\",\n \"def _selection ( self, nick ) :\\n \\n if not self.__selections_.has_key ( self.name() ) :\\n self.__selections_[ self.name() ] = {} \\n \\n return self.__selections_[ self.name() ].get( nick , None )\",\n \"def getValue(self, state):\\n util.raiseNotDefined()\",\n \"def getValue(self, state):\\n util.raiseNotDefined()\",\n \"def get_value(self, locator: Locator) -> Optional[str]:\\n element = self.ctx.get_element(locator)\\n get_value_pattern = self.get_value_pattern(element)\\n\\n if get_value_pattern:\\n func_name = get_value_pattern.__name__\\n self.logger.info(\\n \\\"Retrieving the element value with the %r method.\\\", func_name\\n )\\n value_pattern = get_value_pattern()\\n return value_pattern.Value if value_pattern else None\\n\\n raise ActionNotPossible(\\n f\\\"Element found with {locator!r} doesn't support value retrieval\\\"\\n )\",\n \"def select(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"select\\\")\",\n \"def select(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"select\\\")\",\n \"def value(self, value: Optional[int] = None) -> Optional[int]:\\n ...\",\n \"def value(\\n self, key: _K = 0, default: t.Optional[object] = None\\n ) -> t.Any:\\n try:\\n index = self.index(key)\\n except (IndexError, KeyError):\\n return default\\n else:\\n return self[index]\",\n \"def get(self, key, default=None):\\n key = self._validate_key(key)\\n sql = u\\\"\\\"\\\"\\n SELECT `value` FROM `{table}` WHERE key = ?\\n \\\"\\\"\\\".format(table=self.name)\\n\\n r = self.conn.execute(sql, (key,)).fetchone()\\n\\n if r:\\n return self.convert_out(r['value'])\\n\\n return default\",\n \"def get(self, index):\\n if 0 <= index <= len(self.nums):\\n return self.nums[index]\\n return -1\",\n \"def getValue(self, name):\\n values = self.__get('values')\\n return values[name]\",\n \"def _get_value(self, value):\\r\\n try:\\r\\n return int(value)\\r\\n except ValueError:\\r\\n return self.registers[value]\",\n \"def get_value(self):\\n return self.value\",\n \"def get_value(self):\\n return self.value\",\n \"def get_value(self):\\n return self.value\",\n \"def getValue(self):\\n raise Exception(\\\"getValue function not defined with class {0}\\\".format(self.__class__.__name__))\",\n \"def get_selected(self):\\n return self.selected\",\n \"def pick(\\n self, values: Counter, default: Optional[Union[Callable, Value]] = None,\\n raise_error: Optional[bool] = False\\n ) -> Value:\\n if len(values) == 1:\\n return values.most_common(1)[0][0]\\n elif not raise_error:\\n return default\\n raise ValueError('received set of {} values'.format(len(values)))\",\n \"def get(self, state):\\n return state[self.primary or self]\",\n \"def getSelectedItem(*args):\",\n \"def __getitem__(self, item):\\r\\n return self.select(item)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6543452","0.6478195","0.64064497","0.6406406","0.640156","0.6355146","0.6348945","0.634662","0.634554","0.6221234","0.6221234","0.6220085","0.6185762","0.61845344","0.6182689","0.61672604","0.61638516","0.61610883","0.6157245","0.6145623","0.614436","0.6143934","0.6128151","0.6119701","0.610969","0.6108915","0.610479","0.6090514","0.6085301","0.60548496","0.60491383","0.6041142","0.60369855","0.6032232","0.6027032","0.60234493","0.60228914","0.60111517","0.60081506","0.6006784","0.6006784","0.6006784","0.6006784","0.6006784","0.6006784","0.6006784","0.6006784","0.6006784","0.6006784","0.6006784","0.6006784","0.599525","0.5993795","0.59924114","0.5984491","0.5983377","0.5978891","0.5976345","0.59735465","0.5966652","0.5965808","0.5965322","0.59635097","0.5958147","0.5955559","0.59477764","0.5941488","0.59313333","0.5916049","0.5902231","0.5895164","0.5891614","0.58898103","0.5881058","0.5872152","0.58509666","0.5846827","0.58435994","0.5842561","0.584088","0.58407015","0.584006","0.584006","0.58377844","0.58329463","0.58329463","0.58251476","0.5821172","0.5818497","0.58082813","0.5802708","0.5802646","0.5799716","0.5799716","0.5799716","0.5797895","0.5795798","0.57951605","0.5792799","0.57906115","0.5788792"],"string":"[\n \"0.6543452\",\n \"0.6478195\",\n \"0.64064497\",\n \"0.6406406\",\n \"0.640156\",\n \"0.6355146\",\n \"0.6348945\",\n \"0.634662\",\n \"0.634554\",\n \"0.6221234\",\n \"0.6221234\",\n \"0.6220085\",\n \"0.6185762\",\n \"0.61845344\",\n \"0.6182689\",\n \"0.61672604\",\n \"0.61638516\",\n \"0.61610883\",\n \"0.6157245\",\n \"0.6145623\",\n \"0.614436\",\n \"0.6143934\",\n \"0.6128151\",\n \"0.6119701\",\n \"0.610969\",\n \"0.6108915\",\n \"0.610479\",\n \"0.6090514\",\n \"0.6085301\",\n \"0.60548496\",\n \"0.60491383\",\n \"0.6041142\",\n \"0.60369855\",\n \"0.6032232\",\n \"0.6027032\",\n \"0.60234493\",\n \"0.60228914\",\n \"0.60111517\",\n \"0.60081506\",\n \"0.6006784\",\n \"0.6006784\",\n \"0.6006784\",\n \"0.6006784\",\n \"0.6006784\",\n \"0.6006784\",\n \"0.6006784\",\n \"0.6006784\",\n \"0.6006784\",\n \"0.6006784\",\n \"0.6006784\",\n \"0.6006784\",\n \"0.599525\",\n \"0.5993795\",\n \"0.59924114\",\n \"0.5984491\",\n \"0.5983377\",\n \"0.5978891\",\n \"0.5976345\",\n \"0.59735465\",\n \"0.5966652\",\n \"0.5965808\",\n \"0.5965322\",\n \"0.59635097\",\n \"0.5958147\",\n \"0.5955559\",\n \"0.59477764\",\n \"0.5941488\",\n \"0.59313333\",\n \"0.5916049\",\n \"0.5902231\",\n \"0.5895164\",\n \"0.5891614\",\n \"0.58898103\",\n \"0.5881058\",\n \"0.5872152\",\n \"0.58509666\",\n \"0.5846827\",\n \"0.58435994\",\n \"0.5842561\",\n \"0.584088\",\n \"0.58407015\",\n \"0.584006\",\n \"0.584006\",\n \"0.58377844\",\n \"0.58329463\",\n \"0.58329463\",\n \"0.58251476\",\n \"0.5821172\",\n \"0.5818497\",\n \"0.58082813\",\n \"0.5802708\",\n \"0.5802646\",\n \"0.5799716\",\n \"0.5799716\",\n \"0.5799716\",\n \"0.5797895\",\n \"0.5795798\",\n \"0.57951605\",\n \"0.5792799\",\n \"0.57906115\",\n \"0.5788792\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":8780,"cells":{"query":{"kind":"string","value":"Fetches data and metadata from an URL."},"document":{"kind":"string","value":"def get_content(url, etag=None, use_http_compression=True, return_etag=False, return_status_code=False, return_datetime=False, return_response=False):\r\n error_msg = 'HTTP GET %s' % (url,)\r\n\r\n # Sets the headers.\r\n headers = {}\r\n if etag:\r\n headers['If-None-Match'] = etag\r\n if not use_http_compression:\r\n headers['Accept-Encoding'] = ''\r\n\r\n downloaded_date = (return_datetime and [timezone.now()] or [None])[0]\r\n\r\n # Makes the request.\r\n try:\r\n response = requests.get(url, headers=headers)\r\n except StandardError as e:\r\n raise RequestsModuleError('%s - Requests module error\\n%s' % (error_msg, e))\r\n\r\n data = response.content\r\n etag = (return_etag and [response.headers.get('ETag', None)] or [None])[0]\r\n status_code = response.status_code\r\n\r\n return _return((True, data), (return_etag, etag), (return_status_code, status_code), (return_datetime, downloaded_date), (return_response, response))"},"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 __fetch_from_url(url: str) -> Any:\n song_information: Any = None\n try:\n # Send the request and load the returned contents.\n req = request.Request(url, headers={\n 'User-Agent': Config.Config.get_user_agent()\n })\n response = request.urlopen(req)\n contents: str = response.read().decode('utf-8')\n except (HTTPError, TimeoutError) as ex:\n Logger.Logger.log_error(str(ex))\n Logger.Logger.log_error('Request failed for URL: ' + url)\n return\n # Parse the response from the endpoint as a JSON encoded string\n data: Any = json.loads(contents)\n # Check if response contains at least one result, otherwise return \"None\".\n if data['resultCount'] > 0:\n song_information = data\n return song_information","def FetchUrlContent(url):\n content = memcache.get(url)\n if content:\n return content\n\n request = urlfetch.fetch(url)\n\n if request.status_code == 200:\n content = request.content\n memcache.add(url, content, 60 * 60)\n return content\n\n raise LookupError('Unable to fetch URL. Response code: ' +\n str(request.status_code))","async def fetch_data(self, url: str) -> dict:\n async with self.bot.http_session.get(url) as r:\n return await r.json()","def fetch_url_feed(self, url, **args):\n return self.fetch(\"/url\", url=url, **args)","def urlfetch(self, url, **kwargs):\n logging.debug('Fetching %s with kwargs %s', url, kwargs)\n resp = urlfetch.fetch(url, deadline=999, **kwargs)\n\n if resp.status_code == 200:\n return resp.content\n else:\n logging.warning('GET %s returned %d:\\n%s',\n url, resp.status_code, resp.content)\n self.handler.response.headers.update(resp.headers)\n self.handler.response.out.write(resp.content)\n raise exc.status_map.get(resp.status_code)(resp.content)","def fetch_data(data_url):\n return requests.get(data_url).content","def get_fred_data(url):\n pass","def fetch(url):\n content = requests.get(url).text\n if \"Error\" in content:\n raise ValueError(f\"Cannot read from: {url}\")\n return content","def fetch(self,url=URL):\n\t\tlog.info('downloading latest PHE case data')\n#\t\tself.data=lookup_json(url)\n\t\tself.fetch_csv() #JSON discontinued; switched back to CSV\n\t\tself.edition=self.latest_samples\n\t\tlog.info(f'Last samples from {self.edition}')","def fetchJson(url):","def fetch(self, url, listener, useCache = True): #$NON-NLS-1$\r","def fetch_content(self, url):\n # log.debug(\"Fetching content from: %s\", url)\n prepare_curl_callback = lambda x: x.setopt(pycurl.HTTPAUTH, pycurl.HTTPAUTH_GSSNEGOTIATE)\n self.http.fetch(url, self.handle_response, prepare_curl_callback=prepare_curl_callback, auth_username=':')","def GetDataFromURL(self, url):\n try:\n deftimeout = socket.getdefaulttimeout()\n socket.setdefaulttimeout(1)\n try:\n logging.debug('Slide fetching data from %s' % url)\n u = urllib.urlopen(url)\n data = u.read()\n return data\n except:\n logging.exception('Uh oh!')\n return None\n finally:\n socket.setdefaulttimeout(deftimeout)","def fetch(cls, url):\n delta = time.time() - cls._time_last_fetched\n wait_time = TIME_TIL_RETRY - delta\n if wait_time > 0:\n time.sleep(wait_time)\n resp = requests.get(url)\n cls._time_last_fetched = time.time()\n resp.raise_for_status()\n return resp","def downloadData(url):\n \n content = urllib2.urlopen(url)\n return content","def fetch_url(self, url: str):\n log.debug(f\"Fetching {url}\")\n answer = self.session.get(url, timeout=self.timeout)\n answer.raise_for_status()\n\n # returning raw answer object, because due to redirects we may need to\n # double check answer.url to proceed\n return answer","def _load_data(self, url, options=None, location=None):\n # Set API key in query parameters\n params = { \"api-key\": self.key }\n\n # Add options to query parameters\n if options is not None:\n params.update(options)\n\n # Load the data from the API, raise error if there's an invalid status code\n res = self.session.get(self.protocol + url, params=params, timeout=(4, 10))\n if res.status_code == 401:\n raise ValueError(\"Invalid API Key\")\n elif res.status_code == 404:\n raise RuntimeError(\"Error 404: This page is not available\")\n res.raise_for_status()\n\n if orjson is None:\n parsed_res = res.json()\n else:\n parsed_res = orjson.loads(res.content)\n\n # Get the data from the usual results location\n if location is None:\n results = parsed_res.get(\"results\")\n\n # Sometimes the results are in a different location, this location can be defined in a list\n # Load the data from that location\n else:\n results = parsed_res\n for loc in location:\n results = results.get(loc)\n\n return results","def fetch_song_data(url):\r\n response = requests.get(url)\r\n return response.text","def fetch_url(url):\n logger.info(\"Resolving \" + url)\n try:\n resp = requests.get(url, timeout=1.5)\n resp.raise_for_status()\n return {\n \"resolved_url\": resp.url,\n \"raw_content\": resp.text\n }\n except Exception as e:\n logger.error('Error fetching %s' % url, e)\n return {\n \"resolved_url\": url,\n \"raw_content\": \"\",\n \"url_error\": str(e)\n }","def url_fetch(self, url):\n user_agent = random.choice(self.conf.user_agents)\n if self.isCompress == True:\n headers = {\n 'Uesr-Agent': user_agent,\n \"Accept-Encoding\": \"gzip,deflate\",\n \"Accept-Charset\" : \"UTF-8,*\"\n }\n else:\n headers = {\n 'Uesr-Agent': user_agent,\n \"Accept-Charset\" : \"UTF-8,*\"\n }\n raw_data = ''\n try:\n conn = httplib.HTTPConnection(self.proxy, timeout=3.0)\n conn.request('GET', url, None, headers)\n response = conn.getresponse()\n raw_data = response.read()\n except Exception as err:\n self.logger.error('connect error[%s]' % err)\n return '999', 'Request failed', ''\n finally:\n conn.close()\n \n content = ''\n if self.isCompress == True:\n if response.status == 200:\n try:\n stream = StringIO.StringIO(raw_data)\n decompressor = gzip.GzipFile(fileobj=stream)\n content = decompressor.read()\n except:\n self.logger.error('status[%s] len_raw_data[%d]' % (response.status, len(raw_data)))\n return '998', 'content err', ''\n else:\n if response.status == 200:\n content = raw_data \n\n return response.status, response.reason, content","def _request_data(self, url):\n connection = httplib.HTTPConnection(self.url)\n connection.request(\"GET\", url)\n response = connection.getresponse()\n\n if response.status != 200:\n raise Exception(response.reason)\n\n data = response.read()\n response.close()\n\n return json.loads(data)","def fetch(self, url, headers=DEFAULTHEADERS):\n logger = self.loggers['http']\n request = urllib2.Request(url, headers=headers)\n try:\n response = urllib2.urlopen(request)\n except urllib2.HTTPError:\n logger.error(\"failed to retrieve the resource at %s\" % url)\n raise\n urlgot = response.geturl()\n rawcontent = response.read()\n if urlgot != url:\n logger.info(\"successfully retrieved resource from %s, redirected from %s\" % (urlgot, url))\n self.http['redirect'] = True\n else:\n logger.info(\"successfully retrieved resource from %s\" % url)\n self.http['redirect'] = False\n rheaders = response.info()\n \n # store useful info on the object for later access\n self.http['request'] = {}\n self.http['request']['headers'] = headers\n self.http['urlsought'] = url\n self.http['urlgot'] = urlgot\n self.http['response'] = response\n self.http['response_headers'] = {}\n for k in sorted(rheaders.keys()): \n logger.debug(\"response header %s: '%s'\" % (k, rheaders[k]))\n self.http['response_headers'][k.strip().lower()] = rheaders[k].strip() \n self.documenturl = urlgot\n self.rawcontent = rawcontent","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 \"\"","def fetch(url, verbose=False):\n\n resp = requests.get(url)\n if verbose:\n print(resp.json())\n if resp.status_code == 200:\n\n resp=resp.json()\n return resp\n else:\n return None","def fetch_dataset(url, pandas_impl=pandas):\n\n print(f'fetching dataset at {url}')\n return pandas_impl.read_csv(url)","def fetch_50(url):\n\n results = requests.get(url,headers = headers).json()\n return results","async def fetch(self, session, url):\n async with session.get(url) as response:\n if response.status != 200:\n response.raise_for_status()\n response = await response.text()\n return json.loads(response)","def get_data(url):\n response = get(url, timeout=10)\n \n if response.status_code >= 400:\n raise RuntimeError(f'Request failed: { response.text }')\n \n return response.json()","def fetch_save(url):\n\n name = url.split(\"/\")[-1]\n response = requests.get(url, stream=True)\n if response.status_code == 200:\n with open(f\"{DATA_PATH}/{name}\", \"wb\") as f:\n f.write(response.raw.read())\n else:\n logging.info(f\"Failed {url} download\")","def _by_url(session: Session, url: URL) -> UnifiedDataset:\n r = session.get(str(url))\n if r.status_code == 404:\n raise NotFound(str(url))\n data = response.successful(r).json()\n return _from_json(url, data)","def fetch(self, path, **kwargs):\n self.http_client.fetch(self.get_url(path), self.stop, **kwargs)\n return self.wait()","def data_loader(self, url, type_of):\n i = url.rfind('/')\n data_name = url[(i + 1):]\n data_def = {\n \"displayName\": data_name,\n \"url\": url\n }\n if type_of == \"csv\":\n data_loader = self.csv_data_loader\n else:\n data_loader = self.json_data_loader\n\n return Downloader(data_def).download(data_loader)","def fetch_metadata(requests_impl=requests):\n\n print(f'fetching metadata at {Network.METADATA_URL}')\n return requests_impl.get(Network.METADATA_URL).json()","def fromurl(cls, url: str):\n return cls.parse_obj(requests.get(url).json())","def fetch(self, url):\n self.log.info(\"Fetching URL: \" + url)\n\n r = requests.get(url, verify=False)\n # raise an HTTPError on badness\n r.raise_for_status()\n\n # this decodes r.content using a guessed encoding\n return r.text","def get_data(self, url):\n\n req = urllib2.Request(url)\n # urlencode the query dictionary\n try:\n r = urllib2.urlopen(req)\n result = r.read()\n except:\n result = 'The url: %s is not responding.' % (url)\n return result","def load_url_content(url):\n try:\n r = requests.get(url)\n if r.ok:\n return r.text\n else:\n return None\n except Exception:\n return None","def _fetch(url, ssl_verify = True):\n req = Request(url)\n if ssl_verify:\n page = urlopen(req)\n else:\n ctx = ssl.create_default_context()\n ctx.check_hostname = False\n ctx.verify_mode = ssl.CERT_NONE\n\n page = urlopen(req, context=ctx)\n content = page.read().decode('utf-8')\n page.close()\n return content","def fetch_url(self, url: str) -> Union[Dict, None]:\n\n try:\n req = requests.get(url)\n req.raise_for_status()\n res = req.json()\n except (requests.HTTPError, json.JSONDecodeError) as e:\n logging.warning(f'{self.__class__.__name__} failed to retrieve/parse {url}')\n # logging.debug(e)\n return\n\n # safe-check for empty response from server\n if not res:\n logging.warning(f\"{self.__class__.__name__} empty response from {url}\")\n return\n\n return res","def _get_data(self, url: str)->dict:\n data = None\n resp = self._get(url)\n if resp:\n data = resp.json()['data']\n return data","def fetch(self, url: furl) -> str:\n try:\n contents = self._download(url)\n except requests.ConnectionError as err:\n logger.exception(f\"Request failed with {err}\")\n click.secho(\n f\"The URL {url} could not be downloaded. Either your network is unreachable or the URL is broken.\"\n f\" Check the URL, fix your connection, or use \"\n f\" {OptionEnum.OFFLINE.as_flake8_flag()} / {OptionEnum.OFFLINE.as_envvar()}=1\",\n fg=\"red\",\n err=True,\n )\n return \"\"\n return contents","def load(self, url):\n pass","def load(self, url):\n pass","def get_url_data(self, url):\n # print \"opening: \" + url\n request = urllib2.Request(url)\n base64string = '%s:%s' % (self.username, self.key)\n request.add_header(\"Authorization\", \"ApiKey %s\" % base64string)\n response = urllib2.urlopen(request)\n data = json.loads(response.read())\n return data","def _raw_get(self, url):\n logger.debug('Fetching URL %s', url)\n self._conn.request('GET', url, None, {\n 'Accept-Encoding': 'gzip',\n 'User-Agent': USER_AGENT,\n 'Cookie': self.cookie,\n 'Connection': 'keep-alive',\n 'DNT': '1',\n })\n self._resp = self._conn.getresponse()\n if self.cookie == '':\n complete_cookie = self._resp.getheader('Set-Cookie')\n # Cookie won't be available is already blocked\n if complete_cookie is not None:\n self.cookie = complete_cookie[:complete_cookie.find(';')]\n logger.debug('Cookie: %s' % self.cookie)","async def fetch(url, session):\n async with session.get(url) as response:\n return await response.read()","def fetch_object(url):\n print(' GET ' + url)\n session = requests.Session()\n retry = Retry(connect=3, backoff_factor=15)\n adapter = HTTPAdapter(max_retries=retry)\n session.mount('http://', adapter)\n session.mount('https://', adapter)\n r = session.get(url)\n # Covering internal server errors by retrying one more time\n if r.status_code == 500:\n time.sleep(5)\n r = requests.get(url, allow_redirects=True)\n elif r.status_code != 200:\n print(f\"Problem with request: {str(r)}\")\n raise RuntimeError(\"Non-200 status code\")\n return r","def _get(self, url, **kwargs):\n return self._http.get(self.cluster + url, timeout=self.timeout, **kwargs)","async def fetch(session, url):\n async with session.get(url) as response:\n return await response.text()","def get_data(self, url):\n return self.get(url).get('data', [])","def get(self, url):\n\n\t\ttry:\n\t\t\trequest = urllib2.Request(url)\n\t\t\trequest.add_header('User-Agent', self.user_agent)\n\n\t\t\tlogging.debug('Get.get - getting url ' + url)\n\n\t\t\tresult = urllib2.urlopen(request)\n\n\t\texcept: raise RuntimeError('unable to open url')\n\n\t\treturn result","def get(self, url):\n return json.loads(self.as_source.urlopen(url).read())","def http_get(url):\n\n count = 0\n result = ''\n ok = False\n while count < 3 and not ok:\n try:\n result = urllib.urlopen(url).read()\n ok = True\n except:\n count += 1\n return result","def fetch(self):\n # This method also sets self._results_filtered and\n # self._urltable.\n page = self._conn.fetch_page(self._ddg_url.relative())\n\n if logger.isEnabledFor(logging.DEBUG):\n import tempfile\n fd, tmpfile = tempfile.mkstemp(prefix='ddgr-response-')\n os.close(fd)\n with open(tmpfile, 'w', encoding='utf-8') as fp:\n fp.write(page)\n logger.debug(\"Response body written to '%s'.\", tmpfile)\n\n parser = DdgParser(news=self._ddg_url.news)\n parser.feed(page)\n\n self.results = parser.results\n self._results_filtered = parser.filtered\n self._urltable = {}\n for r in self.results:\n self._urltable.update(r.urltable())","async def _fetch(self, session, url, proxy=None, raw=False, which_site=False):\n print(url)\n result = None\n site = None\n if 'hare' in url: # {'Unknown': -1, 'Pixnet': 0, 'Hares': 1}\n site = self._websites['Hares']\n elif 'pixnet' in url:\n site = self._websites['Pixnet']\n else:\n site = self._websites['Unknown']\n\n count = 1\n while count <= 2:\n soup = ''\n status = 0\n try:\n async with session.get(url, proxy=proxy) as response:\n source_code = await response.text('utf-8')\n status = response.status\n soup = source_code if raw else BeautifulSoup(source_code, 'lxml')\n except Exception as e:\n print('Connection error: ' + str(e))\n soup = None\n finally:\n result = (url, soup, status, site) if which_site else (url, soup, status)\n if status != 0:\n return result\n if 'searcharticle' not in url:\n count += 1\n result = (url, soup, status, site) if which_site else (url, soup, status)\n return result","def data_loader(self, url, type_of):\n\n data_loader = None\n if type_of == \"csv\":\n data_loader = self.csv\n elif type_of == \"json\":\n data_loader = self.json\n elif type_of == \"parquet\":\n data_loader = self.parquet\n elif type_of == \"avro\":\n data_loader = self.avro\n else:\n RaiseIt.type_error(data_loader, [\"csv\", \"json\", \"parquet\", \"avro\", ])\n\n i = url.rfind('/')\n data_name = url[(i + 1):]\n data_def = {\n \"displayName\": data_name,\n \"url\": url\n }\n return Downloader(data_def).download(data_loader, type_of)","def _fetch(\n cls, url: str, headers: Mapping[str, str], params: Mapping[str, Any]\n ) -> Tuple[List[EventType], Optional[str]]:\n status_url = cls._post_query(url, headers, params)\n # Await a while before polling the results\n time.sleep(0.1)\n result_url = cls._poll_status(status_url, headers, params)\n data, headers = cls._get_results(result_url, headers, params)\n result = json.loads(data)\n return result, headers.get(\"x-next-token\")","def _extract_data(self):\n if self.URL_type == \"youtube\" or self.URL_type == \"ytmusic\":\n self._get_youtube_data_url()\n elif self.URL_type == \"soundcloud\":\n self._get_soundcloud_data()","def load_data(url: str):\n\n page = requests.get(url=url)\n soup = BeautifulSoup(page.content, 'html.parser')\n return soup","def request_data(url): \n requests_cache.install_cache('data_cache')\n while True:\n data = requests.get(url)\n if not data.status_code == 200 or \"try again later\" in data.text:\n continue\n else:\n break\n return data.text","async def fetch(self, url=None, method='GET', body=None):\n log.debug('fetching \\n method: [%s] \\n url: %s \\n body: %s',\n method,\n url,\n body)\n if not method:\n method = HttpMethod.GET\n status: int = None\n text: str = None\n if method == HttpMethod.GET:\n async with self._http_session.get(url) as response:\n status = response.status\n text = await response.text()\n elif method == HttpMethod.POST:\n async with self._http_session.post(url, data=body) as response:\n log.debug('fetch POST response: %r', response)\n status = response.status\n text = await response.text()\n else:\n raise NotImplementedError(\n f\"HTTP requst method {method} not implemented yet. \"\n \"Contributions welcome!\")\n log.debug('fetch result status: %d, text: %s', status, text)\n return (status, text)","def get_data_with_http_request(self, url):\n _LOGGER.debug(\"[SERVICES][HTTPCLIENT] sendHTTPRequest\")\n try:\n request = self.request(url)\n response = self.create_response(request)\n data = self.decode_response(response)\n except TypeError:\n _LOGGER.error(\"Could not fetch data from \"+url)\n return None\n return data","def read_url(url):\n response = requests.get(url)\n return response.text","async def fetch(self, url, params={}, loop=None, max_workers=5, **extra):\n\n result = {}\n pool = ProcessPoolExecutor(max_workers)\n extra.update({\n \"loop\": loop\n })\n parsed_url = url_concat(url, **params)\n if inspect.iscoroutinefunction(self.on_fetch):\n result = await self.on_fetch(parsed_url, extra)\n else:\n loop = loop or asyncio.get_event_loop()\n result = await loop.run_in_executor(pool, self.on_fetch, parsed_url, extra)\n return result","def fetch_temp_data(url):\n res = requests.get(url)\n return res.json()","def request(self, url):\n requested_data = None\n try:\n requested_data = urllib.request.Request(url, headers=self.headers)\n except urllib.error.URLError as err:\n _LOGGER.error(\"Could not connect: \" + err.reason)\n except urllib.error.HTTPError as err:\n _LOGGER.error(\"Server return code \" + err.code + \". \" +\n err.reason + \" Error caused by the following \"\n \"header(s): \" + err.headers + \".\")\n except urllib.error.ContentTooShortError as err:\n _LOGGER.error(\"Could not connect! The amount of the downloaded \"\n \"data is less than the expected amount (given by \"\n \"the Content-Length header).\")\n except ValueError as err:\n _LOGGER.error(\"Invalid url, please insert a valid url.\")\n return requested_data","def fetch_csv_from_url(url):\n\t\n\t#cache avoidance.\n\twith requests_cache.disabled():\n\t\tr = requests.get(url)\n\t\tif r.status_code == 200:\n\t\t\treturn r.iter_lines()","def _FetchBuilderData(builder_url):\n data = None\n try:\n url = urllib2.urlopen(builder_url)\n except urllib2.URLError, e:\n print ('urllib2.urlopen error %s, waterfall status page down.[%s]' % (\n builder_url, str(e)))\n return None\n if url is not None:\n try:\n data = url.read()\n except IOError, e:\n print 'urllib2 file object read error %s, [%s].' % (builder_url, str(e))\n return data","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(self, url):\n \n content = \"\"\n if hasattr(http.client, \"HTTPSConnection\"): \n url_options = urlparse(url)\n\n conn = http.client.HTTPSConnection(url_options.netloc)\n conn.request('GET', url_options.path + '?' + url_options.query)\n content = conn.getresponse().read().decode('utf-8')\n conn.close()\n else: \n p = os.popen('curl -k \"' + url + '\"')\n content = p.read()\n p.close() \n\n return content","def download_data(self, format = 'srt'):\n resp, content = httplib2.Http(\".cache\").request(self.url, \"GET\")\n suburl = json.loads(content)['url']\n resp, content = httplib2.Http(\".cache\").request(suburl, \"GET\")\n\n return content","def read_url(url):\n return requests.get(url).text","def fetch_housing_data(housing_url=HOUSING_URL, housing_path=HOUSING_PATH):\n logging.info(\"Fetch housing data.....\")\n os.makedirs(housing_path, exist_ok=True)\n tgz_path = os.path.join(housing_path, \"housing.tgz\")\n urllib.request.urlretrieve(housing_url, tgz_path)\n housing_tgz = tarfile.open(tgz_path)\n housing_tgz.extractall(path=housing_path)\n housing_tgz.close()","async def fetch(url: str, session: ClientSession) -> Tuple[str, bytes]:\n async with session.get(url) as response:\n resp = await response.read()\n return url, resp","def _fetch(self):\n self._data = self._get(self.url)\n\n if self._data['released_errata'] is not None:\n self._released_errata = Erratum(errata_id=self._data[\n 'released_errata']['id'])\n\n for errata_dict in self._data['all_errata']:\n errata = Erratum(errata_id=errata_dict['id'])\n self._all_errata.append(errata)\n\n self._signed_rpms = self._data.get('rpms_signed')\n\n for et_file in self._data['files']:\n self._files.append(et_file['path'])","def _get(self, url):\n return self._request(url)","def parse(self):\n \n r = requests.get(self.url)\n if r:\n self.title = fetch_title(self.url)\n self.domain = self.fetch_domain()\n self.favicon = self.fetch_favicon()\n self.topics = self.classify_topics()\n self.description = self.fetch_description()\n return self","def _getFeedContent(self, url, excludeRead=False, continuation=None, loadLimit=20, since=None, until=None):\r\n parameters = {}\r\n if excludeRead:\r\n parameters['xt'] = 'user/-/state/com.google/read'\r\n if continuation:\r\n parameters['c'] = continuation\r\n parameters['n'] = loadLimit\r\n if since:\r\n parameters['ot'] = since\r\n if until:\r\n parameters['nt'] = until\r\n contentJson = self.httpGet(url, parameters)\r\n return json.loads(contentJson, strict=False)","def fetch_meta(url, filter=None):\n\n link = LinkMeta(url)\n link.parse()\n\n # returns the local variables in this functions scope as a \n # dict.\n return link","def get_records_from_url(url):\n with requests.get(url) as response:\n source = response.text\n return parseString(source)","async def http_get(url):\n async with aiohttp.ClientSession() as session:\n async with session.get(url) as r:\n return await r.text()","def fetch(url: str, raise_for_status: bool=True, **query_params) -> Tuple[int, Dict[str, Any]]:\n # HINT carefully read the requests documentation to figure out the cleanest way to raise a requests error.\n #query_params is a dict, **query_params is keyword arg \n res_obj = requests.get(url, params=query_params)\n if raise_for_status:# default to True \n res_obj.raise_for_status()# if 200 result is None \"All is well\"\n return (res_obj.status_code, res_obj.json()) # returns code and dict ","def loadu(self, url, **kwargs):\n return self.load(self.open(url, **kwargs), **kwargs)","def _get_result(url, etag=None, last_modified=None, use_discovery=False):\n _validate_url(url)\n\n result = feedparser.parse(url, etag=etag, modified=last_modified)\n # update URL for any redirects that feedparser followed\n url = result.get('href', url)\n\n if _is_not_modified_result(result):\n raise FeedNotModifiedError\n elif not _is_valid_result(result):\n if use_discovery:\n url = _discover_url(result)\n return _get_result(url)\n else:\n _fail(url, \"Failed to download or parse feed\")\n else:\n return url, result","def __get(self, url, headers=None):\n return self.__req(url, \"GET\", headers=headers)","def get_data_from_web():\n pass","def downloadData(url):\r\n\r\n data = urllib2.urlopen(url)\r\n csvdata = data.read()","def _get(url):\n url = urlparse(url)\n conn = HTTPConnection(url.hostname, url.port)\n conn.request('GET', url.path+url.query)\n return conn.getresponse().fp.read()","def _fetch_data(url: str, d: datetime) -> pd.DataFrame:\n return pd.read_json(url)","def download_data(self, url: str, source_type: str) -> None:\n r = None # request\n\n # download data from nextcloud\n if source_type == \"nextcloud\":\n token = url\n r = requests.get(\n os.environ[\"NC_WEBDAV_URL\"], auth=(token, os.environ[\"NC_PASSWORD\"])\n )\n\n # download data from generic URLs\n if source_type == \"generic_url\":\n s = requests.Session()\n headers = {\n \"User-Agent\": \"Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:88.0) Gecko/20100101 Firefox/88.0\"\n }\n s.headers.update(headers)\n r = s.get(url)\n\n f_name = None # file name\n\n if \"content-disposition\" in r.headers.keys():\n d = r.headers[\"content-disposition\"]\n f_name = re.findall('filename=\"(.+)\"', d)[0]\n else:\n f_name = url.split(\"/\")[-1]\n\n # save file\n try:\n with open(Path(os.environ[\"DATA_PATH\"]) / f_name, \"wb\") as f:\n for chunk in r.iter_content(self.chunk_size):\n f.write(chunk)\n except OSError:\n print(f\"Error: {list(Path(os.environ['DATA_PATH']).iterdir())}\")","def get(self, url):\r\n response = self.requestHelper.get(url)\r\n return self.process(response)","def fetch_url(session, url):\n return session.get(url).text","def get_at_url(self, url):\n class NullDevice():\n def write(self, s):\n pass\n\n def get_gallery_item(id):\n \"\"\"\n Special helper method to get gallery items.\n\n The problem is that it's impossible to distinguish albums and\n images from each other based on the url. And there isn't a common\n url endpoints that return either a Gallery_album or a Gallery_image\n depending on what the id represents. So the only option is to\n assume it's a Gallery_image and if we get an exception then try\n Gallery_album. Gallery_image is attempted first because there is\n the most of them.\n \"\"\"\n try:\n # HACK: Problem is that send_request prints the error message\n # from Imgur when it encounters an error. This is nice because\n # this error message is more descriptive than just the status\n # code that Requests give. But since we first assume the id\n # belong to an image, it means we will get an error whenever\n # the id belongs to an album. The following code temporarily\n # disables stdout to avoid give a cryptic and incorrect error.\n\n # Code for disabling stdout is from\n # http://coreygoldberg.blogspot.dk/2009/05/\n # python-redirect-or-turn-off-stdout-and.html\n original_stdout = sys.stdout # keep a reference to STDOUT\n sys.stdout = NullDevice() # redirect the real STDOUT\n return self.get_gallery_image(id)\n # TODO: Add better error codes so I don't have to do a catch-all\n except Exception:\n return self.get_gallery_album(id)\n finally:\n sys.stdout = original_stdout # turn STDOUT back on\n\n if not self.is_imgur_url(url):\n return None\n\n objects = {'album': {'regex': \"a/(?P<id>[\\w.]*?)$\",\n 'method': self.get_album},\n 'comment': {'regex': \"gallery/\\w*/comment/(?P<id>[\\w.]*?)$\",\n 'method': self.get_comment},\n 'gallery': {'regex': \"(gallery|r/\\w*?)/(?P<id>[\\w.]*?)$\",\n 'method': get_gallery_item},\n # Valid image extensions: http://imgur.com/faq#types\n # All are between 3 and 4 chars long.\n 'image': {'regex': \"(?P<id>[\\w.]*?)(\\\\.\\w{3,4})?$\",\n 'method': self.get_image},\n 'user': {'regex': \"user/(?P<id>[\\w.]*?)$\",\n 'method': self.get_user}\n }\n parsed_url = urlparse(url)\n for obj_type, values in objects.items():\n regex_result = re.match('/' + values['regex'], parsed_url.path)\n if regex_result is not None:\n obj_id = regex_result.group('id')\n initial_object = values['method'](obj_id)\n if obj_type == 'image':\n try:\n # A better version might be to ping the url where the\n # gallery_image should be with a requests.head call. If\n # we get a 200 returned, then that means it exists and\n # this becomes less hacky.\n original_stdout = sys.stdout\n sys.stdout = NullDevice()\n if getattr(initial_object, 'section', None):\n sub = initial_object.section\n return self.get_subreddit_image(sub, obj_id)\n return self.get_gallery_image(obj_id)\n except Exception:\n pass\n finally:\n sys.stdout = original_stdout\n return initial_object","def _get_raw_data(self, url, series):\n url = self._get_url(url, series)\n try:\n response = self.http.request(url, headers=self._reqheaders)\n except httplib2.ServerNotFoundError as e:\n raise TVDBConnectError(e.message), None, sys.exc_info()[2]\n rep = response[0]\n log.debug(\n 'http-status:%s,content:%s', \n rep['status'], \n rep['content-type']\n )\n if int(rep['status']) >= 400:\n raise TVDBConnectError(\n 'Failed to get \"%s\" from thetvdb. errno:%s' % (\n series, rep['status']),\n rep['status']\n ) \n return response[1]","def __fetch_data(self, url):\n try:\n response = urlopen(url)\n root = ET.fromstring(response.read())\n except HTTPError as exc:\n root = ET.fromstring(exc.read())\n raise ValueError(root.get('message'))\n return root","def download_http(self, url):\n\n # Set things up.\n # ==============\n\n out = None\n headers = {}\n if (url.username is not None) and (url.password is not None):\n tmp = base64.b64encode(':'.join([url.username, url.password]))\n headers['Authorization'] = \"Basic %s\" % tmp\n\n\n # Toe the waters.\n # ===============\n # We start with an HTTP HEAD request to check the status.\n\n conn = httplib.HTTPConnection(url.netloc)\n conn.request(\"HEAD\", url.path, '', headers)\n r = conn.getresponse()\n conn.close()\n if self.verbose:\n print >> sys.stderr, url, r.status, ''\n\n\n # Bail.\n # =====\n # Short-cut when we just care whether it's a package.\n\n if url.path.endswith('/'):\n out = r.status == 200\n\n\n elif r.status == 200:\n\n # Wade in.\n # ========\n # If the status is positive we check to see if we've already\n # downloaded the latest copy.\n\n etag = r.getheader('etag', '')\n lm = r.getheader('last-modified', '')\n key = sha.new(str(url) + etag + lm).hexdigest()\n\n if not self.cachedir:\n raise ValueError(\"netimp.importer.cachedir not set\")\n if not os.path.isdir(self.cachedir):\n raise IOError( \"netimp.importer.cachedir not found \"\n + \"(%s)\" % self.cachedir\n )\n\n path = join(self.cachedir, key)\n if os.path.isfile(path):\n out = open(path, 'rb')\n else:\n\n # Dive in!\n # ========\n # We don't have this module locally yet: download it for real.\n\n conn = httplib.HTTPConnection(url.netloc)\n conn.request(\"GET\", url.path, '', headers)\n r = conn.getresponse()\n if r.status == 200: # just in case!\n fp = open(path, 'w+b')\n fp.write(r.read())\n fp.flush()\n fp.close()\n out = open(path, 'rb')\n conn.close()\n\n return out","def fetch(self, url, data = None, headers = None):\n if not headers:\n headers = {}\n self.url = urllib.parse.urljoin(self.url, url)\n if len(self.fost):\n signed, signed_headers = 'X-FOST-Headers', []\n for header, value in list(self.fost['headers'].items()):\n signed += ' ' + header\n signed_headers.append(value)\n headers[ header ] = value\n utcnow = str(datetime.datetime.utcnow())\n path = urllib.parse.urlsplit(self.url).path\n document = '%s %s\\n%s\\n%s\\n%s' % (\n \"POST\" if data else \"GET\", path,\n utcnow,\n '\\n'.join([signed] + signed_headers),\n data or urllib.parse.urlsplit(self.url).query\n )\n headers['X-FOST-Timestamp'] = utcnow\n headers['X-FOST-Headers'] = signed\n headers['Authorization'] = \"FOST %s:%s\" % (\n self.fost['key'],\n sha1_hmac(self.fost['secret'], document)\n )\n return self.opener.open(urllib.request.Request(self.url, data, headers))","def get(self, url):\n return self._request('GET', url)","def read_url(url):\n try:\n response = requests.get(url)\n except requests.ConnectionError:\n content = '{\"error\": \"Bad Connection\"}'\n except MissingSchema: # The url does not exist\n content = '{\"error\": \"Bad Url\"}'\n else:\n if response.status_code == 200:\n content = response.text\n else:\n content = '{\"error\": \"' + response.reason + '\"}'\n\n return content","def downloadData(url : str, descriptor : str):\n assets = datapackage.Package(url).resources\n\n for data in filter(lambda x: x.tabular and x.descriptor['name'] == descriptor, assets):\n response = requests.get(data.descriptor['path'])\n return io.StringIO(response.content.decode('utf-8'))","async def _fetch(self, session, timeout=10):\n\n self.log.debug(\"Fetching url: %s\", self.url)\n with async_timeout.timeout(timeout):\n try:\n async with session.get(self.url) as response:\n if response.status != 200:\n self.log.error(\"HTTP Error %s fetching feed %s\", response.status, self.url)\n return await self._handle_fetch_failure('no data', f\"HTTP error {response.status}\")\n return await response.text()\n\n except asyncio.exceptions.CancelledError:\n self.log.error(\"Timeout fetching feed %s\", self.url)\n await self._handle_fetch_failure('Timeout', \"Timeout while fetching feed\")\n\n except Exception as e:\n self.log.exception(\"Error fetching feed %s\", self.url)\n etype = '.'.join((type(e).__module__, type(e).__name__))\n await self._handle_fetch_failure('Exception', f\"{etype} fetching feed: {e}\")"],"string":"[\n \"def __fetch_from_url(url: str) -> Any:\\n song_information: Any = None\\n try:\\n # Send the request and load the returned contents.\\n req = request.Request(url, headers={\\n 'User-Agent': Config.Config.get_user_agent()\\n })\\n response = request.urlopen(req)\\n contents: str = response.read().decode('utf-8')\\n except (HTTPError, TimeoutError) as ex:\\n Logger.Logger.log_error(str(ex))\\n Logger.Logger.log_error('Request failed for URL: ' + url)\\n return\\n # Parse the response from the endpoint as a JSON encoded string\\n data: Any = json.loads(contents)\\n # Check if response contains at least one result, otherwise return \\\"None\\\".\\n if data['resultCount'] > 0:\\n song_information = data\\n return song_information\",\n \"def FetchUrlContent(url):\\n content = memcache.get(url)\\n if content:\\n return content\\n\\n request = urlfetch.fetch(url)\\n\\n if request.status_code == 200:\\n content = request.content\\n memcache.add(url, content, 60 * 60)\\n return content\\n\\n raise LookupError('Unable to fetch URL. Response code: ' +\\n str(request.status_code))\",\n \"async def fetch_data(self, url: str) -> dict:\\n async with self.bot.http_session.get(url) as r:\\n return await r.json()\",\n \"def fetch_url_feed(self, url, **args):\\n return self.fetch(\\\"/url\\\", url=url, **args)\",\n \"def urlfetch(self, url, **kwargs):\\n logging.debug('Fetching %s with kwargs %s', url, kwargs)\\n resp = urlfetch.fetch(url, deadline=999, **kwargs)\\n\\n if resp.status_code == 200:\\n return resp.content\\n else:\\n logging.warning('GET %s returned %d:\\\\n%s',\\n url, resp.status_code, resp.content)\\n self.handler.response.headers.update(resp.headers)\\n self.handler.response.out.write(resp.content)\\n raise exc.status_map.get(resp.status_code)(resp.content)\",\n \"def fetch_data(data_url):\\n return requests.get(data_url).content\",\n \"def get_fred_data(url):\\n pass\",\n \"def fetch(url):\\n content = requests.get(url).text\\n if \\\"Error\\\" in content:\\n raise ValueError(f\\\"Cannot read from: {url}\\\")\\n return content\",\n \"def fetch(self,url=URL):\\n\\t\\tlog.info('downloading latest PHE case data')\\n#\\t\\tself.data=lookup_json(url)\\n\\t\\tself.fetch_csv() #JSON discontinued; switched back to CSV\\n\\t\\tself.edition=self.latest_samples\\n\\t\\tlog.info(f'Last samples from {self.edition}')\",\n \"def fetchJson(url):\",\n \"def fetch(self, url, listener, useCache = True): #$NON-NLS-1$\\r\",\n \"def fetch_content(self, url):\\n # log.debug(\\\"Fetching content from: %s\\\", url)\\n prepare_curl_callback = lambda x: x.setopt(pycurl.HTTPAUTH, pycurl.HTTPAUTH_GSSNEGOTIATE)\\n self.http.fetch(url, self.handle_response, prepare_curl_callback=prepare_curl_callback, auth_username=':')\",\n \"def GetDataFromURL(self, url):\\n try:\\n deftimeout = socket.getdefaulttimeout()\\n socket.setdefaulttimeout(1)\\n try:\\n logging.debug('Slide fetching data from %s' % url)\\n u = urllib.urlopen(url)\\n data = u.read()\\n return data\\n except:\\n logging.exception('Uh oh!')\\n return None\\n finally:\\n socket.setdefaulttimeout(deftimeout)\",\n \"def fetch(cls, url):\\n delta = time.time() - cls._time_last_fetched\\n wait_time = TIME_TIL_RETRY - delta\\n if wait_time > 0:\\n time.sleep(wait_time)\\n resp = requests.get(url)\\n cls._time_last_fetched = time.time()\\n resp.raise_for_status()\\n return resp\",\n \"def downloadData(url):\\n \\n content = urllib2.urlopen(url)\\n return content\",\n \"def fetch_url(self, url: str):\\n log.debug(f\\\"Fetching {url}\\\")\\n answer = self.session.get(url, timeout=self.timeout)\\n answer.raise_for_status()\\n\\n # returning raw answer object, because due to redirects we may need to\\n # double check answer.url to proceed\\n return answer\",\n \"def _load_data(self, url, options=None, location=None):\\n # Set API key in query parameters\\n params = { \\\"api-key\\\": self.key }\\n\\n # Add options to query parameters\\n if options is not None:\\n params.update(options)\\n\\n # Load the data from the API, raise error if there's an invalid status code\\n res = self.session.get(self.protocol + url, params=params, timeout=(4, 10))\\n if res.status_code == 401:\\n raise ValueError(\\\"Invalid API Key\\\")\\n elif res.status_code == 404:\\n raise RuntimeError(\\\"Error 404: This page is not available\\\")\\n res.raise_for_status()\\n\\n if orjson is None:\\n parsed_res = res.json()\\n else:\\n parsed_res = orjson.loads(res.content)\\n\\n # Get the data from the usual results location\\n if location is None:\\n results = parsed_res.get(\\\"results\\\")\\n\\n # Sometimes the results are in a different location, this location can be defined in a list\\n # Load the data from that location\\n else:\\n results = parsed_res\\n for loc in location:\\n results = results.get(loc)\\n\\n return results\",\n \"def fetch_song_data(url):\\r\\n response = requests.get(url)\\r\\n return response.text\",\n \"def fetch_url(url):\\n logger.info(\\\"Resolving \\\" + url)\\n try:\\n resp = requests.get(url, timeout=1.5)\\n resp.raise_for_status()\\n return {\\n \\\"resolved_url\\\": resp.url,\\n \\\"raw_content\\\": resp.text\\n }\\n except Exception as e:\\n logger.error('Error fetching %s' % url, e)\\n return {\\n \\\"resolved_url\\\": url,\\n \\\"raw_content\\\": \\\"\\\",\\n \\\"url_error\\\": str(e)\\n }\",\n \"def url_fetch(self, url):\\n user_agent = random.choice(self.conf.user_agents)\\n if self.isCompress == True:\\n headers = {\\n 'Uesr-Agent': user_agent,\\n \\\"Accept-Encoding\\\": \\\"gzip,deflate\\\",\\n \\\"Accept-Charset\\\" : \\\"UTF-8,*\\\"\\n }\\n else:\\n headers = {\\n 'Uesr-Agent': user_agent,\\n \\\"Accept-Charset\\\" : \\\"UTF-8,*\\\"\\n }\\n raw_data = ''\\n try:\\n conn = httplib.HTTPConnection(self.proxy, timeout=3.0)\\n conn.request('GET', url, None, headers)\\n response = conn.getresponse()\\n raw_data = response.read()\\n except Exception as err:\\n self.logger.error('connect error[%s]' % err)\\n return '999', 'Request failed', ''\\n finally:\\n conn.close()\\n \\n content = ''\\n if self.isCompress == True:\\n if response.status == 200:\\n try:\\n stream = StringIO.StringIO(raw_data)\\n decompressor = gzip.GzipFile(fileobj=stream)\\n content = decompressor.read()\\n except:\\n self.logger.error('status[%s] len_raw_data[%d]' % (response.status, len(raw_data)))\\n return '998', 'content err', ''\\n else:\\n if response.status == 200:\\n content = raw_data \\n\\n return response.status, response.reason, content\",\n \"def _request_data(self, url):\\n connection = httplib.HTTPConnection(self.url)\\n connection.request(\\\"GET\\\", url)\\n response = connection.getresponse()\\n\\n if response.status != 200:\\n raise Exception(response.reason)\\n\\n data = response.read()\\n response.close()\\n\\n return json.loads(data)\",\n \"def fetch(self, url, headers=DEFAULTHEADERS):\\n logger = self.loggers['http']\\n request = urllib2.Request(url, headers=headers)\\n try:\\n response = urllib2.urlopen(request)\\n except urllib2.HTTPError:\\n logger.error(\\\"failed to retrieve the resource at %s\\\" % url)\\n raise\\n urlgot = response.geturl()\\n rawcontent = response.read()\\n if urlgot != url:\\n logger.info(\\\"successfully retrieved resource from %s, redirected from %s\\\" % (urlgot, url))\\n self.http['redirect'] = True\\n else:\\n logger.info(\\\"successfully retrieved resource from %s\\\" % url)\\n self.http['redirect'] = False\\n rheaders = response.info()\\n \\n # store useful info on the object for later access\\n self.http['request'] = {}\\n self.http['request']['headers'] = headers\\n self.http['urlsought'] = url\\n self.http['urlgot'] = urlgot\\n self.http['response'] = response\\n self.http['response_headers'] = {}\\n for k in sorted(rheaders.keys()): \\n logger.debug(\\\"response header %s: '%s'\\\" % (k, rheaders[k]))\\n self.http['response_headers'][k.strip().lower()] = rheaders[k].strip() \\n self.documenturl = urlgot\\n self.rawcontent = rawcontent\",\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 \"def fetch(url, verbose=False):\\n\\n resp = requests.get(url)\\n if verbose:\\n print(resp.json())\\n if resp.status_code == 200:\\n\\n resp=resp.json()\\n return resp\\n else:\\n return None\",\n \"def fetch_dataset(url, pandas_impl=pandas):\\n\\n print(f'fetching dataset at {url}')\\n return pandas_impl.read_csv(url)\",\n \"def fetch_50(url):\\n\\n results = requests.get(url,headers = headers).json()\\n return results\",\n \"async def fetch(self, session, url):\\n async with session.get(url) as response:\\n if response.status != 200:\\n response.raise_for_status()\\n response = await response.text()\\n return json.loads(response)\",\n \"def get_data(url):\\n response = get(url, timeout=10)\\n \\n if response.status_code >= 400:\\n raise RuntimeError(f'Request failed: { response.text }')\\n \\n return response.json()\",\n \"def fetch_save(url):\\n\\n name = url.split(\\\"/\\\")[-1]\\n response = requests.get(url, stream=True)\\n if response.status_code == 200:\\n with open(f\\\"{DATA_PATH}/{name}\\\", \\\"wb\\\") as f:\\n f.write(response.raw.read())\\n else:\\n logging.info(f\\\"Failed {url} download\\\")\",\n \"def _by_url(session: Session, url: URL) -> UnifiedDataset:\\n r = session.get(str(url))\\n if r.status_code == 404:\\n raise NotFound(str(url))\\n data = response.successful(r).json()\\n return _from_json(url, data)\",\n \"def fetch(self, path, **kwargs):\\n self.http_client.fetch(self.get_url(path), self.stop, **kwargs)\\n return self.wait()\",\n \"def data_loader(self, url, type_of):\\n i = url.rfind('/')\\n data_name = url[(i + 1):]\\n data_def = {\\n \\\"displayName\\\": data_name,\\n \\\"url\\\": url\\n }\\n if type_of == \\\"csv\\\":\\n data_loader = self.csv_data_loader\\n else:\\n data_loader = self.json_data_loader\\n\\n return Downloader(data_def).download(data_loader)\",\n \"def fetch_metadata(requests_impl=requests):\\n\\n print(f'fetching metadata at {Network.METADATA_URL}')\\n return requests_impl.get(Network.METADATA_URL).json()\",\n \"def fromurl(cls, url: str):\\n return cls.parse_obj(requests.get(url).json())\",\n \"def fetch(self, url):\\n self.log.info(\\\"Fetching URL: \\\" + url)\\n\\n r = requests.get(url, verify=False)\\n # raise an HTTPError on badness\\n r.raise_for_status()\\n\\n # this decodes r.content using a guessed encoding\\n return r.text\",\n \"def get_data(self, url):\\n\\n req = urllib2.Request(url)\\n # urlencode the query dictionary\\n try:\\n r = urllib2.urlopen(req)\\n result = r.read()\\n except:\\n result = 'The url: %s is not responding.' % (url)\\n return result\",\n \"def load_url_content(url):\\n try:\\n r = requests.get(url)\\n if r.ok:\\n return r.text\\n else:\\n return None\\n except Exception:\\n return None\",\n \"def _fetch(url, ssl_verify = True):\\n req = Request(url)\\n if ssl_verify:\\n page = urlopen(req)\\n else:\\n ctx = ssl.create_default_context()\\n ctx.check_hostname = False\\n ctx.verify_mode = ssl.CERT_NONE\\n\\n page = urlopen(req, context=ctx)\\n content = page.read().decode('utf-8')\\n page.close()\\n return content\",\n \"def fetch_url(self, url: str) -> Union[Dict, None]:\\n\\n try:\\n req = requests.get(url)\\n req.raise_for_status()\\n res = req.json()\\n except (requests.HTTPError, json.JSONDecodeError) as e:\\n logging.warning(f'{self.__class__.__name__} failed to retrieve/parse {url}')\\n # logging.debug(e)\\n return\\n\\n # safe-check for empty response from server\\n if not res:\\n logging.warning(f\\\"{self.__class__.__name__} empty response from {url}\\\")\\n return\\n\\n return res\",\n \"def _get_data(self, url: str)->dict:\\n data = None\\n resp = self._get(url)\\n if resp:\\n data = resp.json()['data']\\n return data\",\n \"def fetch(self, url: furl) -> str:\\n try:\\n contents = self._download(url)\\n except requests.ConnectionError as err:\\n logger.exception(f\\\"Request failed with {err}\\\")\\n click.secho(\\n f\\\"The URL {url} could not be downloaded. Either your network is unreachable or the URL is broken.\\\"\\n f\\\" Check the URL, fix your connection, or use \\\"\\n f\\\" {OptionEnum.OFFLINE.as_flake8_flag()} / {OptionEnum.OFFLINE.as_envvar()}=1\\\",\\n fg=\\\"red\\\",\\n err=True,\\n )\\n return \\\"\\\"\\n return contents\",\n \"def load(self, url):\\n pass\",\n \"def load(self, url):\\n pass\",\n \"def get_url_data(self, url):\\n # print \\\"opening: \\\" + url\\n request = urllib2.Request(url)\\n base64string = '%s:%s' % (self.username, self.key)\\n request.add_header(\\\"Authorization\\\", \\\"ApiKey %s\\\" % base64string)\\n response = urllib2.urlopen(request)\\n data = json.loads(response.read())\\n return data\",\n \"def _raw_get(self, url):\\n logger.debug('Fetching URL %s', url)\\n self._conn.request('GET', url, None, {\\n 'Accept-Encoding': 'gzip',\\n 'User-Agent': USER_AGENT,\\n 'Cookie': self.cookie,\\n 'Connection': 'keep-alive',\\n 'DNT': '1',\\n })\\n self._resp = self._conn.getresponse()\\n if self.cookie == '':\\n complete_cookie = self._resp.getheader('Set-Cookie')\\n # Cookie won't be available is already blocked\\n if complete_cookie is not None:\\n self.cookie = complete_cookie[:complete_cookie.find(';')]\\n logger.debug('Cookie: %s' % self.cookie)\",\n \"async def fetch(url, session):\\n async with session.get(url) as response:\\n return await response.read()\",\n \"def fetch_object(url):\\n print(' GET ' + url)\\n session = requests.Session()\\n retry = Retry(connect=3, backoff_factor=15)\\n adapter = HTTPAdapter(max_retries=retry)\\n session.mount('http://', adapter)\\n session.mount('https://', adapter)\\n r = session.get(url)\\n # Covering internal server errors by retrying one more time\\n if r.status_code == 500:\\n time.sleep(5)\\n r = requests.get(url, allow_redirects=True)\\n elif r.status_code != 200:\\n print(f\\\"Problem with request: {str(r)}\\\")\\n raise RuntimeError(\\\"Non-200 status code\\\")\\n return r\",\n \"def _get(self, url, **kwargs):\\n return self._http.get(self.cluster + url, timeout=self.timeout, **kwargs)\",\n \"async def fetch(session, url):\\n async with session.get(url) as response:\\n return await response.text()\",\n \"def get_data(self, url):\\n return self.get(url).get('data', [])\",\n \"def get(self, url):\\n\\n\\t\\ttry:\\n\\t\\t\\trequest = urllib2.Request(url)\\n\\t\\t\\trequest.add_header('User-Agent', self.user_agent)\\n\\n\\t\\t\\tlogging.debug('Get.get - getting url ' + url)\\n\\n\\t\\t\\tresult = urllib2.urlopen(request)\\n\\n\\t\\texcept: raise RuntimeError('unable to open url')\\n\\n\\t\\treturn result\",\n \"def get(self, url):\\n return json.loads(self.as_source.urlopen(url).read())\",\n \"def http_get(url):\\n\\n count = 0\\n result = ''\\n ok = False\\n while count < 3 and not ok:\\n try:\\n result = urllib.urlopen(url).read()\\n ok = True\\n except:\\n count += 1\\n return result\",\n \"def fetch(self):\\n # This method also sets self._results_filtered and\\n # self._urltable.\\n page = self._conn.fetch_page(self._ddg_url.relative())\\n\\n if logger.isEnabledFor(logging.DEBUG):\\n import tempfile\\n fd, tmpfile = tempfile.mkstemp(prefix='ddgr-response-')\\n os.close(fd)\\n with open(tmpfile, 'w', encoding='utf-8') as fp:\\n fp.write(page)\\n logger.debug(\\\"Response body written to '%s'.\\\", tmpfile)\\n\\n parser = DdgParser(news=self._ddg_url.news)\\n parser.feed(page)\\n\\n self.results = parser.results\\n self._results_filtered = parser.filtered\\n self._urltable = {}\\n for r in self.results:\\n self._urltable.update(r.urltable())\",\n \"async def _fetch(self, session, url, proxy=None, raw=False, which_site=False):\\n print(url)\\n result = None\\n site = None\\n if 'hare' in url: # {'Unknown': -1, 'Pixnet': 0, 'Hares': 1}\\n site = self._websites['Hares']\\n elif 'pixnet' in url:\\n site = self._websites['Pixnet']\\n else:\\n site = self._websites['Unknown']\\n\\n count = 1\\n while count <= 2:\\n soup = ''\\n status = 0\\n try:\\n async with session.get(url, proxy=proxy) as response:\\n source_code = await response.text('utf-8')\\n status = response.status\\n soup = source_code if raw else BeautifulSoup(source_code, 'lxml')\\n except Exception as e:\\n print('Connection error: ' + str(e))\\n soup = None\\n finally:\\n result = (url, soup, status, site) if which_site else (url, soup, status)\\n if status != 0:\\n return result\\n if 'searcharticle' not in url:\\n count += 1\\n result = (url, soup, status, site) if which_site else (url, soup, status)\\n return result\",\n \"def data_loader(self, url, type_of):\\n\\n data_loader = None\\n if type_of == \\\"csv\\\":\\n data_loader = self.csv\\n elif type_of == \\\"json\\\":\\n data_loader = self.json\\n elif type_of == \\\"parquet\\\":\\n data_loader = self.parquet\\n elif type_of == \\\"avro\\\":\\n data_loader = self.avro\\n else:\\n RaiseIt.type_error(data_loader, [\\\"csv\\\", \\\"json\\\", \\\"parquet\\\", \\\"avro\\\", ])\\n\\n i = url.rfind('/')\\n data_name = url[(i + 1):]\\n data_def = {\\n \\\"displayName\\\": data_name,\\n \\\"url\\\": url\\n }\\n return Downloader(data_def).download(data_loader, type_of)\",\n \"def _fetch(\\n cls, url: str, headers: Mapping[str, str], params: Mapping[str, Any]\\n ) -> Tuple[List[EventType], Optional[str]]:\\n status_url = cls._post_query(url, headers, params)\\n # Await a while before polling the results\\n time.sleep(0.1)\\n result_url = cls._poll_status(status_url, headers, params)\\n data, headers = cls._get_results(result_url, headers, params)\\n result = json.loads(data)\\n return result, headers.get(\\\"x-next-token\\\")\",\n \"def _extract_data(self):\\n if self.URL_type == \\\"youtube\\\" or self.URL_type == \\\"ytmusic\\\":\\n self._get_youtube_data_url()\\n elif self.URL_type == \\\"soundcloud\\\":\\n self._get_soundcloud_data()\",\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 request_data(url): \\n requests_cache.install_cache('data_cache')\\n while True:\\n data = requests.get(url)\\n if not data.status_code == 200 or \\\"try again later\\\" in data.text:\\n continue\\n else:\\n break\\n return data.text\",\n \"async def fetch(self, url=None, method='GET', body=None):\\n log.debug('fetching \\\\n method: [%s] \\\\n url: %s \\\\n body: %s',\\n method,\\n url,\\n body)\\n if not method:\\n method = HttpMethod.GET\\n status: int = None\\n text: str = None\\n if method == HttpMethod.GET:\\n async with self._http_session.get(url) as response:\\n status = response.status\\n text = await response.text()\\n elif method == HttpMethod.POST:\\n async with self._http_session.post(url, data=body) as response:\\n log.debug('fetch POST response: %r', response)\\n status = response.status\\n text = await response.text()\\n else:\\n raise NotImplementedError(\\n f\\\"HTTP requst method {method} not implemented yet. \\\"\\n \\\"Contributions welcome!\\\")\\n log.debug('fetch result status: %d, text: %s', status, text)\\n return (status, text)\",\n \"def get_data_with_http_request(self, url):\\n _LOGGER.debug(\\\"[SERVICES][HTTPCLIENT] sendHTTPRequest\\\")\\n try:\\n request = self.request(url)\\n response = self.create_response(request)\\n data = self.decode_response(response)\\n except TypeError:\\n _LOGGER.error(\\\"Could not fetch data from \\\"+url)\\n return None\\n return data\",\n \"def read_url(url):\\n response = requests.get(url)\\n return response.text\",\n \"async def fetch(self, url, params={}, loop=None, max_workers=5, **extra):\\n\\n result = {}\\n pool = ProcessPoolExecutor(max_workers)\\n extra.update({\\n \\\"loop\\\": loop\\n })\\n parsed_url = url_concat(url, **params)\\n if inspect.iscoroutinefunction(self.on_fetch):\\n result = await self.on_fetch(parsed_url, extra)\\n else:\\n loop = loop or asyncio.get_event_loop()\\n result = await loop.run_in_executor(pool, self.on_fetch, parsed_url, extra)\\n return result\",\n \"def fetch_temp_data(url):\\n res = requests.get(url)\\n return res.json()\",\n \"def request(self, url):\\n requested_data = None\\n try:\\n requested_data = urllib.request.Request(url, headers=self.headers)\\n except urllib.error.URLError as err:\\n _LOGGER.error(\\\"Could not connect: \\\" + err.reason)\\n except urllib.error.HTTPError as err:\\n _LOGGER.error(\\\"Server return code \\\" + err.code + \\\". \\\" +\\n err.reason + \\\" Error caused by the following \\\"\\n \\\"header(s): \\\" + err.headers + \\\".\\\")\\n except urllib.error.ContentTooShortError as err:\\n _LOGGER.error(\\\"Could not connect! The amount of the downloaded \\\"\\n \\\"data is less than the expected amount (given by \\\"\\n \\\"the Content-Length header).\\\")\\n except ValueError as err:\\n _LOGGER.error(\\\"Invalid url, please insert a valid url.\\\")\\n return requested_data\",\n \"def fetch_csv_from_url(url):\\n\\t\\n\\t#cache avoidance.\\n\\twith requests_cache.disabled():\\n\\t\\tr = requests.get(url)\\n\\t\\tif r.status_code == 200:\\n\\t\\t\\treturn r.iter_lines()\",\n \"def _FetchBuilderData(builder_url):\\n data = None\\n try:\\n url = urllib2.urlopen(builder_url)\\n except urllib2.URLError, e:\\n print ('urllib2.urlopen error %s, waterfall status page down.[%s]' % (\\n builder_url, str(e)))\\n return None\\n if url is not None:\\n try:\\n data = url.read()\\n except IOError, e:\\n print 'urllib2 file object read error %s, [%s].' % (builder_url, str(e))\\n return data\",\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(self, url):\\n \\n content = \\\"\\\"\\n if hasattr(http.client, \\\"HTTPSConnection\\\"): \\n url_options = urlparse(url)\\n\\n conn = http.client.HTTPSConnection(url_options.netloc)\\n conn.request('GET', url_options.path + '?' + url_options.query)\\n content = conn.getresponse().read().decode('utf-8')\\n conn.close()\\n else: \\n p = os.popen('curl -k \\\"' + url + '\\\"')\\n content = p.read()\\n p.close() \\n\\n return content\",\n \"def download_data(self, format = 'srt'):\\n resp, content = httplib2.Http(\\\".cache\\\").request(self.url, \\\"GET\\\")\\n suburl = json.loads(content)['url']\\n resp, content = httplib2.Http(\\\".cache\\\").request(suburl, \\\"GET\\\")\\n\\n return content\",\n \"def read_url(url):\\n return requests.get(url).text\",\n \"def fetch_housing_data(housing_url=HOUSING_URL, housing_path=HOUSING_PATH):\\n logging.info(\\\"Fetch housing data.....\\\")\\n os.makedirs(housing_path, exist_ok=True)\\n tgz_path = os.path.join(housing_path, \\\"housing.tgz\\\")\\n urllib.request.urlretrieve(housing_url, tgz_path)\\n housing_tgz = tarfile.open(tgz_path)\\n housing_tgz.extractall(path=housing_path)\\n housing_tgz.close()\",\n \"async def fetch(url: str, session: ClientSession) -> Tuple[str, bytes]:\\n async with session.get(url) as response:\\n resp = await response.read()\\n return url, resp\",\n \"def _fetch(self):\\n self._data = self._get(self.url)\\n\\n if self._data['released_errata'] is not None:\\n self._released_errata = Erratum(errata_id=self._data[\\n 'released_errata']['id'])\\n\\n for errata_dict in self._data['all_errata']:\\n errata = Erratum(errata_id=errata_dict['id'])\\n self._all_errata.append(errata)\\n\\n self._signed_rpms = self._data.get('rpms_signed')\\n\\n for et_file in self._data['files']:\\n self._files.append(et_file['path'])\",\n \"def _get(self, url):\\n return self._request(url)\",\n \"def parse(self):\\n \\n r = requests.get(self.url)\\n if r:\\n self.title = fetch_title(self.url)\\n self.domain = self.fetch_domain()\\n self.favicon = self.fetch_favicon()\\n self.topics = self.classify_topics()\\n self.description = self.fetch_description()\\n return self\",\n \"def _getFeedContent(self, url, excludeRead=False, continuation=None, loadLimit=20, since=None, until=None):\\r\\n parameters = {}\\r\\n if excludeRead:\\r\\n parameters['xt'] = 'user/-/state/com.google/read'\\r\\n if continuation:\\r\\n parameters['c'] = continuation\\r\\n parameters['n'] = loadLimit\\r\\n if since:\\r\\n parameters['ot'] = since\\r\\n if until:\\r\\n parameters['nt'] = until\\r\\n contentJson = self.httpGet(url, parameters)\\r\\n return json.loads(contentJson, strict=False)\",\n \"def fetch_meta(url, filter=None):\\n\\n link = LinkMeta(url)\\n link.parse()\\n\\n # returns the local variables in this functions scope as a \\n # dict.\\n return link\",\n \"def get_records_from_url(url):\\n with requests.get(url) as response:\\n source = response.text\\n return parseString(source)\",\n \"async def http_get(url):\\n async with aiohttp.ClientSession() as session:\\n async with session.get(url) as r:\\n return await r.text()\",\n \"def fetch(url: str, raise_for_status: bool=True, **query_params) -> Tuple[int, Dict[str, Any]]:\\n # HINT carefully read the requests documentation to figure out the cleanest way to raise a requests error.\\n #query_params is a dict, **query_params is keyword arg \\n res_obj = requests.get(url, params=query_params)\\n if raise_for_status:# default to True \\n res_obj.raise_for_status()# if 200 result is None \\\"All is well\\\"\\n return (res_obj.status_code, res_obj.json()) # returns code and dict \",\n \"def loadu(self, url, **kwargs):\\n return self.load(self.open(url, **kwargs), **kwargs)\",\n \"def _get_result(url, etag=None, last_modified=None, use_discovery=False):\\n _validate_url(url)\\n\\n result = feedparser.parse(url, etag=etag, modified=last_modified)\\n # update URL for any redirects that feedparser followed\\n url = result.get('href', url)\\n\\n if _is_not_modified_result(result):\\n raise FeedNotModifiedError\\n elif not _is_valid_result(result):\\n if use_discovery:\\n url = _discover_url(result)\\n return _get_result(url)\\n else:\\n _fail(url, \\\"Failed to download or parse feed\\\")\\n else:\\n return url, result\",\n \"def __get(self, url, headers=None):\\n return self.__req(url, \\\"GET\\\", headers=headers)\",\n \"def get_data_from_web():\\n pass\",\n \"def downloadData(url):\\r\\n\\r\\n data = urllib2.urlopen(url)\\r\\n csvdata = data.read()\",\n \"def _get(url):\\n url = urlparse(url)\\n conn = HTTPConnection(url.hostname, url.port)\\n conn.request('GET', url.path+url.query)\\n return conn.getresponse().fp.read()\",\n \"def _fetch_data(url: str, d: datetime) -> pd.DataFrame:\\n return pd.read_json(url)\",\n \"def download_data(self, url: str, source_type: str) -> None:\\n r = None # request\\n\\n # download data from nextcloud\\n if source_type == \\\"nextcloud\\\":\\n token = url\\n r = requests.get(\\n os.environ[\\\"NC_WEBDAV_URL\\\"], auth=(token, os.environ[\\\"NC_PASSWORD\\\"])\\n )\\n\\n # download data from generic URLs\\n if source_type == \\\"generic_url\\\":\\n s = requests.Session()\\n headers = {\\n \\\"User-Agent\\\": \\\"Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:88.0) Gecko/20100101 Firefox/88.0\\\"\\n }\\n s.headers.update(headers)\\n r = s.get(url)\\n\\n f_name = None # file name\\n\\n if \\\"content-disposition\\\" in r.headers.keys():\\n d = r.headers[\\\"content-disposition\\\"]\\n f_name = re.findall('filename=\\\"(.+)\\\"', d)[0]\\n else:\\n f_name = url.split(\\\"/\\\")[-1]\\n\\n # save file\\n try:\\n with open(Path(os.environ[\\\"DATA_PATH\\\"]) / f_name, \\\"wb\\\") as f:\\n for chunk in r.iter_content(self.chunk_size):\\n f.write(chunk)\\n except OSError:\\n print(f\\\"Error: {list(Path(os.environ['DATA_PATH']).iterdir())}\\\")\",\n \"def get(self, url):\\r\\n response = self.requestHelper.get(url)\\r\\n return self.process(response)\",\n \"def fetch_url(session, url):\\n return session.get(url).text\",\n \"def get_at_url(self, url):\\n class NullDevice():\\n def write(self, s):\\n pass\\n\\n def get_gallery_item(id):\\n \\\"\\\"\\\"\\n Special helper method to get gallery items.\\n\\n The problem is that it's impossible to distinguish albums and\\n images from each other based on the url. And there isn't a common\\n url endpoints that return either a Gallery_album or a Gallery_image\\n depending on what the id represents. So the only option is to\\n assume it's a Gallery_image and if we get an exception then try\\n Gallery_album. Gallery_image is attempted first because there is\\n the most of them.\\n \\\"\\\"\\\"\\n try:\\n # HACK: Problem is that send_request prints the error message\\n # from Imgur when it encounters an error. This is nice because\\n # this error message is more descriptive than just the status\\n # code that Requests give. But since we first assume the id\\n # belong to an image, it means we will get an error whenever\\n # the id belongs to an album. The following code temporarily\\n # disables stdout to avoid give a cryptic and incorrect error.\\n\\n # Code for disabling stdout is from\\n # http://coreygoldberg.blogspot.dk/2009/05/\\n # python-redirect-or-turn-off-stdout-and.html\\n original_stdout = sys.stdout # keep a reference to STDOUT\\n sys.stdout = NullDevice() # redirect the real STDOUT\\n return self.get_gallery_image(id)\\n # TODO: Add better error codes so I don't have to do a catch-all\\n except Exception:\\n return self.get_gallery_album(id)\\n finally:\\n sys.stdout = original_stdout # turn STDOUT back on\\n\\n if not self.is_imgur_url(url):\\n return None\\n\\n objects = {'album': {'regex': \\\"a/(?P<id>[\\\\w.]*?)$\\\",\\n 'method': self.get_album},\\n 'comment': {'regex': \\\"gallery/\\\\w*/comment/(?P<id>[\\\\w.]*?)$\\\",\\n 'method': self.get_comment},\\n 'gallery': {'regex': \\\"(gallery|r/\\\\w*?)/(?P<id>[\\\\w.]*?)$\\\",\\n 'method': get_gallery_item},\\n # Valid image extensions: http://imgur.com/faq#types\\n # All are between 3 and 4 chars long.\\n 'image': {'regex': \\\"(?P<id>[\\\\w.]*?)(\\\\\\\\.\\\\w{3,4})?$\\\",\\n 'method': self.get_image},\\n 'user': {'regex': \\\"user/(?P<id>[\\\\w.]*?)$\\\",\\n 'method': self.get_user}\\n }\\n parsed_url = urlparse(url)\\n for obj_type, values in objects.items():\\n regex_result = re.match('/' + values['regex'], parsed_url.path)\\n if regex_result is not None:\\n obj_id = regex_result.group('id')\\n initial_object = values['method'](obj_id)\\n if obj_type == 'image':\\n try:\\n # A better version might be to ping the url where the\\n # gallery_image should be with a requests.head call. If\\n # we get a 200 returned, then that means it exists and\\n # this becomes less hacky.\\n original_stdout = sys.stdout\\n sys.stdout = NullDevice()\\n if getattr(initial_object, 'section', None):\\n sub = initial_object.section\\n return self.get_subreddit_image(sub, obj_id)\\n return self.get_gallery_image(obj_id)\\n except Exception:\\n pass\\n finally:\\n sys.stdout = original_stdout\\n return initial_object\",\n \"def _get_raw_data(self, url, series):\\n url = self._get_url(url, series)\\n try:\\n response = self.http.request(url, headers=self._reqheaders)\\n except httplib2.ServerNotFoundError as e:\\n raise TVDBConnectError(e.message), None, sys.exc_info()[2]\\n rep = response[0]\\n log.debug(\\n 'http-status:%s,content:%s', \\n rep['status'], \\n rep['content-type']\\n )\\n if int(rep['status']) >= 400:\\n raise TVDBConnectError(\\n 'Failed to get \\\"%s\\\" from thetvdb. errno:%s' % (\\n series, rep['status']),\\n rep['status']\\n ) \\n return response[1]\",\n \"def __fetch_data(self, url):\\n try:\\n response = urlopen(url)\\n root = ET.fromstring(response.read())\\n except HTTPError as exc:\\n root = ET.fromstring(exc.read())\\n raise ValueError(root.get('message'))\\n return root\",\n \"def download_http(self, url):\\n\\n # Set things up.\\n # ==============\\n\\n out = None\\n headers = {}\\n if (url.username is not None) and (url.password is not None):\\n tmp = base64.b64encode(':'.join([url.username, url.password]))\\n headers['Authorization'] = \\\"Basic %s\\\" % tmp\\n\\n\\n # Toe the waters.\\n # ===============\\n # We start with an HTTP HEAD request to check the status.\\n\\n conn = httplib.HTTPConnection(url.netloc)\\n conn.request(\\\"HEAD\\\", url.path, '', headers)\\n r = conn.getresponse()\\n conn.close()\\n if self.verbose:\\n print >> sys.stderr, url, r.status, ''\\n\\n\\n # Bail.\\n # =====\\n # Short-cut when we just care whether it's a package.\\n\\n if url.path.endswith('/'):\\n out = r.status == 200\\n\\n\\n elif r.status == 200:\\n\\n # Wade in.\\n # ========\\n # If the status is positive we check to see if we've already\\n # downloaded the latest copy.\\n\\n etag = r.getheader('etag', '')\\n lm = r.getheader('last-modified', '')\\n key = sha.new(str(url) + etag + lm).hexdigest()\\n\\n if not self.cachedir:\\n raise ValueError(\\\"netimp.importer.cachedir not set\\\")\\n if not os.path.isdir(self.cachedir):\\n raise IOError( \\\"netimp.importer.cachedir not found \\\"\\n + \\\"(%s)\\\" % self.cachedir\\n )\\n\\n path = join(self.cachedir, key)\\n if os.path.isfile(path):\\n out = open(path, 'rb')\\n else:\\n\\n # Dive in!\\n # ========\\n # We don't have this module locally yet: download it for real.\\n\\n conn = httplib.HTTPConnection(url.netloc)\\n conn.request(\\\"GET\\\", url.path, '', headers)\\n r = conn.getresponse()\\n if r.status == 200: # just in case!\\n fp = open(path, 'w+b')\\n fp.write(r.read())\\n fp.flush()\\n fp.close()\\n out = open(path, 'rb')\\n conn.close()\\n\\n return out\",\n \"def fetch(self, url, data = None, headers = None):\\n if not headers:\\n headers = {}\\n self.url = urllib.parse.urljoin(self.url, url)\\n if len(self.fost):\\n signed, signed_headers = 'X-FOST-Headers', []\\n for header, value in list(self.fost['headers'].items()):\\n signed += ' ' + header\\n signed_headers.append(value)\\n headers[ header ] = value\\n utcnow = str(datetime.datetime.utcnow())\\n path = urllib.parse.urlsplit(self.url).path\\n document = '%s %s\\\\n%s\\\\n%s\\\\n%s' % (\\n \\\"POST\\\" if data else \\\"GET\\\", path,\\n utcnow,\\n '\\\\n'.join([signed] + signed_headers),\\n data or urllib.parse.urlsplit(self.url).query\\n )\\n headers['X-FOST-Timestamp'] = utcnow\\n headers['X-FOST-Headers'] = signed\\n headers['Authorization'] = \\\"FOST %s:%s\\\" % (\\n self.fost['key'],\\n sha1_hmac(self.fost['secret'], document)\\n )\\n return self.opener.open(urllib.request.Request(self.url, data, headers))\",\n \"def get(self, url):\\n return self._request('GET', url)\",\n \"def read_url(url):\\n try:\\n response = requests.get(url)\\n except requests.ConnectionError:\\n content = '{\\\"error\\\": \\\"Bad Connection\\\"}'\\n except MissingSchema: # The url does not exist\\n content = '{\\\"error\\\": \\\"Bad Url\\\"}'\\n else:\\n if response.status_code == 200:\\n content = response.text\\n else:\\n content = '{\\\"error\\\": \\\"' + response.reason + '\\\"}'\\n\\n return content\",\n \"def downloadData(url : str, descriptor : str):\\n assets = datapackage.Package(url).resources\\n\\n for data in filter(lambda x: x.tabular and x.descriptor['name'] == descriptor, assets):\\n response = requests.get(data.descriptor['path'])\\n return io.StringIO(response.content.decode('utf-8'))\",\n \"async def _fetch(self, session, timeout=10):\\n\\n self.log.debug(\\\"Fetching url: %s\\\", self.url)\\n with async_timeout.timeout(timeout):\\n try:\\n async with session.get(self.url) as response:\\n if response.status != 200:\\n self.log.error(\\\"HTTP Error %s fetching feed %s\\\", response.status, self.url)\\n return await self._handle_fetch_failure('no data', f\\\"HTTP error {response.status}\\\")\\n return await response.text()\\n\\n except asyncio.exceptions.CancelledError:\\n self.log.error(\\\"Timeout fetching feed %s\\\", self.url)\\n await self._handle_fetch_failure('Timeout', \\\"Timeout while fetching feed\\\")\\n\\n except Exception as e:\\n self.log.exception(\\\"Error fetching feed %s\\\", self.url)\\n etype = '.'.join((type(e).__module__, type(e).__name__))\\n await self._handle_fetch_failure('Exception', f\\\"{etype} fetching feed: {e}\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7141515","0.68348056","0.67148185","0.6683118","0.6625893","0.6613337","0.6553073","0.6546756","0.6502782","0.6493208","0.6449416","0.6427715","0.6386104","0.6324223","0.6319196","0.63145965","0.6295364","0.6295271","0.6283739","0.6245581","0.6242461","0.6239492","0.6230558","0.6229188","0.6207095","0.61692715","0.61570865","0.6145608","0.61339843","0.60997796","0.6098545","0.6092657","0.6085226","0.6083567","0.60658973","0.6062517","0.60578734","0.6055739","0.6047762","0.6021646","0.6012883","0.60120934","0.60120934","0.6011198","0.60094994","0.59973454","0.599367","0.5992037","0.59890616","0.598259","0.5959343","0.59538454","0.5950832","0.59464604","0.59405035","0.5933654","0.5926804","0.59198934","0.5911495","0.5905699","0.59048295","0.59041744","0.589894","0.5896556","0.5894485","0.58748186","0.5863224","0.58624935","0.58619845","0.58542436","0.5849535","0.5827586","0.5826082","0.58139944","0.5786807","0.57687724","0.5768277","0.5764176","0.576319","0.5752358","0.5747254","0.5745874","0.57387227","0.5738461","0.5737201","0.5728473","0.57262045","0.57249236","0.5723925","0.57232463","0.5714161","0.57103455","0.57090336","0.5707313","0.5702784","0.5698398","0.56933963","0.5687352","0.5681599","0.56807464","0.5676295"],"string":"[\n \"0.7141515\",\n \"0.68348056\",\n \"0.67148185\",\n \"0.6683118\",\n \"0.6625893\",\n \"0.6613337\",\n \"0.6553073\",\n \"0.6546756\",\n \"0.6502782\",\n \"0.6493208\",\n \"0.6449416\",\n \"0.6427715\",\n \"0.6386104\",\n \"0.6324223\",\n \"0.6319196\",\n \"0.63145965\",\n \"0.6295364\",\n \"0.6295271\",\n \"0.6283739\",\n \"0.6245581\",\n \"0.6242461\",\n \"0.6239492\",\n \"0.6230558\",\n \"0.6229188\",\n \"0.6207095\",\n \"0.61692715\",\n \"0.61570865\",\n \"0.6145608\",\n \"0.61339843\",\n \"0.60997796\",\n \"0.6098545\",\n \"0.6092657\",\n \"0.6085226\",\n \"0.6083567\",\n \"0.60658973\",\n \"0.6062517\",\n \"0.60578734\",\n \"0.6055739\",\n \"0.6047762\",\n \"0.6021646\",\n \"0.6012883\",\n \"0.60120934\",\n \"0.60120934\",\n \"0.6011198\",\n \"0.60094994\",\n \"0.59973454\",\n \"0.599367\",\n \"0.5992037\",\n \"0.59890616\",\n \"0.598259\",\n \"0.5959343\",\n \"0.59538454\",\n \"0.5950832\",\n \"0.59464604\",\n \"0.59405035\",\n \"0.5933654\",\n \"0.5926804\",\n \"0.59198934\",\n \"0.5911495\",\n \"0.5905699\",\n \"0.59048295\",\n \"0.59041744\",\n \"0.589894\",\n \"0.5896556\",\n \"0.5894485\",\n \"0.58748186\",\n \"0.5863224\",\n \"0.58624935\",\n \"0.58619845\",\n \"0.58542436\",\n \"0.5849535\",\n \"0.5827586\",\n \"0.5826082\",\n \"0.58139944\",\n \"0.5786807\",\n \"0.57687724\",\n \"0.5768277\",\n \"0.5764176\",\n \"0.576319\",\n \"0.5752358\",\n \"0.5747254\",\n \"0.5745874\",\n \"0.57387227\",\n \"0.5738461\",\n \"0.5737201\",\n \"0.5728473\",\n \"0.57262045\",\n \"0.57249236\",\n \"0.5723925\",\n \"0.57232463\",\n \"0.5714161\",\n \"0.57103455\",\n \"0.57090336\",\n \"0.5707313\",\n \"0.5702784\",\n \"0.5698398\",\n \"0.56933963\",\n \"0.5687352\",\n \"0.5681599\",\n \"0.56807464\",\n \"0.5676295\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":8781,"cells":{"query":{"kind":"string","value":"Takes input ends of all feed pipes and feeds odd numbers starting from low until high both inclusive. in a round robin fashion. process ends by feeding 1 to all pipes. 1 is a sentinel value."},"document":{"kind":"string","value":"def distributor(ls_feed_pipe_open,low,high):\n def getNumber(low,high):\n i = low\n if i%2 == 0: #if i is even, then start from i+1 odd.\n i += 1\n while i<=high:\n yield i\n i+=2 #no need to check for even numbers, so skip it here at begining\n yield -1 #when generator yields -1, it reached high, so terminate\n\n next_pipe = 0\n number = getNumber(low,high)\n while True:\n msg = next(number)\n if msg == -1: #to check when generator reached high.\n break\n else:\n #feed pipes in a round robin fashion,\n #so that over time each generatePrime process experiences same load.\n ls_feed_pipe_open[next_pipe].send(msg)\n next_pipe += 1\n if next_pipe == len(ls_feed_pipe_open):\n next_pipe = 0\n for p in ls_feed_pipe_open:\n p.send(-1) #-1 is sentinel value for all generatePrime processs\n return 0"},"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 odd():\n num = 0\n while True:\n yield num * (num & 1)\n num += 1","def infinite_odd_generator():\n current = 1\n while True:\n yield current\n current = current + 2","def input_pipe():\n x = ''\n while True:\n x = yield x\n yield # to keep the generator in lock step with input","def odd_generator(limit):\n current = 1\n while current < limit:\n yield current\n current = current + 2","def fission_pipes():\n def _pipes(num):\n return [base.BasePipe(i) for i in range(1, num + 1)]\n yield _pipes\n base.reset()","def stage1(self):\n n = self.min\n while True:\n n, bin_ = self.sort_to_bin(n)\n if n is None:\n n = self.get_new_n(bin_)\n if n is None:\n break\n if self.viz:\n yield","def testNumberPipeTwoLines(self):\n pl = Pipeline(loadInitFile=False)\n repl = REPL(pl)\n repl.runCommandLine('4')\n self.assertFalse(pl.inPipeline)\n self.assertEqual(4, pl.stdin)\n repl.runCommandLine('')\n self.assertEqual(4, pl.stdin)\n self.assertEqual(REPL.DEFAULT_PS1, repl.prompt)","def generatePrime(ls_primes, feed_pipe,return_dict):\n local_primes = []\n while True:\n n = feed_pipe.recv()\n if n == -1: # sentinel given by distributor.\n break\n else:\n is_prime = True\n\n ##check for divisibility\n ## no need to check for 2 since all are odd numbers\n for prime in ls_primes[1:]:\n if n%prime == 0:\n is_prime = False\n break\n\n ##if the number is prime, append to global list\n if is_prime:\n local_primes.append(n)\n if len(local_primes) >0:\n return_dict[os.getpid()] = local_primes\n return return_dict\n return 0","def io_pipe():\n r_fd, w_fd = os.pipe()\n with io.open(r_fd, 'rb', 0) as r, \\\n \t io.open(w_fd, 'wb', 0) as w:\n \tyield r, w","def fission_pipe():\n yield base.BasePipe(1)\n base.reset()","def run(self):\n assert len(self.elements) >= 2, \"In order flow, pipe needs 2 or more elements\"\n in_pipe = self.elements[0]\n other_pipes = self.elements[1:-1]\n out_pipe = self.elements[-1]\n\n self.make_assertions(in_pipe, other_pipes, out_pipe)\n\n for data in in_pipe.grasp():\n write = True\n\n for element in other_pipes:\n if isinstance(element, elements.DataPypElement):\n data = element.extend(data)\n elif isinstance(element, elements.FilterPypElement):\n if not element.stay(data):\n write = False\n break\n if write:\n out_pipe.extract(data)","def pipemeter(cmd1, cmd2):\n\n proc1 = subprocess.Popen(cmd1, bufsize=0, shell=True, stdout=subprocess.PIPE)\n proc2 = subprocess.Popen(cmd2, bufsize=0, shell=True, stdin=subprocess.PIPE)\n bytes_piped = 0\n\n while True:\n data = proc1.stdout.read(CHUNKSIZE)\n length = len(data)\n if length == 0:\n break\n\n written = proc2.stdin.write(data)\n if written != length:\n raise RuntimeError(\"Write failed, wanted to write: {}, written={}\".format(length, written))\n\n bytes_piped += length\n\n proc1.stdout.close()\n proc2.stdin.close()\n\n return proc1.wait(), proc2.wait(), bytes_piped","def run(self, data, rewrap=False, prefetch=0):\n if rewrap:\n data = [data]\n\n for pipe in self._pipes:\n pipe.feed(data)\n data = pipe\n else:\n iterable = self._prefetch_callable(data, prefetch) if prefetch else data\n for out_data in iterable:\n yield out_data","def test_1_single_process():\n\n # ********************************************************\n # We will put this function in its own thread in test_1()\n def put_data_in_stream(stream):\n num_steps=5\n step_size=4\n for i in range(num_steps):\n data = list(range(i*step_size, (i+1)*step_size))\n stream.extend(data)\n run()\n return\n\n # ********************************************************\n # We will put these lines in a separate process in test_1()\n x = Stream('x')\n y = Stream('y')\n double(x, y)\n\n # *********************************************************\n # We will put these lines in a separate process in test_1().\n s = Stream(name='s')\n increment(y, s)\n print_stream(s, name=s.name)\n\n # *********************************************************\n # This function is executed in a separate thread in test_1().\n put_data_in_stream(x)","def test_1_single_process():\n\n # ********************************************************\n # We will put this function in its own thread in test_1()\n def put_data_in_stream(stream):\n num_steps=5\n step_size=4\n for i in range(num_steps):\n data = list(range(i*step_size, (i+1)*step_size))\n stream.extend(data)\n run()\n return\n\n # ********************************************************\n # We will put these lines in a separate process in test_1()\n x = Stream('x')\n y = Stream('y')\n double(x, y)\n\n # *********************************************************\n # We will put these lines in a separate process in test_1().\n s = Stream(name='s')\n increment(y, s)\n print_stream(s, name=s.name)\n\n # *********************************************************\n # This function is executed in a separate thread in test_1().\n put_data_in_stream(x)","def get_pipes(self, num = 1):\n if self.api is None:\n self.api = ChessAPI(self)\n self.api.start()\n return [self.api.create_pipe() for _ in range(num)]","def testNumberPipeOneLine(self):\n pl = Pipeline(loadInitFile=False)\n repl = REPL(pl)\n repl.runCommandLine('4 |')\n self.assertAlmostEqual(4, pl.stdin)\n self.assertEqual(REPL.DEFAULT_PS1, repl.prompt)","def task_10_generator_of_simple_numbers() -> Generator[int, None, None]:\n def is_num_simple(n):\n \"\"\"\n Return: True if n is a simple number or False if it is not\n \"\"\"\n for i in range(n, 1, -1):\n if n % i == 0 and i < n and n != 1:\n return False\n return True\n\n # generator part\n n = 2\n while n < 200:\n if is_num_simple(n):\n yield n\n n = n + 1","def next_p2 (num):\n rval = 1\n while rval<num:\n rval <<= 1\n return rval","def run_alternate(bandit1:SlotMachine, bandit2: SlotMachine, num_pulls_to_do):\n using = bandit1\n other = bandit2\n\n num_pulls_so_far = 0\n winning_count = 0\n while num_pulls_so_far < num_pulls_to_do:\n did_I_win = using.pull()\n num_pulls_so_far += 1\n winning_count += did_I_win # an alternative to if did_I_win: winning_count += 1\n\n temp = using\n using = other\n other = temp\n\n return winning_count","def part_two(data: List[int]) -> int:\n app = IntCodeApplication(data, name=\"BOOST Part II\", flexible_memory=True)\n app.stdin.put(2)\n app.run()\n return app.stdout.get()","def integers():\n i = 1\n while True:\n yield i\n i = i + 1","def integers():\n i = 1\n while True:\n yield i\n i = i + 1","def test_io_in_out_loop(self):\n self.l.output(conf_io=0x1, state_io=0x0)\n for i in range(10):\n state_d, state_io, count = self.l.output(state_io=0x1)\n self.assertTrue(state_io & 0x2)\n state_d, state_io, count = self.l.output(state_io=0x0)\n self.assertTrue(not state_io & 0x2)","def incr(n=1):\n for i in xrange(n):\n pulse_hi(INCR)","def next_p2(num):\n rval = 1\n while rval < num:\n rval <<= 1\n return rval","def inout(input_, output_):\n while True:\n chunk = input_.read(1024)\n if not chunk:\n break\n output_.write(chunk)","def split_into_steps(processes, input_limit=None, input_liquid_limit=None, belt_type='blue'):\n\tdef limit(item, input=False):\n\t\tif input and is_liquid(item) and input_liquid_limit is not None:\n\t\t\treturn input_liquid_limit\n\t\telif input and not is_liquid(item) and input_limit is not None:\n\t\t\treturn input_limit\n\t\telse:\n\t\t\treturn line_limit(item, belt_type)\n\n\tresults = []\n\tinputs = []\n\tfor process in processes.values():\n\t\tsteps = max(\n\t\t\t[\n\t\t\t\tthroughput / limit(item, process.is_input)\n\t\t\t\tfor item, throughput in process.inputs().items()\n\t\t\t] + [\n\t\t\t\tthroughput / limit(item, process.is_input)\n\t\t\t\tfor item, throughput in process.outputs().items()\n\t\t\t]\n\t\t)\n\n\t\t# note steps is fractional. by dividing original throughput by perfect number of steps,\n\t\t# each such step would be maximal - the problem is there would need to be a fractional\n\t\t# step at the end. So we put down floor(steps) maximal steps, followed by a step\n\t\t# scaled down to represent the fractional step.\n\t\twhole_steps, leftover = divmod(steps, 1)\n\t\tmaximal_step = process.rescale(process.throughput / steps)\n\t\tfractional_step = maximal_step.rescale(maximal_step.throughput * leftover)\n\n\t\tpart = [maximal_step] * whole_steps\n\t\tif leftover:\n\t\t\tpart.append(fractional_step)\n\n\t\tif process.is_input:\n\t\t\tinputs += part\n\t\telse:\n\t\t\tresults += part\n\n\treturn results, inputs","def infinite_increment():\n i = 0\n while 1:\n yield i\n i += 1","def _limit_helper(stream: Union[BinaryIO, Generator, List], limit: int) -> Generator:\n for value in stream:\n yield value\n if limit == 1:\n return\n else:\n limit = limit - 1 # FIXME","def pipeline(filters):\n pipe = partial(reduce, lambda acc, f: f(acc), filters)\n bil = bilateral()\n\n def procme(img):\n img = bil(img)\n return pipe(img)\n\n return lambda img: map(procme, [img[:, :, 0], img[:, :, 1], img[:, :, 2]])","def _LessPipe():\n try:\n # pylint: disable=unexpected-keyword-arg\n proc = subprocess.Popen(['less'],\n stdin=subprocess.PIPE,\n stdout=sys.stdout,\n encoding='utf-8')\n yield proc.stdin\n proc.stdin.close()\n proc.wait()\n except IOError:\n pass # Happens when less is quit before all data is written.\n except KeyboardInterrupt:\n pass # Assume used to break out of less.","def test_pipe2():\n parser = CmdParser([posandtwo, valprog])\n out = parser.parse(\"posandtwo | valprog | posandtwo\")\n assert isinstance(out[0], ProgramNode)\n assert isinstance(out[1], PipeNode)\n assert isinstance(out[2], ProgramNode)\n assert isinstance(out[3], PipeNode)\n assert isinstance(out[4], ProgramNode)\n assert isinstance(out[5], EndOfCommandNode)","def skip(n):\n\n if n >= 0:\n @filters\n def _dagpype_internal_fn_act_p(target):\n remaining = n\n try:\n while True:\n e = (yield)\n if remaining == 0:\n target.send(e)\n continue\n t = e.shape[0]\n if t > remaining:\n target.send(e[remaining :])\n remaining = 0\n else:\n remaining -= t\n except GeneratorExit:\n target.close()\n\n return _dagpype_internal_fn_act_p\n\n @filters\n def _dagpype_internal_fn_act_n(target):\n m = -n\n pending = collections.deque([])\n try:\n while True:\n pending.append((yield))\n while len(pending) > 0:\n first = pending.popleft()\n if sum((e.shape[0] for e in pending)) >= m: \n target.send(first)\n else:\n pending.appendleft(first)\n break\n except GeneratorExit:\n if sum((e.shape[0] for e in pending)) < m:\n target.close()\n return\n while m > 0:\n e = pending.pop()\n if e.shape[0] < m:\n m -= e.shape[0]\n else:\n e = e[: e.shape[0] - m]\n if e.shape[0] > 0:\n pending.append(e)\n break\n while len(pending) > 0:\n e = pending.pop()\n target.send(e)\n target.close()\n\n return _dagpype_internal_fn_act_n","def stream_handler(args_dict: dict):\n\n color_sequence = args_dict['color_sequence']\n color_seq_len = args_dict['color_seq_len']\n color_itr = args_dict['color_itr']\n n_leds = args_dict['n_leds']\n\n step_sequence = [color_sequence[c % color_seq_len] for c in range(color_itr, n_leds + color_itr)]\n\n # Updating step for the next iteration.\n args_dict['color_itr'] = (color_itr + 1) % color_seq_len\n\n return step_sequence","def next(self, *input):\n self.log.info(\"Starting next for task %s\" % self.__class__.__name__)\n\n self.comm.Barrier()\n\n # This should only be called once.\n try:\n if self.done:\n raise pipeline.PipelineStopIteration()\n except AttributeError:\n self.done = True\n\n # Extract a list of the tags for all input arguments\n input_tags = [\n (\n str(icont.attrs.get(\"tag\"))\n if isinstance(icont, memh5.MemDiskGroup)\n else \"\"\n )\n for icont in input\n ]\n\n # Process input and fetch output\n if self._no_input:\n if len(input) > 0:\n # This should never happen. Just here to catch bugs.\n raise RuntimeError(\"Somehow `input` was set.\")\n output = self.process()\n else:\n output = self.process(*input)\n\n # Return immediately if output is None to skip writing phase.\n if output is None:\n return\n\n # Insert the input tags into the output container\n output.attrs[\"input_tags\"] = input_tags\n\n output = self._process_output(output)\n\n # Increment internal counter\n self._count = self._count + 1\n\n self.log.info(\"Leaving next for task %s\" % self.__class__.__name__)\n\n # Return the output for the next task\n return output","def power_readings():\n chain = [sin(x / (XMAX * 0.1)) * 0.1 + 0.6 for x in range(0, XMAX + 1)]\n cnt = 0\n\n def next():\n nonlocal chain, cnt\n next_reading = chain[cnt % len(chain)]\n cnt += 1\n return next_reading\n\n return next","def inner_pipe (linkp, pn, dt, links1, links2, utype, dtype, p,\n H0, V0, H, V, H10, V10, H20, V20, pump, valve,\n friction, dVdt, dVdx,\n dVdt10, dVdx10, dVdt20, dVdx20):\n\n # Properties of current pipe\n g = 9.8 # m/s^2\n link1 = [p[abs(i)-1] for i in links1]\n link2 = [p[abs(i)-1] for i in links2]\n n = linkp.number_of_segments # spatial discretization\n\n # inner nodes\n if friction == 'steady':\n H[1:-1], V[1:-1] = inner_node_steady(linkp, H0, V0, dt, g)\n elif friction == 'quasi-steady':\n H[1:-1], V[1:-1] = inner_node_quasisteady(linkp, H0, V0, dt, g)\n else:\n H[1:-1], V[1:-1] = inner_node_unsteady(linkp, H0, V0, dt, g,\n dVdx, dVdt)\n\n # Pipe start\n V1 = V10; H1 = H10 #list\n V2 = V0[1]; H2 = H0[1]\n dVdx1 = dVdx10 ; dVdt1 = dVdt10\n dVdx2 = dVdx[0]; dVdt2 = dVdt[1]\n\n if utype[0] == 'Pipe':\n if linkp.start_node.transient_node_type == 'SurgeTank':\n shape = linkp.start_node.tank_shape\n H[0], V[0], Qs = surge_tank(shape, link1, linkp,\n H1, V1, H2, V2, dt, g, 0, np.sign(links1), [-1],\n friction, dVdx1, dVdx2, dVdt1, dVdt2)\n linkp.start_node.water_level = H[0]\n linkp.start_node.tank_flow = Qs\n elif linkp.start_node.transient_node_type == 'Chamber':\n shape = linkp.start_node.tank_shape\n H[0], V[0], Qs, zp = air_chamber(shape, link1, linkp,\n H1, V1, H2, V2, dt, g, 0, np.sign(links1), [-1],\n friction, dVdx1, dVdx2, dVdt1, dVdt2)\n linkp.start_node.water_level = zp\n linkp.start_node.tank_flow = Qs\n else:\n elev = linkp.start_node.elevation\n emitter_coeff = linkp.start_node.emitter_coeff + linkp.start_node.demand_coeff\n block_per = linkp.start_node.block_per\n H[0], V[0] = add_leakage(emitter_coeff, block_per, link1, linkp, elev,\n H1, V1, H2, V2, dt, g, 0, np.sign(links1), [-1],\n friction, dVdx1, dVdx2, dVdt1, dVdt2)\n elif utype[0] == 'Pump':\n pumpc = pump[0]\n H[0], V[0] = pump_node(pumpc, link1, linkp,\n H1, V1, H2, V2, dt, g, 0, np.sign(links1), [-1],\n friction, dVdx1, dVdx2, dVdt1, dVdt2)\n elif utype[0] == 'Valve':\n valvec = valve[0]\n H[0], V[0] = valve_node(valvec, link1, linkp,\n H1, V1, H2, V2, dt, g, 0, np.sign(links1), [-1],\n friction, dVdx1, dVdx2, dVdt1, dVdt2)\n\n # Pipe end\n V1 = V0[n-1]; H1 = H0[n-1]\n V2 = V20; H2 = H20\n dVdx1 = dVdx[n-1] ; dVdt1 = dVdt[n-1]\n dVdx2 = dVdx20; dVdt2 = dVdt20\n if dtype[0] == 'Pipe':\n if linkp.end_node.transient_node_type == 'SurgeTank':\n shape = linkp.end_node.tank_shape\n H[n], V[n], Qs = surge_tank(shape, linkp, link2,\n H1, V1, H2, V2, dt, g, n, [1], np.sign(links2),\n friction, dVdx1, dVdx2, dVdt1, dVdt2)\n linkp.end_node.water_level = H[n]\n linkp.end_node.tank_flow = Qs\n elif linkp.end_node.transient_node_type == 'Chamber':\n shape = linkp.end_node.tank_shape\n H[n], V[n], Qs,zp = air_chamber(shape, linkp, link2,\n H1, V1, H2, V2, dt, g, n, [1], np.sign(links2),\n friction, dVdx1, dVdx2, dVdt1, dVdt2)\n linkp.end_node.water_level = zp\n linkp.end_node.tank_flow = Qs\n else:\n elev = linkp.end_node.elevation\n emitter_coeff = linkp.end_node.emitter_coeff + linkp.end_node.demand_coeff\n block_per = linkp.end_node.block_per\n H[n], V[n] = add_leakage(emitter_coeff, block_per,linkp, link2, elev,\n H1, V1, H2, V2, dt, g, n, [1], np.sign(links2),\n friction, dVdx1, dVdx2, dVdt1, dVdt2)\n elif dtype[0] == 'Pump':\n pumpc = pump[1]\n H[n], V[n] = pump_node(pumpc, linkp, link2,\n H1, V1, H2, V2, dt, g, n, [1], np.sign(links2),\n friction, dVdx1, dVdx2, dVdt1, dVdt2)\n\n elif dtype[0] == 'Valve':\n valvec = valve[1]\n H[n], V[n] = valve_node(valvec, linkp, link2,\n H1, V1, H2, V2, dt, g, n, [1], np.sign(links2),\n friction, dVdx1, dVdx2, dVdt1, dVdt2)\n return H, V","def run(outs, ins_filter='/dev/ttyUSB.*', newport=lambda conn: None, write_queue=None):\r\n data_queue = multiprocessing.Queue()\r\n\r\n multiprocessing.Process(\r\n target=writer,\r\n args=(data_queue, write_queue, outs)\r\n ).start()\r\n\r\n readers = {}\r\n\r\n while True:\r\n\r\n for (path, _, _) in serial.tools.list_ports.grep(ins_filter):\r\n\r\n if path not in readers.keys() or not readers[path].is_alive():\r\n\r\n readers[path] = multiprocessing.Process(\r\n target=reader, args=(data_queue, path, newport)\r\n )\r\n readers[path].start()","def interleave_bits(odd, even):\n val = 0\n max0 = max(odd, even)\n n = 0\n while (max0 > 0):\n n += 1\n max0 >>= 1\n for i in xrange(n):\n bitMask = 1 << i\n a = (1 << (2*i)) if (even & bitMask) > 0 else 0\n b = (1 << (2*i+1)) if (odd & bitMask) > 0 else 0\n val += a + b\n return val","def Barrier(nprocesses, signalIN, signalOUT):\t\n\twhile True:\n\t\tfor i in range (0,nprocesses):\n\t\t\tsignalIN()\n\t\tfor i in range (0,nprocesses):\n\t\t\tsignalOUT(0)","def readlines(self, n = None):\n\t\tif not self._input: raise PlumberExceptions.PipeTypeException(self)\n\t\tresult = []\n\t\twhile n == None or n > 0:\n\t\t\tline = self.readline()\n\t\t\tif not line: return result\n\t\t\tresult.append(line)\n\t\t\tn -= 1\n\t\treturn result","def _worker(pipelines: List[Pipeline], source: Queue, sink: Queue):\n pipelines = list(pipelines)\n for i, p in enumerate(pipelines):\n if isinstance(p, ConvertT2S):\n pipelines[i] = ConvertT2S()\n\n def processor(article):\n for p in pipelines:\n article = p(article)\n return article\n\n while True:\n article = source.get()\n if article == 'EXIT':\n return\n article = list(processor(article))\n sink.put(article)","def xorRange(num: int, floor: int, higher: int) -> Generator[Tuple[int, int], None, None]:\r\n assert 0 <= floor, \"floor must be non-negative\"\r\n assert 0 <= num, \"num must be non-negative\"\r\n\r\n digit = 0\r\n while floor < higher:\r\n if floor & 1:\r\n yield (floor ^ num) << digit, ((floor ^ num) + 1) << digit\r\n floor += 1\r\n if higher & 1:\r\n higher -= 1\r\n yield (higher ^ num) << digit, ((higher ^ num) + 1) << digit\r\n floor >>= 1\r\n higher >>= 1\r\n num >>= 1\r\n digit += 1","def consume(pipeline, seq):\n try:\n for value in seq:\n pipeline.send(value)\n except StopConsumption:\n pass","def odd_only(CC):\n if CC % 2 == 0 & CC > 0:\n CC -= 1\n if CC < 0:\n CC = 0\n while CC % 2 == 1:\n yield CC\n CC -= 2\n if CC == -1:\n break","def run(self):\r\n for pipe in self.inputs:\r\n for row in pipe.rows():\r\n self.put(row)","def broken_pipe_handler(func: Callable[[List[str]], int], arguments: List[str]) -> int:\n try:\n returncode = func(arguments)\n sys.stdout.flush()\n except BrokenPipeError:\n devnull = os.open(os.devnull, os.O_WRONLY)\n os.dup2(devnull, sys.stdout.fileno())\n # Convention is 128 + whatever the return code would otherwise be\n returncode = 128 + 1\n return returncode","def __call__(self, input=None): # pragma: no cover\n while False:\n yield None","def processes(start, end, processes):\n end_things = [processes[x][2] for x in range(len(processes))]\n if start == end or end not in end_things:\n return []\n\n seq = []\n seen = 0\n inp = ''\n out = ''\n do = ''\n \n for i in range(len(processes)):\n if processes[i][2] == end:\n out = processes[i][2]\n inp = processes[i][1]\n do = processes[i][0]\n seq.append(do)\n seen += 1\n break\n\n while seen < len(processes):\n for i in range(len(processes)):\n if processes[i][2] == inp:\n out = processes[i][2]\n inp = processes[i][1]\n do = processes[i][0]\n seq.append(do)\n seen += 1\n\n seq.reverse()\n return seq","def zpipe(ctx):\n a = ctx.socket(zmq.PAIR)\n b = ctx.socket(zmq.PAIR)\n a.linger = b.linger = 0\n a.hwm = b.hwm = 1\n iface = f\"inproc://{binascii.hexlify(os.urandom(8))}\"\n a.bind(iface)\n b.connect(iface)\n return a, b","def better_grouper(inputs, n):\n iters = [iter(inputs)] * n\n return zip(*iters)","def microbit_process(pipe):\n gamepad_listener = MicroBitListener(pipe)\n gamepad_listener.listen()","def parity(it):\n \n return sum(it)%2","def __rshift__(self, next: 'IO[TResult]') -> 'IO[TResult]':\n return self.bind(lambda _: next)","def rm_odd_numbers(int_list):\n output = []\n\n for item in int_list:\n if not item % 2:\n output.append(item)\n\n return output","def _split(self):\r\n \r\n temp = [self.upstream.demand]\r\n for item, p in zip(self.downstream, self.priority):\r\n temp.append(item.supply/p)\r\n \r\n flow = min(temp) # total flow\r\n \r\n self.upstream.outflow = flow\r\n \r\n for item, p in zip(self.downstream, self.priority):\r\n item.inflow = p * flow","def readValues(n):\n for i in xrange(n):\n yield int(raw_input().strip())","def readValues(n):\n for i in xrange(n):\n yield int(raw_input().strip())","def test_pipe_simple():\n\n def transform(array):\n \"\"\"Turns the (n,2) array into a (n,4) array.\"\"\"\n assert array.shape == (10, 2)\n new = Array(columns=\"abcd\")\n for x, y in array:\n new.append([x, y, x + y, x * y])\n return new\n\n group = Pipe(Group({\"a\": Numerical(), \"b\": Numerical()}), transform)\n for _ in range(10):\n group.set_a(1e-6 + random())\n group.set_b(1e-6 + random())\n group.push()\n\n array = group.array()\n assert array.shape == (10, 4)\n\n for row in array:\n assert row[0] > 0.0 and row[1] > 0.0\n assert row[2] == row[0] + row[1]\n assert row[3] == row[0] * row[1]","def output_to_pipe(pipe_in):\n os.dup2(pipe_in, 1) # stdout\n # os.dup2(pipe_in, 2) # stderr","def sort_012(input_list):\n i = 0\n next_0 = 0\n next_2 = len(input_list) - 1\n\n while i <= next_2:\n if input_list[i] == 0:\n input_list[i] = input_list[next_0]\n input_list[next_0] = 0\n next_0 += 1\n i += 1\n elif input_list[i] == 2:\n input_list[i] = input_list[next_2]\n input_list[next_2] = 2\n next_2 -= 1\n else:\n i += 1\n\n return input_list","def piped(self):\n\t\tpass","def process(self):\n\n count = 0\n total = 0\n\n while total < 200 and count < 10:\n digits = self._stream.read(2)\n if len(digits) < 2:\n break\n \n number = int(digits)\n \n total += number\n \n count += 1\n\n return count","def pair_stream(n):\n n_str = str(n)\n if len(n_str) % 2 != 0:\n n_str = '0' + n_str\n pairs = textwrap.wrap(n_str, 2)\n digit_pairs = [int(p) for p in pairs]\n return itertools.chain(digit_pairs, itertools.repeat(0))","def skipp(self):\n for x in range(4):\n self.fwd(right=100, left=100)\n time.sleep(.5)\n self.servo(1000)\n time.sleep(.1)\n self.servo(2000)\n time.sleep(.1)\n self.fwd(right=-100, left=-100)\n time.sleep(.1)\n self.servo(-1000)\n self.stop()","def demoChained():\n \n class ChainingSOFP(StreamingOutputFormattingProcess):\n def onStdoutLine(self, tag, line):\n super().onStdoutLine(tag, \"[{}] {}\".format(tag, line.decode()).encode())\n\n def onStderrLine(self, tag, line):\n super().onStderrLine(tag, \"[{}] {}\".format(tag, line.decode()).encode())\n if tag == \"main\" and b\"trigger\" in line:\n cmdChained = \"bash -c 'echo chained stdout && sleep 2 && echo stderr chained 1>&2 && sleep 1 && echo done chained'\"\n self.run(cmdChained, \"chained\")\n\n cmdInitial = \"bash -c 'echo stdout && sleep 1 && echo trigger chained 1>&2 && sleep 1 && echo more output && sleep 1 && echo done && exit 3'\"\n Spec = ChainingSOFP.OutputSpec\n sofp = ChainingSOFP(Spec(\"STDOUT: {}\"), Spec(\"STDERR: {}\", sys.stderr))\n status = sofp.run(cmdInitial, \"main\")\n print(\"Initial finished with status: {}.\".format(status))","def read(self, n = None):\n\t\tif not self._input: raise PlumberExceptions.PipeTypeException(self)\n\t\tsaved = self._state.read(n)\n\t\tif n == None:\n\t\t\treturn saved + pservlet.pipe_read(self._pipe_desc)\n\t\telif n == len(saved): \n\t\t\treturn saved\n\t\telse:\n\t\t\treturn saved + pservlet.pipe_read(self._pipe_desc, n - len(saved))","def next ( num = 1 ) :\n return run ( num )","def stream(_) -> int:\n return 1 << 9","def stream(_) -> int:\n return 1 << 9","def cmd_iter(cmd):\n\n def thread_enqueue(label, f, q):\n t = threading.Thread(target=enqueue_output, args=(label, f, q))\n t.daemon = True ## thread dies with the program\n t.start()\n return t\n\n def enqueue_output(label, out, queue):\n prev_line = None\n for line in out.read():\n if prev_line is not None:\n queue.put((label, \"%s\\n\" % prev_line))\n prev_line = line\n # print(\"%s: %r\" % (label, line))\n # print(\"END of %s\" % (label, ))\n if prev_line:\n queue.put((label, prev_line))\n out.close()\n\n proc = Proc(cmd)\n proc.stdin.close()\n q = Queue()\n t1 = thread_enqueue(\"out\", proc.stdout, q)\n t2 = thread_enqueue(\"err\", proc.stderr, q)\n running = True\n while True:\n try:\n yield q.get(True, 0.001)\n except Empty:\n if not running:\n break\n proc.poll()\n running = proc.returncode is None or \\\n any(t.is_alive() for t in (t1, t2))\n\n # print(\"%s: %r\" % (\"errlvl\", proc.returncode))\n yield \"errorlevel\", proc.returncode","def make_paired_end_reads(sequence):\n \n R1 = sequence[0:n]\n R2 = sequence[len(sequence) - n:len(sequence)]\n\n #one reads are reverse complement, so make reverse complement of R2\n R2 = make_reverse_complement(R2)\n\n return [R1, R2]","def _pipe_and_accumulate(val, fns):\n for fn in fns:\n val = fn(val)\n yield val","def partition(seq):\n\n return 0","def unroll_stream(\n stream: Generator, skip_first: bool = False, pbar: Union[bool, Sequence[Any]] = True\n) -> Any:\n # init\n obs = next(stream)\n\n obs_flat, treedef = tree_flatten(obs)\n num_leaves = len(obs_flat)\n\n # stream_scan\n def _init_outputs():\n if skip_first:\n return [[]] * num_leaves\n else:\n return list(map(lambda x: [x], obs_flat))\n\n outputs = _init_outputs()\n\n if pbar:\n stream = tqdm(stream, desc=\"stream_unroll\")\n\n for obs in stream:\n obs_flat = tree_leaves(obs)\n assert len(obs_flat) == num_leaves\n for y, x in zip(outputs, obs_flat):\n y.append(x)\n\n # stack outputs\n for i in range(num_leaves):\n outputs[i] = onp.stack(outputs[i])\n\n # transpose outputs\n return tree_unflatten(treedef, outputs)","def Piping(T_in, p_in, m_dot, d_inner, l_pipe, f, epsilon_pipe, T_shield, N):\r\n\r\n ## Estimation of the influence of the arcs\r\n # Calculation according to VDI Heatatlas 2013\r\n # Assumption isoenthalpic flow\r\n state_Arc = FlowRestriction(T_in, p_in, m_dot, d_inner, f)\r\n p_Arc = state_Arc.get(\"p\")\r\n T_Arc = state_Arc.get(\"T\")\r\n\r\n ## Estimation of the influence of thermal radiation on the compressible flow\r\n\r\n # Emission coefficent for an enclosed vessel\r\n # Assuming much bigger hot surface -> emissivity of hot surface doesnt matter anymore, just the cold one\r\n # Thus the simple equation can be used\r\n q_pipe = epsilon_pipe * sp.constants.Stefan_Boltzmann * (T_shield**4 - T_Arc**4) #W\r\n\r\n # Calling of the function SimplePipe\r\n state_out = SimplePipe(T_Arc, p_Arc, m_dot, d_inner, l_pipe, N, 0, q_pipe)\r\n #Transfer results\r\n p_out = state_out.get(\"p\")\r\n T_out = state_out.get(\"T\")\r\n h_out = state_out.get(\"h\")\r\n state_out = {\"h\": h_out, \"T\": T_out, \"p\": p_out}\r\n\r\n return state_out","def process(self, count):\n self.data.add_node(0)\n for index in range(1, count + 1):\n # print(\"{}.: {}\".format(index, self.data))\n self.data.move_circular(self.stepforward)\n self.data.add_node(index)\n return self.data.get_next()","def main():\n dt = DropToken()\n play = True\n while play:\n try:\n line = sys.stdin.readline()\n except KeyboardInterrupt:\n break\n if not line:\n break\n play = dt.inputProcess(line)","def generator(factor, current, condition=0):\n while True:\n next_current = factor * current % 2147483647\n if condition == 0 or (next_current % condition == 0):\n yield next_current\n current = next_current","def get_even_numbers(x, stop, z):\r\n result = []\r\n counter = 0\r\n while len(result) is not x:\r\n if counter % 2 == 0 and counter < stop and counter // z:\r\n result.append(counter)\r\n counter += 1\r\n return result","def e_seq():\n yield 2;\n for n in count(2, 2):\n yield 1\n yield n\n yield 1","def pipe(*functions):\n\n return reduce(compose, functions, identity)","def task5(count):\n number_1, number_2 = 1, 1\n for _ in range(count):\n yield number_1\n number_1, number_2 = number_2, number_1 + number_2","def connect_pipes(input, output, service=VoidService, config={}):\n return connect_stream(PipeStream(input, output), service=service, config=config)","def _order_streams(in1, in2, out1, out2):\n if in1.T < in2.T:\n return in1, in2, out1, out2\n else:\n return in2, in1, out2, out1","def pipes(self):\n for name in self._pipes:\n yield name, self._data[name]","def progression(first_item:int, amount:int,func):\n item = first_item\n count = 0\n stop = False\n while count < amount and not stop:\n stop = yield item\n item = func(item)\n count += 1","def ring_filter(data):\n out = 1\n for src in data:\n out *= src\n return out","def pow2(limit):\n i = 0\n bin_num = 1\n while bin_num <= limit:\n yield bin_num\n i += 1\n bin_num = 2 ** i","def step(nodes, outputs, edges):\n flowed = []\n for node_name in nodes.copy():\n if node_name in flowed:\n continue\n if len(nodes[node_name]) == 2:\n if node_name in flowed:\n continue\n node = [int(value) for value in nodes[node_name]]\n low_value, high_value = min(node), max(node)\n low_flow, high_flow = edges[node_name] \n low_dictionary, low_node_name = low_flow\n high_dictionary, high_node_name = high_flow\n low_node = low_dictionary.get(low_node_name, tuple())\n high_node = high_dictionary.get(high_node_name, tuple())\n low_dictionary[low_node_name] = low_node + (str(low_value),)\n high_dictionary[high_node_name] = high_node + (str(high_value),)\n nodes[node_name] = tuple()\n if low_dictionary is nodes:\n flowed.append(low_node_name)\n if high_dictionary is nodes:\n flowed.append(high_node_name)\n return nodes, outputs, edges","def test_pipe():\n parser = CmdParser([posandtwo, valprog])\n out = parser.parse(\"posandtwo | valprog\")\n assert isinstance(out[0], ProgramNode)\n assert out[0].program_desc == posandtwo\n assert isinstance(out[1], PipeNode)\n assert isinstance(out[2], ProgramNode)\n assert out[2].program_desc == valprog\n assert isinstance(out[3], EndOfCommandNode)","def mapper():\n\n for line in sys.stdin:\n data = line.strip().split(',')\n if len(data) != 22 or data[5] != 'REGULAR':\n continue\n print('{}\\t{}'.format(data[1], data[6]))","def binario(num):\n\tbi = []\n\tnum = abs(int(num))\n\twhile num >0:\n\t\tres = num % 2\n\t\tbi.append(res)\n\n\t\tnum = num //2\n\n\treturn bi","def processData(pipe, event, pulses):\n logging.info(\"Started processData\")\n start_time = time.time()\n for pulse in range(pulses):\n samples = pipe.get()\n# time.sleep(0.001)\n end_time = time.time()\n elapsed = end_time - start_time\n samplesProcessed = (pulses * len(samples[0]) * len(samples))\n logging.info(\"processData processed %d Msamples in %.3f s\",\n samplesProcessed / 1e6,\n elapsed)\n logging.info(\"processData rate: %.3f Msa/s in lumps of %d samples\",\n samplesProcessed / elapsed / 1e6,\n dig.pointsPerCycle)","def part2():\n\n program = IntCodeProcessor.load_program('day13input.txt')\n program[0] = 2\n cpu = IntCodeProcessor(program)\n result = None\n next_input = None\n ball_pos = None\n paddle_pos = None\n score = None\n while result is None:\n try:\n result = cpu.execute_program(next_input, reset=False)\n except ExecutionError as err:\n assert err.reason == ExecutionCode.NEED_INPUT\n\n ball_pos, paddle_pos, score = process_output(cpu.outputs, ball_pos, paddle_pos, score)\n cpu.outputs = []\n next_input = next_input_for(ball_pos, paddle_pos)\n print(f'Part 2 answer: {score}')","def algo(a: int, b: int) -> int:\n\n while b != 0:\n a, b = b, a % b\n return a","def even_odd_sums(seq):\n even = seq[0::2]\n odd = seq[1::2]\n return [sum(even), sum(odd)]","def stream():\n while True:\n yield random_point()","def range_with_status(total):\n n = 0\n while n < total:\n done = '#' * (n+1)\n todo = '-'*(total-n-1)\n s = '<{0}>'.format(done+todo)\n if not todo:\n s += '\\n'\n if n > 0:\n s = '\\r'+s\n print(s, end='')\n yield n\n n += 1"],"string":"[\n \"def odd():\\n num = 0\\n while True:\\n yield num * (num & 1)\\n num += 1\",\n \"def infinite_odd_generator():\\n current = 1\\n while True:\\n yield current\\n current = current + 2\",\n \"def input_pipe():\\n x = ''\\n while True:\\n x = yield x\\n yield # to keep the generator in lock step with input\",\n \"def odd_generator(limit):\\n current = 1\\n while current < limit:\\n yield current\\n current = current + 2\",\n \"def fission_pipes():\\n def _pipes(num):\\n return [base.BasePipe(i) for i in range(1, num + 1)]\\n yield _pipes\\n base.reset()\",\n \"def stage1(self):\\n n = self.min\\n while True:\\n n, bin_ = self.sort_to_bin(n)\\n if n is None:\\n n = self.get_new_n(bin_)\\n if n is None:\\n break\\n if self.viz:\\n yield\",\n \"def testNumberPipeTwoLines(self):\\n pl = Pipeline(loadInitFile=False)\\n repl = REPL(pl)\\n repl.runCommandLine('4')\\n self.assertFalse(pl.inPipeline)\\n self.assertEqual(4, pl.stdin)\\n repl.runCommandLine('')\\n self.assertEqual(4, pl.stdin)\\n self.assertEqual(REPL.DEFAULT_PS1, repl.prompt)\",\n \"def generatePrime(ls_primes, feed_pipe,return_dict):\\n local_primes = []\\n while True:\\n n = feed_pipe.recv()\\n if n == -1: # sentinel given by distributor.\\n break\\n else:\\n is_prime = True\\n\\n ##check for divisibility\\n ## no need to check for 2 since all are odd numbers\\n for prime in ls_primes[1:]:\\n if n%prime == 0:\\n is_prime = False\\n break\\n\\n ##if the number is prime, append to global list\\n if is_prime:\\n local_primes.append(n)\\n if len(local_primes) >0:\\n return_dict[os.getpid()] = local_primes\\n return return_dict\\n return 0\",\n \"def io_pipe():\\n r_fd, w_fd = os.pipe()\\n with io.open(r_fd, 'rb', 0) as r, \\\\\\n \\t io.open(w_fd, 'wb', 0) as w:\\n \\tyield r, w\",\n \"def fission_pipe():\\n yield base.BasePipe(1)\\n base.reset()\",\n \"def run(self):\\n assert len(self.elements) >= 2, \\\"In order flow, pipe needs 2 or more elements\\\"\\n in_pipe = self.elements[0]\\n other_pipes = self.elements[1:-1]\\n out_pipe = self.elements[-1]\\n\\n self.make_assertions(in_pipe, other_pipes, out_pipe)\\n\\n for data in in_pipe.grasp():\\n write = True\\n\\n for element in other_pipes:\\n if isinstance(element, elements.DataPypElement):\\n data = element.extend(data)\\n elif isinstance(element, elements.FilterPypElement):\\n if not element.stay(data):\\n write = False\\n break\\n if write:\\n out_pipe.extract(data)\",\n \"def pipemeter(cmd1, cmd2):\\n\\n proc1 = subprocess.Popen(cmd1, bufsize=0, shell=True, stdout=subprocess.PIPE)\\n proc2 = subprocess.Popen(cmd2, bufsize=0, shell=True, stdin=subprocess.PIPE)\\n bytes_piped = 0\\n\\n while True:\\n data = proc1.stdout.read(CHUNKSIZE)\\n length = len(data)\\n if length == 0:\\n break\\n\\n written = proc2.stdin.write(data)\\n if written != length:\\n raise RuntimeError(\\\"Write failed, wanted to write: {}, written={}\\\".format(length, written))\\n\\n bytes_piped += length\\n\\n proc1.stdout.close()\\n proc2.stdin.close()\\n\\n return proc1.wait(), proc2.wait(), bytes_piped\",\n \"def run(self, data, rewrap=False, prefetch=0):\\n if rewrap:\\n data = [data]\\n\\n for pipe in self._pipes:\\n pipe.feed(data)\\n data = pipe\\n else:\\n iterable = self._prefetch_callable(data, prefetch) if prefetch else data\\n for out_data in iterable:\\n yield out_data\",\n \"def test_1_single_process():\\n\\n # ********************************************************\\n # We will put this function in its own thread in test_1()\\n def put_data_in_stream(stream):\\n num_steps=5\\n step_size=4\\n for i in range(num_steps):\\n data = list(range(i*step_size, (i+1)*step_size))\\n stream.extend(data)\\n run()\\n return\\n\\n # ********************************************************\\n # We will put these lines in a separate process in test_1()\\n x = Stream('x')\\n y = Stream('y')\\n double(x, y)\\n\\n # *********************************************************\\n # We will put these lines in a separate process in test_1().\\n s = Stream(name='s')\\n increment(y, s)\\n print_stream(s, name=s.name)\\n\\n # *********************************************************\\n # This function is executed in a separate thread in test_1().\\n put_data_in_stream(x)\",\n \"def test_1_single_process():\\n\\n # ********************************************************\\n # We will put this function in its own thread in test_1()\\n def put_data_in_stream(stream):\\n num_steps=5\\n step_size=4\\n for i in range(num_steps):\\n data = list(range(i*step_size, (i+1)*step_size))\\n stream.extend(data)\\n run()\\n return\\n\\n # ********************************************************\\n # We will put these lines in a separate process in test_1()\\n x = Stream('x')\\n y = Stream('y')\\n double(x, y)\\n\\n # *********************************************************\\n # We will put these lines in a separate process in test_1().\\n s = Stream(name='s')\\n increment(y, s)\\n print_stream(s, name=s.name)\\n\\n # *********************************************************\\n # This function is executed in a separate thread in test_1().\\n put_data_in_stream(x)\",\n \"def get_pipes(self, num = 1):\\n if self.api is None:\\n self.api = ChessAPI(self)\\n self.api.start()\\n return [self.api.create_pipe() for _ in range(num)]\",\n \"def testNumberPipeOneLine(self):\\n pl = Pipeline(loadInitFile=False)\\n repl = REPL(pl)\\n repl.runCommandLine('4 |')\\n self.assertAlmostEqual(4, pl.stdin)\\n self.assertEqual(REPL.DEFAULT_PS1, repl.prompt)\",\n \"def task_10_generator_of_simple_numbers() -> Generator[int, None, None]:\\n def is_num_simple(n):\\n \\\"\\\"\\\"\\n Return: True if n is a simple number or False if it is not\\n \\\"\\\"\\\"\\n for i in range(n, 1, -1):\\n if n % i == 0 and i < n and n != 1:\\n return False\\n return True\\n\\n # generator part\\n n = 2\\n while n < 200:\\n if is_num_simple(n):\\n yield n\\n n = n + 1\",\n \"def next_p2 (num):\\n rval = 1\\n while rval<num:\\n rval <<= 1\\n return rval\",\n \"def run_alternate(bandit1:SlotMachine, bandit2: SlotMachine, num_pulls_to_do):\\n using = bandit1\\n other = bandit2\\n\\n num_pulls_so_far = 0\\n winning_count = 0\\n while num_pulls_so_far < num_pulls_to_do:\\n did_I_win = using.pull()\\n num_pulls_so_far += 1\\n winning_count += did_I_win # an alternative to if did_I_win: winning_count += 1\\n\\n temp = using\\n using = other\\n other = temp\\n\\n return winning_count\",\n \"def part_two(data: List[int]) -> int:\\n app = IntCodeApplication(data, name=\\\"BOOST Part II\\\", flexible_memory=True)\\n app.stdin.put(2)\\n app.run()\\n return app.stdout.get()\",\n \"def integers():\\n i = 1\\n while True:\\n yield i\\n i = i + 1\",\n \"def integers():\\n i = 1\\n while True:\\n yield i\\n i = i + 1\",\n \"def test_io_in_out_loop(self):\\n self.l.output(conf_io=0x1, state_io=0x0)\\n for i in range(10):\\n state_d, state_io, count = self.l.output(state_io=0x1)\\n self.assertTrue(state_io & 0x2)\\n state_d, state_io, count = self.l.output(state_io=0x0)\\n self.assertTrue(not state_io & 0x2)\",\n \"def incr(n=1):\\n for i in xrange(n):\\n pulse_hi(INCR)\",\n \"def next_p2(num):\\n rval = 1\\n while rval < num:\\n rval <<= 1\\n return rval\",\n \"def inout(input_, output_):\\n while True:\\n chunk = input_.read(1024)\\n if not chunk:\\n break\\n output_.write(chunk)\",\n \"def split_into_steps(processes, input_limit=None, input_liquid_limit=None, belt_type='blue'):\\n\\tdef limit(item, input=False):\\n\\t\\tif input and is_liquid(item) and input_liquid_limit is not None:\\n\\t\\t\\treturn input_liquid_limit\\n\\t\\telif input and not is_liquid(item) and input_limit is not None:\\n\\t\\t\\treturn input_limit\\n\\t\\telse:\\n\\t\\t\\treturn line_limit(item, belt_type)\\n\\n\\tresults = []\\n\\tinputs = []\\n\\tfor process in processes.values():\\n\\t\\tsteps = max(\\n\\t\\t\\t[\\n\\t\\t\\t\\tthroughput / limit(item, process.is_input)\\n\\t\\t\\t\\tfor item, throughput in process.inputs().items()\\n\\t\\t\\t] + [\\n\\t\\t\\t\\tthroughput / limit(item, process.is_input)\\n\\t\\t\\t\\tfor item, throughput in process.outputs().items()\\n\\t\\t\\t]\\n\\t\\t)\\n\\n\\t\\t# note steps is fractional. by dividing original throughput by perfect number of steps,\\n\\t\\t# each such step would be maximal - the problem is there would need to be a fractional\\n\\t\\t# step at the end. So we put down floor(steps) maximal steps, followed by a step\\n\\t\\t# scaled down to represent the fractional step.\\n\\t\\twhole_steps, leftover = divmod(steps, 1)\\n\\t\\tmaximal_step = process.rescale(process.throughput / steps)\\n\\t\\tfractional_step = maximal_step.rescale(maximal_step.throughput * leftover)\\n\\n\\t\\tpart = [maximal_step] * whole_steps\\n\\t\\tif leftover:\\n\\t\\t\\tpart.append(fractional_step)\\n\\n\\t\\tif process.is_input:\\n\\t\\t\\tinputs += part\\n\\t\\telse:\\n\\t\\t\\tresults += part\\n\\n\\treturn results, inputs\",\n \"def infinite_increment():\\n i = 0\\n while 1:\\n yield i\\n i += 1\",\n \"def _limit_helper(stream: Union[BinaryIO, Generator, List], limit: int) -> Generator:\\n for value in stream:\\n yield value\\n if limit == 1:\\n return\\n else:\\n limit = limit - 1 # FIXME\",\n \"def pipeline(filters):\\n pipe = partial(reduce, lambda acc, f: f(acc), filters)\\n bil = bilateral()\\n\\n def procme(img):\\n img = bil(img)\\n return pipe(img)\\n\\n return lambda img: map(procme, [img[:, :, 0], img[:, :, 1], img[:, :, 2]])\",\n \"def _LessPipe():\\n try:\\n # pylint: disable=unexpected-keyword-arg\\n proc = subprocess.Popen(['less'],\\n stdin=subprocess.PIPE,\\n stdout=sys.stdout,\\n encoding='utf-8')\\n yield proc.stdin\\n proc.stdin.close()\\n proc.wait()\\n except IOError:\\n pass # Happens when less is quit before all data is written.\\n except KeyboardInterrupt:\\n pass # Assume used to break out of less.\",\n \"def test_pipe2():\\n parser = CmdParser([posandtwo, valprog])\\n out = parser.parse(\\\"posandtwo | valprog | posandtwo\\\")\\n assert isinstance(out[0], ProgramNode)\\n assert isinstance(out[1], PipeNode)\\n assert isinstance(out[2], ProgramNode)\\n assert isinstance(out[3], PipeNode)\\n assert isinstance(out[4], ProgramNode)\\n assert isinstance(out[5], EndOfCommandNode)\",\n \"def skip(n):\\n\\n if n >= 0:\\n @filters\\n def _dagpype_internal_fn_act_p(target):\\n remaining = n\\n try:\\n while True:\\n e = (yield)\\n if remaining == 0:\\n target.send(e)\\n continue\\n t = e.shape[0]\\n if t > remaining:\\n target.send(e[remaining :])\\n remaining = 0\\n else:\\n remaining -= t\\n except GeneratorExit:\\n target.close()\\n\\n return _dagpype_internal_fn_act_p\\n\\n @filters\\n def _dagpype_internal_fn_act_n(target):\\n m = -n\\n pending = collections.deque([])\\n try:\\n while True:\\n pending.append((yield))\\n while len(pending) > 0:\\n first = pending.popleft()\\n if sum((e.shape[0] for e in pending)) >= m: \\n target.send(first)\\n else:\\n pending.appendleft(first)\\n break\\n except GeneratorExit:\\n if sum((e.shape[0] for e in pending)) < m:\\n target.close()\\n return\\n while m > 0:\\n e = pending.pop()\\n if e.shape[0] < m:\\n m -= e.shape[0]\\n else:\\n e = e[: e.shape[0] - m]\\n if e.shape[0] > 0:\\n pending.append(e)\\n break\\n while len(pending) > 0:\\n e = pending.pop()\\n target.send(e)\\n target.close()\\n\\n return _dagpype_internal_fn_act_n\",\n \"def stream_handler(args_dict: dict):\\n\\n color_sequence = args_dict['color_sequence']\\n color_seq_len = args_dict['color_seq_len']\\n color_itr = args_dict['color_itr']\\n n_leds = args_dict['n_leds']\\n\\n step_sequence = [color_sequence[c % color_seq_len] for c in range(color_itr, n_leds + color_itr)]\\n\\n # Updating step for the next iteration.\\n args_dict['color_itr'] = (color_itr + 1) % color_seq_len\\n\\n return step_sequence\",\n \"def next(self, *input):\\n self.log.info(\\\"Starting next for task %s\\\" % self.__class__.__name__)\\n\\n self.comm.Barrier()\\n\\n # This should only be called once.\\n try:\\n if self.done:\\n raise pipeline.PipelineStopIteration()\\n except AttributeError:\\n self.done = True\\n\\n # Extract a list of the tags for all input arguments\\n input_tags = [\\n (\\n str(icont.attrs.get(\\\"tag\\\"))\\n if isinstance(icont, memh5.MemDiskGroup)\\n else \\\"\\\"\\n )\\n for icont in input\\n ]\\n\\n # Process input and fetch output\\n if self._no_input:\\n if len(input) > 0:\\n # This should never happen. Just here to catch bugs.\\n raise RuntimeError(\\\"Somehow `input` was set.\\\")\\n output = self.process()\\n else:\\n output = self.process(*input)\\n\\n # Return immediately if output is None to skip writing phase.\\n if output is None:\\n return\\n\\n # Insert the input tags into the output container\\n output.attrs[\\\"input_tags\\\"] = input_tags\\n\\n output = self._process_output(output)\\n\\n # Increment internal counter\\n self._count = self._count + 1\\n\\n self.log.info(\\\"Leaving next for task %s\\\" % self.__class__.__name__)\\n\\n # Return the output for the next task\\n return output\",\n \"def power_readings():\\n chain = [sin(x / (XMAX * 0.1)) * 0.1 + 0.6 for x in range(0, XMAX + 1)]\\n cnt = 0\\n\\n def next():\\n nonlocal chain, cnt\\n next_reading = chain[cnt % len(chain)]\\n cnt += 1\\n return next_reading\\n\\n return next\",\n \"def inner_pipe (linkp, pn, dt, links1, links2, utype, dtype, p,\\n H0, V0, H, V, H10, V10, H20, V20, pump, valve,\\n friction, dVdt, dVdx,\\n dVdt10, dVdx10, dVdt20, dVdx20):\\n\\n # Properties of current pipe\\n g = 9.8 # m/s^2\\n link1 = [p[abs(i)-1] for i in links1]\\n link2 = [p[abs(i)-1] for i in links2]\\n n = linkp.number_of_segments # spatial discretization\\n\\n # inner nodes\\n if friction == 'steady':\\n H[1:-1], V[1:-1] = inner_node_steady(linkp, H0, V0, dt, g)\\n elif friction == 'quasi-steady':\\n H[1:-1], V[1:-1] = inner_node_quasisteady(linkp, H0, V0, dt, g)\\n else:\\n H[1:-1], V[1:-1] = inner_node_unsteady(linkp, H0, V0, dt, g,\\n dVdx, dVdt)\\n\\n # Pipe start\\n V1 = V10; H1 = H10 #list\\n V2 = V0[1]; H2 = H0[1]\\n dVdx1 = dVdx10 ; dVdt1 = dVdt10\\n dVdx2 = dVdx[0]; dVdt2 = dVdt[1]\\n\\n if utype[0] == 'Pipe':\\n if linkp.start_node.transient_node_type == 'SurgeTank':\\n shape = linkp.start_node.tank_shape\\n H[0], V[0], Qs = surge_tank(shape, link1, linkp,\\n H1, V1, H2, V2, dt, g, 0, np.sign(links1), [-1],\\n friction, dVdx1, dVdx2, dVdt1, dVdt2)\\n linkp.start_node.water_level = H[0]\\n linkp.start_node.tank_flow = Qs\\n elif linkp.start_node.transient_node_type == 'Chamber':\\n shape = linkp.start_node.tank_shape\\n H[0], V[0], Qs, zp = air_chamber(shape, link1, linkp,\\n H1, V1, H2, V2, dt, g, 0, np.sign(links1), [-1],\\n friction, dVdx1, dVdx2, dVdt1, dVdt2)\\n linkp.start_node.water_level = zp\\n linkp.start_node.tank_flow = Qs\\n else:\\n elev = linkp.start_node.elevation\\n emitter_coeff = linkp.start_node.emitter_coeff + linkp.start_node.demand_coeff\\n block_per = linkp.start_node.block_per\\n H[0], V[0] = add_leakage(emitter_coeff, block_per, link1, linkp, elev,\\n H1, V1, H2, V2, dt, g, 0, np.sign(links1), [-1],\\n friction, dVdx1, dVdx2, dVdt1, dVdt2)\\n elif utype[0] == 'Pump':\\n pumpc = pump[0]\\n H[0], V[0] = pump_node(pumpc, link1, linkp,\\n H1, V1, H2, V2, dt, g, 0, np.sign(links1), [-1],\\n friction, dVdx1, dVdx2, dVdt1, dVdt2)\\n elif utype[0] == 'Valve':\\n valvec = valve[0]\\n H[0], V[0] = valve_node(valvec, link1, linkp,\\n H1, V1, H2, V2, dt, g, 0, np.sign(links1), [-1],\\n friction, dVdx1, dVdx2, dVdt1, dVdt2)\\n\\n # Pipe end\\n V1 = V0[n-1]; H1 = H0[n-1]\\n V2 = V20; H2 = H20\\n dVdx1 = dVdx[n-1] ; dVdt1 = dVdt[n-1]\\n dVdx2 = dVdx20; dVdt2 = dVdt20\\n if dtype[0] == 'Pipe':\\n if linkp.end_node.transient_node_type == 'SurgeTank':\\n shape = linkp.end_node.tank_shape\\n H[n], V[n], Qs = surge_tank(shape, linkp, link2,\\n H1, V1, H2, V2, dt, g, n, [1], np.sign(links2),\\n friction, dVdx1, dVdx2, dVdt1, dVdt2)\\n linkp.end_node.water_level = H[n]\\n linkp.end_node.tank_flow = Qs\\n elif linkp.end_node.transient_node_type == 'Chamber':\\n shape = linkp.end_node.tank_shape\\n H[n], V[n], Qs,zp = air_chamber(shape, linkp, link2,\\n H1, V1, H2, V2, dt, g, n, [1], np.sign(links2),\\n friction, dVdx1, dVdx2, dVdt1, dVdt2)\\n linkp.end_node.water_level = zp\\n linkp.end_node.tank_flow = Qs\\n else:\\n elev = linkp.end_node.elevation\\n emitter_coeff = linkp.end_node.emitter_coeff + linkp.end_node.demand_coeff\\n block_per = linkp.end_node.block_per\\n H[n], V[n] = add_leakage(emitter_coeff, block_per,linkp, link2, elev,\\n H1, V1, H2, V2, dt, g, n, [1], np.sign(links2),\\n friction, dVdx1, dVdx2, dVdt1, dVdt2)\\n elif dtype[0] == 'Pump':\\n pumpc = pump[1]\\n H[n], V[n] = pump_node(pumpc, linkp, link2,\\n H1, V1, H2, V2, dt, g, n, [1], np.sign(links2),\\n friction, dVdx1, dVdx2, dVdt1, dVdt2)\\n\\n elif dtype[0] == 'Valve':\\n valvec = valve[1]\\n H[n], V[n] = valve_node(valvec, linkp, link2,\\n H1, V1, H2, V2, dt, g, n, [1], np.sign(links2),\\n friction, dVdx1, dVdx2, dVdt1, dVdt2)\\n return H, V\",\n \"def run(outs, ins_filter='/dev/ttyUSB.*', newport=lambda conn: None, write_queue=None):\\r\\n data_queue = multiprocessing.Queue()\\r\\n\\r\\n multiprocessing.Process(\\r\\n target=writer,\\r\\n args=(data_queue, write_queue, outs)\\r\\n ).start()\\r\\n\\r\\n readers = {}\\r\\n\\r\\n while True:\\r\\n\\r\\n for (path, _, _) in serial.tools.list_ports.grep(ins_filter):\\r\\n\\r\\n if path not in readers.keys() or not readers[path].is_alive():\\r\\n\\r\\n readers[path] = multiprocessing.Process(\\r\\n target=reader, args=(data_queue, path, newport)\\r\\n )\\r\\n readers[path].start()\",\n \"def interleave_bits(odd, even):\\n val = 0\\n max0 = max(odd, even)\\n n = 0\\n while (max0 > 0):\\n n += 1\\n max0 >>= 1\\n for i in xrange(n):\\n bitMask = 1 << i\\n a = (1 << (2*i)) if (even & bitMask) > 0 else 0\\n b = (1 << (2*i+1)) if (odd & bitMask) > 0 else 0\\n val += a + b\\n return val\",\n \"def Barrier(nprocesses, signalIN, signalOUT):\\t\\n\\twhile True:\\n\\t\\tfor i in range (0,nprocesses):\\n\\t\\t\\tsignalIN()\\n\\t\\tfor i in range (0,nprocesses):\\n\\t\\t\\tsignalOUT(0)\",\n \"def readlines(self, n = None):\\n\\t\\tif not self._input: raise PlumberExceptions.PipeTypeException(self)\\n\\t\\tresult = []\\n\\t\\twhile n == None or n > 0:\\n\\t\\t\\tline = self.readline()\\n\\t\\t\\tif not line: return result\\n\\t\\t\\tresult.append(line)\\n\\t\\t\\tn -= 1\\n\\t\\treturn result\",\n \"def _worker(pipelines: List[Pipeline], source: Queue, sink: Queue):\\n pipelines = list(pipelines)\\n for i, p in enumerate(pipelines):\\n if isinstance(p, ConvertT2S):\\n pipelines[i] = ConvertT2S()\\n\\n def processor(article):\\n for p in pipelines:\\n article = p(article)\\n return article\\n\\n while True:\\n article = source.get()\\n if article == 'EXIT':\\n return\\n article = list(processor(article))\\n sink.put(article)\",\n \"def xorRange(num: int, floor: int, higher: int) -> Generator[Tuple[int, int], None, None]:\\r\\n assert 0 <= floor, \\\"floor must be non-negative\\\"\\r\\n assert 0 <= num, \\\"num must be non-negative\\\"\\r\\n\\r\\n digit = 0\\r\\n while floor < higher:\\r\\n if floor & 1:\\r\\n yield (floor ^ num) << digit, ((floor ^ num) + 1) << digit\\r\\n floor += 1\\r\\n if higher & 1:\\r\\n higher -= 1\\r\\n yield (higher ^ num) << digit, ((higher ^ num) + 1) << digit\\r\\n floor >>= 1\\r\\n higher >>= 1\\r\\n num >>= 1\\r\\n digit += 1\",\n \"def consume(pipeline, seq):\\n try:\\n for value in seq:\\n pipeline.send(value)\\n except StopConsumption:\\n pass\",\n \"def odd_only(CC):\\n if CC % 2 == 0 & CC > 0:\\n CC -= 1\\n if CC < 0:\\n CC = 0\\n while CC % 2 == 1:\\n yield CC\\n CC -= 2\\n if CC == -1:\\n break\",\n \"def run(self):\\r\\n for pipe in self.inputs:\\r\\n for row in pipe.rows():\\r\\n self.put(row)\",\n \"def broken_pipe_handler(func: Callable[[List[str]], int], arguments: List[str]) -> int:\\n try:\\n returncode = func(arguments)\\n sys.stdout.flush()\\n except BrokenPipeError:\\n devnull = os.open(os.devnull, os.O_WRONLY)\\n os.dup2(devnull, sys.stdout.fileno())\\n # Convention is 128 + whatever the return code would otherwise be\\n returncode = 128 + 1\\n return returncode\",\n \"def __call__(self, input=None): # pragma: no cover\\n while False:\\n yield None\",\n \"def processes(start, end, processes):\\n end_things = [processes[x][2] for x in range(len(processes))]\\n if start == end or end not in end_things:\\n return []\\n\\n seq = []\\n seen = 0\\n inp = ''\\n out = ''\\n do = ''\\n \\n for i in range(len(processes)):\\n if processes[i][2] == end:\\n out = processes[i][2]\\n inp = processes[i][1]\\n do = processes[i][0]\\n seq.append(do)\\n seen += 1\\n break\\n\\n while seen < len(processes):\\n for i in range(len(processes)):\\n if processes[i][2] == inp:\\n out = processes[i][2]\\n inp = processes[i][1]\\n do = processes[i][0]\\n seq.append(do)\\n seen += 1\\n\\n seq.reverse()\\n return seq\",\n \"def zpipe(ctx):\\n a = ctx.socket(zmq.PAIR)\\n b = ctx.socket(zmq.PAIR)\\n a.linger = b.linger = 0\\n a.hwm = b.hwm = 1\\n iface = f\\\"inproc://{binascii.hexlify(os.urandom(8))}\\\"\\n a.bind(iface)\\n b.connect(iface)\\n return a, b\",\n \"def better_grouper(inputs, n):\\n iters = [iter(inputs)] * n\\n return zip(*iters)\",\n \"def microbit_process(pipe):\\n gamepad_listener = MicroBitListener(pipe)\\n gamepad_listener.listen()\",\n \"def parity(it):\\n \\n return sum(it)%2\",\n \"def __rshift__(self, next: 'IO[TResult]') -> 'IO[TResult]':\\n return self.bind(lambda _: next)\",\n \"def rm_odd_numbers(int_list):\\n output = []\\n\\n for item in int_list:\\n if not item % 2:\\n output.append(item)\\n\\n return output\",\n \"def _split(self):\\r\\n \\r\\n temp = [self.upstream.demand]\\r\\n for item, p in zip(self.downstream, self.priority):\\r\\n temp.append(item.supply/p)\\r\\n \\r\\n flow = min(temp) # total flow\\r\\n \\r\\n self.upstream.outflow = flow\\r\\n \\r\\n for item, p in zip(self.downstream, self.priority):\\r\\n item.inflow = p * flow\",\n \"def readValues(n):\\n for i in xrange(n):\\n yield int(raw_input().strip())\",\n \"def readValues(n):\\n for i in xrange(n):\\n yield int(raw_input().strip())\",\n \"def test_pipe_simple():\\n\\n def transform(array):\\n \\\"\\\"\\\"Turns the (n,2) array into a (n,4) array.\\\"\\\"\\\"\\n assert array.shape == (10, 2)\\n new = Array(columns=\\\"abcd\\\")\\n for x, y in array:\\n new.append([x, y, x + y, x * y])\\n return new\\n\\n group = Pipe(Group({\\\"a\\\": Numerical(), \\\"b\\\": Numerical()}), transform)\\n for _ in range(10):\\n group.set_a(1e-6 + random())\\n group.set_b(1e-6 + random())\\n group.push()\\n\\n array = group.array()\\n assert array.shape == (10, 4)\\n\\n for row in array:\\n assert row[0] > 0.0 and row[1] > 0.0\\n assert row[2] == row[0] + row[1]\\n assert row[3] == row[0] * row[1]\",\n \"def output_to_pipe(pipe_in):\\n os.dup2(pipe_in, 1) # stdout\\n # os.dup2(pipe_in, 2) # stderr\",\n \"def sort_012(input_list):\\n i = 0\\n next_0 = 0\\n next_2 = len(input_list) - 1\\n\\n while i <= next_2:\\n if input_list[i] == 0:\\n input_list[i] = input_list[next_0]\\n input_list[next_0] = 0\\n next_0 += 1\\n i += 1\\n elif input_list[i] == 2:\\n input_list[i] = input_list[next_2]\\n input_list[next_2] = 2\\n next_2 -= 1\\n else:\\n i += 1\\n\\n return input_list\",\n \"def piped(self):\\n\\t\\tpass\",\n \"def process(self):\\n\\n count = 0\\n total = 0\\n\\n while total < 200 and count < 10:\\n digits = self._stream.read(2)\\n if len(digits) < 2:\\n break\\n \\n number = int(digits)\\n \\n total += number\\n \\n count += 1\\n\\n return count\",\n \"def pair_stream(n):\\n n_str = str(n)\\n if len(n_str) % 2 != 0:\\n n_str = '0' + n_str\\n pairs = textwrap.wrap(n_str, 2)\\n digit_pairs = [int(p) for p in pairs]\\n return itertools.chain(digit_pairs, itertools.repeat(0))\",\n \"def skipp(self):\\n for x in range(4):\\n self.fwd(right=100, left=100)\\n time.sleep(.5)\\n self.servo(1000)\\n time.sleep(.1)\\n self.servo(2000)\\n time.sleep(.1)\\n self.fwd(right=-100, left=-100)\\n time.sleep(.1)\\n self.servo(-1000)\\n self.stop()\",\n \"def demoChained():\\n \\n class ChainingSOFP(StreamingOutputFormattingProcess):\\n def onStdoutLine(self, tag, line):\\n super().onStdoutLine(tag, \\\"[{}] {}\\\".format(tag, line.decode()).encode())\\n\\n def onStderrLine(self, tag, line):\\n super().onStderrLine(tag, \\\"[{}] {}\\\".format(tag, line.decode()).encode())\\n if tag == \\\"main\\\" and b\\\"trigger\\\" in line:\\n cmdChained = \\\"bash -c 'echo chained stdout && sleep 2 && echo stderr chained 1>&2 && sleep 1 && echo done chained'\\\"\\n self.run(cmdChained, \\\"chained\\\")\\n\\n cmdInitial = \\\"bash -c 'echo stdout && sleep 1 && echo trigger chained 1>&2 && sleep 1 && echo more output && sleep 1 && echo done && exit 3'\\\"\\n Spec = ChainingSOFP.OutputSpec\\n sofp = ChainingSOFP(Spec(\\\"STDOUT: {}\\\"), Spec(\\\"STDERR: {}\\\", sys.stderr))\\n status = sofp.run(cmdInitial, \\\"main\\\")\\n print(\\\"Initial finished with status: {}.\\\".format(status))\",\n \"def read(self, n = None):\\n\\t\\tif not self._input: raise PlumberExceptions.PipeTypeException(self)\\n\\t\\tsaved = self._state.read(n)\\n\\t\\tif n == None:\\n\\t\\t\\treturn saved + pservlet.pipe_read(self._pipe_desc)\\n\\t\\telif n == len(saved): \\n\\t\\t\\treturn saved\\n\\t\\telse:\\n\\t\\t\\treturn saved + pservlet.pipe_read(self._pipe_desc, n - len(saved))\",\n \"def next ( num = 1 ) :\\n return run ( num )\",\n \"def stream(_) -> int:\\n return 1 << 9\",\n \"def stream(_) -> int:\\n return 1 << 9\",\n \"def cmd_iter(cmd):\\n\\n def thread_enqueue(label, f, q):\\n t = threading.Thread(target=enqueue_output, args=(label, f, q))\\n t.daemon = True ## thread dies with the program\\n t.start()\\n return t\\n\\n def enqueue_output(label, out, queue):\\n prev_line = None\\n for line in out.read():\\n if prev_line is not None:\\n queue.put((label, \\\"%s\\\\n\\\" % prev_line))\\n prev_line = line\\n # print(\\\"%s: %r\\\" % (label, line))\\n # print(\\\"END of %s\\\" % (label, ))\\n if prev_line:\\n queue.put((label, prev_line))\\n out.close()\\n\\n proc = Proc(cmd)\\n proc.stdin.close()\\n q = Queue()\\n t1 = thread_enqueue(\\\"out\\\", proc.stdout, q)\\n t2 = thread_enqueue(\\\"err\\\", proc.stderr, q)\\n running = True\\n while True:\\n try:\\n yield q.get(True, 0.001)\\n except Empty:\\n if not running:\\n break\\n proc.poll()\\n running = proc.returncode is None or \\\\\\n any(t.is_alive() for t in (t1, t2))\\n\\n # print(\\\"%s: %r\\\" % (\\\"errlvl\\\", proc.returncode))\\n yield \\\"errorlevel\\\", proc.returncode\",\n \"def make_paired_end_reads(sequence):\\n \\n R1 = sequence[0:n]\\n R2 = sequence[len(sequence) - n:len(sequence)]\\n\\n #one reads are reverse complement, so make reverse complement of R2\\n R2 = make_reverse_complement(R2)\\n\\n return [R1, R2]\",\n \"def _pipe_and_accumulate(val, fns):\\n for fn in fns:\\n val = fn(val)\\n yield val\",\n \"def partition(seq):\\n\\n return 0\",\n \"def unroll_stream(\\n stream: Generator, skip_first: bool = False, pbar: Union[bool, Sequence[Any]] = True\\n) -> Any:\\n # init\\n obs = next(stream)\\n\\n obs_flat, treedef = tree_flatten(obs)\\n num_leaves = len(obs_flat)\\n\\n # stream_scan\\n def _init_outputs():\\n if skip_first:\\n return [[]] * num_leaves\\n else:\\n return list(map(lambda x: [x], obs_flat))\\n\\n outputs = _init_outputs()\\n\\n if pbar:\\n stream = tqdm(stream, desc=\\\"stream_unroll\\\")\\n\\n for obs in stream:\\n obs_flat = tree_leaves(obs)\\n assert len(obs_flat) == num_leaves\\n for y, x in zip(outputs, obs_flat):\\n y.append(x)\\n\\n # stack outputs\\n for i in range(num_leaves):\\n outputs[i] = onp.stack(outputs[i])\\n\\n # transpose outputs\\n return tree_unflatten(treedef, outputs)\",\n \"def Piping(T_in, p_in, m_dot, d_inner, l_pipe, f, epsilon_pipe, T_shield, N):\\r\\n\\r\\n ## Estimation of the influence of the arcs\\r\\n # Calculation according to VDI Heatatlas 2013\\r\\n # Assumption isoenthalpic flow\\r\\n state_Arc = FlowRestriction(T_in, p_in, m_dot, d_inner, f)\\r\\n p_Arc = state_Arc.get(\\\"p\\\")\\r\\n T_Arc = state_Arc.get(\\\"T\\\")\\r\\n\\r\\n ## Estimation of the influence of thermal radiation on the compressible flow\\r\\n\\r\\n # Emission coefficent for an enclosed vessel\\r\\n # Assuming much bigger hot surface -> emissivity of hot surface doesnt matter anymore, just the cold one\\r\\n # Thus the simple equation can be used\\r\\n q_pipe = epsilon_pipe * sp.constants.Stefan_Boltzmann * (T_shield**4 - T_Arc**4) #W\\r\\n\\r\\n # Calling of the function SimplePipe\\r\\n state_out = SimplePipe(T_Arc, p_Arc, m_dot, d_inner, l_pipe, N, 0, q_pipe)\\r\\n #Transfer results\\r\\n p_out = state_out.get(\\\"p\\\")\\r\\n T_out = state_out.get(\\\"T\\\")\\r\\n h_out = state_out.get(\\\"h\\\")\\r\\n state_out = {\\\"h\\\": h_out, \\\"T\\\": T_out, \\\"p\\\": p_out}\\r\\n\\r\\n return state_out\",\n \"def process(self, count):\\n self.data.add_node(0)\\n for index in range(1, count + 1):\\n # print(\\\"{}.: {}\\\".format(index, self.data))\\n self.data.move_circular(self.stepforward)\\n self.data.add_node(index)\\n return self.data.get_next()\",\n \"def main():\\n dt = DropToken()\\n play = True\\n while play:\\n try:\\n line = sys.stdin.readline()\\n except KeyboardInterrupt:\\n break\\n if not line:\\n break\\n play = dt.inputProcess(line)\",\n \"def generator(factor, current, condition=0):\\n while True:\\n next_current = factor * current % 2147483647\\n if condition == 0 or (next_current % condition == 0):\\n yield next_current\\n current = next_current\",\n \"def get_even_numbers(x, stop, z):\\r\\n result = []\\r\\n counter = 0\\r\\n while len(result) is not x:\\r\\n if counter % 2 == 0 and counter < stop and counter // z:\\r\\n result.append(counter)\\r\\n counter += 1\\r\\n return result\",\n \"def e_seq():\\n yield 2;\\n for n in count(2, 2):\\n yield 1\\n yield n\\n yield 1\",\n \"def pipe(*functions):\\n\\n return reduce(compose, functions, identity)\",\n \"def task5(count):\\n number_1, number_2 = 1, 1\\n for _ in range(count):\\n yield number_1\\n number_1, number_2 = number_2, number_1 + number_2\",\n \"def connect_pipes(input, output, service=VoidService, config={}):\\n return connect_stream(PipeStream(input, output), service=service, config=config)\",\n \"def _order_streams(in1, in2, out1, out2):\\n if in1.T < in2.T:\\n return in1, in2, out1, out2\\n else:\\n return in2, in1, out2, out1\",\n \"def pipes(self):\\n for name in self._pipes:\\n yield name, self._data[name]\",\n \"def progression(first_item:int, amount:int,func):\\n item = first_item\\n count = 0\\n stop = False\\n while count < amount and not stop:\\n stop = yield item\\n item = func(item)\\n count += 1\",\n \"def ring_filter(data):\\n out = 1\\n for src in data:\\n out *= src\\n return out\",\n \"def pow2(limit):\\n i = 0\\n bin_num = 1\\n while bin_num <= limit:\\n yield bin_num\\n i += 1\\n bin_num = 2 ** i\",\n \"def step(nodes, outputs, edges):\\n flowed = []\\n for node_name in nodes.copy():\\n if node_name in flowed:\\n continue\\n if len(nodes[node_name]) == 2:\\n if node_name in flowed:\\n continue\\n node = [int(value) for value in nodes[node_name]]\\n low_value, high_value = min(node), max(node)\\n low_flow, high_flow = edges[node_name] \\n low_dictionary, low_node_name = low_flow\\n high_dictionary, high_node_name = high_flow\\n low_node = low_dictionary.get(low_node_name, tuple())\\n high_node = high_dictionary.get(high_node_name, tuple())\\n low_dictionary[low_node_name] = low_node + (str(low_value),)\\n high_dictionary[high_node_name] = high_node + (str(high_value),)\\n nodes[node_name] = tuple()\\n if low_dictionary is nodes:\\n flowed.append(low_node_name)\\n if high_dictionary is nodes:\\n flowed.append(high_node_name)\\n return nodes, outputs, edges\",\n \"def test_pipe():\\n parser = CmdParser([posandtwo, valprog])\\n out = parser.parse(\\\"posandtwo | valprog\\\")\\n assert isinstance(out[0], ProgramNode)\\n assert out[0].program_desc == posandtwo\\n assert isinstance(out[1], PipeNode)\\n assert isinstance(out[2], ProgramNode)\\n assert out[2].program_desc == valprog\\n assert isinstance(out[3], EndOfCommandNode)\",\n \"def mapper():\\n\\n for line in sys.stdin:\\n data = line.strip().split(',')\\n if len(data) != 22 or data[5] != 'REGULAR':\\n continue\\n print('{}\\\\t{}'.format(data[1], data[6]))\",\n \"def binario(num):\\n\\tbi = []\\n\\tnum = abs(int(num))\\n\\twhile num >0:\\n\\t\\tres = num % 2\\n\\t\\tbi.append(res)\\n\\n\\t\\tnum = num //2\\n\\n\\treturn bi\",\n \"def processData(pipe, event, pulses):\\n logging.info(\\\"Started processData\\\")\\n start_time = time.time()\\n for pulse in range(pulses):\\n samples = pipe.get()\\n# time.sleep(0.001)\\n end_time = time.time()\\n elapsed = end_time - start_time\\n samplesProcessed = (pulses * len(samples[0]) * len(samples))\\n logging.info(\\\"processData processed %d Msamples in %.3f s\\\",\\n samplesProcessed / 1e6,\\n elapsed)\\n logging.info(\\\"processData rate: %.3f Msa/s in lumps of %d samples\\\",\\n samplesProcessed / elapsed / 1e6,\\n dig.pointsPerCycle)\",\n \"def part2():\\n\\n program = IntCodeProcessor.load_program('day13input.txt')\\n program[0] = 2\\n cpu = IntCodeProcessor(program)\\n result = None\\n next_input = None\\n ball_pos = None\\n paddle_pos = None\\n score = None\\n while result is None:\\n try:\\n result = cpu.execute_program(next_input, reset=False)\\n except ExecutionError as err:\\n assert err.reason == ExecutionCode.NEED_INPUT\\n\\n ball_pos, paddle_pos, score = process_output(cpu.outputs, ball_pos, paddle_pos, score)\\n cpu.outputs = []\\n next_input = next_input_for(ball_pos, paddle_pos)\\n print(f'Part 2 answer: {score}')\",\n \"def algo(a: int, b: int) -> int:\\n\\n while b != 0:\\n a, b = b, a % b\\n return a\",\n \"def even_odd_sums(seq):\\n even = seq[0::2]\\n odd = seq[1::2]\\n return [sum(even), sum(odd)]\",\n \"def stream():\\n while True:\\n yield random_point()\",\n \"def range_with_status(total):\\n n = 0\\n while n < total:\\n done = '#' * (n+1)\\n todo = '-'*(total-n-1)\\n s = '<{0}>'.format(done+todo)\\n if not todo:\\n s += '\\\\n'\\n if n > 0:\\n s = '\\\\r'+s\\n print(s, end='')\\n yield n\\n n += 1\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5789352","0.5761657","0.5741719","0.564393","0.52422297","0.51917","0.50984246","0.50861835","0.5054945","0.50331575","0.50145054","0.5011917","0.50026035","0.49603093","0.49603093","0.4935153","0.49219003","0.49094537","0.4875977","0.4841634","0.48397136","0.4836972","0.4836972","0.4836903","0.4833675","0.4786137","0.4757106","0.47484192","0.47403568","0.47188297","0.46804073","0.4680056","0.46638858","0.46535045","0.46494767","0.4640372","0.46219885","0.4616029","0.4614172","0.45958653","0.45601532","0.45490527","0.45465764","0.45464134","0.45383313","0.45381302","0.45289934","0.45063296","0.44881156","0.44873834","0.44822907","0.44757962","0.44757175","0.44571972","0.44567752","0.44527715","0.4452481","0.44428644","0.44428644","0.44414747","0.4440443","0.4440408","0.4438423","0.4433434","0.44272584","0.44245097","0.44186425","0.4409343","0.44079348","0.44056123","0.44056123","0.4402442","0.43886682","0.4387215","0.43811455","0.43806687","0.43659988","0.43630558","0.43622518","0.43620506","0.43543762","0.43530148","0.4351027","0.4346529","0.43351042","0.4334508","0.43311596","0.43236965","0.43235353","0.43196285","0.4318981","0.43175405","0.43173966","0.4316531","0.43110257","0.43098044","0.43086824","0.4307655","0.43069398","0.43057218"],"string":"[\n \"0.5789352\",\n \"0.5761657\",\n \"0.5741719\",\n \"0.564393\",\n \"0.52422297\",\n \"0.51917\",\n \"0.50984246\",\n \"0.50861835\",\n \"0.5054945\",\n \"0.50331575\",\n \"0.50145054\",\n \"0.5011917\",\n \"0.50026035\",\n \"0.49603093\",\n \"0.49603093\",\n \"0.4935153\",\n \"0.49219003\",\n \"0.49094537\",\n \"0.4875977\",\n \"0.4841634\",\n \"0.48397136\",\n \"0.4836972\",\n \"0.4836972\",\n \"0.4836903\",\n \"0.4833675\",\n \"0.4786137\",\n \"0.4757106\",\n \"0.47484192\",\n \"0.47403568\",\n \"0.47188297\",\n \"0.46804073\",\n \"0.4680056\",\n \"0.46638858\",\n \"0.46535045\",\n \"0.46494767\",\n \"0.4640372\",\n \"0.46219885\",\n \"0.4616029\",\n \"0.4614172\",\n \"0.45958653\",\n \"0.45601532\",\n \"0.45490527\",\n \"0.45465764\",\n \"0.45464134\",\n \"0.45383313\",\n \"0.45381302\",\n \"0.45289934\",\n \"0.45063296\",\n \"0.44881156\",\n \"0.44873834\",\n \"0.44822907\",\n \"0.44757962\",\n \"0.44757175\",\n \"0.44571972\",\n \"0.44567752\",\n \"0.44527715\",\n \"0.4452481\",\n \"0.44428644\",\n \"0.44428644\",\n \"0.44414747\",\n \"0.4440443\",\n \"0.4440408\",\n \"0.4438423\",\n \"0.4433434\",\n \"0.44272584\",\n \"0.44245097\",\n \"0.44186425\",\n \"0.4409343\",\n \"0.44079348\",\n \"0.44056123\",\n \"0.44056123\",\n \"0.4402442\",\n \"0.43886682\",\n \"0.4387215\",\n \"0.43811455\",\n \"0.43806687\",\n \"0.43659988\",\n \"0.43630558\",\n \"0.43622518\",\n \"0.43620506\",\n \"0.43543762\",\n \"0.43530148\",\n \"0.4351027\",\n \"0.4346529\",\n \"0.43351042\",\n \"0.4334508\",\n \"0.43311596\",\n \"0.43236965\",\n \"0.43235353\",\n \"0.43196285\",\n \"0.4318981\",\n \"0.43175405\",\n \"0.43173966\",\n \"0.4316531\",\n \"0.43110257\",\n \"0.43098044\",\n \"0.43086824\",\n \"0.4307655\",\n \"0.43069398\",\n \"0.43057218\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.68875015"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":8782,"cells":{"query":{"kind":"string","value":"will take numbers sequentially from feed_pipe, verify if it is prime. any primes found will be returned as a dict to main process. dict contains only one key value pair. val is always a list."},"document":{"kind":"string","value":"def generatePrime(ls_primes, feed_pipe,return_dict):\n local_primes = []\n while True:\n n = feed_pipe.recv()\n if n == -1: # sentinel given by distributor.\n break\n else:\n is_prime = True\n\n ##check for divisibility\n ## no need to check for 2 since all are odd numbers\n for prime in ls_primes[1:]:\n if n%prime == 0:\n is_prime = False\n break\n\n ##if the number is prime, append to global list\n if is_prime:\n local_primes.append(n)\n if len(local_primes) >0:\n return_dict[os.getpid()] = local_primes\n return return_dict\n return 0"},"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 worker(nums, outdict):\n for n in nums:\n outdict[n] = primes2(n)","def primes():\n D = {} # map composite integers to primes witnessing their compositeness\n q = 2 # first integer to test for primality\n while True:\n if q not in D:\n yield q # not marked composite, must be prime\n D[q*q] = [q] # first multiple of q not already marked\n else:\n for p in D[q]: # move each witness to its next multiple\n D.setdefault(p+q,[]).append(p)\n del D[q] # no longer need D[q], free memory\n q += 1","def distributor(ls_feed_pipe_open,low,high):\n def getNumber(low,high):\n i = low\n if i%2 == 0: #if i is even, then start from i+1 odd.\n i += 1\n while i<=high:\n yield i\n i+=2 #no need to check for even numbers, so skip it here at begining\n yield -1 #when generator yields -1, it reached high, so terminate\n\n next_pipe = 0\n number = getNumber(low,high)\n while True:\n msg = next(number)\n if msg == -1: #to check when generator reached high.\n break\n else:\n #feed pipes in a round robin fashion,\n #so that over time each generatePrime process experiences same load.\n ls_feed_pipe_open[next_pipe].send(msg)\n next_pipe += 1\n if next_pipe == len(ls_feed_pipe_open):\n next_pipe = 0\n for p in ls_feed_pipe_open:\n p.send(-1) #-1 is sentinel value for all generatePrime processs\n return 0","def getNums():\n key = allprimes() # Empty list for key is created\n\n # Runs code endlessly as no instruction was\n while True: # given to end the code\n num = input(\"Please enter a number:\") # Changed number to integer as it's outputted\n try: # as a string from input\n selected_num = int(num) # Asked for number with try function\n except:\n print(\"\\n Please input only a number!\") # Only accepts a number\n continue\n if selected_num > 100: # Limits number to 100 as that was limit\n print(\"Please only select a number up to 100.\")\n continue\n if selected_num in key:\n print(\"You have picked a prime number please select another number.\")\n continue\n for i, number in enumerate(key): # Iterator function to run through key\n complementary = selected_num - number # Initiated formula\n if complementary in key[i:]: # Obtained complimentary number if available\n print(str(selected_num) + \" = {} + {}\".format(number, complementary))\n break # Printed values as requested for assignment","def allprimes():\n\n key = [] # The empty list is initiated\n\n for val in range(2, 101): # Set to obtain all prime values from 2 to 100\n if val >= 2: # They are then stored into the list\n for n in range(2, val): # The values have to be greater than 2 as 1 cannot\n if not (val % n): # be included\n break # Pulls all prime numbers by iterating through them\n else: # If a number does not obtain a remainder that means\n key.append(val) # it cannot be divisable by anything but it's own\n # number it is appended as a prime number\n return key","def primes(count):\n\n prime_list = []\n num = 2\n\n while count > 0:\n\n if prime_checker(num):\n prime_list.append(num)\n count -= 1\n num += 1\n\n return prime_list","def primes(count):\n\n prime_numbers = [2]\n next_num = 3 \n\n def is_prime(next_num):\n if next_num % 2 == 0:\n return False \n \n for i in range(3, next_num, 2):\n if next_num % i == 0:\n return False \n return True \n\n while count > len(prime_numbers): \n if is_prime(next_num): \n prime_numbers.append(next_num)\n next_num += 1\n\n return prime_numbers","def test_prime_12(self):\n\t self.assertTrue(prime_generator(12), [2, 3, 5, 7, 11])","def test_prime_10(self):\n\t self.assertTrue(prime_generator(10), [2, 3, 5, 7])","def get_primes(self, startnum=2):\n i = startnum\n while True:\n if self.is_prime(i):\n yield i\n i += 1","def primes():\n yield 1\n primes = []\n for n in itertools.count(2):\n if not any(n % p == 0 for p in primes):\n # No divisor found among previous primes\n yield n\n primes.append(n)","def prime_generator():\r\n # map of composites (key) with at least one prime factor in list as value\r\n D = {}\r\n\r\n # first number to test if prime\r\n q = 2\r\n\r\n while 1:\r\n if q not in D:\r\n # next prime found\r\n yield q\r\n # add it's square as a composite to D\r\n D[q**2] = [q]\r\n else:\r\n # update dictionary entries based on composite and its listed primes\r\n for p in D[q]:\r\n D.setdefault(p+q, []).append(p)\r\n del D[q]\r\n q += 1","def primes():\r\n try:\r\n args = request.args\r\n start_num, end_num = validate_request(args)\r\n # cache key\r\n key = f'primes:{start_num}:{end_num}'\r\n rv = cache.get(key)\r\n if rv is None: # not in cache\r\n job = get_primes_list.queue(start_num, end_num)\r\n print(job.get_id())\r\n cache.set(key, job.get_id(), timeout=3600)\r\n return jsonify(job.get_id()), 200\r\n else:\r\n return jsonify(rv), 200\r\n except Exception as e:\r\n raise InvalidUsage(\"Error Processing request {}\".format(e))","def gen_primes():\n # Maps composites to primes witnessing their compositeness.\n # This is memory efficient, as the sieve is not \"run forward\"\n # indefinitely, but only as long as required by the current\n # number being tested.\n\n D = {}\n\n # The running integer that's checked for primeness\n\n q = 2\n\n while True:\n if q not in D:\n # q is a new prime.\n # Yield it and mark its first multiple that isn't\n # already marked in previous iterations\n yield q\n D[q * q] = [q]\n else:\n # q is composite. D[q] is the list of primes that\n # divide it. Since we've reached q, we no longer\n # need it in the map, but we'll mark the next\n # multiples of its witnesses to prepare for larger\n # numbers\n for p in D[q]:\n D.setdefault(p + q, []).append(p)\n del D[q]\n\n q += 1","def primes():\n yield 2\n found_primes = [2]\n a = 3\n while True:\n for p in found_primes:\n if p**2 > a:\n found_primes.append(a)\n yield a\n a += 2\n break\n elif a % p == 0:\n a += 2\n break","def find_prime(num):\n\n if not isinstance(num, int) or isinstance(num, bool):\n raise TypeError(\"number input must be an integer\")\n\n if num <= 1:\n raise ValueError(\"number must be greater than 1\")\n\n pri_num = [2]\n\n # The code below will test if every iteration of 'var' is a prime number\n for var in range(2, num + 1):\n res = 0\n for var2 in pri_num:\n if var == 2:\n break\n elif (var % var2) == 0:\n break\n elif (var2 == pri_num[-1]):\n res = var\n if res:\n pri_num.append(res)\n print(pri_num)\n\n return 0","def gen_primes():\n\n # Maps composites to primes witnessing their compositeness.\n # This is memory efficient, as the sieve is not \"run forward\"\n # indefinitely, but only as long as required by the current number\n # being tested\n\n D = {}\n\n # The runing integer that is checked for primeness\n q = 2\n\n while True:\n if q not in D:\n # q is a new prime.\n # Yield it and mark its first multiple that isn't\n # already marked in previous iterations\n\n yield q\n D[q * q] = [q]\n else:\n # q is composite. D[q] is the list of primes that\n # divide it. Since we've reached q, we no longer\n # need it in the map, but we'll mark the next multiples\n # of its witnesses to prepare for larger numbers\n\n for p in D[q]:\n D.setdefault(p + q, []).append(p)\n del D[q]\n\n q += 1","def gen_primes():\n\n # Maps composites (=non-primes) to primes witnessing their compositeness.\n # This is memory efficient, as the sieve is not \"run forward\" indefinitely,\n # but only as long as required by the current number being tested.\n D = {}\n\n q = 1 # the running integer that is checked for primeness\n while (q := q+1):\n if q not in D:\n # q is a new prime. Yield it and mark its first multiple that is\n # not already marked in previous iterations\n yield q\n D[q*q] = [q]\n else:\n # q is composite. D[q] is the list of primes that divide it. Since\n # we have reached q, we no longer need it in the map, but we will\n # mark the next multiples of its witnesses to prepare for larger\n # numbers\n for p in D[q]:\n D.setdefault(p+q, []).append(p)\n del D[q]","def test_prime_2(self):\n\t self.assertTrue(prime_generator(2), [2])","def primes():\n yield 2\n found = []\n for i in itertools.count(start=3, step=2):\n for p in found:\n if i % p == 0:\n break\n else:\n yield i\n found.append(i)","def check_prime_worker(job_queue):\n while True:\n # your code here\n # 1. get next available number from queue\n try:\n number = job_queue.get(block=False)\n print(f\"Process {current_process()} checks number {number}\")\n except Empty:\n break\n\n # 2. print the number and whether it\n # is prime or not, use is_prime()\n if is_prime(number):\n print(f\"{number} is prime\")\n else:\n print(f\"{number} is not prime\")\n\n # 3. use try/except to catch Empty exception\n # and quit the loop if no number remains in queue\n # done in step 1","def primeIterator(no = 0,lessThan = None ):\r\n \r\n prmd = {2:1,3:2}\r\n sqrtn = 2\r\n l = 1\r\n count = 0\r\n #or (no==-1 and not lessThan) l < no or:\r\n print(\"no\", no)\r\n while ((no!=0 and count < no) or ( (no==0) and (lessThan and l<lessThan ) or (not lessThan ) ))and (l<4) :\r\n if l in prmd:\r\n count += 1\r\n yield l\r\n l+=1\r\n l=5\r\n add = 2\r\n \r\n while (no!=0 and count < no) or ( (no==0) and ( (lessThan and l<lessThan ) or (not lessThan )) ) : #check only 6n-1 and 6n+1\r\n if l > sqrtn**2:\r\n sqrtn = l**0.5\r\n for i in prmd:\r\n if i > sqrtn:\r\n prmd[l] = len(prmd)\r\n add = 2 if add==4 else 2\r\n count +=1\r\n yield l\r\n break\r\n if l%i ==0 : \r\n break\r\n l+=add","def test_15(self):\n\t self.assertTrue(prime_generator(15), [2, 3, 5, 7, 11, 13])","def getPrime(bits):\n\twhile(True) :\n\t\t# on continue a tirer des nombres tant que l'on n'a pas trouve de nombre premier\n\t\tp = getrandbits(bits)\n\t\tif(miller_rabin(p,100)) :\n\t\t\treturn p","def prime_generator() -> int:\n \n #Start with the first prime.\n counter = count(2)\n candidate = next(counter)\n cache: list = [candidate]\n yield candidate\n \n # Set a flag.\n divisible = False\n while True:\n candidate = next(counter)\n # Check if the candidate is prime.\n for number in cache:\n # If number is greater than the squareroot of candidate, we are done.\n if number * number > candidate:\n break\n # If number divides candidate, candidate is not prime.\n if candidate % number == 0:\n divisible = True\n break\n # If is is prime, add it to the list.\n if not divisible:\n cache.append(candidate)\n yield candidate\n # Reset the flag.\n divisible = False","def getPrime(self, group=17):\n default_group = 17\n\n primes = {\n 5: 0xFFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3DC2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F83655D23DCA3AD961C62F356208552BB9ED529077096966D670C354E4ABC9804F1746C08CA237327FFFFFFFFFFFFFFFF,\n 14: 0xFFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3DC2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F83655D23DCA3AD961C62F356208552BB9ED529077096966D670C354E4ABC9804F1746C08CA18217C32905E462E36CE3BE39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF6955817183995497CEA956AE515D2261898FA051015728E5A8AACAA68FFFFFFFFFFFFFFFF,\n 15: 0xFFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3DC2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F83655D23DCA3AD961C62F356208552BB9ED529077096966D670C354E4ABC9804F1746C08CA18217C32905E462E36CE3BE39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF6955817183995497CEA956AE515D2261898FA051015728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6BF12FFA06D98A0864D87602733EC86A64521F2B18177B200CBBE117577A615D6C770988C0BAD946E208E24FA074E5AB3143DB5BFCE0FD108E4B82D120A93AD2CAFFFFFFFFFFFFFFFF,\n 16: 0xFFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3DC2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F83655D23DCA3AD961C62F356208552BB9ED529077096966D670C354E4ABC9804F1746C08CA18217C32905E462E36CE3BE39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF6955817183995497CEA956AE515D2261898FA051015728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6BF12FFA06D98A0864D87602733EC86A64521F2B18177B200CBBE117577A615D6C770988C0BAD946E208E24FA074E5AB3143DB5BFCE0FD108E4B82D120A92108011A723C12A787E6D788719A10BDBA5B2699C327186AF4E23C1A946834B6150BDA2583E9CA2AD44CE8DBBBC2DB04DE8EF92E8EFC141FBECAA6287C59474E6BC05D99B2964FA090C3A2233BA186515BE7ED1F612970CEE2D7AFB81BDD762170481CD0069127D5B05AA993B4EA988D8FDDC186FFB7DC90A6C08F4DF435C934063199FFFFFFFFFFFFFFFF,\n 17:\n 0xFFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3DC2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F83655D23DCA3AD961C62F356208552BB9ED529077096966D670C354E4ABC9804F1746C08CA18217C32905E462E36CE3BE39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF6955817183995497CEA956AE515D2261898FA051015728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6BF12FFA06D98A0864D87602733EC86A64521F2B18177B200CBBE117577A615D6C770988C0BAD946E208E24FA074E5AB3143DB5BFCE0FD108E4B82D120A92108011A723C12A787E6D788719A10BDBA5B2699C327186AF4E23C1A946834B6150BDA2583E9CA2AD44CE8DBBBC2DB04DE8EF92E8EFC141FBECAA6287C59474E6BC05D99B2964FA090C3A2233BA186515BE7ED1F612970CEE2D7AFB81BDD762170481CD0069127D5B05AA993B4EA988D8FDDC186FFB7DC90A6C08F4DF435C93402849236C3FAB4D27C7026C1D4DCB2602646DEC9751E763DBA37BDF8FF9406AD9E530EE5DB382F413001AEB06A53ED9027D831179727B0865A8918DA3EDBEBCF9B14ED44CE6CBACED4BB1BDB7F1447E6CC254B332051512BD7AF426FB8F401378CD2BF5983CA01C64B92ECF032EA15D1721D03F482D7CE6E74FEF6D55E702F46980C82B5A84031900B1C9E59E7C97FBEC7E8F323A97A7E36CC88BE0F1D45B7FF585AC54BD407B22B4154AACC8F6D7EBF48E1D814CC5ED20F8037E0A79715EEF29BE32806A1D58BB7C5DA76F550AA3D8A1FBFF0EB19CCB1A313D55CDA56C9EC2EF29632387FE8D76E3C0468043E8F663F4860EE12BF2D5B0B7474D6E694F91E6DCC4024FFFFFFFFFFFFFFFF,\n 18:\n 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n }\n\n if group in primes.keys():\n return primes[group]\n else:\n print(\"Error: No prime with group %i. Using default.\" % group)\n return primes[default_group]","def primes(count):\n\n # store lst of prime numbers to be returned @ end\n primes = []\n\n # set up prime # generator from other fn starting at 2\n num = 2\n\n while count > 0:\n\n # check if prime\n if is_prime(num):\n # if so, append to primes lst\n primes.append(num)\n # decrement by 1; used to keep track of how many primes enter lst\n count -= 1\n\n # check next number if prime, etc.\n num += 1\n\n # return final lst\n return primes","def primes(count):\n\n prime_nums = [2]\n prime = 3\n\n for i in range(1, count):\n\n while prime not in [3, 5, 7] and (\n prime % 3 == 0 or prime % 5 == 0 or prime % 7 == 0\n ):\n prime += 2\n\n prime_nums.append(prime)\n prime += 2\n\n return prime_nums","def prime_numbers(x: int):\n A = [True] * x\n A[0] = A[1] = False\n for i in range(2, x, 1):\n if is_simple_number(i):\n for m in range(2 * i, x, i):\n A[m] = False\n n = 0\n for k in range(x):\n print(k, \"is prime\" if A[k] else \"is not prime\")\n if A[k]:\n n += 1\n\n B = [0] * n\n n = 0\n for k in range(x):\n if A[k]:\n B[n] = k\n n += 1\n return B","def primes(count):\n\n primes = []\n number_to_check = 2\n\n while len(primes) < count:\n # check if number is prime\n # if prime, add to list\n # if not prime, move on\n # increment number to check\n \n is_prime = True\n\n for num in range(2,number_to_check):\n if number_to_check % num == 0 and num != number_to_check:\n is_prime = False\n break\n \n if is_prime == True:\n primes.append(number_to_check)\n\n number_to_check += 1\n\n return primes","def generate_primes():\n # David Eppstein, UC Irvine, 28 Feb 2002\n # Source : http://code.activestate.com/recipes/117119/\n yield 2\n\n D = {} # map composite integers to primes witnessing their compositeness\n for q in count(start=3, step=2):\n if q not in D:\n yield q # not marked composite, must be prime\n D[q*q] = [q] # first multiple of q not already marked\n else:\n for p in D[q]: # move each witness to its next multiple\n D.setdefault(2*p+q,[]).append(p)\n del D[q] # no longer need D[q], free memory","def primes():\n yield 2\n candidate = 3\n while True:\n for i in range(3, int(sqrt(candidate)) + 1, 2):\n if (candidate % i) == 0:\n break\n else:\n yield candidate\n candidate += 2","def primes():\n yield 2\n candidate = 3\n while True:\n for i in range(3, int(sqrt(candidate)) + 1, 2):\n if (candidate % i) == 0:\n break\n else:\n yield candidate\n candidate += 2","def primes(count):\n\n # START SOLUTION\n\n primes = []\n num = 2\n\n while count > 0:\n\n if is_prime(num):\n primes.append(num)\n count -= 1\n\n num += 1\n\n return primes","def loop():\n num = 1\n while(len(primes) < didget ):\n if(isprime(num) == True):\n primes.append(num)\n \n num = num + 1","def getPrimeFactors(num):\n n = num\n primes = {}\n\n p = 2\n sqrt = math.sqrt(num)\n\n def checkAndUpdate(inc):\n nonlocal n\n nonlocal p\n nonlocal primes\n if n % p == 0:\n if str(p) in primes.keys():\n primes[str(p)] += 1\n else:\n primes[str(p)] = 1\n n /= p\n else:\n p += inc\n \n while p == 2 and p <= n:\n checkAndUpdate(1)\n while p <= n and p <= sqrt:\n checkAndUpdate(2)\n if len(primes.keys()) == 0:\n primes[str(num)] = 1\n elif n != 1:\n primes[str(n)] = 1\n return primes","def gen_primes():\n\n n = 1\n while True:\n while not isPrime(n):\n n += 1\n\n yield n\n n += 1","def prime():\n prime_set = {2} # Set of prime numbers that have been found\n yield 2 # First prime\n for x in itertools.count(3, 2): # Check odd numbers, starting with 3\n primes_below_sqrt = {i for i in prime_set if i <= sqrt(x)} \n for prime in primes_below_sqrt:\n if x % prime == 0:\n break # x is divisible by a prime factor, so it is not prime\n else:\n prime_set.add(x) # x has been shown to be prime\n yield x","def primes(max_number_of_primes) -> iter:\n number_primes = count(1)\n prime = prime_generator()\n while next(number_primes) <= max_number_of_primes:\n yield next(prime)","def primes(numOfPrimes):\n\n primes = []\n # we want to start at 2003, which is the first prime after 2000, seeing as\n # we absolutely need to fit all 2000 keys on the hash table,\n i = 2003\n\n while len(primes) < numOfPrimes:\n isPrime = True\n\n for k in range(2, i):\n if i % k == 0:\n isPrime = False\n break\n\n if isPrime:\n primes.append(i)\n i += 1\n\n return primes","def gen_Primes(pp, K, Q, L):\r\n global MAX_PRIME\r\n global MAX_NUMBER\r\n global cnt_divisions\r\n global cnt_no_primes\r\n global cnt_compares\r\n global cnt_numbers\r\n global dict_P_runlen\r\n global dict_N_runlen\r\n # get the primes by testing the remainder\r\n # after division with formerly computed primes\r\n # stop when found square of prime greater current number\r\n cnt_divisions = 0\r\n cnt_no_primes = 0\r\n cnt_compares = 0\r\n cnt_numbers = 0\r\n X = gen_Numbers(0, L)\r\n # we already know some primes - skip them\r\n while True:\r\n x = next(X)\r\n if x >= pp: # also ignore pp - it's a square\r\n break # we are at the edge\r\n # now compare numbers revers against squares - think about roots\r\n # and test the remainder ...\r\n while True:\r\n x = next(X)\r\n if x > MAX_NUMBER:\r\n break\r\n cnt_numbers += 1\r\n prime_found = True # assume tha's a prime\r\n cnt_runlength = 0\r\n for p, q in zip(K, Q):\r\n cnt_compares += 1\r\n if q > x:\r\n # compare current x against the sqare of known primes\r\n # if gretaer than we need no more divisors from list\r\n break\r\n cnt_runlength += 1\r\n cnt_divisions += 1\r\n if x % p == 0:\r\n # primitive test for a prime\r\n prime_found = False # wrong assumptions - get next x\r\n cnt_no_primes += 1\r\n break\r\n else:\r\n prime_found = False\r\n assert False, \"PrimeDivisorError/SquareRuleError\"\r\n if prime_found:\r\n # ok - we found one - also store new values for future compares\r\n K.append(x)\r\n Q.append(x*x)\r\n dict_P_runlen[cnt_runlength] = dict_P_runlen.get(\r\n cnt_runlength, 0) + 1\r\n yield x\r\n else:\r\n dict_N_runlen[cnt_runlength] = dict_N_runlen.get(\r\n cnt_runlength, 0) + 1\r\n return","def is_prime(self, it):\n return it > 0 \\\n and (it == 2 or it % 2 != 0) \\\n and (it == 1 or not (any(it % number == 0 for number in range(3, it // 2, 2))))","def is_prime(self):\n pass","def main():\n user_input = int(input(\"Enter an integer which is greater than 1, we will\"\n + \" print out all of prime numbers: \"))\n\n while user_input <= 1:\n print(\"Invalid input, please enter again: \")\n user_input = int(input(\"\"))\n else:\n prime_num = PrimeGenerator()\n prime_list = prime_num.primes_to_max(user_input)\n\n print(prime_list)","def prime_gen():\n for i in memo_primes: yield i\n x = memo_primes[-1] + 1\n \n while True:\n if prime_with(x, memo_primes):\n yield x\n memo_primes.append(x)\n x += 1","def prime_generator() -> Iterator[int]:\n\n num = 2\n while True:\n if is_prime(num):\n yield num\n num += 1","def is_prime(value):\n if value < 4:\n return True\n \n lower_bound = 2\n upper_bound = value-1\n \n prime = True\n test_value = lower_bound\n \n while test_value < upper_bound:\n #print \"testing divisibility of %d for %d\" % (value, test_value)\n if value % test_value == 0:\n prime = False\n test_value += 1\n return prime","def count_prime():\n nums = []\n for i in range(2, 10000):\n if is_prime(i):\n nums.append(i)\n return nums","def prime_generator():\n i = 0 # prime numbers counter\n num = 0 # current number\n while True:\n num += 1\n if is_prime(num):\n i += 1\n yield i, num","def get_primes(maxi):\n\n is_prime = [True] * (maxi + 1)\n \n is_prime[0] = False\n is_prime[1] = False\n # is_prime[2] = True and all other even numbers are not prime\n for i in range(2,maxi+1):\n if is_prime[i]: # if current is prime, set multiples to current not prime\n for j in range(2*i, maxi+1, i):\n is_prime[j] = False\n\n return is_prime","def start_prime_test():","def gen_primes():\n\tyield 2\n\tyield 3\n\tprime_list = [2, 3]\n\twhile 1:\n\t\tnext = prime_list[-1] + 2\n\t\ti = 0\n\t\twhile i < len(prime_list):\n\t\t\tif next%prime_list[i] == 0:\n\t\t\t\tnext+=2\n\t\t\t\ti=0\n\t\t\telse:\n\t\t\t\ti+=1\n\t\tprime_list.append(next)\n\t\tyield next","def factorize(n:int,primesDict:dict = primesDict):\r\n\r\n \r\n if isPrime(n,primesDict):\r\n return {n:1}\r\n\r\n factors = {}\r\n\r\n lastPrime = getLastPrime(primesDict)\r\n print (lastPrime,\"Lastprimes\")\r\n if lastPrime < n:\r\n print (\"Creating DictS\")\r\n\r\n prma(n,lastPrime,primesDict)\r\n\r\n for i in primesDict:\r\n if n%i == 0 :\r\n count = 0\r\n while n % i**(count+1) == 0 :\r\n count+=1 \r\n factors[i]= count\r\n\r\n return factors","def is_prime_number(number_):\n flag = 0\n for values in range(2, number_//2):\n if number_ % values == 0:\n flag += 1\n if flag == 1:\n return True\n else:\n return False","def divide(self, val):\n ancien_pri = 999999\n ancien_chunck = 1\n for pri in prime_array:\n if val % pri == 0 and pri >= self.MINIMUM_NUMBER_OF_CHUNK and val / pri < self.MAXIMUM_SIZE_PER_CHUNK:\n ancien_pri = int(pri)\n ancien_chunck = int(val / pri)\n print({\"size\": ancien_pri, \"chunck\": ancien_chunck})\n self.divide(ancien_chunck)\n\n return {\"size\": ancien_pri, \"chunck\": ancien_chunck}","def get_primes_in(self, grange):\n for n in grange:\n if self.is_prime(n):\n yield n","def prime():\n number = random.randint(1, 100)\n if len(primfacs(number)) == 1:\n return number, 'yes'\n return number, 'no'","def find_all_primes(x=22):\n allprimes = []\n for i in range(2, x + 1):\n ##allows all the numbers between 2(smallest prime) and x be divided by x \n if is_prime(i):\n #using the function that set up just now\n allprimes.append(i)\n #\n print(\"There are %d primes between 2 and %d\" % (len(allprimes), x))\n return allprimes","def count_prime_args(num):\n nums = []\n for i in range(2, num):\n if is_prime(i):\n nums.append(i)\n return nums","def factor_primes(x, iter):\n factors = []\n for factor in prime:\n while x % factor == 0:\n x = x / factor\n factors.append(factor)\n if x == 1:\n break\n return factors","def main():\n primes = getNPrime(100)\n\n write_primes(primes, 'output.csv')\n\n prime_list = read_primes('output.csv')\n\n print(prime_list)","def findPrimes(prime_bit, N, num):\n primes = []\n total_bits = 0\n prime = pow(2, prime_bit - 1)\n while len(primes) != num:\n prime = nextprime(prime)\n if prime % (2 * N) == 1:\n primes.append(prime)\n total_bits += prime.bit_length()\n\n return primes, total_bits","def prime_checker(num):\n\n assert num > 0\n\n if num < 2:\n return False\n\n if num == 2:\n return True\n\n if num % 2 == 0:\n return False\n\n n = 3\n\n while n * n <= num:\n\n if num % n == 0:\n return False\n\n else:\n num += 2\n\n return True","def is_prime(num1):\n num2 = 2\n while num2 < num1:\n if num1 % num2 == 0:\n return False\n num2 += 1\n return True","def prime_numbers(max_number_eval=100):\n prime_numbers_list = list(next_prime(max_number_eval))\n print('The prime numbers from 2 to {} are:{}'.format(max_number_eval, prime_numbers_list))","def primes(n):\n return [i for i, v in enumerate(prime_cache(n)) if v]","def is_prime(num: int) -> bool:\n if num < 2:\n return False\n low_primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73,\n 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163,\n 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251,\n 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349,\n 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443,\n 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557,\n 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647,\n 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757,\n 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863,\n 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983,\n 991, 997]\n if num in low_primes:\n return True\n for prime in low_primes:\n if num % prime == 0:\n return False\n return rabin_miller(num)","def Primes():\n candidate = 1\n _primes_so_far = [2] # first prime, only even prime\n yield _primes_so_far[-1]\n while True:\n candidate += 2 # check odds only from now on\n for prev in _primes_so_far:\n if prev**2 > candidate:\n yield candidate\n _primes_so_far.append(candidate)\n break\n if not divmod(candidate, prev)[1]: # no remainder!\n break # done looping","def is_prime(value):\n\n if value < 2: raise ValueError\n\n for i in range(2, value):\n if value % i == 0:\n return False\n\n return True","def test_prime(n):\n if SIEVE[n]:\n return True\n else:\n return False","def run_test_sum_until_prime_input():\n print()\n print(\"--------------------------------------------------\")\n print(\"Testing the sum_until_prime_input function:\")\n print(\"--------------------------------------------------\")\n\n sum_until_prime_input()","def prime_facts(primes, number):\n\n facts = set()\n sqr = number ** 0.5\n for prime in primes:\n if prime > sqr:\n if number > 1:\n facts.add(number)\n break\n while number % prime == 0:\n facts.add(prime)\n number /= prime\n sqr = number ** 0.5\n\n return facts","def primes(n):\n primfac = {}\n primfac = defaultdict(lambda: 0, primfac)\n while (n % 2) == 0:\n primfac[2] += 1 \n n //= 2\n d = 3\n while d*d <= n:\n while (n % d) == 0:\n primfac[d] += 1 # supposing you want multiple factors repeated\n n //= d\n d += 2\n if n > 1:\n primfac[n] = 1\n return primfac","def find_prime_divisors(self, num):\n # If the number is prime, it is only divisible by itself.\n if pe_005.is_prime(num) or num < 2:\n return {num: 1}\n\n # If there were no primes searched for, then search for primes.\n if len(self._primes) <= 0:\n self.find_primes(num)\n\n results = dict()\n # Loop through the sorted primes list and stop when the prime is larger than the given number.\n for prime in self._primes[::-1]:\n if num <= 0:\n break\n\n # Count the number of divisions of the prime number into the current number.\n count, num = pe_005.count_divisions(num, prime)\n if count > 0:\n results[prime] = count\n\n return results","def prime_generator(num):\n prime_list = [i for i in range(1,num+1,2) if prime_checker(i)]\n\n if num > 1:\n prime_list.insert(0,2)\n\n return prime_list","def comprobar_primo(num):\n primo = True\n for i in range(2, num):\n if num%i == 0:\n primo = False\n return primo","def prime_factors(number: int) -> dict:\n f = {}\n i = 2\n while number > 1 and number >= i:\n if number % i == 0:\n if i not in f:\n f[i] = 1\n else:\n f[i] += 1\n number //= i\n else:\n i += 1\n return f","def getPrimes(self):\n try:\n primes_file = open(self.primes_path, 'r')\n except FileNotFoundError:\n logger.warning(f\"Unable to open moduli file '{self.primes_path}'. This will reduce the number of\"\n f\"available key exchange algorithms, and may affect compatibility.\")\n return {}\n\n try:\n primes = {}\n for line in primes_file:\n line = line.strip()\n if not line or line[0] == '#':\n continue\n tim, typ, tst, tri, size, gen, mod = line.split()\n size = int(size) + 1\n gen = int(gen)\n mod = int(mod, 16)\n if size not in primes:\n primes[size] = []\n primes[size].append((gen, mod))\n return primes\n finally:\n primes_file.close()","def generatePrimesSieve(count):\n\tif count < 1:\n\t\treturn None\n\n\tsieve = itertools.count(3, 2)\n\tlastPrime = 2\n\tfor i in xrange(1, count):\n\t\tlastPrime = sieve.next()\n\t\tprint lastPrime\n\t\tsieve = filterPrime(sieve, lastPrime)\n\treturn lastPrime","def get_primes(self, state, action): #make direct call to environment's get_primes\n pass","def async_is_prime(x):\n if x < 2:\n return False\n for i in range(2, int(math.sqrt(x)) + 1):\n time.sleep(0.1)\n if x % i == 0:\n return False\n yield from async_sleep(0)\n return True","def prime():\n from transformers import pipeline\n\n primer = pipeline(\"feature-extraction\")\n result = primer([\"hello\"])","def get_primes(lower: int, upper: int) -> typing.Generator[int, None, None]:\r\n for num in range(lower, upper + 1):\r\n if num > 1:\r\n for i in range(2, int(math.sqrt(num)) + 1):\r\n if num % i == 0:\r\n break\r\n else:\r\n yield num","def all_primes(nums):\n return list(filter(lambda x: all(x % i != 0 for i in range(2, x)), nums))\n # assume is_prime is defined:\n # def is_prime(n):\n # return all(n % i != 0 for i in range(2, n))\n # return list(filter(is_prime, nums))","def primos(x):\n def esprimo(n):\n \"\"\"\n Determines whether a natural number is a prime number\n :param n: Agiven natural number\n :return: True if prime, False otherwise\n \"\"\"\n toret = False\n if x == 2:\n toret = True\n elif x % 2 == 0:\n toret = False\n else:\n for i in range(3, x, 2):\n if x % i == 0:\n break\n else:\n toret = True\n # Se ejecuta cuando no se rompe el bucle\n\n return toret\n\n toret = []\n for i in range(0, x):\n if esprimo(i):\n toret.append(i)\n\n return toret","def is_prime(num):\n\n if num == 2:\n return True\n for i in range(2, num):\n if num % i == 0:\n return False\n return True","def problem077():\n\n cond = lambda n: num_prime_sum_ways(n) > 5000\n ans = next(filter(cond, itertools.count(2)))\n return ans","def isprime(n):\r\n\treturn is_prime(n)","def is_prime(num):\n if num < 2:\n return False\n\n for i in range(2, num):\n if num % i == 0:\n return True","def get_set_prime_numbers(number):\n prime_numbers = set()\n\n for i in range(2, number + 1):\n for j in prime_numbers:\n if i % j == 0:\n break\n else:\n prime_numbers.add(i)\n\n return prime_numbers","def gen_primes(N):\n primes = set()\n for n in range(2, N):\n if all(n % p > 0 for p in primes):\n primes.add(n)\n yield n","def is_prime(number):\n if number <=3:\n return True\n \n for i in range(2, number):\n if number % i == 0:\n return False\n \n return True","def check_valves(self):\n for name in self._pipes:\n if self._data[name].check_valve:\n yield name","def return_prime_numbers_less_tahn_100():\r\n primes = []\r\n for num in range(100):\r\n is_prime = True\r\n for i in range(2, num):\r\n if num % i == 0:\r\n is_prime = False \r\n if is_prime:\r\n primes.append(num)\r\n return primes","def prime_generator():\r\n for i in itertools.count(start=1):\r\n for j in ((6 * i) - 1, (6 * i) + 1):\r\n if is_prime(j): yield(j)","def primes(upper_bound):\n global cache\n lower_bound = 2\n prime_set = new_primes(upper_bound, cache, lower_bound)\n prime_set.update(cache)\n cache = prime_set\n\n return prime_set","def test_if_it_outputs_correct_output(self):\n self.assertEquals(prime_numbers(5), [2, 3, 5])","def is_prime(num):\n\n assert num >= 0, \"Num should be a positive integer!\"\n\n if num < 2:\n return False\n\n if num == 2:\n return True\n\n if num % 2 == 0:\n return False\n\n n = 3\n while n * n <= num:\n if num % n == 0:\n return False\n n += 2\n\n return True","def prevPrimes(n):\r\n from numbers import Integral as types #'Integral' is a class of integers/long-numbers\r\n if not isinstance(n, types): raise TypeError(\"n must be int, not \" + str(type(n)))\r\n if n < 2: raise ValueError(\"n must greater than 2\")\r\n primes_dict = {i : True for i in range(2, n + 1)} # initializes the dictionary\r\n for i in primes_dict:\r\n if primes_dict[i]: #avoids going through multiples of numbers already declared False\r\n num = 2\r\n while (num * i <= n): #sets all multiples of i (up to n) as False\r\n primes_dict[num*i] = False\r\n num += 1\r\n return [num for num in primes_dict if primes_dict[num]]","def xprimes(step=1000):\n\n\tif step % 2:\n\t\traise ValueError(\"step is not even\")\n\n\tprimes = [2]\n\tmultiples = [4] # least multiple of prime at index i in primes not yet marked\n\tlower = 2\n\tupper = 4\n\t\n\twhile True:\n\t\t\n\t\t# non-prime numbers will live here\n\t\tnums = set()\n\t\t\n\t\tfor i, p in enumerate(primes):\n\n\t\t\t# You've marked everything worth marking (for now)\n\t\t\tif p * p > upper:\n\t\t\t\tbreak\n\t\t\t# Pick up marking where you left off\n\t\t\tm = multiples[i]\n\t\t\t\n\t\t\t# Do some marking\n\t\t\twhile m < upper: # upper is even, cannot be prime\n\t\t\t\tnums.add(m)\n\t\t\t\tm += p\n\t\t\t\n\t\t\t# Left off on this multiple (save for later)\n\t\t\tmultiples[i] = m\n\t\t\n\t\t# Collect primes between lower and upper\n\t\tfor i in xrange(lower, upper): # upper is even, cannot be prime\n\t\t\tif i not in nums:\n\t\t\t\tyield i\n\t\t\t\tprimes.append(i)\n\t\t\t\tmultiples.append(i + i) # 2 * i (i is a new prime)\n\t\t\n\t\t# Got all the primes in this interval; move it up\n\t\tlower = upper + 1\n\t\tupper += min(upper, step)"],"string":"[\n \"def worker(nums, outdict):\\n for n in nums:\\n outdict[n] = primes2(n)\",\n \"def primes():\\n D = {} # map composite integers to primes witnessing their compositeness\\n q = 2 # first integer to test for primality\\n while True:\\n if q not in D:\\n yield q # not marked composite, must be prime\\n D[q*q] = [q] # first multiple of q not already marked\\n else:\\n for p in D[q]: # move each witness to its next multiple\\n D.setdefault(p+q,[]).append(p)\\n del D[q] # no longer need D[q], free memory\\n q += 1\",\n \"def distributor(ls_feed_pipe_open,low,high):\\n def getNumber(low,high):\\n i = low\\n if i%2 == 0: #if i is even, then start from i+1 odd.\\n i += 1\\n while i<=high:\\n yield i\\n i+=2 #no need to check for even numbers, so skip it here at begining\\n yield -1 #when generator yields -1, it reached high, so terminate\\n\\n next_pipe = 0\\n number = getNumber(low,high)\\n while True:\\n msg = next(number)\\n if msg == -1: #to check when generator reached high.\\n break\\n else:\\n #feed pipes in a round robin fashion,\\n #so that over time each generatePrime process experiences same load.\\n ls_feed_pipe_open[next_pipe].send(msg)\\n next_pipe += 1\\n if next_pipe == len(ls_feed_pipe_open):\\n next_pipe = 0\\n for p in ls_feed_pipe_open:\\n p.send(-1) #-1 is sentinel value for all generatePrime processs\\n return 0\",\n \"def getNums():\\n key = allprimes() # Empty list for key is created\\n\\n # Runs code endlessly as no instruction was\\n while True: # given to end the code\\n num = input(\\\"Please enter a number:\\\") # Changed number to integer as it's outputted\\n try: # as a string from input\\n selected_num = int(num) # Asked for number with try function\\n except:\\n print(\\\"\\\\n Please input only a number!\\\") # Only accepts a number\\n continue\\n if selected_num > 100: # Limits number to 100 as that was limit\\n print(\\\"Please only select a number up to 100.\\\")\\n continue\\n if selected_num in key:\\n print(\\\"You have picked a prime number please select another number.\\\")\\n continue\\n for i, number in enumerate(key): # Iterator function to run through key\\n complementary = selected_num - number # Initiated formula\\n if complementary in key[i:]: # Obtained complimentary number if available\\n print(str(selected_num) + \\\" = {} + {}\\\".format(number, complementary))\\n break # Printed values as requested for assignment\",\n \"def allprimes():\\n\\n key = [] # The empty list is initiated\\n\\n for val in range(2, 101): # Set to obtain all prime values from 2 to 100\\n if val >= 2: # They are then stored into the list\\n for n in range(2, val): # The values have to be greater than 2 as 1 cannot\\n if not (val % n): # be included\\n break # Pulls all prime numbers by iterating through them\\n else: # If a number does not obtain a remainder that means\\n key.append(val) # it cannot be divisable by anything but it's own\\n # number it is appended as a prime number\\n return key\",\n \"def primes(count):\\n\\n prime_list = []\\n num = 2\\n\\n while count > 0:\\n\\n if prime_checker(num):\\n prime_list.append(num)\\n count -= 1\\n num += 1\\n\\n return prime_list\",\n \"def primes(count):\\n\\n prime_numbers = [2]\\n next_num = 3 \\n\\n def is_prime(next_num):\\n if next_num % 2 == 0:\\n return False \\n \\n for i in range(3, next_num, 2):\\n if next_num % i == 0:\\n return False \\n return True \\n\\n while count > len(prime_numbers): \\n if is_prime(next_num): \\n prime_numbers.append(next_num)\\n next_num += 1\\n\\n return prime_numbers\",\n \"def test_prime_12(self):\\n\\t self.assertTrue(prime_generator(12), [2, 3, 5, 7, 11])\",\n \"def test_prime_10(self):\\n\\t self.assertTrue(prime_generator(10), [2, 3, 5, 7])\",\n \"def get_primes(self, startnum=2):\\n i = startnum\\n while True:\\n if self.is_prime(i):\\n yield i\\n i += 1\",\n \"def primes():\\n yield 1\\n primes = []\\n for n in itertools.count(2):\\n if not any(n % p == 0 for p in primes):\\n # No divisor found among previous primes\\n yield n\\n primes.append(n)\",\n \"def prime_generator():\\r\\n # map of composites (key) with at least one prime factor in list as value\\r\\n D = {}\\r\\n\\r\\n # first number to test if prime\\r\\n q = 2\\r\\n\\r\\n while 1:\\r\\n if q not in D:\\r\\n # next prime found\\r\\n yield q\\r\\n # add it's square as a composite to D\\r\\n D[q**2] = [q]\\r\\n else:\\r\\n # update dictionary entries based on composite and its listed primes\\r\\n for p in D[q]:\\r\\n D.setdefault(p+q, []).append(p)\\r\\n del D[q]\\r\\n q += 1\",\n \"def primes():\\r\\n try:\\r\\n args = request.args\\r\\n start_num, end_num = validate_request(args)\\r\\n # cache key\\r\\n key = f'primes:{start_num}:{end_num}'\\r\\n rv = cache.get(key)\\r\\n if rv is None: # not in cache\\r\\n job = get_primes_list.queue(start_num, end_num)\\r\\n print(job.get_id())\\r\\n cache.set(key, job.get_id(), timeout=3600)\\r\\n return jsonify(job.get_id()), 200\\r\\n else:\\r\\n return jsonify(rv), 200\\r\\n except Exception as e:\\r\\n raise InvalidUsage(\\\"Error Processing request {}\\\".format(e))\",\n \"def gen_primes():\\n # Maps composites to primes witnessing their compositeness.\\n # This is memory efficient, as the sieve is not \\\"run forward\\\"\\n # indefinitely, but only as long as required by the current\\n # number being tested.\\n\\n D = {}\\n\\n # The running integer that's checked for primeness\\n\\n q = 2\\n\\n while True:\\n if q not in D:\\n # q is a new prime.\\n # Yield it and mark its first multiple that isn't\\n # already marked in previous iterations\\n yield q\\n D[q * q] = [q]\\n else:\\n # q is composite. D[q] is the list of primes that\\n # divide it. Since we've reached q, we no longer\\n # need it in the map, but we'll mark the next\\n # multiples of its witnesses to prepare for larger\\n # numbers\\n for p in D[q]:\\n D.setdefault(p + q, []).append(p)\\n del D[q]\\n\\n q += 1\",\n \"def primes():\\n yield 2\\n found_primes = [2]\\n a = 3\\n while True:\\n for p in found_primes:\\n if p**2 > a:\\n found_primes.append(a)\\n yield a\\n a += 2\\n break\\n elif a % p == 0:\\n a += 2\\n break\",\n \"def find_prime(num):\\n\\n if not isinstance(num, int) or isinstance(num, bool):\\n raise TypeError(\\\"number input must be an integer\\\")\\n\\n if num <= 1:\\n raise ValueError(\\\"number must be greater than 1\\\")\\n\\n pri_num = [2]\\n\\n # The code below will test if every iteration of 'var' is a prime number\\n for var in range(2, num + 1):\\n res = 0\\n for var2 in pri_num:\\n if var == 2:\\n break\\n elif (var % var2) == 0:\\n break\\n elif (var2 == pri_num[-1]):\\n res = var\\n if res:\\n pri_num.append(res)\\n print(pri_num)\\n\\n return 0\",\n \"def gen_primes():\\n\\n # Maps composites to primes witnessing their compositeness.\\n # This is memory efficient, as the sieve is not \\\"run forward\\\"\\n # indefinitely, but only as long as required by the current number\\n # being tested\\n\\n D = {}\\n\\n # The runing integer that is checked for primeness\\n q = 2\\n\\n while True:\\n if q not in D:\\n # q is a new prime.\\n # Yield it and mark its first multiple that isn't\\n # already marked in previous iterations\\n\\n yield q\\n D[q * q] = [q]\\n else:\\n # q is composite. D[q] is the list of primes that\\n # divide it. Since we've reached q, we no longer\\n # need it in the map, but we'll mark the next multiples\\n # of its witnesses to prepare for larger numbers\\n\\n for p in D[q]:\\n D.setdefault(p + q, []).append(p)\\n del D[q]\\n\\n q += 1\",\n \"def gen_primes():\\n\\n # Maps composites (=non-primes) to primes witnessing their compositeness.\\n # This is memory efficient, as the sieve is not \\\"run forward\\\" indefinitely,\\n # but only as long as required by the current number being tested.\\n D = {}\\n\\n q = 1 # the running integer that is checked for primeness\\n while (q := q+1):\\n if q not in D:\\n # q is a new prime. Yield it and mark its first multiple that is\\n # not already marked in previous iterations\\n yield q\\n D[q*q] = [q]\\n else:\\n # q is composite. D[q] is the list of primes that divide it. Since\\n # we have reached q, we no longer need it in the map, but we will\\n # mark the next multiples of its witnesses to prepare for larger\\n # numbers\\n for p in D[q]:\\n D.setdefault(p+q, []).append(p)\\n del D[q]\",\n \"def test_prime_2(self):\\n\\t self.assertTrue(prime_generator(2), [2])\",\n \"def primes():\\n yield 2\\n found = []\\n for i in itertools.count(start=3, step=2):\\n for p in found:\\n if i % p == 0:\\n break\\n else:\\n yield i\\n found.append(i)\",\n \"def check_prime_worker(job_queue):\\n while True:\\n # your code here\\n # 1. get next available number from queue\\n try:\\n number = job_queue.get(block=False)\\n print(f\\\"Process {current_process()} checks number {number}\\\")\\n except Empty:\\n break\\n\\n # 2. print the number and whether it\\n # is prime or not, use is_prime()\\n if is_prime(number):\\n print(f\\\"{number} is prime\\\")\\n else:\\n print(f\\\"{number} is not prime\\\")\\n\\n # 3. use try/except to catch Empty exception\\n # and quit the loop if no number remains in queue\\n # done in step 1\",\n \"def primeIterator(no = 0,lessThan = None ):\\r\\n \\r\\n prmd = {2:1,3:2}\\r\\n sqrtn = 2\\r\\n l = 1\\r\\n count = 0\\r\\n #or (no==-1 and not lessThan) l < no or:\\r\\n print(\\\"no\\\", no)\\r\\n while ((no!=0 and count < no) or ( (no==0) and (lessThan and l<lessThan ) or (not lessThan ) ))and (l<4) :\\r\\n if l in prmd:\\r\\n count += 1\\r\\n yield l\\r\\n l+=1\\r\\n l=5\\r\\n add = 2\\r\\n \\r\\n while (no!=0 and count < no) or ( (no==0) and ( (lessThan and l<lessThan ) or (not lessThan )) ) : #check only 6n-1 and 6n+1\\r\\n if l > sqrtn**2:\\r\\n sqrtn = l**0.5\\r\\n for i in prmd:\\r\\n if i > sqrtn:\\r\\n prmd[l] = len(prmd)\\r\\n add = 2 if add==4 else 2\\r\\n count +=1\\r\\n yield l\\r\\n break\\r\\n if l%i ==0 : \\r\\n break\\r\\n l+=add\",\n \"def test_15(self):\\n\\t self.assertTrue(prime_generator(15), [2, 3, 5, 7, 11, 13])\",\n \"def getPrime(bits):\\n\\twhile(True) :\\n\\t\\t# on continue a tirer des nombres tant que l'on n'a pas trouve de nombre premier\\n\\t\\tp = getrandbits(bits)\\n\\t\\tif(miller_rabin(p,100)) :\\n\\t\\t\\treturn p\",\n \"def prime_generator() -> int:\\n \\n #Start with the first prime.\\n counter = count(2)\\n candidate = next(counter)\\n cache: list = [candidate]\\n yield candidate\\n \\n # Set a flag.\\n divisible = False\\n while True:\\n candidate = next(counter)\\n # Check if the candidate is prime.\\n for number in cache:\\n # If number is greater than the squareroot of candidate, we are done.\\n if number * number > candidate:\\n break\\n # If number divides candidate, candidate is not prime.\\n if candidate % number == 0:\\n divisible = True\\n break\\n # If is is prime, add it to the list.\\n if not divisible:\\n cache.append(candidate)\\n yield candidate\\n # Reset the flag.\\n divisible = False\",\n \"def getPrime(self, group=17):\\n default_group = 17\\n\\n primes = {\\n 5: 0xFFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3DC2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F83655D23DCA3AD961C62F356208552BB9ED529077096966D670C354E4ABC9804F1746C08CA237327FFFFFFFFFFFFFFFF,\\n 14: 0xFFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3DC2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F83655D23DCA3AD961C62F356208552BB9ED529077096966D670C354E4ABC9804F1746C08CA18217C32905E462E36CE3BE39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF6955817183995497CEA956AE515D2261898FA051015728E5A8AACAA68FFFFFFFFFFFFFFFF,\\n 15: 0xFFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3DC2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F83655D23DCA3AD961C62F356208552BB9ED529077096966D670C354E4ABC9804F1746C08CA18217C32905E462E36CE3BE39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF6955817183995497CEA956AE515D2261898FA051015728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6BF12FFA06D98A0864D87602733EC86A64521F2B18177B200CBBE117577A615D6C770988C0BAD946E208E24FA074E5AB3143DB5BFCE0FD108E4B82D120A93AD2CAFFFFFFFFFFFFFFFF,\\n 16: 0xFFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3DC2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F83655D23DCA3AD961C62F356208552BB9ED529077096966D670C354E4ABC9804F1746C08CA18217C32905E462E36CE3BE39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF6955817183995497CEA956AE515D2261898FA051015728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6BF12FFA06D98A0864D87602733EC86A64521F2B18177B200CBBE117577A615D6C770988C0BAD946E208E24FA074E5AB3143DB5BFCE0FD108E4B82D120A92108011A723C12A787E6D788719A10BDBA5B2699C327186AF4E23C1A946834B6150BDA2583E9CA2AD44CE8DBBBC2DB04DE8EF92E8EFC141FBECAA6287C59474E6BC05D99B2964FA090C3A2233BA186515BE7ED1F612970CEE2D7AFB81BDD762170481CD0069127D5B05AA993B4EA988D8FDDC186FFB7DC90A6C08F4DF435C934063199FFFFFFFFFFFFFFFF,\\n 17:\\n 0xFFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3DC2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F83655D23DCA3AD961C62F356208552BB9ED529077096966D670C354E4ABC9804F1746C08CA18217C32905E462E36CE3BE39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF6955817183995497CEA956AE515D2261898FA051015728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6BF12FFA06D98A0864D87602733EC86A64521F2B18177B200CBBE117577A615D6C770988C0BAD946E208E24FA074E5AB3143DB5BFCE0FD108E4B82D120A92108011A723C12A787E6D788719A10BDBA5B2699C327186AF4E23C1A946834B6150BDA2583E9CA2AD44CE8DBBBC2DB04DE8EF92E8EFC141FBECAA6287C59474E6BC05D99B2964FA090C3A2233BA186515BE7ED1F612970CEE2D7AFB81BDD762170481CD0069127D5B05AA993B4EA988D8FDDC186FFB7DC90A6C08F4DF435C93402849236C3FAB4D27C7026C1D4DCB2602646DEC9751E763DBA37BDF8FF9406AD9E530EE5DB382F413001AEB06A53ED9027D831179727B0865A8918DA3EDBEBCF9B14ED44CE6CBACED4BB1BDB7F1447E6CC254B332051512BD7AF426FB8F401378CD2BF5983CA01C64B92ECF032EA15D1721D03F482D7CE6E74FEF6D55E702F46980C82B5A84031900B1C9E59E7C97FBEC7E8F323A97A7E36CC88BE0F1D45B7FF585AC54BD407B22B4154AACC8F6D7EBF48E1D814CC5ED20F8037E0A79715EEF29BE32806A1D58BB7C5DA76F550AA3D8A1FBFF0EB19CCB1A313D55CDA56C9EC2EF29632387FE8D76E3C0468043E8F663F4860EE12BF2D5B0B7474D6E694F91E6DCC4024FFFFFFFFFFFFFFFF,\\n 18:\\n 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n }\\n\\n if group in primes.keys():\\n return primes[group]\\n else:\\n print(\\\"Error: No prime with group %i. Using default.\\\" % group)\\n return primes[default_group]\",\n \"def primes(count):\\n\\n # store lst of prime numbers to be returned @ end\\n primes = []\\n\\n # set up prime # generator from other fn starting at 2\\n num = 2\\n\\n while count > 0:\\n\\n # check if prime\\n if is_prime(num):\\n # if so, append to primes lst\\n primes.append(num)\\n # decrement by 1; used to keep track of how many primes enter lst\\n count -= 1\\n\\n # check next number if prime, etc.\\n num += 1\\n\\n # return final lst\\n return primes\",\n \"def primes(count):\\n\\n prime_nums = [2]\\n prime = 3\\n\\n for i in range(1, count):\\n\\n while prime not in [3, 5, 7] and (\\n prime % 3 == 0 or prime % 5 == 0 or prime % 7 == 0\\n ):\\n prime += 2\\n\\n prime_nums.append(prime)\\n prime += 2\\n\\n return prime_nums\",\n \"def prime_numbers(x: int):\\n A = [True] * x\\n A[0] = A[1] = False\\n for i in range(2, x, 1):\\n if is_simple_number(i):\\n for m in range(2 * i, x, i):\\n A[m] = False\\n n = 0\\n for k in range(x):\\n print(k, \\\"is prime\\\" if A[k] else \\\"is not prime\\\")\\n if A[k]:\\n n += 1\\n\\n B = [0] * n\\n n = 0\\n for k in range(x):\\n if A[k]:\\n B[n] = k\\n n += 1\\n return B\",\n \"def primes(count):\\n\\n primes = []\\n number_to_check = 2\\n\\n while len(primes) < count:\\n # check if number is prime\\n # if prime, add to list\\n # if not prime, move on\\n # increment number to check\\n \\n is_prime = True\\n\\n for num in range(2,number_to_check):\\n if number_to_check % num == 0 and num != number_to_check:\\n is_prime = False\\n break\\n \\n if is_prime == True:\\n primes.append(number_to_check)\\n\\n number_to_check += 1\\n\\n return primes\",\n \"def generate_primes():\\n # David Eppstein, UC Irvine, 28 Feb 2002\\n # Source : http://code.activestate.com/recipes/117119/\\n yield 2\\n\\n D = {} # map composite integers to primes witnessing their compositeness\\n for q in count(start=3, step=2):\\n if q not in D:\\n yield q # not marked composite, must be prime\\n D[q*q] = [q] # first multiple of q not already marked\\n else:\\n for p in D[q]: # move each witness to its next multiple\\n D.setdefault(2*p+q,[]).append(p)\\n del D[q] # no longer need D[q], free memory\",\n \"def primes():\\n yield 2\\n candidate = 3\\n while True:\\n for i in range(3, int(sqrt(candidate)) + 1, 2):\\n if (candidate % i) == 0:\\n break\\n else:\\n yield candidate\\n candidate += 2\",\n \"def primes():\\n yield 2\\n candidate = 3\\n while True:\\n for i in range(3, int(sqrt(candidate)) + 1, 2):\\n if (candidate % i) == 0:\\n break\\n else:\\n yield candidate\\n candidate += 2\",\n \"def primes(count):\\n\\n # START SOLUTION\\n\\n primes = []\\n num = 2\\n\\n while count > 0:\\n\\n if is_prime(num):\\n primes.append(num)\\n count -= 1\\n\\n num += 1\\n\\n return primes\",\n \"def loop():\\n num = 1\\n while(len(primes) < didget ):\\n if(isprime(num) == True):\\n primes.append(num)\\n \\n num = num + 1\",\n \"def getPrimeFactors(num):\\n n = num\\n primes = {}\\n\\n p = 2\\n sqrt = math.sqrt(num)\\n\\n def checkAndUpdate(inc):\\n nonlocal n\\n nonlocal p\\n nonlocal primes\\n if n % p == 0:\\n if str(p) in primes.keys():\\n primes[str(p)] += 1\\n else:\\n primes[str(p)] = 1\\n n /= p\\n else:\\n p += inc\\n \\n while p == 2 and p <= n:\\n checkAndUpdate(1)\\n while p <= n and p <= sqrt:\\n checkAndUpdate(2)\\n if len(primes.keys()) == 0:\\n primes[str(num)] = 1\\n elif n != 1:\\n primes[str(n)] = 1\\n return primes\",\n \"def gen_primes():\\n\\n n = 1\\n while True:\\n while not isPrime(n):\\n n += 1\\n\\n yield n\\n n += 1\",\n \"def prime():\\n prime_set = {2} # Set of prime numbers that have been found\\n yield 2 # First prime\\n for x in itertools.count(3, 2): # Check odd numbers, starting with 3\\n primes_below_sqrt = {i for i in prime_set if i <= sqrt(x)} \\n for prime in primes_below_sqrt:\\n if x % prime == 0:\\n break # x is divisible by a prime factor, so it is not prime\\n else:\\n prime_set.add(x) # x has been shown to be prime\\n yield x\",\n \"def primes(max_number_of_primes) -> iter:\\n number_primes = count(1)\\n prime = prime_generator()\\n while next(number_primes) <= max_number_of_primes:\\n yield next(prime)\",\n \"def primes(numOfPrimes):\\n\\n primes = []\\n # we want to start at 2003, which is the first prime after 2000, seeing as\\n # we absolutely need to fit all 2000 keys on the hash table,\\n i = 2003\\n\\n while len(primes) < numOfPrimes:\\n isPrime = True\\n\\n for k in range(2, i):\\n if i % k == 0:\\n isPrime = False\\n break\\n\\n if isPrime:\\n primes.append(i)\\n i += 1\\n\\n return primes\",\n \"def gen_Primes(pp, K, Q, L):\\r\\n global MAX_PRIME\\r\\n global MAX_NUMBER\\r\\n global cnt_divisions\\r\\n global cnt_no_primes\\r\\n global cnt_compares\\r\\n global cnt_numbers\\r\\n global dict_P_runlen\\r\\n global dict_N_runlen\\r\\n # get the primes by testing the remainder\\r\\n # after division with formerly computed primes\\r\\n # stop when found square of prime greater current number\\r\\n cnt_divisions = 0\\r\\n cnt_no_primes = 0\\r\\n cnt_compares = 0\\r\\n cnt_numbers = 0\\r\\n X = gen_Numbers(0, L)\\r\\n # we already know some primes - skip them\\r\\n while True:\\r\\n x = next(X)\\r\\n if x >= pp: # also ignore pp - it's a square\\r\\n break # we are at the edge\\r\\n # now compare numbers revers against squares - think about roots\\r\\n # and test the remainder ...\\r\\n while True:\\r\\n x = next(X)\\r\\n if x > MAX_NUMBER:\\r\\n break\\r\\n cnt_numbers += 1\\r\\n prime_found = True # assume tha's a prime\\r\\n cnt_runlength = 0\\r\\n for p, q in zip(K, Q):\\r\\n cnt_compares += 1\\r\\n if q > x:\\r\\n # compare current x against the sqare of known primes\\r\\n # if gretaer than we need no more divisors from list\\r\\n break\\r\\n cnt_runlength += 1\\r\\n cnt_divisions += 1\\r\\n if x % p == 0:\\r\\n # primitive test for a prime\\r\\n prime_found = False # wrong assumptions - get next x\\r\\n cnt_no_primes += 1\\r\\n break\\r\\n else:\\r\\n prime_found = False\\r\\n assert False, \\\"PrimeDivisorError/SquareRuleError\\\"\\r\\n if prime_found:\\r\\n # ok - we found one - also store new values for future compares\\r\\n K.append(x)\\r\\n Q.append(x*x)\\r\\n dict_P_runlen[cnt_runlength] = dict_P_runlen.get(\\r\\n cnt_runlength, 0) + 1\\r\\n yield x\\r\\n else:\\r\\n dict_N_runlen[cnt_runlength] = dict_N_runlen.get(\\r\\n cnt_runlength, 0) + 1\\r\\n return\",\n \"def is_prime(self, it):\\n return it > 0 \\\\\\n and (it == 2 or it % 2 != 0) \\\\\\n and (it == 1 or not (any(it % number == 0 for number in range(3, it // 2, 2))))\",\n \"def is_prime(self):\\n pass\",\n \"def main():\\n user_input = int(input(\\\"Enter an integer which is greater than 1, we will\\\"\\n + \\\" print out all of prime numbers: \\\"))\\n\\n while user_input <= 1:\\n print(\\\"Invalid input, please enter again: \\\")\\n user_input = int(input(\\\"\\\"))\\n else:\\n prime_num = PrimeGenerator()\\n prime_list = prime_num.primes_to_max(user_input)\\n\\n print(prime_list)\",\n \"def prime_gen():\\n for i in memo_primes: yield i\\n x = memo_primes[-1] + 1\\n \\n while True:\\n if prime_with(x, memo_primes):\\n yield x\\n memo_primes.append(x)\\n x += 1\",\n \"def prime_generator() -> Iterator[int]:\\n\\n num = 2\\n while True:\\n if is_prime(num):\\n yield num\\n num += 1\",\n \"def is_prime(value):\\n if value < 4:\\n return True\\n \\n lower_bound = 2\\n upper_bound = value-1\\n \\n prime = True\\n test_value = lower_bound\\n \\n while test_value < upper_bound:\\n #print \\\"testing divisibility of %d for %d\\\" % (value, test_value)\\n if value % test_value == 0:\\n prime = False\\n test_value += 1\\n return prime\",\n \"def count_prime():\\n nums = []\\n for i in range(2, 10000):\\n if is_prime(i):\\n nums.append(i)\\n return nums\",\n \"def prime_generator():\\n i = 0 # prime numbers counter\\n num = 0 # current number\\n while True:\\n num += 1\\n if is_prime(num):\\n i += 1\\n yield i, num\",\n \"def get_primes(maxi):\\n\\n is_prime = [True] * (maxi + 1)\\n \\n is_prime[0] = False\\n is_prime[1] = False\\n # is_prime[2] = True and all other even numbers are not prime\\n for i in range(2,maxi+1):\\n if is_prime[i]: # if current is prime, set multiples to current not prime\\n for j in range(2*i, maxi+1, i):\\n is_prime[j] = False\\n\\n return is_prime\",\n \"def start_prime_test():\",\n \"def gen_primes():\\n\\tyield 2\\n\\tyield 3\\n\\tprime_list = [2, 3]\\n\\twhile 1:\\n\\t\\tnext = prime_list[-1] + 2\\n\\t\\ti = 0\\n\\t\\twhile i < len(prime_list):\\n\\t\\t\\tif next%prime_list[i] == 0:\\n\\t\\t\\t\\tnext+=2\\n\\t\\t\\t\\ti=0\\n\\t\\t\\telse:\\n\\t\\t\\t\\ti+=1\\n\\t\\tprime_list.append(next)\\n\\t\\tyield next\",\n \"def factorize(n:int,primesDict:dict = primesDict):\\r\\n\\r\\n \\r\\n if isPrime(n,primesDict):\\r\\n return {n:1}\\r\\n\\r\\n factors = {}\\r\\n\\r\\n lastPrime = getLastPrime(primesDict)\\r\\n print (lastPrime,\\\"Lastprimes\\\")\\r\\n if lastPrime < n:\\r\\n print (\\\"Creating DictS\\\")\\r\\n\\r\\n prma(n,lastPrime,primesDict)\\r\\n\\r\\n for i in primesDict:\\r\\n if n%i == 0 :\\r\\n count = 0\\r\\n while n % i**(count+1) == 0 :\\r\\n count+=1 \\r\\n factors[i]= count\\r\\n\\r\\n return factors\",\n \"def is_prime_number(number_):\\n flag = 0\\n for values in range(2, number_//2):\\n if number_ % values == 0:\\n flag += 1\\n if flag == 1:\\n return True\\n else:\\n return False\",\n \"def divide(self, val):\\n ancien_pri = 999999\\n ancien_chunck = 1\\n for pri in prime_array:\\n if val % pri == 0 and pri >= self.MINIMUM_NUMBER_OF_CHUNK and val / pri < self.MAXIMUM_SIZE_PER_CHUNK:\\n ancien_pri = int(pri)\\n ancien_chunck = int(val / pri)\\n print({\\\"size\\\": ancien_pri, \\\"chunck\\\": ancien_chunck})\\n self.divide(ancien_chunck)\\n\\n return {\\\"size\\\": ancien_pri, \\\"chunck\\\": ancien_chunck}\",\n \"def get_primes_in(self, grange):\\n for n in grange:\\n if self.is_prime(n):\\n yield n\",\n \"def prime():\\n number = random.randint(1, 100)\\n if len(primfacs(number)) == 1:\\n return number, 'yes'\\n return number, 'no'\",\n \"def find_all_primes(x=22):\\n allprimes = []\\n for i in range(2, x + 1):\\n ##allows all the numbers between 2(smallest prime) and x be divided by x \\n if is_prime(i):\\n #using the function that set up just now\\n allprimes.append(i)\\n #\\n print(\\\"There are %d primes between 2 and %d\\\" % (len(allprimes), x))\\n return allprimes\",\n \"def count_prime_args(num):\\n nums = []\\n for i in range(2, num):\\n if is_prime(i):\\n nums.append(i)\\n return nums\",\n \"def factor_primes(x, iter):\\n factors = []\\n for factor in prime:\\n while x % factor == 0:\\n x = x / factor\\n factors.append(factor)\\n if x == 1:\\n break\\n return factors\",\n \"def main():\\n primes = getNPrime(100)\\n\\n write_primes(primes, 'output.csv')\\n\\n prime_list = read_primes('output.csv')\\n\\n print(prime_list)\",\n \"def findPrimes(prime_bit, N, num):\\n primes = []\\n total_bits = 0\\n prime = pow(2, prime_bit - 1)\\n while len(primes) != num:\\n prime = nextprime(prime)\\n if prime % (2 * N) == 1:\\n primes.append(prime)\\n total_bits += prime.bit_length()\\n\\n return primes, total_bits\",\n \"def prime_checker(num):\\n\\n assert num > 0\\n\\n if num < 2:\\n return False\\n\\n if num == 2:\\n return True\\n\\n if num % 2 == 0:\\n return False\\n\\n n = 3\\n\\n while n * n <= num:\\n\\n if num % n == 0:\\n return False\\n\\n else:\\n num += 2\\n\\n return True\",\n \"def is_prime(num1):\\n num2 = 2\\n while num2 < num1:\\n if num1 % num2 == 0:\\n return False\\n num2 += 1\\n return True\",\n \"def prime_numbers(max_number_eval=100):\\n prime_numbers_list = list(next_prime(max_number_eval))\\n print('The prime numbers from 2 to {} are:{}'.format(max_number_eval, prime_numbers_list))\",\n \"def primes(n):\\n return [i for i, v in enumerate(prime_cache(n)) if v]\",\n \"def is_prime(num: int) -> bool:\\n if num < 2:\\n return False\\n low_primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73,\\n 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163,\\n 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251,\\n 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349,\\n 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443,\\n 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557,\\n 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647,\\n 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757,\\n 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863,\\n 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983,\\n 991, 997]\\n if num in low_primes:\\n return True\\n for prime in low_primes:\\n if num % prime == 0:\\n return False\\n return rabin_miller(num)\",\n \"def Primes():\\n candidate = 1\\n _primes_so_far = [2] # first prime, only even prime\\n yield _primes_so_far[-1]\\n while True:\\n candidate += 2 # check odds only from now on\\n for prev in _primes_so_far:\\n if prev**2 > candidate:\\n yield candidate\\n _primes_so_far.append(candidate)\\n break\\n if not divmod(candidate, prev)[1]: # no remainder!\\n break # done looping\",\n \"def is_prime(value):\\n\\n if value < 2: raise ValueError\\n\\n for i in range(2, value):\\n if value % i == 0:\\n return False\\n\\n return True\",\n \"def test_prime(n):\\n if SIEVE[n]:\\n return True\\n else:\\n return False\",\n \"def run_test_sum_until_prime_input():\\n print()\\n print(\\\"--------------------------------------------------\\\")\\n print(\\\"Testing the sum_until_prime_input function:\\\")\\n print(\\\"--------------------------------------------------\\\")\\n\\n sum_until_prime_input()\",\n \"def prime_facts(primes, number):\\n\\n facts = set()\\n sqr = number ** 0.5\\n for prime in primes:\\n if prime > sqr:\\n if number > 1:\\n facts.add(number)\\n break\\n while number % prime == 0:\\n facts.add(prime)\\n number /= prime\\n sqr = number ** 0.5\\n\\n return facts\",\n \"def primes(n):\\n primfac = {}\\n primfac = defaultdict(lambda: 0, primfac)\\n while (n % 2) == 0:\\n primfac[2] += 1 \\n n //= 2\\n d = 3\\n while d*d <= n:\\n while (n % d) == 0:\\n primfac[d] += 1 # supposing you want multiple factors repeated\\n n //= d\\n d += 2\\n if n > 1:\\n primfac[n] = 1\\n return primfac\",\n \"def find_prime_divisors(self, num):\\n # If the number is prime, it is only divisible by itself.\\n if pe_005.is_prime(num) or num < 2:\\n return {num: 1}\\n\\n # If there were no primes searched for, then search for primes.\\n if len(self._primes) <= 0:\\n self.find_primes(num)\\n\\n results = dict()\\n # Loop through the sorted primes list and stop when the prime is larger than the given number.\\n for prime in self._primes[::-1]:\\n if num <= 0:\\n break\\n\\n # Count the number of divisions of the prime number into the current number.\\n count, num = pe_005.count_divisions(num, prime)\\n if count > 0:\\n results[prime] = count\\n\\n return results\",\n \"def prime_generator(num):\\n prime_list = [i for i in range(1,num+1,2) if prime_checker(i)]\\n\\n if num > 1:\\n prime_list.insert(0,2)\\n\\n return prime_list\",\n \"def comprobar_primo(num):\\n primo = True\\n for i in range(2, num):\\n if num%i == 0:\\n primo = False\\n return primo\",\n \"def prime_factors(number: int) -> dict:\\n f = {}\\n i = 2\\n while number > 1 and number >= i:\\n if number % i == 0:\\n if i not in f:\\n f[i] = 1\\n else:\\n f[i] += 1\\n number //= i\\n else:\\n i += 1\\n return f\",\n \"def getPrimes(self):\\n try:\\n primes_file = open(self.primes_path, 'r')\\n except FileNotFoundError:\\n logger.warning(f\\\"Unable to open moduli file '{self.primes_path}'. This will reduce the number of\\\"\\n f\\\"available key exchange algorithms, and may affect compatibility.\\\")\\n return {}\\n\\n try:\\n primes = {}\\n for line in primes_file:\\n line = line.strip()\\n if not line or line[0] == '#':\\n continue\\n tim, typ, tst, tri, size, gen, mod = line.split()\\n size = int(size) + 1\\n gen = int(gen)\\n mod = int(mod, 16)\\n if size not in primes:\\n primes[size] = []\\n primes[size].append((gen, mod))\\n return primes\\n finally:\\n primes_file.close()\",\n \"def generatePrimesSieve(count):\\n\\tif count < 1:\\n\\t\\treturn None\\n\\n\\tsieve = itertools.count(3, 2)\\n\\tlastPrime = 2\\n\\tfor i in xrange(1, count):\\n\\t\\tlastPrime = sieve.next()\\n\\t\\tprint lastPrime\\n\\t\\tsieve = filterPrime(sieve, lastPrime)\\n\\treturn lastPrime\",\n \"def get_primes(self, state, action): #make direct call to environment's get_primes\\n pass\",\n \"def async_is_prime(x):\\n if x < 2:\\n return False\\n for i in range(2, int(math.sqrt(x)) + 1):\\n time.sleep(0.1)\\n if x % i == 0:\\n return False\\n yield from async_sleep(0)\\n return True\",\n \"def prime():\\n from transformers import pipeline\\n\\n primer = pipeline(\\\"feature-extraction\\\")\\n result = primer([\\\"hello\\\"])\",\n \"def get_primes(lower: int, upper: int) -> typing.Generator[int, None, None]:\\r\\n for num in range(lower, upper + 1):\\r\\n if num > 1:\\r\\n for i in range(2, int(math.sqrt(num)) + 1):\\r\\n if num % i == 0:\\r\\n break\\r\\n else:\\r\\n yield num\",\n \"def all_primes(nums):\\n return list(filter(lambda x: all(x % i != 0 for i in range(2, x)), nums))\\n # assume is_prime is defined:\\n # def is_prime(n):\\n # return all(n % i != 0 for i in range(2, n))\\n # return list(filter(is_prime, nums))\",\n \"def primos(x):\\n def esprimo(n):\\n \\\"\\\"\\\"\\n Determines whether a natural number is a prime number\\n :param n: Agiven natural number\\n :return: True if prime, False otherwise\\n \\\"\\\"\\\"\\n toret = False\\n if x == 2:\\n toret = True\\n elif x % 2 == 0:\\n toret = False\\n else:\\n for i in range(3, x, 2):\\n if x % i == 0:\\n break\\n else:\\n toret = True\\n # Se ejecuta cuando no se rompe el bucle\\n\\n return toret\\n\\n toret = []\\n for i in range(0, x):\\n if esprimo(i):\\n toret.append(i)\\n\\n return toret\",\n \"def is_prime(num):\\n\\n if num == 2:\\n return True\\n for i in range(2, num):\\n if num % i == 0:\\n return False\\n return True\",\n \"def problem077():\\n\\n cond = lambda n: num_prime_sum_ways(n) > 5000\\n ans = next(filter(cond, itertools.count(2)))\\n return ans\",\n \"def isprime(n):\\r\\n\\treturn is_prime(n)\",\n \"def is_prime(num):\\n if num < 2:\\n return False\\n\\n for i in range(2, num):\\n if num % i == 0:\\n return True\",\n \"def get_set_prime_numbers(number):\\n prime_numbers = set()\\n\\n for i in range(2, number + 1):\\n for j in prime_numbers:\\n if i % j == 0:\\n break\\n else:\\n prime_numbers.add(i)\\n\\n return prime_numbers\",\n \"def gen_primes(N):\\n primes = set()\\n for n in range(2, N):\\n if all(n % p > 0 for p in primes):\\n primes.add(n)\\n yield n\",\n \"def is_prime(number):\\n if number <=3:\\n return True\\n \\n for i in range(2, number):\\n if number % i == 0:\\n return False\\n \\n return True\",\n \"def check_valves(self):\\n for name in self._pipes:\\n if self._data[name].check_valve:\\n yield name\",\n \"def return_prime_numbers_less_tahn_100():\\r\\n primes = []\\r\\n for num in range(100):\\r\\n is_prime = True\\r\\n for i in range(2, num):\\r\\n if num % i == 0:\\r\\n is_prime = False \\r\\n if is_prime:\\r\\n primes.append(num)\\r\\n return primes\",\n \"def prime_generator():\\r\\n for i in itertools.count(start=1):\\r\\n for j in ((6 * i) - 1, (6 * i) + 1):\\r\\n if is_prime(j): yield(j)\",\n \"def primes(upper_bound):\\n global cache\\n lower_bound = 2\\n prime_set = new_primes(upper_bound, cache, lower_bound)\\n prime_set.update(cache)\\n cache = prime_set\\n\\n return prime_set\",\n \"def test_if_it_outputs_correct_output(self):\\n self.assertEquals(prime_numbers(5), [2, 3, 5])\",\n \"def is_prime(num):\\n\\n assert num >= 0, \\\"Num should be a positive integer!\\\"\\n\\n if num < 2:\\n return False\\n\\n if num == 2:\\n return True\\n\\n if num % 2 == 0:\\n return False\\n\\n n = 3\\n while n * n <= num:\\n if num % n == 0:\\n return False\\n n += 2\\n\\n return True\",\n \"def prevPrimes(n):\\r\\n from numbers import Integral as types #'Integral' is a class of integers/long-numbers\\r\\n if not isinstance(n, types): raise TypeError(\\\"n must be int, not \\\" + str(type(n)))\\r\\n if n < 2: raise ValueError(\\\"n must greater than 2\\\")\\r\\n primes_dict = {i : True for i in range(2, n + 1)} # initializes the dictionary\\r\\n for i in primes_dict:\\r\\n if primes_dict[i]: #avoids going through multiples of numbers already declared False\\r\\n num = 2\\r\\n while (num * i <= n): #sets all multiples of i (up to n) as False\\r\\n primes_dict[num*i] = False\\r\\n num += 1\\r\\n return [num for num in primes_dict if primes_dict[num]]\",\n \"def xprimes(step=1000):\\n\\n\\tif step % 2:\\n\\t\\traise ValueError(\\\"step is not even\\\")\\n\\n\\tprimes = [2]\\n\\tmultiples = [4] # least multiple of prime at index i in primes not yet marked\\n\\tlower = 2\\n\\tupper = 4\\n\\t\\n\\twhile True:\\n\\t\\t\\n\\t\\t# non-prime numbers will live here\\n\\t\\tnums = set()\\n\\t\\t\\n\\t\\tfor i, p in enumerate(primes):\\n\\n\\t\\t\\t# You've marked everything worth marking (for now)\\n\\t\\t\\tif p * p > upper:\\n\\t\\t\\t\\tbreak\\n\\t\\t\\t# Pick up marking where you left off\\n\\t\\t\\tm = multiples[i]\\n\\t\\t\\t\\n\\t\\t\\t# Do some marking\\n\\t\\t\\twhile m < upper: # upper is even, cannot be prime\\n\\t\\t\\t\\tnums.add(m)\\n\\t\\t\\t\\tm += p\\n\\t\\t\\t\\n\\t\\t\\t# Left off on this multiple (save for later)\\n\\t\\t\\tmultiples[i] = m\\n\\t\\t\\n\\t\\t# Collect primes between lower and upper\\n\\t\\tfor i in xrange(lower, upper): # upper is even, cannot be prime\\n\\t\\t\\tif i not in nums:\\n\\t\\t\\t\\tyield i\\n\\t\\t\\t\\tprimes.append(i)\\n\\t\\t\\t\\tmultiples.append(i + i) # 2 * i (i is a new prime)\\n\\t\\t\\n\\t\\t# Got all the primes in this interval; move it up\\n\\t\\tlower = upper + 1\\n\\t\\tupper += min(upper, step)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.62043977","0.60420763","0.6040586","0.59742284","0.5961007","0.59362507","0.5920342","0.5811969","0.5799837","0.57528454","0.5740674","0.5735719","0.5734782","0.5734576","0.5731913","0.5719384","0.5716878","0.5673636","0.5661564","0.56440914","0.5617547","0.5578173","0.5564181","0.5558922","0.55565923","0.5552255","0.555117","0.5508194","0.5504439","0.55032545","0.55011624","0.5487311","0.5487311","0.54709274","0.54572856","0.54407775","0.54397815","0.54036415","0.5392185","0.53752345","0.53607804","0.53607565","0.53553426","0.535175","0.5343479","0.53317267","0.5323993","0.5319864","0.53195685","0.53178823","0.5305513","0.5301813","0.5297095","0.5290977","0.52860576","0.5275716","0.5270868","0.5270836","0.52675486","0.5242941","0.52350926","0.5231719","0.5218083","0.5207062","0.5186822","0.51792186","0.51734275","0.5160786","0.51425296","0.51405346","0.51399857","0.5136314","0.5135468","0.5129973","0.5128546","0.51267517","0.5119112","0.5119068","0.51160455","0.5114746","0.5111454","0.5105649","0.5105542","0.5103376","0.5102204","0.5102189","0.5101645","0.50802064","0.50772744","0.507401","0.50720185","0.50702053","0.50654787","0.5062128","0.50594157","0.50522876","0.5051625","0.5049884","0.50385785","0.50350606"],"string":"[\n \"0.62043977\",\n \"0.60420763\",\n \"0.6040586\",\n \"0.59742284\",\n \"0.5961007\",\n \"0.59362507\",\n \"0.5920342\",\n \"0.5811969\",\n \"0.5799837\",\n \"0.57528454\",\n \"0.5740674\",\n \"0.5735719\",\n \"0.5734782\",\n \"0.5734576\",\n \"0.5731913\",\n \"0.5719384\",\n \"0.5716878\",\n \"0.5673636\",\n \"0.5661564\",\n \"0.56440914\",\n \"0.5617547\",\n \"0.5578173\",\n \"0.5564181\",\n \"0.5558922\",\n \"0.55565923\",\n \"0.5552255\",\n \"0.555117\",\n \"0.5508194\",\n \"0.5504439\",\n \"0.55032545\",\n \"0.55011624\",\n \"0.5487311\",\n \"0.5487311\",\n \"0.54709274\",\n \"0.54572856\",\n \"0.54407775\",\n \"0.54397815\",\n \"0.54036415\",\n \"0.5392185\",\n \"0.53752345\",\n \"0.53607804\",\n \"0.53607565\",\n \"0.53553426\",\n \"0.535175\",\n \"0.5343479\",\n \"0.53317267\",\n \"0.5323993\",\n \"0.5319864\",\n \"0.53195685\",\n \"0.53178823\",\n \"0.5305513\",\n \"0.5301813\",\n \"0.5297095\",\n \"0.5290977\",\n \"0.52860576\",\n \"0.5275716\",\n \"0.5270868\",\n \"0.5270836\",\n \"0.52675486\",\n \"0.5242941\",\n \"0.52350926\",\n \"0.5231719\",\n \"0.5218083\",\n \"0.5207062\",\n \"0.5186822\",\n \"0.51792186\",\n \"0.51734275\",\n \"0.5160786\",\n \"0.51425296\",\n \"0.51405346\",\n \"0.51399857\",\n \"0.5136314\",\n \"0.5135468\",\n \"0.5129973\",\n \"0.5128546\",\n \"0.51267517\",\n \"0.5119112\",\n \"0.5119068\",\n \"0.51160455\",\n \"0.5114746\",\n \"0.5111454\",\n \"0.5105649\",\n \"0.5105542\",\n \"0.5103376\",\n \"0.5102204\",\n \"0.5102189\",\n \"0.5101645\",\n \"0.50802064\",\n \"0.50772744\",\n \"0.507401\",\n \"0.50720185\",\n \"0.50702053\",\n \"0.50654787\",\n \"0.5062128\",\n \"0.50594157\",\n \"0.50522876\",\n \"0.5051625\",\n \"0.5049884\",\n \"0.50385785\",\n \"0.50350606\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.78329885"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":8783,"cells":{"query":{"kind":"string","value":"Reject unsuported chain parts"},"document":{"kind":"string","value":"def _select_simple_chainparts(chain_parts):\n\n for cp in chain_parts:\n if reject_substr_res.search(cp['chainPartName']):\n return False\n\n return True"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def validate_chain():","def reject(self):\n pass","def test_blind_sig_chain_wrong_intermediary(self): # pylint: disable=too-many-locals\n\n test_levels = 4\n msg = os.urandom(1024)\n wrong_level = 2\n\n ca = ECCBlind()\n signer_obj = ca\n fake_intermediary = ECCBlind()\n\n output = bytearray()\n\n for level in range(test_levels):\n if not level:\n output.extend(ca.pubkey())\n requester_obj = ECCBlind(pubkey=signer_obj.pubkey())\n child_obj = ECCBlind()\n point_r = signer_obj.signer_init()\n pubkey = child_obj.pubkey()\n\n if level == test_levels - 1:\n msg_blinded = requester_obj.create_signing_request(point_r,\n msg)\n else:\n msg_blinded = requester_obj.create_signing_request(point_r,\n pubkey)\n signature_blinded = signer_obj.blind_sign(msg_blinded)\n signature = requester_obj.unblind(signature_blinded)\n if level == wrong_level:\n output.extend(fake_intermediary.pubkey())\n elif level != test_levels - 1:\n output.extend(pubkey)\n output.extend(signature)\n signer_obj = child_obj\n verifychain = ECCBlindChain(ca=ca.pubkey(), chain=str(output))\n self.assertFalse(verifychain.verify(msg, 1))","def _filter_committees_failing_weak_representation(self, profile: list[set[int]], committees: list[list[int]]) -> list[list[int]]:\n unique_approval_scores = self._compute_unique_approval_scores(profile)\n parties_deserving_representation = {party for party in self.parties if unique_approval_scores[party] >= self.n / self.k}\n possible_committees = [committee for committee in committees if parties_deserving_representation.issubset(set(committee))]\n return possible_committees","def test_exact_nonsupercontrolled_decompose(self):\n with self.assertWarns(UserWarning, msg=\"Supposed to warn when basis non-supercontrolled\"):\n TwoQubitBasisDecomposer(UnitaryGate(Ud(np.pi / 4, 0.2, 0.1)))","def test_blind_sig_chain_wrong_msg(self): # pylint: disable=too-many-locals\n\n test_levels = 4\n msg = os.urandom(1024)\n fake_msg = os.urandom(1024)\n\n ca = ECCBlind()\n signer_obj = ca\n\n output = bytearray()\n\n for level in range(test_levels):\n if not level:\n output.extend(ca.pubkey())\n requester_obj = ECCBlind(pubkey=signer_obj.pubkey())\n child_obj = ECCBlind()\n point_r = signer_obj.signer_init()\n pubkey = child_obj.pubkey()\n\n if level == test_levels - 1:\n msg_blinded = requester_obj.create_signing_request(point_r,\n msg)\n else:\n msg_blinded = requester_obj.create_signing_request(point_r,\n pubkey)\n signature_blinded = signer_obj.blind_sign(msg_blinded)\n signature = requester_obj.unblind(signature_blinded)\n if level != test_levels - 1:\n output.extend(pubkey)\n output.extend(signature)\n signer_obj = child_obj\n verifychain = ECCBlindChain(ca=ca.pubkey(), chain=str(output))\n self.assertFalse(verifychain.verify(fake_msg, 1))","def valid_chain(chain):\n last_block = chain[0]\n current_index = 1\n\n while current_index < len(chain):\n block = chain[current_index]\n #print(last_block)\n #print(block)\n #print(\"\\n-----------\\n\")\n # Check that the hash of the block is correct\n if block['previous_hash'] != hash(last_block):\n return False\n\n # Check that the Proof of Work is correct\n #Delete the reward transaction\n transactions = block['transactions'][:-1]\n # Need to make sure that the dictionary is ordered. Otherwise we'll get a different hash\n transaction_elements = ['sender_address', 'recipient_address', 'value']\n transactions = [OrderedDict((k, transaction[k]) for k in transaction_elements) for transaction in transactions]\n\n if not valid_proof(transactions, block['previous_hash'], block['nonce'], MINING_DIFFICULTY):\n return False\n\n last_block = block\n current_index += 1\n\n return True","def squeeze_accept(partition):\n Write a function that\n - Sort districts by most Democratic heavy and most Republican heavy\n\n - Assign a base value of competitiveness for each district\n - Run chain, accept only if districts satisfy values under or order\n \"\"\"\n\n#--- CONSTRAINTS\n\n\"\"\"","def remove_incompatible_operations(pipelines):\n\n def find_duplicates(pipelines):\n for idx in range(len(pipelines)):\n for idx_ in range(idx + 1, len(pipelines)):\n if pipelines[idx] == pipelines[idx_]:\n return idx\n return -1\n\n\n def _remove_illegal_combination(pipelines, combination):\n illegal_pipes = []\n pipelines_ = []\n for idx, pipeline in enumerate(pipelines):\n combination_ = list(set.intersection(set(pipeline.keys()), set(combination)))\n actives = [pipeline[key] != None for key in pipeline if key in combination_]\n\n if sum(actives) > 1:\n illegal_pipes.append(idx) # Store the index of bad combination\n for param in combination_: # Generate substituting legal combinations\n if pipeline[param] != None: # we need to make new pipe\n pipeline_ = pipeline.copy()\n for param_ in combination_: # Set ALL conflicting parameters to None\n pipeline_[param_] = None\n pipeline_[param] = pipeline[param] # Set current parameter back to original value\n pipelines_.append(pipeline_)\n\n new_pipelines = [i for j, i in enumerate(pipelines) if j not in illegal_pipes]\n # new_pipelines.extend(pipelines_)\n return new_pipelines, pipelines_\n\n illegal_combinations = [['BASELINE', 'MSC', 'EMSC', 'RNV', 'SNV', 'LSNV'],\n ['SMOOTH', 'SAVGOL']]\n\n for combination in illegal_combinations:\n pipelines, new_pipes = _remove_illegal_combination(pipelines, combination)\n\n pipelines.extend(new_pipes)\n pipelines_set = {json.dumps(pipeline, sort_keys=True) for pipeline in pipelines}\n pipelines = [json.loads(item) for item in pipelines_set]\n\n\n return pipelines","def extract_mixed_chains(raw_chains):\n chain_isolation_regex = re.compile(r'^\\w+\\s+\\d+\\s+(.*)')\n\n mixed_chains = [\n re.search(chain_isolation_regex,\n raw_chain).group(1).strip() # remove whitespace\n for raw_chain in raw_chains\n ]\n return mixed_chains","def test_unrequired_chain_delete(self):\n self.txn.store_delete(\"felix-c\")\n self.assertEqual(self.txn.affected_chains, set([\"felix-c\"]))\n self.assertEqual(self.txn.chains_to_stub_out, set([]))\n self.assertEqual(self.txn.chains_to_delete, set([\"felix-c\"]))\n self.assertEqual(self.txn.referenced_chains,\n set([\"felix-b\", \"felix-stub\"]))\n self.assertEqual(\n self.txn.prog_chains,\n {\n \"felix-a\": [],\n \"felix-b\": [],\n })\n self.assertEqual(self.txn.required_chns,\n {\"felix-a\": set([\"felix-b\", \"felix-stub\"])})\n self.assertEqual(self.txn.requiring_chns,\n {\"felix-b\": set([\"felix-a\"]),\n \"felix-stub\": set([\"felix-a\"])})","def valid_chain(chain):\n\n for i in range(len(chain) - 1):\n parent_edge = chain[i]\n child_edge = chain[i + 1]\n # verify that the child of the parent edge (second node) matches the parent of the child edge (first node)\n if not parent_edge[1] == child_edge[0]:\n # if this isn't\n return False\n return True","def resolve_conflicts(self):\n neighbours = self.nodes\n new_chain = None\n # Look only for chains longer than this\n max_length = len(self.chain)\n # Get and verify the chains from all the nodes in the network\n for node in neighbours:\n response = requests.get(f'http://{node}/chain')\n if response.status_code == 200:\n length = response.json()['length']\n chain = response.json()['chain']\n # Check if chain is longer and valid\n if length > max_length and self.valid_chain(chain):\n max_length = length\n new_chain = chain\n # Replace this chain if a longer valid chain is discovered\n if new_chain:\n self.chain = new_chain\n return True\n return False","def validate_blockchain(chain):\n assert isinstance(chain, list)\n\n for hook in chain[::-1]:\n pass","def valid_chain(self, chain):\n last_block = chain[0]\n current_index = 1\n\n while current_index < len(chain):\n block = chain[current_index]\n print(f'{last_block}')\n print(f'{block}')\n print(\"\\n----------------\\n\")\n # verify hash integrity\n if block['previous_hash'] != self.hash(last_block):\n return False\n\n # verify proof integrity\n if not self.valid_proof(last_block['proof'], block['proof']):\n return False\n\n last_block = block\n current_index += 1\n\n return True","def route_rejected(self, prefix, next_hop, as_path):","def test_fail_missing_signature_fragment_underflow(self):\n # Adjust bundle balance, since we will also remove the change\n # transaction.\n self.bundle[0].value += self.bundle[-1].value\n\n # Remove the last input's second signature fragment, and the change\n # transaction.\n del self.bundle.transactions[-2:]\n for txn in self.bundle:\n txn.last_index -= 2\n\n validator = BundleValidator(self.bundle)\n\n self.assertFalse(validator.is_valid())\n\n self.assertListEqual(\n validator.errors,\n\n [\n 'Transaction 4 has invalid signature (using 2 fragments).',\n ],\n )","def resolve_conflicts(self):\n neighbours = self.nodes\n new_chain = None\n\n # We are only looking for chains longer that ours\n max_length = len(self.chain)\n\n # Checking for the length of each chain in our network\n for node in neighbours:\n response = requests.get(f'http://{node}/chain')\n\n if response.status_code == 200:\n length = response.json()['length']\n chain = response.json()['chain']\n\n if length > max_length and self.validate_chain(chain):\n new_chain = chain\n max_length = length\n\n # Replace our chain with a new, longer, valid chain in our network (if present)\n if new_chain:\n self.chain = new_chain\n return True\n\n return False","def chain(self):\n return ValueError(\"chain function not set.\")","def chain_rangeValid(start, stop):\r\n for i in range(start, stop):\r\n chain = chain_153(i)\r\n if len(chain) > 1 or chain[0] == 153:\r\n for j in chain_153(i):\r\n print(j)","def resolve_conflicts(self):\n\n neighbours = self.nodes\n new_chain = None\n\n # We're only looking for chains longer than ours\n max_length = len(self.chain)\n\n # Grab and verify the chains from all the nodes in our network\n for node in neighbours:\n response = requests.get(f'http://{node}:5000/chain')\n\n if response.status_code == 200:\n length = response.json()['length']\n chain = response.json()['chain']\n\n # Check if the length is longer and the chain is valid\n if length > max_length:\n max_length = length\n new_chain = chain\n\n # Replace our chain if we discovered a new, valid chain longer than ours\n if new_chain:\n self.chain = new_chain\n return True\n\n return False","def test_blind_sig_chain_wrong_ca(self): # pylint: disable=too-many-locals\n\n test_levels = 4\n msg = os.urandom(1024)\n\n ca = ECCBlind()\n fake_ca = ECCBlind()\n signer_obj = fake_ca\n\n output = bytearray()\n\n for level in range(test_levels):\n requester_obj = ECCBlind(pubkey=signer_obj.pubkey())\n child_obj = ECCBlind()\n if not level:\n # unlisted CA, but a syntactically valid pubkey\n output.extend(fake_ca.pubkey())\n point_r = signer_obj.signer_init()\n pubkey = child_obj.pubkey()\n\n if level == test_levels - 1:\n msg_blinded = requester_obj.create_signing_request(point_r,\n msg)\n else:\n msg_blinded = requester_obj.create_signing_request(point_r,\n pubkey)\n signature_blinded = signer_obj.blind_sign(msg_blinded)\n signature = requester_obj.unblind(signature_blinded)\n if level != test_levels - 1:\n output.extend(pubkey)\n output.extend(signature)\n signer_obj = child_obj\n verifychain = ECCBlindChain(ca=ca.pubkey(), chain=str(output))\n self.assertFalse(verifychain.verify(msg, 1))","def valid_chain(self, chain):\n last_block = chain[0]\n current_index = 1\n\n while current_index < len(chain):\n block = chain[current_index]\n # print(f'{last_block}')\n # print(f'{block}')\n # print(\"\\n-----------\\n\")\n # Check that the hash of the block is correct\n last_block_hash = self.hash(last_block)\n if block['previous_hash'] != self.hash(last_block):\n return False\n\n # Check that the Proof of Work is correct\n if not self.valid_proof(last_block['proof'], block['proof'], last_block_hash):\n return False\n\n last_block = block\n current_index += 1\n\n return True","def valid_chain(self, chain):\n\n last_block = chain[0]\n current_index = 1\n \n while current_index < len(chain):\n block = chain[current_index]\n # Check correctness of last block's hash\n if block['previous_hash'] != self.hash(last_block): \n return False\n # Check correctness of proof-of-work\n if not self.valid_proof(last_block['proof'], block['proof'], block['previous_hash']):\n return False\n last_block = block \n current_index += 1\n\n return True","def valid_chain(self, chain):\n last_block = chain[0]\n current_index = 1\n\n while current_index < len(chain):\n block = chain[current_index]\n print(last_block)\n print(block)\n print(\"\\n--------\\n\")\n \n #check that the hash of the previous block is correct\n\n if block[\"previous_hash\"] != self.hash(last_block):\n print(\"Previous hash does not match\")\n return False\n\n if not self.valid_proof(block):\n print(\"Block proof of work is invalid\")\n return False\n\n last_block = block\n current_index += 1\n\n return True","def resolve_conflicts(self):\n neighbors = self.nodes\n print(neighbors)\n new_chain = None\n\n # We only care about chains longer than our own\n max_length = len(self.chain)\n\n # Get and verify all neighbors chains\n for node in neighbors:\n try:\n url = 'http://{}/chain'.format(node)\n response = requests.get(url)\n if response.status_code == 200:\n length = response.json()['length']\n chain = response.json()['chain']\n\n # Check if longer and chain is valid\n if length > max_length and self.valid_chain(chain):\n max_length = length\n new_chain = chain\n except:\n return False\n # Replace our chain if necessary\n if new_chain:\n self.chain = new_chain\n self._write_chain()\n return True\n\n return False","def resolve_conflicts(self):\n\n neighbours = self.nodes\n new_chain = None\n\n # We're only looking for chains longer than ours\n max_length = len(self.chain)\n\n # Grab and verify the chains from all the nodes in our network\n for node in neighbours:\n response = requests.get(f'http://{node}/chain')\n\n if response.status_code == 200:\n length = response.json()['length']\n chain = response.json()['chain']\n\n # Check if the length is longer and the chain is valid\n if length > max_length and self.valid_chain(chain):\n max_length = length\n new_chain = chain\n\n # Replace our chain if we discovered a new, valid chain longer than ours\n if new_chain:\n self.rewrite_chain(new_chain)\n return True\n\n return False","def test_sort_chain_two_content_3():\n chain = N.Node(2, N.Node(2))\n result = A8.sort_chain(chain)\n\n assert result.data <= result.next.data, \"sort_chain returned chain out of order given input chain size 2 with dupicates\"","def skip_sub_components(self, reason):\n pass","def test_sort_chain_multiple_content_decreasing():\n n = 17\n data = range(n)\n chain = None\n for item in data:\n chain = N.Node(item, chain)\n\n result = A8.sort_chain(chain)\n\n walker = result\n prev = None\n seen = [False]*n\n for i in range(n):\n assert walker.data in data, \"sort_chain created extraneous data {} given chain with values decreasing\".format(walker.data)\n seen[walker.data] = True\n if prev is not None:\n assert prev.data <= walker.data, \"sort_chain placed {} before {} given chain with values decreasing\".format(prev.data, walker.data)\n prev = walker\n walker = walker.next\n\n for i,b in enumerate(seen):\n assert b, \"sort_chain omitted data value {} from returned chain given chain with values decreasing\".format(i)","def test_specific_peer_prefixes_rejected(self):\n rejected_prefixes = self.pybird.get_peer_prefixes_rejected(\"PS1\")\n self.assertEquals(len(rejected_prefixes), 1)\n self.assertEquals(rejected_prefixes[0]['as_path'], '8954 20144')","def test_block_bad_consensus(self):\n pass","def valid_chain(self, chain):\n\n last_block = chain[0]\n current_index = 1\n\n while current_index < len(chain):\n block = chain[current_index]\n print(f'{last_block}')\n print(f'{block}')\n print(\"\\n-----------\\n\")\n # Check that the hash of the block is correct\n last_block_hash = self.hash(last_block)\n if block['previous_hash'] != last_block_hash:\n return False\n\n # Check that the Proof of Work is correct\n if not self.valid_proof(last_block['proof'], block['proof'], last_block_hash):\n return False\n\n last_block = block\n current_index += 1\n\n return True","def pruneblockchain(self) -> None:\n return self.rpc_call(\"pruneblockchain\")","def test_reject_proposal_demand(self):\n pass","def chainIsValid(self):\n for i in range(1, len(self.blocks)):\n prev_block = self.blocks[i-1]\n cur_block = self.blocks[i]\n if cur_block.header['prevBlockH'] != getHashBlock(prev_block):\n return False\n return True","def test_rewrite_existing_chain_remove_normal_dependency(self):\n self.txn.store_rewrite_chain(\"felix-a\", [\"foo\"], set([\"felix-stub\"]))\n self.assertEqual(self.txn.affected_chains, set([\"felix-a\"]))\n self.assertEqual(self.txn.chains_to_stub_out, set([]))\n self.assertEqual(self.txn.chains_to_delete, set([]))\n self.assertEqual(self.txn.referenced_chains, set([\"felix-stub\"]))\n self.assertEqual(\n self.txn.prog_chains,\n {\n \"felix-a\": [\"foo\"],\n \"felix-b\": [],\n \"felix-c\": [],\n })\n self.assertEqual(self.txn.required_chns,\n {\"felix-a\": set([\"felix-stub\"])})\n self.assertEqual(self.txn.requiring_chns,\n {\"felix-stub\": set([\"felix-a\"])})","def verify_chain():\n for (index, block) in enumerate(blockchain):\n if index == 0:\n continue\n if block['previous_hash'] != hash_block(blockchain[index - 1]):\n return False\n # Here [:-1] excludes the reward from being a part of validation\n if not valid_proof(block['transactions'][:-1], block['previous_hash'], block['proof']):\n print('Proof of work is invalid.')\n return False\n return True","def compose(\n # Left side positive filters\n chainLeftIn,resiNumLeftIn,resiNameLeftIn,atomSerialLeftIn,\n atomNameLeftIn,\n # Left side negative filters\n chainLeftOut,resiNumLeftOut,resiNameLeftOut, atomSerialLeftOut,\n atomNameLeftOut,\n # Right side positive filters\n chainRightIn,resiNumRightIn,resiNameRightIn,atomSerialRightIn,\n atomNameRightIn,\n # Right side negative filters\n chainRightOut,resiNumRightOut,resiNameRightOut,atomSerialRightOut,\n atomNameRightOut,\n # Contact Area\n contactAreaMin,contactAreaMax,\n # Minimal distance\n minimalDistanceMin,minimalDistanceMax,\n # Sequence separation\n seqSeparationMin,seqSeparationMax\n ):\n\n output=''\n\n match_first=''\n match_first=append_to_local_output(match_first, 'c', Generic(chainLeftIn))\n match_first=append_to_local_output(match_first, 'r', Generic(resiNumLeftIn))\n match_first=append_to_local_output(match_first, 'a', Generic(atomSerialLeftIn))\n match_first=append_to_local_output(match_first, 'R', Generic(resiNameLeftIn))\n match_first=append_to_local_output(match_first, 'A', Generic(atomNameLeftIn))\n output=append_to_global_output(output, '--match-first', match_first)\n\n match_first_not=''\n match_first_not=append_to_local_output(match_first_not, 'c', Generic(chainLeftOut))\n match_first_not=append_to_local_output(match_first_not, 'r', Generic(resiNumLeftOut))\n match_first_not=append_to_local_output(match_first_not, 'a', Generic(atomSerialLeftOut))\n match_first_not=append_to_local_output(match_first_not, 'R', Generic(resiNameLeftOut))\n match_first_not=append_to_local_output(match_first_not, 'A', Generic(atomNameLeftOut))\n output=append_to_global_output(output, '--match-first-not', match_first_not)\n\n match_second=''\n match_second=append_to_local_output(match_second, 'c', Generic(chainRightIn))\n match_second=append_to_local_output(match_second, 'r', Generic(resiNumRightIn))\n match_second=append_to_local_output(match_second, 'a', Generic(atomSerialRightIn))\n match_second=append_to_local_output(match_second, 'R', Generic(resiNameRightIn))\n match_second=append_to_local_output(match_second, 'A', Generic(atomNameRightIn))\n output=append_to_global_output(output, '--match-second', match_second)\n\n match_second_not=''\n match_second_not=append_to_local_output(match_second_not, 'c', Generic(chainRightOut))\n match_second_not=append_to_local_output(match_second_not, 'r', Generic(resiNumRightOut))\n match_second_not=append_to_local_output(match_second_not, 'a', Generic(atomSerialRightOut))\n match_second_not=append_to_local_output(match_second_not, 'R', Generic(resiNameRightOut))\n match_second_not=append_to_local_output(match_second_not, 'A', Generic(atomNameRightOut))\n output=append_to_global_output(output, '--match-second-not', match_second_not)\n\n output=append_to_global_output(output, '--match-min-area', Float(contactAreaMin))\n output=append_to_global_output(output, '--match-max-area', Float(contactAreaMax))\n\n output=append_to_global_output(output, '--match-min-dist', Float(minimalDistanceMin))\n output=append_to_global_output(output, '--match-max-dist', Float(minimalDistanceMax))\n\n output=append_to_global_output(output, '--match-min-seq-sep', Int(seqSeparationMin))\n output=append_to_global_output(output, '--match-max-seq-sep', Int(seqSeparationMax))\n\n return output","def test_mediate_transfer_fails_if_intermediate_trustline_frozen(\n currency_network_contract_with_frozen_trustline, accounts\n):\n network = currency_network_contract_with_frozen_trustline\n\n path = [accounts[4], accounts[0], accounts[1], accounts[2]]\n\n with pytest.raises(eth_tester.exceptions.TransactionFailed):\n network.functions.transfer(10, 10, path, b\"\").transact({\"from\": accounts[4]})","def resolve_conflict(self):\n neighbours = self.nodes\n new_chain = None\n #We're only looking for chains Longer than ours\n max_length = len(self.chain)\n #Grab and verify the chains from all the other nodes in our netwrok\n for node in neighbours:\n response = requests.get(f'http://{node}/chain')\n if response.status_code == 200:\n length = response.json()['length']\n chain = response.json()['chain']\n #check if the lentgh is longer and the cain is valid\n if length > max_length and self.valid_chain(chain):\n max_length = length\n new_chain = chain\n\n #replace our chain if we're discovered a new valid chain, Longer than ours\n if new_chain:\n self.chain = new_chain\n return True\n\n return False","def filter_invalid_combos(m: 'Mods') -> 'Mods':\n if m & (Mods.DOUBLETIME | Mods.NIGHTCORE) and m & Mods.HALFTIME:\n m &= ~Mods.HALFTIME\n if m & Mods.EASY and m & Mods.HARDROCK:\n m &= ~Mods.HARDROCK\n if m & Mods.RELAX and m & Mods.AUTOPILOT:\n m &= ~Mods.AUTOPILOT\n if m & Mods.PERFECT and m & Mods.SUDDENDEATH:\n m &= ~Mods.SUDDENDEATH\n\n return m","def valid_chain(self, chain):\n last_block = chain[0]\n current_index = 1\n\n while current_index < len(chain):\n block = chain[current_index]\n\n # Check that the hash of block is correct\n if block['previous_hash'] != self.hash(last_block):\n return False\n\n # Check the Proof of Work\n if not self.valid_proof(last_block['proof'], block['proof']):\n return False\n \n last_block = block\n current_index += 1\n return True","def strip_loan(chain):\n while chain[-1]['action'] == 'LOAN':\n chain.pop()\n\n return chain","def reject_fairness(experiment):\n num_heads = len([flip for flip in experiment if flip])\n return num_heads < 469 or num_heads > 531","def reject_fairness(experiment):\n num_heads = len([flip for flip in experiment if flip])\n return num_heads < 469 or num_heads > 531","def reject_fairness(experiment):\n num_heads = len([flip for flip in experiment if flip])\n return num_heads < 469 or num_heads > 531","def badMuons(self, allmuons, allvertices):\n\n muons = list(m for m in allmuons) # make it a python list\n goodMuon = []\n\n if len(allvertices) < 1: raise RuntimeError\n PV = allvertices[0].position()\n \n out = [] \n for mu in muons:\n if (not(mu.isPFMuon()) or mu.innerTrack().isNull()):\n goodMuon.append(-1); # bad but we don't care\n continue;\n if (self.preselection(mu)):\n dxypv = abs(mu.innerTrack().dxy(PV));\n dzpv = abs(mu.innerTrack().dz(PV));\n if (self.tighterId(mu)):\n ipLoose = ((dxypv < 0.5 and dzpv < 2.0) or mu.innerTrack().hitPattern().pixelLayersWithMeasurement() >= 2);\n goodMuon.append(ipLoose or (not(self.selectClones_) and self.tightGlobal(mu)));\n elif (self.safeId(mu)):\n ipTight = (dxypv < 0.2 and dzpv < 0.5);\n goodMuon.append(ipTight);\n else:\n goodMuon.append(0);\n else:\n goodMuon.append(3); # maybe good, maybe bad, but we don't care\n\n n = len(muons)\n for i in range(n):\n if (muons[i].pt() < self.ptCut_ or goodMuon[i] != 0): continue;\n bad = True;\n if (self.selectClones_):\n bad = False; # unless proven otherwise\n n1 = muons[i].numberOfMatches(ROOT.reco.Muon.SegmentArbitration);\n for j in range(n):\n if (j == i or goodMuon[j] <= 0 or not(self.partnerId(muons[j]))): continue\n n2 = muons[j].numberOfMatches(ROOT.reco.Muon.SegmentArbitration);\n if (deltaR(muons[i],muons[j]) < 0.4 or (n1 > 0 and n2 > 0 and ROOT.muon.sharedSegments(muons[i],muons[j]) >= 0.5*min(n1,n2))):\n bad = True;\n break;\n if (bad):\n out.append(muons[i]);\n return out","def filter_unknown_bases(self):\n self.failed[\"unknowns\"] = self.stats.index[\n self.stats[\"unknowns\"] > self.tolerance[\"unknowns\"]\n ]\n self.passed = self.stats.drop(self.failed[\"unknowns\"])","def is_chain_valid(self, chain):\r\n previous_block = chain[0]\r\n block_index = 1\r\n while block_index < len(chain):\r\n block = chain[block_index]\r\n if block['previous_hash'] != self.hash(previous_block):\r\n return False\r\n previous_proof = previous_block['proof']\r\n proof = block['proof']\r\n hash_operation = self.hash(block)\r\n if hash_operation[:4] != '0000':\r\n return False\r\n previous_block = block\r\n block_index += 1\r\n return True","def reject_fairness(experiment):\n num_heads = len([flip for flip in experiment if flip])\n return num_heads < 468 or num_heads > 531","def validate_chain(self):\n chain_length = len(self.chain)\n isValid = None\n\n if(chain_length == 1):\n return \"Add blocks and then validate chain.\"\n\n for x in range(0, chain_length, 1):\n if(x < chain_length-1):\n # Hash the current block\n hash = self.hash(self.chain[x])\n next_block_prev_hash = self.chain[x+1]['prev_hash']\n\n if(hash == \"0\" and x == 0):\n isValid = True\n\n if(hash != next_block_prev_hash):\n isValid = False\n return isValid\n else:\n isValid = True\n\n return isValid","def test_ensure_passage_is_not_removed(self):\n simple = self.TEI.getPassage(MyCapytain.common.reference.Reference(\"1.pr.1-1.2.5\"))\n orig_refs = self.TEI.getValidReff(level=3)\n self.assertIn(\"1.pr.1\", orig_refs)\n self.assertIn(\"1.1.1\", orig_refs)\n self.assertIn(\"1.2.4\", orig_refs)\n self.assertIn(\"1.2.5\", orig_refs)\n\n simple = self.TEI.getPassage(MyCapytain.common.reference.Reference(\"1.pr-1.2\"))\n orig_refs = self.TEI.getValidReff(level=3)\n self.assertIn(\"1.pr.1\", orig_refs)\n self.assertIn(\"1.1.1\", orig_refs)\n self.assertIn(\"1.2.4\", orig_refs)\n self.assertIn(\"1.2.5\", orig_refs)","def check_auto_reject(self):\r\n for pr in self:\r\n if not pr.line_ids.filtered(lambda l: l.cancelled is False):\r\n pr.write({'state': 'rejected'})","def repair(self):\n self.dot = self.dot.replace('()', '..').replace('(.)', '...').replace('(..)', '....').replace('(...)', '.....')\n self.matrix = pair_matrix(self)\n length = len(self.seq)\n for x in range(length):\n for y in range(x, length):\n if self.matrix[x, y] == 1:\n if not is_pair_allowed(self.seq[x], self.seq[y]):\n self.dot = self.dot[:x] + '.' + self.dot[x + 1:y] + '.' + self.dot[y + 1:]\n return self","def diagnose_chain(chain):\n if chain[0] == 'all':\n dir = data.meta_dir_base()\n if os.path.exists(dir):\n for chain_id in os.listdir(dir):\n if utils.valid_chain_id(chain_id):\n diagnose_server(chain_id)\n else:\n consoler.info(' No published chain exist, do nothing.')\n else:\n for i in range(len(chain)):\n chain_get = chain[i].split(':')\n if len(chain_get) == 1:\n if utils.valid_chain_id(chain_get[0]):\n diagnose_server(chain_get[0])\n else:\n consoler.info(\n ' skip, invalid chain_id, chain_id is %s', chain_get[0])\n elif len(chain_get) == 2:\n if utils.valid_chain_id(chain_get[0]):\n if utils.valid_ip(chain_get[1]):\n ansible.diagnose_module(\n chain_get[1], ansible.get_dir() + '/' + chain_get[0])\n else:\n consoler.info(\n ' skip, invalid host, chain_id is %s, host is %s', chain_get[0], chain_get[1])\n else:\n consoler.info(\n ' skip, invalid chain_id, chain_id is %s, host is %s', chain_get[0], chain_get[1])\n else:\n consoler.info(\n ' skip, invalid format, not chain_id:host, input %s', chain_get)","def checkGuide(seq, plen, pam, rpam, is_upstream_pam):\n if is_upstream_pam:\n if pam.match(seq[:plen]):\n yield seq, \"+\"\n if rpam.match(seq[-plen:]):\n yield reverseComplement(seq), \"-\"\n else:\n if pam.match(seq[-plen:]):\n yield seq, \"+\"\n if rpam.match(seq[:plen]):\n yield reverseComplement(seq), \"-\"\n #yield \"\", \"\"","def badExitPrevMolecule(self):\n if self.molecules > 0:\n # collect list of any atoms where num departed is not expected num per molecule\n departErrors = [(atom.name, count) for atom, count in self.departed.items() if self.departed[atom] != atom.value]\n if len(departErrors) > 0:\n print(\"too many or too few atoms exited between previous and this molecule creations.\")\n print( \"Exit counts:\", departErrors)\n return False\n return True","def test_sort_chain_two_structure_3():\n chain = N.Node(2, N.Node(2))\n result = A8.sort_chain(chain)\n\n assert result is not None, \"sort_chain returned empty chain given input chain size 2 with dupicates\"\n assert result.next is not None, \"sort_chain returned singleton chain given input chain size 2 with dupicates\"\n assert result.next.next is None, \"sort_chain returned extended chain given input chain size 2 with dupicates\"","def check_seps(seps):\n if seps:\n seps = seps.keys()\n seps.sort()\n NodeWarning.emit(\n \"Ignoring separator node(s) without accompanying content \"\n \"node: %s\" % (', '.join(map(repr, seps)),), stacklevel=5\n )","def without(self, *args):\n return self.reject(lambda x: x in args)","def pre_flight(self):\n\n def check_already_chain():\n \"\"\"In case a user runs the command twice on the same input\"\"\"\n all_are_already_rigids = True\n for transform, _ in self._pairs:\n if not transform.shape(type=\"rdRigid\"):\n all_are_already_rigids = False\n break\n\n assert not all_are_already_rigids, (\n \"Every transform is already dynamic\"\n )\n\n def check_hierarchy():\n \"\"\"Ensure incoming chain reflects a physical hierarchy\n\n For example, this is what a valid selection looks like,\n including a non-selected offset group that is still part\n of the hierarchy.\n\n o- clavicle\n |-o upperArm\n |-o lowerArm\n |-o ( offsetGroup )\n |-o hand\n\n \"\"\"\n\n pairs = self._pairs[:]\n while pairs:\n transform, _ = pairs.pop()\n expected_parent, _ = pairs[-1] if pairs else (None, None)\n\n if not expected_parent:\n break\n\n # Walk up the hierarchy until you find what\n # is supposed to be the parent.\n #\n # .\n # |--o a /|\\\n # |--o B |\n # |--o c |\n # |--o d |\n # |\n #\n valid = False\n for parent in transform.lineage():\n if parent == expected_parent:\n valid = True\n break\n\n problem = (\n \"%s was not a parent of %s\" % (\n expected_parent, transform)\n )\n\n # Ok, so the prior link isn't a parent, but we\n # also must make it isn't a child of the subsequent\n # link, as that would mean a cycle\n #\n # |\n # |--o a |\n # |--o B |\n # |--o c |\n # |--o d |\n # \\ /\n # `\n if not valid:\n is_child = False\n for child in transform.descendents():\n if child == expected_parent:\n is_child = True\n break\n\n # It's valid if the Maya parent isn't a Ragdoll child\n valid = not is_child\n\n # This flips the problem on its head\n problem = (\n \"%s cannot be a child of %s, that's a cycle\" % (\n expected_parent, transform)\n )\n\n assert valid, problem\n\n def pre_cache():\n \"\"\"Pre-cache attributes to avoid needless evaluation\"\"\"\n for transform, _ in self._pairs:\n world_matrix = transform[\"worldMatrix\"][0].asMatrix()\n parent_matrix = transform[\"parentMatrix\"][0].asMatrix()\n matrix = transform[\"matrix\"].asMatrix()\n translate = transform[\"translate\"].as_vector()\n rotate = transform[\"rotate\"].as_euler()\n\n if \"jointOrient\" in transform:\n joint_orient = transform[\"jointOrient\"].as_quaternion()\n else:\n # Only joints have these\n joint_orient = cmdx.Quaternion()\n\n self._cache[(transform, \"worldMatrix\")] = world_matrix\n self._cache[(transform, \"parentMatrix\")] = parent_matrix\n self._cache[(transform, \"matrix\")] = matrix\n self._cache[(transform, \"translate\")] = translate\n self._cache[(transform, \"rotate\")] = rotate\n self._cache[(transform, \"jointOrient\")] = joint_orient\n\n def remember_existing_inputs():\n # Remember existing animation\n for transform, _ in self._pairs:\n transform.data[\"priorConnections\"] = {}\n for channel in (\"translate\", \"rotate\"):\n for axis in \"XYZ\":\n src = transform[channel + axis]\n src = src.connection(plug=True, destination=False)\n\n if src is not None:\n anim = transform.data[\"priorConnections\"]\n dst = \"in%s%s1\" % (channel.title(), axis)\n anim[src] = dst\n\n check_already_chain()\n check_hierarchy()\n remember_existing_inputs()\n pre_cache()\n\n return True","def resolve_conflict(self):\n neighbours = self.nodes\n new_chain = None\n\n max_length = len(self.chain)\n\n for node in neighbours:\n response = requests.get('http://{}/chain'.format(node))\n if response.status_code == 200:\n length = response.json()['length']\n chain = response.json()['chain']\n\n if length > max_length and self.valid_chain(chain):\n max_length = length\n new_chain = chain\n if new_chain:\n self.chain = new_chain\n return True\n return False","def solve_part1(start):\n all_ilists = load_inputs()\n\n allergen_map = get_allergen_map(all_ilists)\n all_ingredients = get_all_ingredients(all_ilists)\n\n all_potential_bad_ingredients = set()\n\n for l in allergen_map.values():\n all_potential_bad_ingredients.update(l)\n\n safe_ingredients = [a for a in all_ingredients if a not in all_potential_bad_ingredients]\n\n safe_ingred_count = 0\n for ilist in all_ilists:\n this_ingredients = ilist.get_ingredients()\n this_safe_ingredients = [a for a in this_ingredients if a in safe_ingredients]\n safe_ingred_count += len(this_safe_ingredients)\n\n return safe_ingred_count","def _filter_committees_failing_pareto_optimality(self, profile: list[set[int]], committees: list[list[int]]) -> list[list[int]]:\n pareto_dominated_parties = set()\n for party1 in self.parties:\n for party2 in self.parties:\n if self._pareto_dominance(party1, party2, profile):\n pareto_dominated_parties.add(party2)\n possible_committees = [committee for committee in committees if set(committee).isdisjoint(pareto_dominated_parties)]\n return possible_committees","def _filter_committees_failing_weak_representation_clever(self, profile: list[set[int]], committees: list[list[int]],\n value_of_committee_for_ballot: dict) -> list[list[int]]:\n unique_approval_scores = self._compute_unique_approval_scores(profile)\n parties_deserving_representation = {party for party in self.parties if\n unique_approval_scores[party] >= self.n / self.k}\n\n required_number_of_approved_members = {}\n for ballot in profile:\n ballot_as_tuple = tuple(ballot)\n if len(ballot) == 1 and ballot_as_tuple[0] in parties_deserving_representation:\n required_number_of_approved_members[ballot_as_tuple] = 1\n else:\n required_number_of_approved_members[ballot_as_tuple] = 0\n\n reduced_profile = [ballot for ballot in profile if not ballot.issubset(parties_deserving_representation)]\n reduced_profile.reverse()\n 'By our construction, profiles are always ordered such that A_i subset A_j if and only if i <= j.'\n 'By reversing the profile, all subsets of a voters ballots are therefore right of it.'\n 'This is required for _profile_contains_subset_list as this profile looks from the start index to the right'\n 'side for find finding subset lists.'\n for index in range(0, len(reduced_profile)):\n if self._profile_contains_subset_list(reduced_profile, reduced_profile[index], index + 1, math.ceil(self.n / self.k)-1):\n required_number_of_approved_members[tuple(reduced_profile[index])] = \\\n len(parties_deserving_representation.intersection(reduced_profile[index])) + 1\n return [committee for committee in committees\n if all([value_of_committee_for_ballot[tuple([entry for item in [committee, ballot] for entry in item])]\n >= required_number_of_approved_members[tuple(ballot)] for ballot in profile])]","def test_bad_curie_in_list():\n with pytest.raises(ValidationError):\n pub = Publication(id='PMID:123', mesh_terms=['foo:bar', 'bad_curie'])","def remove_ill_matched_pair(phi1,S1,TU1,TV1): #---- remove ill matched pair\r\n #--- mark inlier= 1; outlier= 0 ---\r\n mask, phi0= pano_tools.remove_outlier(phi1);\r\n mask, S0 = pano_tools.remove_outlier(S1 ,Nstd=2, mask= mask);\r\n mask, TU0 = pano_tools.remove_outlier(TU1 ,Nstd=2, mask= mask);\r\n mask, TV0 = pano_tools.remove_outlier(TV1 ,Nstd=2, mask= mask); \r\n mask, phi0= pano_tools.remove_outlier(phi1,Nstd=3, mask= mask);\r\n mask, S0 = pano_tools.remove_outlier(S1 ,Nstd=3, mask= mask);\r\n mask, TU0 = pano_tools.remove_outlier(TU1 ,Nstd=3, mask= mask);\r\n #--- select reliable data pair ---\r\n # mask is M*M matrix: 1= reliable pair combination;\r\n M = phi1.shape[0];\r\n sumx= np.sum(mask,axis=0); # large number= reliable\r\n seq = []; # chosen reliable data\r\n for k in range(0, int(M*0.7)):\r\n maxx = np.argmax(sumx);\r\n seq.append(maxx);\r\n sumx[maxx]= 0; \r\n return seq, phi0, S0, TU0, TV0","def test_stratis_bad_subcommand(self):\n for command_line in [\n [\"notasub\"],\n [\"daemon\", \"notasub\"],\n [\"pool\", \"notasub\"],\n [\"blockdev\", \"notasub\"],\n [\"filesystem\", \"notasub\"],\n ]:\n for prefix in [[], [\"--propagate\"]]:\n self.check_system_exit(prefix + command_line, _PARSE_ERROR)","def test_sort_chain_multiple_structure_decreasing():\n n = 14\n data = range(n)\n chain = None\n for item in data:\n chain = N.Node(item, chain)\n\n result = A8.sort_chain(chain)\n\n walker = result\n for i in range(n):\n assert walker is not None, \"sort_chain returned chain of length {} given chain with values decreasing\".format(i)\n walker = walker.next\n\n assert walker is None, \"sort_chain returned chain longer than length {} given chain with values decreasing\".format(n)","def clean_edges(self):","def unprocessed(self):\n for v in self.iter():\n if v.intersect and not v.checked:\n yield True","def test_sort_chain_two_content_2():\n chain = N.Node(3, N.Node(2))\n result = A8.sort_chain(chain)\n\n assert result.data <= result.next.data, \"sort_chain returned chain out of order given input chain size 2 in reverse order\"","def purgeTrp(atoms):\n for a in atoms:\n found = False\n if getAtype(a) == \"N\":\n for c in atoms:\n if not c == a and dist(c,a) < COVALENT_BOND_DIST:\n found = True\n if not found:\n atoms.remove(a)\n return atoms\n if DEBUG: print \"Warning! Residue %s appears to be incomplete\" % (atoms[0][17:20]+atoms[0][22:26]+atoms[0][21])\n return False","def normalize_chain(cls, chain):\n\n if isinstance(chain, cls):\n chain = (chain,)\n return tuple(x for x in chain if x is not None)","def verify_chain():\n for (index,block) in enumerate(blockchain):\n if index ==0:\n continue\n if block['previous_hash'] != hash_block(blockchain[index-1]):\n return False\n if not valid_proof(block['transactions'][:-1],block['previous_hash'],block['proof']):\n print('Proof of Work is Invalid')\n return False\n return True","def violated(self) -> bool:\n ...","def fork_choice(chainA, chainB):\n\n if not chainA:\n if validate_all_transactions_and_blocks(chainB):\n print(\"There's no ChainA, and ChainB is valid!\")\n return chainB\n elif chainB.get_size() > chainA.get_size():\n if validate_all_transactions_and_blocks(chainB):\n print(\"ChainB is longer and valid!\")\n return chainB\n return chainA","def test_specific_peer_prefixes_accepted_nonexistant_peer(self):\n accepted_prefixes = self.pybird.get_peer_prefixes_accepted(\"PS99\")\n self.assertEquals(len(accepted_prefixes), 0)","def test_reject_negative(self):\n self.spawn(\"./binary\").stdin(\"-1\").reject()","def test_transfer_blocked(chain, token, shareholder1, boogieman):\n\n set_state(chain, token, canTransferFlag=False)\n with pytest.raises(ValueError):\n token.transact({\"from\": shareholder1}).transfer(boogieman, 4000)","def test_disallow_feature() -> None:\n # Given 'a', this FST will reject\n # Given 'b', this FST will reject\n # Given 'c', this FST will print both 'a', and 'b'\n fst = make_fst(\n # 1 -@D.x@-> 5; 5 -0:a-> (2)\n \"1 150 5 0\",\n \"5 0 97 2 0\",\n # 1 -@D.x@-> 6; 6 -0:b-> (2)\n \"1 150 6 0\",\n \"6 0 98 2 0\",\n )\n\n assert set(fst.generate(\"a\")) == set()\n assert set(fst.generate(\"b\")) == set()\n assert set(fst.generate(\"c\")) == {\"a\", \"b\"}","def test_heuristic_abort(self):\n graph = {}\n for u in self.complete:\n graph[u] = set()\n for v in self.complete[u]:\n if u != v: # ignore self-loop\n graph[u].add(v)\n next_node = min_fill_in_heuristic(graph)\n if next_node is None:\n pass\n else:\n assert False","def test_no_combine_with_fee(self):\n unspents_single = [Unspent(5000, 0, '', '', 0)]\n unspents_original = [Unspent(5000, 0, '', '', 0), Unspent(5000, 0, '', '', 0)]\n outputs_original = [(RETURN_ADDRESS, 1000, 'satoshi')]\n\n unspents, outputs = sanitize_tx_data(\n unspents_original,\n outputs_original,\n fee=1,\n leftover=RETURN_ADDRESS,\n combine=False,\n message=None,\n version='test',\n )\n\n unspents_single, outputs_single = sanitize_tx_data(\n unspents_single,\n outputs_original,\n fee=1,\n leftover=RETURN_ADDRESS,\n combine=False,\n message=None,\n version='test',\n )\n\n assert unspents == [Unspent(5000, 0, '', '', 0)]\n assert unspents_single == [Unspent(5000, 0, '', '', 0)]\n assert len(outputs) == 2\n assert len(outputs_single) == 2\n assert outputs[1][0] == RETURN_ADDRESS\n assert outputs_single[1][0] == RETURN_ADDRESS\n assert outputs[1][1] == outputs_single[1][1]","def empty_chain(self, chain, wrap=True):\n chained_rules = [rule for rule in self.rules\n if rule.chain == chain and rule.wrap == wrap]\n if chained_rules:\n self.dirty = True\n for rule in chained_rules:\n self.rules.remove(rule)","def test_sort_chain_multiple_content_increasing():\n n = 11\n data = range(n)\n chain = None\n for item in data:\n chain = N.Node(n-item-1, chain)\n\n result = A8.sort_chain(chain)\n\n walker = result\n prev = None\n seen = [False]*n\n for i in range(n):\n assert walker.data in data, \"sort_chain created extraneous data {} given chain with values increasing\".format(walker.data)\n seen[walker.data] = True\n if prev is not None:\n assert prev.data <= walker.data, \"sort_chain placed {} before {} given chain with values increasing\".format(prev.data, walker.data)\n prev = walker\n walker = walker.next\n\n for i,b in enumerate(seen):\n assert b, \"sort_chain omitted data value {} from returned chain given chain with values increasing\".format(i)","def test_sort_chain_two_content():\n chain = N.Node(1, N.Node(2))\n result = A8.sort_chain(chain)\n\n assert result.data <= result.next.data, \"sort_chain returned chain out of order given input chain size 2 already in order\"","def reject_fairness(experiment: List[bool]) -> bool:\n num_heads = len([flip for flip in experiment if flip])\n return num_heads < 469 or num_heads > 531","def test_negate_tips_to_keep(self):\r\n t = DndParser(\"((S5:0.00014,S7:0.00015)0.752:0.45762,(S3:0.00014,\"\r\n \"seq6:0.00014)0.180:0.00015,(Seq1:0.00014,s2:0.00014)0.528:1.0466);\")\r\n\r\n tips_to_keep = [\"S5\", \"Seq1\", \"s2\"]\r\n expected = [\"S7\", \"S3\", \"seq6\"]\r\n self.assertItemsEqual(negate_tips_to_keep(tips_to_keep, t), expected)\r\n\r\n tips_to_keep = [\"S5\", \"Seq1\"]\r\n expected = [\"S7\", \"S3\", \"seq6\", \"s2\"]\r\n self.assertItemsEqual(negate_tips_to_keep(tips_to_keep, t), expected)\r\n\r\n tips_to_keep = []\r\n expected = [\"S7\", \"S3\", \"seq6\", \"s2\", \"S5\", \"Seq1\"]\r\n self.assertItemsEqual(negate_tips_to_keep(tips_to_keep, t), expected)\r\n\r\n tips_to_keep = [\"S7\", \"S3\", \"seq6\", \"s2\", \"S5\", \"Seq1\"]\r\n expected = []\r\n self.assertItemsEqual(negate_tips_to_keep(tips_to_keep, t), expected)","def check_canonical(g):\n if not is_separated(g):\n raise ValueError(\"Non-separated grammar was given\")\n\n nonts = nonterminals(g)\n\n broken_rules = set()\n\n ends = {nont: set() for nont in nonts}\n counts = {nont: 0 for nont in nonts}\n\n for prod in g.productions():\n ends[prod.lhs()].add(prod.rhs()[-1])\n counts[prod.lhs()] += 1\n\n for item in prod.rhs():\n if item == g.start():\n broken_rules.add(1)\n\n for end in ends.values():\n if len(end) == 1:\n if is_nonterminal(end.pop()):\n broken_rules.add(6)\n else:\n broken_rules.add(4)\n\n for nont, num in counts.items():\n if nont == g.start():\n continue\n\n if num == 1:\n broken_rules.add(3)\n\n trash1 = unproductive(g)\n trash2 = unreachable(g)\n\n if trash1 or trash2:\n broken_rules.add(2)\n\n for n1, n2 in itertools.combinations(nonts, 2):\n if nonterm_equal(g, n1, n2):\n broken_rules.add(5)\n\n return broken_rules","def test_heuristic_abort(self):\n graph = {}\n for u in self.complete:\n graph[u] = set()\n for v in self.complete[u]:\n if u != v: # ignore self-loop\n graph[u].add(v)\n\n deg_heuristic = MinDegreeHeuristic(graph)\n node = deg_heuristic.best_node(graph)\n if node is None:\n pass\n else:\n assert False","def test_block_bad_signature(self):\n pass","def filter_some_usages(EN):\n bad_markers = [\n # 'ecclesiastical', actually not a good idea:\n # reachtaire\n # - rector (ecclesiastical)\n # - master of ceremonies\n ]\n ret = '\\n'.join([line for line in EN.split('\\n') if\n (not line.endswith(')')\n or\n line.rsplit('(', 1)[1].rstrip(')')\n not in bad_markers)])\n if ret:\n return ret\n return EN","def reject(self):\n self.new_rom = None\n self.new_reductor = None","def test_invalid_overprovision_value(self):\n command_line = [\"pool\", \"overprovision\", \"thispool\", \"1.2\"]\n for prefix in [[], [\"-propagate\"]]:\n self.check_system_exit(prefix + command_line, _PARSE_ERROR)","def unusedFromKDOTDataPreparation():","def test_case_05_not_legal_triangle(self):\n self.__assert_equals_test_case([(4, 6, 11)], 'NotATriangle')","def test_mark_all_OR_predecessors_dead(self):\n F = FaultDiagnosis(\"tests/TOY_graph.csv\")\n F.simulate_element_perturbation([\"8\", \"15\"])\n survived_nodes_mark = nx.get_node_attributes(F.G, 'mark')\n\n mark_all_OR_predecessors_dead = {\n '1': '1',\n '2': '2',\n '3': '3',\n '4': '4',\n '5': '5'\n }\n\n self.assertDictEqual(\n mark_all_OR_predecessors_dead,\n survived_nodes_mark,\n msg=\"MARK failure: all OR predecessors dead\")","def test_fail_signed_in_wrong_order(self):\n # Swap the signatures from the first and second keys.\n # Note that the keys have security level of 3, so we need to swap\n # out a total of 6 signatures.\n sig_1_1 = self.bundle[1].signature_message_fragment\n sig_1_2 = self.bundle[2].signature_message_fragment\n sig_1_3 = self.bundle[3].signature_message_fragment\n\n sig_2_1 = self.bundle[4].signature_message_fragment\n sig_2_2 = self.bundle[5].signature_message_fragment\n sig_2_3 = self.bundle[6].signature_message_fragment\n\n self.bundle[1].signature_message_fragment = sig_2_1\n self.bundle[2].signature_message_fragment = sig_2_2\n self.bundle[3].signature_message_fragment = sig_2_3\n\n self.bundle[4].signature_message_fragment = sig_1_1\n self.bundle[5].signature_message_fragment = sig_1_2\n self.bundle[6].signature_message_fragment = sig_1_3\n\n validator = BundleValidator(self.bundle)\n\n self.assertFalse(validator.is_valid())\n\n self.assertListEqual(\n validator.errors,\n\n [\n 'Transaction 1 has invalid signature (using 8 fragments).',\n ],\n )","def __eliminate_unused_constraits (self, objects):\n result = []\n for c in self.constraints_:\n if c [0] in objects and c [1] in objects:\n result.append (c)\n\n return result"],"string":"[\n \"def validate_chain():\",\n \"def reject(self):\\n pass\",\n \"def test_blind_sig_chain_wrong_intermediary(self): # pylint: disable=too-many-locals\\n\\n test_levels = 4\\n msg = os.urandom(1024)\\n wrong_level = 2\\n\\n ca = ECCBlind()\\n signer_obj = ca\\n fake_intermediary = ECCBlind()\\n\\n output = bytearray()\\n\\n for level in range(test_levels):\\n if not level:\\n output.extend(ca.pubkey())\\n requester_obj = ECCBlind(pubkey=signer_obj.pubkey())\\n child_obj = ECCBlind()\\n point_r = signer_obj.signer_init()\\n pubkey = child_obj.pubkey()\\n\\n if level == test_levels - 1:\\n msg_blinded = requester_obj.create_signing_request(point_r,\\n msg)\\n else:\\n msg_blinded = requester_obj.create_signing_request(point_r,\\n pubkey)\\n signature_blinded = signer_obj.blind_sign(msg_blinded)\\n signature = requester_obj.unblind(signature_blinded)\\n if level == wrong_level:\\n output.extend(fake_intermediary.pubkey())\\n elif level != test_levels - 1:\\n output.extend(pubkey)\\n output.extend(signature)\\n signer_obj = child_obj\\n verifychain = ECCBlindChain(ca=ca.pubkey(), chain=str(output))\\n self.assertFalse(verifychain.verify(msg, 1))\",\n \"def _filter_committees_failing_weak_representation(self, profile: list[set[int]], committees: list[list[int]]) -> list[list[int]]:\\n unique_approval_scores = self._compute_unique_approval_scores(profile)\\n parties_deserving_representation = {party for party in self.parties if unique_approval_scores[party] >= self.n / self.k}\\n possible_committees = [committee for committee in committees if parties_deserving_representation.issubset(set(committee))]\\n return possible_committees\",\n \"def test_exact_nonsupercontrolled_decompose(self):\\n with self.assertWarns(UserWarning, msg=\\\"Supposed to warn when basis non-supercontrolled\\\"):\\n TwoQubitBasisDecomposer(UnitaryGate(Ud(np.pi / 4, 0.2, 0.1)))\",\n \"def test_blind_sig_chain_wrong_msg(self): # pylint: disable=too-many-locals\\n\\n test_levels = 4\\n msg = os.urandom(1024)\\n fake_msg = os.urandom(1024)\\n\\n ca = ECCBlind()\\n signer_obj = ca\\n\\n output = bytearray()\\n\\n for level in range(test_levels):\\n if not level:\\n output.extend(ca.pubkey())\\n requester_obj = ECCBlind(pubkey=signer_obj.pubkey())\\n child_obj = ECCBlind()\\n point_r = signer_obj.signer_init()\\n pubkey = child_obj.pubkey()\\n\\n if level == test_levels - 1:\\n msg_blinded = requester_obj.create_signing_request(point_r,\\n msg)\\n else:\\n msg_blinded = requester_obj.create_signing_request(point_r,\\n pubkey)\\n signature_blinded = signer_obj.blind_sign(msg_blinded)\\n signature = requester_obj.unblind(signature_blinded)\\n if level != test_levels - 1:\\n output.extend(pubkey)\\n output.extend(signature)\\n signer_obj = child_obj\\n verifychain = ECCBlindChain(ca=ca.pubkey(), chain=str(output))\\n self.assertFalse(verifychain.verify(fake_msg, 1))\",\n \"def valid_chain(chain):\\n last_block = chain[0]\\n current_index = 1\\n\\n while current_index < len(chain):\\n block = chain[current_index]\\n #print(last_block)\\n #print(block)\\n #print(\\\"\\\\n-----------\\\\n\\\")\\n # Check that the hash of the block is correct\\n if block['previous_hash'] != hash(last_block):\\n return False\\n\\n # Check that the Proof of Work is correct\\n #Delete the reward transaction\\n transactions = block['transactions'][:-1]\\n # Need to make sure that the dictionary is ordered. Otherwise we'll get a different hash\\n transaction_elements = ['sender_address', 'recipient_address', 'value']\\n transactions = [OrderedDict((k, transaction[k]) for k in transaction_elements) for transaction in transactions]\\n\\n if not valid_proof(transactions, block['previous_hash'], block['nonce'], MINING_DIFFICULTY):\\n return False\\n\\n last_block = block\\n current_index += 1\\n\\n return True\",\n \"def squeeze_accept(partition):\\n Write a function that\\n - Sort districts by most Democratic heavy and most Republican heavy\\n\\n - Assign a base value of competitiveness for each district\\n - Run chain, accept only if districts satisfy values under or order\\n \\\"\\\"\\\"\\n\\n#--- CONSTRAINTS\\n\\n\\\"\\\"\\\"\",\n \"def remove_incompatible_operations(pipelines):\\n\\n def find_duplicates(pipelines):\\n for idx in range(len(pipelines)):\\n for idx_ in range(idx + 1, len(pipelines)):\\n if pipelines[idx] == pipelines[idx_]:\\n return idx\\n return -1\\n\\n\\n def _remove_illegal_combination(pipelines, combination):\\n illegal_pipes = []\\n pipelines_ = []\\n for idx, pipeline in enumerate(pipelines):\\n combination_ = list(set.intersection(set(pipeline.keys()), set(combination)))\\n actives = [pipeline[key] != None for key in pipeline if key in combination_]\\n\\n if sum(actives) > 1:\\n illegal_pipes.append(idx) # Store the index of bad combination\\n for param in combination_: # Generate substituting legal combinations\\n if pipeline[param] != None: # we need to make new pipe\\n pipeline_ = pipeline.copy()\\n for param_ in combination_: # Set ALL conflicting parameters to None\\n pipeline_[param_] = None\\n pipeline_[param] = pipeline[param] # Set current parameter back to original value\\n pipelines_.append(pipeline_)\\n\\n new_pipelines = [i for j, i in enumerate(pipelines) if j not in illegal_pipes]\\n # new_pipelines.extend(pipelines_)\\n return new_pipelines, pipelines_\\n\\n illegal_combinations = [['BASELINE', 'MSC', 'EMSC', 'RNV', 'SNV', 'LSNV'],\\n ['SMOOTH', 'SAVGOL']]\\n\\n for combination in illegal_combinations:\\n pipelines, new_pipes = _remove_illegal_combination(pipelines, combination)\\n\\n pipelines.extend(new_pipes)\\n pipelines_set = {json.dumps(pipeline, sort_keys=True) for pipeline in pipelines}\\n pipelines = [json.loads(item) for item in pipelines_set]\\n\\n\\n return pipelines\",\n \"def extract_mixed_chains(raw_chains):\\n chain_isolation_regex = re.compile(r'^\\\\w+\\\\s+\\\\d+\\\\s+(.*)')\\n\\n mixed_chains = [\\n re.search(chain_isolation_regex,\\n raw_chain).group(1).strip() # remove whitespace\\n for raw_chain in raw_chains\\n ]\\n return mixed_chains\",\n \"def test_unrequired_chain_delete(self):\\n self.txn.store_delete(\\\"felix-c\\\")\\n self.assertEqual(self.txn.affected_chains, set([\\\"felix-c\\\"]))\\n self.assertEqual(self.txn.chains_to_stub_out, set([]))\\n self.assertEqual(self.txn.chains_to_delete, set([\\\"felix-c\\\"]))\\n self.assertEqual(self.txn.referenced_chains,\\n set([\\\"felix-b\\\", \\\"felix-stub\\\"]))\\n self.assertEqual(\\n self.txn.prog_chains,\\n {\\n \\\"felix-a\\\": [],\\n \\\"felix-b\\\": [],\\n })\\n self.assertEqual(self.txn.required_chns,\\n {\\\"felix-a\\\": set([\\\"felix-b\\\", \\\"felix-stub\\\"])})\\n self.assertEqual(self.txn.requiring_chns,\\n {\\\"felix-b\\\": set([\\\"felix-a\\\"]),\\n \\\"felix-stub\\\": set([\\\"felix-a\\\"])})\",\n \"def valid_chain(chain):\\n\\n for i in range(len(chain) - 1):\\n parent_edge = chain[i]\\n child_edge = chain[i + 1]\\n # verify that the child of the parent edge (second node) matches the parent of the child edge (first node)\\n if not parent_edge[1] == child_edge[0]:\\n # if this isn't\\n return False\\n return True\",\n \"def resolve_conflicts(self):\\n neighbours = self.nodes\\n new_chain = None\\n # Look only for chains longer than this\\n max_length = len(self.chain)\\n # Get and verify the chains from all the nodes in the network\\n for node in neighbours:\\n response = requests.get(f'http://{node}/chain')\\n if response.status_code == 200:\\n length = response.json()['length']\\n chain = response.json()['chain']\\n # Check if chain is longer and valid\\n if length > max_length and self.valid_chain(chain):\\n max_length = length\\n new_chain = chain\\n # Replace this chain if a longer valid chain is discovered\\n if new_chain:\\n self.chain = new_chain\\n return True\\n return False\",\n \"def validate_blockchain(chain):\\n assert isinstance(chain, list)\\n\\n for hook in chain[::-1]:\\n pass\",\n \"def valid_chain(self, chain):\\n last_block = chain[0]\\n current_index = 1\\n\\n while current_index < len(chain):\\n block = chain[current_index]\\n print(f'{last_block}')\\n print(f'{block}')\\n print(\\\"\\\\n----------------\\\\n\\\")\\n # verify hash integrity\\n if block['previous_hash'] != self.hash(last_block):\\n return False\\n\\n # verify proof integrity\\n if not self.valid_proof(last_block['proof'], block['proof']):\\n return False\\n\\n last_block = block\\n current_index += 1\\n\\n return True\",\n \"def route_rejected(self, prefix, next_hop, as_path):\",\n \"def test_fail_missing_signature_fragment_underflow(self):\\n # Adjust bundle balance, since we will also remove the change\\n # transaction.\\n self.bundle[0].value += self.bundle[-1].value\\n\\n # Remove the last input's second signature fragment, and the change\\n # transaction.\\n del self.bundle.transactions[-2:]\\n for txn in self.bundle:\\n txn.last_index -= 2\\n\\n validator = BundleValidator(self.bundle)\\n\\n self.assertFalse(validator.is_valid())\\n\\n self.assertListEqual(\\n validator.errors,\\n\\n [\\n 'Transaction 4 has invalid signature (using 2 fragments).',\\n ],\\n )\",\n \"def resolve_conflicts(self):\\n neighbours = self.nodes\\n new_chain = None\\n\\n # We are only looking for chains longer that ours\\n max_length = len(self.chain)\\n\\n # Checking for the length of each chain in our network\\n for node in neighbours:\\n response = requests.get(f'http://{node}/chain')\\n\\n if response.status_code == 200:\\n length = response.json()['length']\\n chain = response.json()['chain']\\n\\n if length > max_length and self.validate_chain(chain):\\n new_chain = chain\\n max_length = length\\n\\n # Replace our chain with a new, longer, valid chain in our network (if present)\\n if new_chain:\\n self.chain = new_chain\\n return True\\n\\n return False\",\n \"def chain(self):\\n return ValueError(\\\"chain function not set.\\\")\",\n \"def chain_rangeValid(start, stop):\\r\\n for i in range(start, stop):\\r\\n chain = chain_153(i)\\r\\n if len(chain) > 1 or chain[0] == 153:\\r\\n for j in chain_153(i):\\r\\n print(j)\",\n \"def resolve_conflicts(self):\\n\\n neighbours = self.nodes\\n new_chain = None\\n\\n # We're only looking for chains longer than ours\\n max_length = len(self.chain)\\n\\n # Grab and verify the chains from all the nodes in our network\\n for node in neighbours:\\n response = requests.get(f'http://{node}:5000/chain')\\n\\n if response.status_code == 200:\\n length = response.json()['length']\\n chain = response.json()['chain']\\n\\n # Check if the length is longer and the chain is valid\\n if length > max_length:\\n max_length = length\\n new_chain = chain\\n\\n # Replace our chain if we discovered a new, valid chain longer than ours\\n if new_chain:\\n self.chain = new_chain\\n return True\\n\\n return False\",\n \"def test_blind_sig_chain_wrong_ca(self): # pylint: disable=too-many-locals\\n\\n test_levels = 4\\n msg = os.urandom(1024)\\n\\n ca = ECCBlind()\\n fake_ca = ECCBlind()\\n signer_obj = fake_ca\\n\\n output = bytearray()\\n\\n for level in range(test_levels):\\n requester_obj = ECCBlind(pubkey=signer_obj.pubkey())\\n child_obj = ECCBlind()\\n if not level:\\n # unlisted CA, but a syntactically valid pubkey\\n output.extend(fake_ca.pubkey())\\n point_r = signer_obj.signer_init()\\n pubkey = child_obj.pubkey()\\n\\n if level == test_levels - 1:\\n msg_blinded = requester_obj.create_signing_request(point_r,\\n msg)\\n else:\\n msg_blinded = requester_obj.create_signing_request(point_r,\\n pubkey)\\n signature_blinded = signer_obj.blind_sign(msg_blinded)\\n signature = requester_obj.unblind(signature_blinded)\\n if level != test_levels - 1:\\n output.extend(pubkey)\\n output.extend(signature)\\n signer_obj = child_obj\\n verifychain = ECCBlindChain(ca=ca.pubkey(), chain=str(output))\\n self.assertFalse(verifychain.verify(msg, 1))\",\n \"def valid_chain(self, chain):\\n last_block = chain[0]\\n current_index = 1\\n\\n while current_index < len(chain):\\n block = chain[current_index]\\n # print(f'{last_block}')\\n # print(f'{block}')\\n # print(\\\"\\\\n-----------\\\\n\\\")\\n # Check that the hash of the block is correct\\n last_block_hash = self.hash(last_block)\\n if block['previous_hash'] != self.hash(last_block):\\n return False\\n\\n # Check that the Proof of Work is correct\\n if not self.valid_proof(last_block['proof'], block['proof'], last_block_hash):\\n return False\\n\\n last_block = block\\n current_index += 1\\n\\n return True\",\n \"def valid_chain(self, chain):\\n\\n last_block = chain[0]\\n current_index = 1\\n \\n while current_index < len(chain):\\n block = chain[current_index]\\n # Check correctness of last block's hash\\n if block['previous_hash'] != self.hash(last_block): \\n return False\\n # Check correctness of proof-of-work\\n if not self.valid_proof(last_block['proof'], block['proof'], block['previous_hash']):\\n return False\\n last_block = block \\n current_index += 1\\n\\n return True\",\n \"def valid_chain(self, chain):\\n last_block = chain[0]\\n current_index = 1\\n\\n while current_index < len(chain):\\n block = chain[current_index]\\n print(last_block)\\n print(block)\\n print(\\\"\\\\n--------\\\\n\\\")\\n \\n #check that the hash of the previous block is correct\\n\\n if block[\\\"previous_hash\\\"] != self.hash(last_block):\\n print(\\\"Previous hash does not match\\\")\\n return False\\n\\n if not self.valid_proof(block):\\n print(\\\"Block proof of work is invalid\\\")\\n return False\\n\\n last_block = block\\n current_index += 1\\n\\n return True\",\n \"def resolve_conflicts(self):\\n neighbors = self.nodes\\n print(neighbors)\\n new_chain = None\\n\\n # We only care about chains longer than our own\\n max_length = len(self.chain)\\n\\n # Get and verify all neighbors chains\\n for node in neighbors:\\n try:\\n url = 'http://{}/chain'.format(node)\\n response = requests.get(url)\\n if response.status_code == 200:\\n length = response.json()['length']\\n chain = response.json()['chain']\\n\\n # Check if longer and chain is valid\\n if length > max_length and self.valid_chain(chain):\\n max_length = length\\n new_chain = chain\\n except:\\n return False\\n # Replace our chain if necessary\\n if new_chain:\\n self.chain = new_chain\\n self._write_chain()\\n return True\\n\\n return False\",\n \"def resolve_conflicts(self):\\n\\n neighbours = self.nodes\\n new_chain = None\\n\\n # We're only looking for chains longer than ours\\n max_length = len(self.chain)\\n\\n # Grab and verify the chains from all the nodes in our network\\n for node in neighbours:\\n response = requests.get(f'http://{node}/chain')\\n\\n if response.status_code == 200:\\n length = response.json()['length']\\n chain = response.json()['chain']\\n\\n # Check if the length is longer and the chain is valid\\n if length > max_length and self.valid_chain(chain):\\n max_length = length\\n new_chain = chain\\n\\n # Replace our chain if we discovered a new, valid chain longer than ours\\n if new_chain:\\n self.rewrite_chain(new_chain)\\n return True\\n\\n return False\",\n \"def test_sort_chain_two_content_3():\\n chain = N.Node(2, N.Node(2))\\n result = A8.sort_chain(chain)\\n\\n assert result.data <= result.next.data, \\\"sort_chain returned chain out of order given input chain size 2 with dupicates\\\"\",\n \"def skip_sub_components(self, reason):\\n pass\",\n \"def test_sort_chain_multiple_content_decreasing():\\n n = 17\\n data = range(n)\\n chain = None\\n for item in data:\\n chain = N.Node(item, chain)\\n\\n result = A8.sort_chain(chain)\\n\\n walker = result\\n prev = None\\n seen = [False]*n\\n for i in range(n):\\n assert walker.data in data, \\\"sort_chain created extraneous data {} given chain with values decreasing\\\".format(walker.data)\\n seen[walker.data] = True\\n if prev is not None:\\n assert prev.data <= walker.data, \\\"sort_chain placed {} before {} given chain with values decreasing\\\".format(prev.data, walker.data)\\n prev = walker\\n walker = walker.next\\n\\n for i,b in enumerate(seen):\\n assert b, \\\"sort_chain omitted data value {} from returned chain given chain with values decreasing\\\".format(i)\",\n \"def test_specific_peer_prefixes_rejected(self):\\n rejected_prefixes = self.pybird.get_peer_prefixes_rejected(\\\"PS1\\\")\\n self.assertEquals(len(rejected_prefixes), 1)\\n self.assertEquals(rejected_prefixes[0]['as_path'], '8954 20144')\",\n \"def test_block_bad_consensus(self):\\n pass\",\n \"def valid_chain(self, chain):\\n\\n last_block = chain[0]\\n current_index = 1\\n\\n while current_index < len(chain):\\n block = chain[current_index]\\n print(f'{last_block}')\\n print(f'{block}')\\n print(\\\"\\\\n-----------\\\\n\\\")\\n # Check that the hash of the block is correct\\n last_block_hash = self.hash(last_block)\\n if block['previous_hash'] != last_block_hash:\\n return False\\n\\n # Check that the Proof of Work is correct\\n if not self.valid_proof(last_block['proof'], block['proof'], last_block_hash):\\n return False\\n\\n last_block = block\\n current_index += 1\\n\\n return True\",\n \"def pruneblockchain(self) -> None:\\n return self.rpc_call(\\\"pruneblockchain\\\")\",\n \"def test_reject_proposal_demand(self):\\n pass\",\n \"def chainIsValid(self):\\n for i in range(1, len(self.blocks)):\\n prev_block = self.blocks[i-1]\\n cur_block = self.blocks[i]\\n if cur_block.header['prevBlockH'] != getHashBlock(prev_block):\\n return False\\n return True\",\n \"def test_rewrite_existing_chain_remove_normal_dependency(self):\\n self.txn.store_rewrite_chain(\\\"felix-a\\\", [\\\"foo\\\"], set([\\\"felix-stub\\\"]))\\n self.assertEqual(self.txn.affected_chains, set([\\\"felix-a\\\"]))\\n self.assertEqual(self.txn.chains_to_stub_out, set([]))\\n self.assertEqual(self.txn.chains_to_delete, set([]))\\n self.assertEqual(self.txn.referenced_chains, set([\\\"felix-stub\\\"]))\\n self.assertEqual(\\n self.txn.prog_chains,\\n {\\n \\\"felix-a\\\": [\\\"foo\\\"],\\n \\\"felix-b\\\": [],\\n \\\"felix-c\\\": [],\\n })\\n self.assertEqual(self.txn.required_chns,\\n {\\\"felix-a\\\": set([\\\"felix-stub\\\"])})\\n self.assertEqual(self.txn.requiring_chns,\\n {\\\"felix-stub\\\": set([\\\"felix-a\\\"])})\",\n \"def verify_chain():\\n for (index, block) in enumerate(blockchain):\\n if index == 0:\\n continue\\n if block['previous_hash'] != hash_block(blockchain[index - 1]):\\n return False\\n # Here [:-1] excludes the reward from being a part of validation\\n if not valid_proof(block['transactions'][:-1], block['previous_hash'], block['proof']):\\n print('Proof of work is invalid.')\\n return False\\n return True\",\n \"def compose(\\n # Left side positive filters\\n chainLeftIn,resiNumLeftIn,resiNameLeftIn,atomSerialLeftIn,\\n atomNameLeftIn,\\n # Left side negative filters\\n chainLeftOut,resiNumLeftOut,resiNameLeftOut, atomSerialLeftOut,\\n atomNameLeftOut,\\n # Right side positive filters\\n chainRightIn,resiNumRightIn,resiNameRightIn,atomSerialRightIn,\\n atomNameRightIn,\\n # Right side negative filters\\n chainRightOut,resiNumRightOut,resiNameRightOut,atomSerialRightOut,\\n atomNameRightOut,\\n # Contact Area\\n contactAreaMin,contactAreaMax,\\n # Minimal distance\\n minimalDistanceMin,minimalDistanceMax,\\n # Sequence separation\\n seqSeparationMin,seqSeparationMax\\n ):\\n\\n output=''\\n\\n match_first=''\\n match_first=append_to_local_output(match_first, 'c', Generic(chainLeftIn))\\n match_first=append_to_local_output(match_first, 'r', Generic(resiNumLeftIn))\\n match_first=append_to_local_output(match_first, 'a', Generic(atomSerialLeftIn))\\n match_first=append_to_local_output(match_first, 'R', Generic(resiNameLeftIn))\\n match_first=append_to_local_output(match_first, 'A', Generic(atomNameLeftIn))\\n output=append_to_global_output(output, '--match-first', match_first)\\n\\n match_first_not=''\\n match_first_not=append_to_local_output(match_first_not, 'c', Generic(chainLeftOut))\\n match_first_not=append_to_local_output(match_first_not, 'r', Generic(resiNumLeftOut))\\n match_first_not=append_to_local_output(match_first_not, 'a', Generic(atomSerialLeftOut))\\n match_first_not=append_to_local_output(match_first_not, 'R', Generic(resiNameLeftOut))\\n match_first_not=append_to_local_output(match_first_not, 'A', Generic(atomNameLeftOut))\\n output=append_to_global_output(output, '--match-first-not', match_first_not)\\n\\n match_second=''\\n match_second=append_to_local_output(match_second, 'c', Generic(chainRightIn))\\n match_second=append_to_local_output(match_second, 'r', Generic(resiNumRightIn))\\n match_second=append_to_local_output(match_second, 'a', Generic(atomSerialRightIn))\\n match_second=append_to_local_output(match_second, 'R', Generic(resiNameRightIn))\\n match_second=append_to_local_output(match_second, 'A', Generic(atomNameRightIn))\\n output=append_to_global_output(output, '--match-second', match_second)\\n\\n match_second_not=''\\n match_second_not=append_to_local_output(match_second_not, 'c', Generic(chainRightOut))\\n match_second_not=append_to_local_output(match_second_not, 'r', Generic(resiNumRightOut))\\n match_second_not=append_to_local_output(match_second_not, 'a', Generic(atomSerialRightOut))\\n match_second_not=append_to_local_output(match_second_not, 'R', Generic(resiNameRightOut))\\n match_second_not=append_to_local_output(match_second_not, 'A', Generic(atomNameRightOut))\\n output=append_to_global_output(output, '--match-second-not', match_second_not)\\n\\n output=append_to_global_output(output, '--match-min-area', Float(contactAreaMin))\\n output=append_to_global_output(output, '--match-max-area', Float(contactAreaMax))\\n\\n output=append_to_global_output(output, '--match-min-dist', Float(minimalDistanceMin))\\n output=append_to_global_output(output, '--match-max-dist', Float(minimalDistanceMax))\\n\\n output=append_to_global_output(output, '--match-min-seq-sep', Int(seqSeparationMin))\\n output=append_to_global_output(output, '--match-max-seq-sep', Int(seqSeparationMax))\\n\\n return output\",\n \"def test_mediate_transfer_fails_if_intermediate_trustline_frozen(\\n currency_network_contract_with_frozen_trustline, accounts\\n):\\n network = currency_network_contract_with_frozen_trustline\\n\\n path = [accounts[4], accounts[0], accounts[1], accounts[2]]\\n\\n with pytest.raises(eth_tester.exceptions.TransactionFailed):\\n network.functions.transfer(10, 10, path, b\\\"\\\").transact({\\\"from\\\": accounts[4]})\",\n \"def resolve_conflict(self):\\n neighbours = self.nodes\\n new_chain = None\\n #We're only looking for chains Longer than ours\\n max_length = len(self.chain)\\n #Grab and verify the chains from all the other nodes in our netwrok\\n for node in neighbours:\\n response = requests.get(f'http://{node}/chain')\\n if response.status_code == 200:\\n length = response.json()['length']\\n chain = response.json()['chain']\\n #check if the lentgh is longer and the cain is valid\\n if length > max_length and self.valid_chain(chain):\\n max_length = length\\n new_chain = chain\\n\\n #replace our chain if we're discovered a new valid chain, Longer than ours\\n if new_chain:\\n self.chain = new_chain\\n return True\\n\\n return False\",\n \"def filter_invalid_combos(m: 'Mods') -> 'Mods':\\n if m & (Mods.DOUBLETIME | Mods.NIGHTCORE) and m & Mods.HALFTIME:\\n m &= ~Mods.HALFTIME\\n if m & Mods.EASY and m & Mods.HARDROCK:\\n m &= ~Mods.HARDROCK\\n if m & Mods.RELAX and m & Mods.AUTOPILOT:\\n m &= ~Mods.AUTOPILOT\\n if m & Mods.PERFECT and m & Mods.SUDDENDEATH:\\n m &= ~Mods.SUDDENDEATH\\n\\n return m\",\n \"def valid_chain(self, chain):\\n last_block = chain[0]\\n current_index = 1\\n\\n while current_index < len(chain):\\n block = chain[current_index]\\n\\n # Check that the hash of block is correct\\n if block['previous_hash'] != self.hash(last_block):\\n return False\\n\\n # Check the Proof of Work\\n if not self.valid_proof(last_block['proof'], block['proof']):\\n return False\\n \\n last_block = block\\n current_index += 1\\n return True\",\n \"def strip_loan(chain):\\n while chain[-1]['action'] == 'LOAN':\\n chain.pop()\\n\\n return chain\",\n \"def reject_fairness(experiment):\\n num_heads = len([flip for flip in experiment if flip])\\n return num_heads < 469 or num_heads > 531\",\n \"def reject_fairness(experiment):\\n num_heads = len([flip for flip in experiment if flip])\\n return num_heads < 469 or num_heads > 531\",\n \"def reject_fairness(experiment):\\n num_heads = len([flip for flip in experiment if flip])\\n return num_heads < 469 or num_heads > 531\",\n \"def badMuons(self, allmuons, allvertices):\\n\\n muons = list(m for m in allmuons) # make it a python list\\n goodMuon = []\\n\\n if len(allvertices) < 1: raise RuntimeError\\n PV = allvertices[0].position()\\n \\n out = [] \\n for mu in muons:\\n if (not(mu.isPFMuon()) or mu.innerTrack().isNull()):\\n goodMuon.append(-1); # bad but we don't care\\n continue;\\n if (self.preselection(mu)):\\n dxypv = abs(mu.innerTrack().dxy(PV));\\n dzpv = abs(mu.innerTrack().dz(PV));\\n if (self.tighterId(mu)):\\n ipLoose = ((dxypv < 0.5 and dzpv < 2.0) or mu.innerTrack().hitPattern().pixelLayersWithMeasurement() >= 2);\\n goodMuon.append(ipLoose or (not(self.selectClones_) and self.tightGlobal(mu)));\\n elif (self.safeId(mu)):\\n ipTight = (dxypv < 0.2 and dzpv < 0.5);\\n goodMuon.append(ipTight);\\n else:\\n goodMuon.append(0);\\n else:\\n goodMuon.append(3); # maybe good, maybe bad, but we don't care\\n\\n n = len(muons)\\n for i in range(n):\\n if (muons[i].pt() < self.ptCut_ or goodMuon[i] != 0): continue;\\n bad = True;\\n if (self.selectClones_):\\n bad = False; # unless proven otherwise\\n n1 = muons[i].numberOfMatches(ROOT.reco.Muon.SegmentArbitration);\\n for j in range(n):\\n if (j == i or goodMuon[j] <= 0 or not(self.partnerId(muons[j]))): continue\\n n2 = muons[j].numberOfMatches(ROOT.reco.Muon.SegmentArbitration);\\n if (deltaR(muons[i],muons[j]) < 0.4 or (n1 > 0 and n2 > 0 and ROOT.muon.sharedSegments(muons[i],muons[j]) >= 0.5*min(n1,n2))):\\n bad = True;\\n break;\\n if (bad):\\n out.append(muons[i]);\\n return out\",\n \"def filter_unknown_bases(self):\\n self.failed[\\\"unknowns\\\"] = self.stats.index[\\n self.stats[\\\"unknowns\\\"] > self.tolerance[\\\"unknowns\\\"]\\n ]\\n self.passed = self.stats.drop(self.failed[\\\"unknowns\\\"])\",\n \"def is_chain_valid(self, chain):\\r\\n previous_block = chain[0]\\r\\n block_index = 1\\r\\n while block_index < len(chain):\\r\\n block = chain[block_index]\\r\\n if block['previous_hash'] != self.hash(previous_block):\\r\\n return False\\r\\n previous_proof = previous_block['proof']\\r\\n proof = block['proof']\\r\\n hash_operation = self.hash(block)\\r\\n if hash_operation[:4] != '0000':\\r\\n return False\\r\\n previous_block = block\\r\\n block_index += 1\\r\\n return True\",\n \"def reject_fairness(experiment):\\n num_heads = len([flip for flip in experiment if flip])\\n return num_heads < 468 or num_heads > 531\",\n \"def validate_chain(self):\\n chain_length = len(self.chain)\\n isValid = None\\n\\n if(chain_length == 1):\\n return \\\"Add blocks and then validate chain.\\\"\\n\\n for x in range(0, chain_length, 1):\\n if(x < chain_length-1):\\n # Hash the current block\\n hash = self.hash(self.chain[x])\\n next_block_prev_hash = self.chain[x+1]['prev_hash']\\n\\n if(hash == \\\"0\\\" and x == 0):\\n isValid = True\\n\\n if(hash != next_block_prev_hash):\\n isValid = False\\n return isValid\\n else:\\n isValid = True\\n\\n return isValid\",\n \"def test_ensure_passage_is_not_removed(self):\\n simple = self.TEI.getPassage(MyCapytain.common.reference.Reference(\\\"1.pr.1-1.2.5\\\"))\\n orig_refs = self.TEI.getValidReff(level=3)\\n self.assertIn(\\\"1.pr.1\\\", orig_refs)\\n self.assertIn(\\\"1.1.1\\\", orig_refs)\\n self.assertIn(\\\"1.2.4\\\", orig_refs)\\n self.assertIn(\\\"1.2.5\\\", orig_refs)\\n\\n simple = self.TEI.getPassage(MyCapytain.common.reference.Reference(\\\"1.pr-1.2\\\"))\\n orig_refs = self.TEI.getValidReff(level=3)\\n self.assertIn(\\\"1.pr.1\\\", orig_refs)\\n self.assertIn(\\\"1.1.1\\\", orig_refs)\\n self.assertIn(\\\"1.2.4\\\", orig_refs)\\n self.assertIn(\\\"1.2.5\\\", orig_refs)\",\n \"def check_auto_reject(self):\\r\\n for pr in self:\\r\\n if not pr.line_ids.filtered(lambda l: l.cancelled is False):\\r\\n pr.write({'state': 'rejected'})\",\n \"def repair(self):\\n self.dot = self.dot.replace('()', '..').replace('(.)', '...').replace('(..)', '....').replace('(...)', '.....')\\n self.matrix = pair_matrix(self)\\n length = len(self.seq)\\n for x in range(length):\\n for y in range(x, length):\\n if self.matrix[x, y] == 1:\\n if not is_pair_allowed(self.seq[x], self.seq[y]):\\n self.dot = self.dot[:x] + '.' + self.dot[x + 1:y] + '.' + self.dot[y + 1:]\\n return self\",\n \"def diagnose_chain(chain):\\n if chain[0] == 'all':\\n dir = data.meta_dir_base()\\n if os.path.exists(dir):\\n for chain_id in os.listdir(dir):\\n if utils.valid_chain_id(chain_id):\\n diagnose_server(chain_id)\\n else:\\n consoler.info(' No published chain exist, do nothing.')\\n else:\\n for i in range(len(chain)):\\n chain_get = chain[i].split(':')\\n if len(chain_get) == 1:\\n if utils.valid_chain_id(chain_get[0]):\\n diagnose_server(chain_get[0])\\n else:\\n consoler.info(\\n ' skip, invalid chain_id, chain_id is %s', chain_get[0])\\n elif len(chain_get) == 2:\\n if utils.valid_chain_id(chain_get[0]):\\n if utils.valid_ip(chain_get[1]):\\n ansible.diagnose_module(\\n chain_get[1], ansible.get_dir() + '/' + chain_get[0])\\n else:\\n consoler.info(\\n ' skip, invalid host, chain_id is %s, host is %s', chain_get[0], chain_get[1])\\n else:\\n consoler.info(\\n ' skip, invalid chain_id, chain_id is %s, host is %s', chain_get[0], chain_get[1])\\n else:\\n consoler.info(\\n ' skip, invalid format, not chain_id:host, input %s', chain_get)\",\n \"def checkGuide(seq, plen, pam, rpam, is_upstream_pam):\\n if is_upstream_pam:\\n if pam.match(seq[:plen]):\\n yield seq, \\\"+\\\"\\n if rpam.match(seq[-plen:]):\\n yield reverseComplement(seq), \\\"-\\\"\\n else:\\n if pam.match(seq[-plen:]):\\n yield seq, \\\"+\\\"\\n if rpam.match(seq[:plen]):\\n yield reverseComplement(seq), \\\"-\\\"\\n #yield \\\"\\\", \\\"\\\"\",\n \"def badExitPrevMolecule(self):\\n if self.molecules > 0:\\n # collect list of any atoms where num departed is not expected num per molecule\\n departErrors = [(atom.name, count) for atom, count in self.departed.items() if self.departed[atom] != atom.value]\\n if len(departErrors) > 0:\\n print(\\\"too many or too few atoms exited between previous and this molecule creations.\\\")\\n print( \\\"Exit counts:\\\", departErrors)\\n return False\\n return True\",\n \"def test_sort_chain_two_structure_3():\\n chain = N.Node(2, N.Node(2))\\n result = A8.sort_chain(chain)\\n\\n assert result is not None, \\\"sort_chain returned empty chain given input chain size 2 with dupicates\\\"\\n assert result.next is not None, \\\"sort_chain returned singleton chain given input chain size 2 with dupicates\\\"\\n assert result.next.next is None, \\\"sort_chain returned extended chain given input chain size 2 with dupicates\\\"\",\n \"def check_seps(seps):\\n if seps:\\n seps = seps.keys()\\n seps.sort()\\n NodeWarning.emit(\\n \\\"Ignoring separator node(s) without accompanying content \\\"\\n \\\"node: %s\\\" % (', '.join(map(repr, seps)),), stacklevel=5\\n )\",\n \"def without(self, *args):\\n return self.reject(lambda x: x in args)\",\n \"def pre_flight(self):\\n\\n def check_already_chain():\\n \\\"\\\"\\\"In case a user runs the command twice on the same input\\\"\\\"\\\"\\n all_are_already_rigids = True\\n for transform, _ in self._pairs:\\n if not transform.shape(type=\\\"rdRigid\\\"):\\n all_are_already_rigids = False\\n break\\n\\n assert not all_are_already_rigids, (\\n \\\"Every transform is already dynamic\\\"\\n )\\n\\n def check_hierarchy():\\n \\\"\\\"\\\"Ensure incoming chain reflects a physical hierarchy\\n\\n For example, this is what a valid selection looks like,\\n including a non-selected offset group that is still part\\n of the hierarchy.\\n\\n o- clavicle\\n |-o upperArm\\n |-o lowerArm\\n |-o ( offsetGroup )\\n |-o hand\\n\\n \\\"\\\"\\\"\\n\\n pairs = self._pairs[:]\\n while pairs:\\n transform, _ = pairs.pop()\\n expected_parent, _ = pairs[-1] if pairs else (None, None)\\n\\n if not expected_parent:\\n break\\n\\n # Walk up the hierarchy until you find what\\n # is supposed to be the parent.\\n #\\n # .\\n # |--o a /|\\\\\\n # |--o B |\\n # |--o c |\\n # |--o d |\\n # |\\n #\\n valid = False\\n for parent in transform.lineage():\\n if parent == expected_parent:\\n valid = True\\n break\\n\\n problem = (\\n \\\"%s was not a parent of %s\\\" % (\\n expected_parent, transform)\\n )\\n\\n # Ok, so the prior link isn't a parent, but we\\n # also must make it isn't a child of the subsequent\\n # link, as that would mean a cycle\\n #\\n # |\\n # |--o a |\\n # |--o B |\\n # |--o c |\\n # |--o d |\\n # \\\\ /\\n # `\\n if not valid:\\n is_child = False\\n for child in transform.descendents():\\n if child == expected_parent:\\n is_child = True\\n break\\n\\n # It's valid if the Maya parent isn't a Ragdoll child\\n valid = not is_child\\n\\n # This flips the problem on its head\\n problem = (\\n \\\"%s cannot be a child of %s, that's a cycle\\\" % (\\n expected_parent, transform)\\n )\\n\\n assert valid, problem\\n\\n def pre_cache():\\n \\\"\\\"\\\"Pre-cache attributes to avoid needless evaluation\\\"\\\"\\\"\\n for transform, _ in self._pairs:\\n world_matrix = transform[\\\"worldMatrix\\\"][0].asMatrix()\\n parent_matrix = transform[\\\"parentMatrix\\\"][0].asMatrix()\\n matrix = transform[\\\"matrix\\\"].asMatrix()\\n translate = transform[\\\"translate\\\"].as_vector()\\n rotate = transform[\\\"rotate\\\"].as_euler()\\n\\n if \\\"jointOrient\\\" in transform:\\n joint_orient = transform[\\\"jointOrient\\\"].as_quaternion()\\n else:\\n # Only joints have these\\n joint_orient = cmdx.Quaternion()\\n\\n self._cache[(transform, \\\"worldMatrix\\\")] = world_matrix\\n self._cache[(transform, \\\"parentMatrix\\\")] = parent_matrix\\n self._cache[(transform, \\\"matrix\\\")] = matrix\\n self._cache[(transform, \\\"translate\\\")] = translate\\n self._cache[(transform, \\\"rotate\\\")] = rotate\\n self._cache[(transform, \\\"jointOrient\\\")] = joint_orient\\n\\n def remember_existing_inputs():\\n # Remember existing animation\\n for transform, _ in self._pairs:\\n transform.data[\\\"priorConnections\\\"] = {}\\n for channel in (\\\"translate\\\", \\\"rotate\\\"):\\n for axis in \\\"XYZ\\\":\\n src = transform[channel + axis]\\n src = src.connection(plug=True, destination=False)\\n\\n if src is not None:\\n anim = transform.data[\\\"priorConnections\\\"]\\n dst = \\\"in%s%s1\\\" % (channel.title(), axis)\\n anim[src] = dst\\n\\n check_already_chain()\\n check_hierarchy()\\n remember_existing_inputs()\\n pre_cache()\\n\\n return True\",\n \"def resolve_conflict(self):\\n neighbours = self.nodes\\n new_chain = None\\n\\n max_length = len(self.chain)\\n\\n for node in neighbours:\\n response = requests.get('http://{}/chain'.format(node))\\n if response.status_code == 200:\\n length = response.json()['length']\\n chain = response.json()['chain']\\n\\n if length > max_length and self.valid_chain(chain):\\n max_length = length\\n new_chain = chain\\n if new_chain:\\n self.chain = new_chain\\n return True\\n return False\",\n \"def solve_part1(start):\\n all_ilists = load_inputs()\\n\\n allergen_map = get_allergen_map(all_ilists)\\n all_ingredients = get_all_ingredients(all_ilists)\\n\\n all_potential_bad_ingredients = set()\\n\\n for l in allergen_map.values():\\n all_potential_bad_ingredients.update(l)\\n\\n safe_ingredients = [a for a in all_ingredients if a not in all_potential_bad_ingredients]\\n\\n safe_ingred_count = 0\\n for ilist in all_ilists:\\n this_ingredients = ilist.get_ingredients()\\n this_safe_ingredients = [a for a in this_ingredients if a in safe_ingredients]\\n safe_ingred_count += len(this_safe_ingredients)\\n\\n return safe_ingred_count\",\n \"def _filter_committees_failing_pareto_optimality(self, profile: list[set[int]], committees: list[list[int]]) -> list[list[int]]:\\n pareto_dominated_parties = set()\\n for party1 in self.parties:\\n for party2 in self.parties:\\n if self._pareto_dominance(party1, party2, profile):\\n pareto_dominated_parties.add(party2)\\n possible_committees = [committee for committee in committees if set(committee).isdisjoint(pareto_dominated_parties)]\\n return possible_committees\",\n \"def _filter_committees_failing_weak_representation_clever(self, profile: list[set[int]], committees: list[list[int]],\\n value_of_committee_for_ballot: dict) -> list[list[int]]:\\n unique_approval_scores = self._compute_unique_approval_scores(profile)\\n parties_deserving_representation = {party for party in self.parties if\\n unique_approval_scores[party] >= self.n / self.k}\\n\\n required_number_of_approved_members = {}\\n for ballot in profile:\\n ballot_as_tuple = tuple(ballot)\\n if len(ballot) == 1 and ballot_as_tuple[0] in parties_deserving_representation:\\n required_number_of_approved_members[ballot_as_tuple] = 1\\n else:\\n required_number_of_approved_members[ballot_as_tuple] = 0\\n\\n reduced_profile = [ballot for ballot in profile if not ballot.issubset(parties_deserving_representation)]\\n reduced_profile.reverse()\\n 'By our construction, profiles are always ordered such that A_i subset A_j if and only if i <= j.'\\n 'By reversing the profile, all subsets of a voters ballots are therefore right of it.'\\n 'This is required for _profile_contains_subset_list as this profile looks from the start index to the right'\\n 'side for find finding subset lists.'\\n for index in range(0, len(reduced_profile)):\\n if self._profile_contains_subset_list(reduced_profile, reduced_profile[index], index + 1, math.ceil(self.n / self.k)-1):\\n required_number_of_approved_members[tuple(reduced_profile[index])] = \\\\\\n len(parties_deserving_representation.intersection(reduced_profile[index])) + 1\\n return [committee for committee in committees\\n if all([value_of_committee_for_ballot[tuple([entry for item in [committee, ballot] for entry in item])]\\n >= required_number_of_approved_members[tuple(ballot)] for ballot in profile])]\",\n \"def test_bad_curie_in_list():\\n with pytest.raises(ValidationError):\\n pub = Publication(id='PMID:123', mesh_terms=['foo:bar', 'bad_curie'])\",\n \"def remove_ill_matched_pair(phi1,S1,TU1,TV1): #---- remove ill matched pair\\r\\n #--- mark inlier= 1; outlier= 0 ---\\r\\n mask, phi0= pano_tools.remove_outlier(phi1);\\r\\n mask, S0 = pano_tools.remove_outlier(S1 ,Nstd=2, mask= mask);\\r\\n mask, TU0 = pano_tools.remove_outlier(TU1 ,Nstd=2, mask= mask);\\r\\n mask, TV0 = pano_tools.remove_outlier(TV1 ,Nstd=2, mask= mask); \\r\\n mask, phi0= pano_tools.remove_outlier(phi1,Nstd=3, mask= mask);\\r\\n mask, S0 = pano_tools.remove_outlier(S1 ,Nstd=3, mask= mask);\\r\\n mask, TU0 = pano_tools.remove_outlier(TU1 ,Nstd=3, mask= mask);\\r\\n #--- select reliable data pair ---\\r\\n # mask is M*M matrix: 1= reliable pair combination;\\r\\n M = phi1.shape[0];\\r\\n sumx= np.sum(mask,axis=0); # large number= reliable\\r\\n seq = []; # chosen reliable data\\r\\n for k in range(0, int(M*0.7)):\\r\\n maxx = np.argmax(sumx);\\r\\n seq.append(maxx);\\r\\n sumx[maxx]= 0; \\r\\n return seq, phi0, S0, TU0, TV0\",\n \"def test_stratis_bad_subcommand(self):\\n for command_line in [\\n [\\\"notasub\\\"],\\n [\\\"daemon\\\", \\\"notasub\\\"],\\n [\\\"pool\\\", \\\"notasub\\\"],\\n [\\\"blockdev\\\", \\\"notasub\\\"],\\n [\\\"filesystem\\\", \\\"notasub\\\"],\\n ]:\\n for prefix in [[], [\\\"--propagate\\\"]]:\\n self.check_system_exit(prefix + command_line, _PARSE_ERROR)\",\n \"def test_sort_chain_multiple_structure_decreasing():\\n n = 14\\n data = range(n)\\n chain = None\\n for item in data:\\n chain = N.Node(item, chain)\\n\\n result = A8.sort_chain(chain)\\n\\n walker = result\\n for i in range(n):\\n assert walker is not None, \\\"sort_chain returned chain of length {} given chain with values decreasing\\\".format(i)\\n walker = walker.next\\n\\n assert walker is None, \\\"sort_chain returned chain longer than length {} given chain with values decreasing\\\".format(n)\",\n \"def clean_edges(self):\",\n \"def unprocessed(self):\\n for v in self.iter():\\n if v.intersect and not v.checked:\\n yield True\",\n \"def test_sort_chain_two_content_2():\\n chain = N.Node(3, N.Node(2))\\n result = A8.sort_chain(chain)\\n\\n assert result.data <= result.next.data, \\\"sort_chain returned chain out of order given input chain size 2 in reverse order\\\"\",\n \"def purgeTrp(atoms):\\n for a in atoms:\\n found = False\\n if getAtype(a) == \\\"N\\\":\\n for c in atoms:\\n if not c == a and dist(c,a) < COVALENT_BOND_DIST:\\n found = True\\n if not found:\\n atoms.remove(a)\\n return atoms\\n if DEBUG: print \\\"Warning! Residue %s appears to be incomplete\\\" % (atoms[0][17:20]+atoms[0][22:26]+atoms[0][21])\\n return False\",\n \"def normalize_chain(cls, chain):\\n\\n if isinstance(chain, cls):\\n chain = (chain,)\\n return tuple(x for x in chain if x is not None)\",\n \"def verify_chain():\\n for (index,block) in enumerate(blockchain):\\n if index ==0:\\n continue\\n if block['previous_hash'] != hash_block(blockchain[index-1]):\\n return False\\n if not valid_proof(block['transactions'][:-1],block['previous_hash'],block['proof']):\\n print('Proof of Work is Invalid')\\n return False\\n return True\",\n \"def violated(self) -> bool:\\n ...\",\n \"def fork_choice(chainA, chainB):\\n\\n if not chainA:\\n if validate_all_transactions_and_blocks(chainB):\\n print(\\\"There's no ChainA, and ChainB is valid!\\\")\\n return chainB\\n elif chainB.get_size() > chainA.get_size():\\n if validate_all_transactions_and_blocks(chainB):\\n print(\\\"ChainB is longer and valid!\\\")\\n return chainB\\n return chainA\",\n \"def test_specific_peer_prefixes_accepted_nonexistant_peer(self):\\n accepted_prefixes = self.pybird.get_peer_prefixes_accepted(\\\"PS99\\\")\\n self.assertEquals(len(accepted_prefixes), 0)\",\n \"def test_reject_negative(self):\\n self.spawn(\\\"./binary\\\").stdin(\\\"-1\\\").reject()\",\n \"def test_transfer_blocked(chain, token, shareholder1, boogieman):\\n\\n set_state(chain, token, canTransferFlag=False)\\n with pytest.raises(ValueError):\\n token.transact({\\\"from\\\": shareholder1}).transfer(boogieman, 4000)\",\n \"def test_disallow_feature() -> None:\\n # Given 'a', this FST will reject\\n # Given 'b', this FST will reject\\n # Given 'c', this FST will print both 'a', and 'b'\\n fst = make_fst(\\n # 1 -@D.x@-> 5; 5 -0:a-> (2)\\n \\\"1 150 5 0\\\",\\n \\\"5 0 97 2 0\\\",\\n # 1 -@D.x@-> 6; 6 -0:b-> (2)\\n \\\"1 150 6 0\\\",\\n \\\"6 0 98 2 0\\\",\\n )\\n\\n assert set(fst.generate(\\\"a\\\")) == set()\\n assert set(fst.generate(\\\"b\\\")) == set()\\n assert set(fst.generate(\\\"c\\\")) == {\\\"a\\\", \\\"b\\\"}\",\n \"def test_heuristic_abort(self):\\n graph = {}\\n for u in self.complete:\\n graph[u] = set()\\n for v in self.complete[u]:\\n if u != v: # ignore self-loop\\n graph[u].add(v)\\n next_node = min_fill_in_heuristic(graph)\\n if next_node is None:\\n pass\\n else:\\n assert False\",\n \"def test_no_combine_with_fee(self):\\n unspents_single = [Unspent(5000, 0, '', '', 0)]\\n unspents_original = [Unspent(5000, 0, '', '', 0), Unspent(5000, 0, '', '', 0)]\\n outputs_original = [(RETURN_ADDRESS, 1000, 'satoshi')]\\n\\n unspents, outputs = sanitize_tx_data(\\n unspents_original,\\n outputs_original,\\n fee=1,\\n leftover=RETURN_ADDRESS,\\n combine=False,\\n message=None,\\n version='test',\\n )\\n\\n unspents_single, outputs_single = sanitize_tx_data(\\n unspents_single,\\n outputs_original,\\n fee=1,\\n leftover=RETURN_ADDRESS,\\n combine=False,\\n message=None,\\n version='test',\\n )\\n\\n assert unspents == [Unspent(5000, 0, '', '', 0)]\\n assert unspents_single == [Unspent(5000, 0, '', '', 0)]\\n assert len(outputs) == 2\\n assert len(outputs_single) == 2\\n assert outputs[1][0] == RETURN_ADDRESS\\n assert outputs_single[1][0] == RETURN_ADDRESS\\n assert outputs[1][1] == outputs_single[1][1]\",\n \"def empty_chain(self, chain, wrap=True):\\n chained_rules = [rule for rule in self.rules\\n if rule.chain == chain and rule.wrap == wrap]\\n if chained_rules:\\n self.dirty = True\\n for rule in chained_rules:\\n self.rules.remove(rule)\",\n \"def test_sort_chain_multiple_content_increasing():\\n n = 11\\n data = range(n)\\n chain = None\\n for item in data:\\n chain = N.Node(n-item-1, chain)\\n\\n result = A8.sort_chain(chain)\\n\\n walker = result\\n prev = None\\n seen = [False]*n\\n for i in range(n):\\n assert walker.data in data, \\\"sort_chain created extraneous data {} given chain with values increasing\\\".format(walker.data)\\n seen[walker.data] = True\\n if prev is not None:\\n assert prev.data <= walker.data, \\\"sort_chain placed {} before {} given chain with values increasing\\\".format(prev.data, walker.data)\\n prev = walker\\n walker = walker.next\\n\\n for i,b in enumerate(seen):\\n assert b, \\\"sort_chain omitted data value {} from returned chain given chain with values increasing\\\".format(i)\",\n \"def test_sort_chain_two_content():\\n chain = N.Node(1, N.Node(2))\\n result = A8.sort_chain(chain)\\n\\n assert result.data <= result.next.data, \\\"sort_chain returned chain out of order given input chain size 2 already in order\\\"\",\n \"def reject_fairness(experiment: List[bool]) -> bool:\\n num_heads = len([flip for flip in experiment if flip])\\n return num_heads < 469 or num_heads > 531\",\n \"def test_negate_tips_to_keep(self):\\r\\n t = DndParser(\\\"((S5:0.00014,S7:0.00015)0.752:0.45762,(S3:0.00014,\\\"\\r\\n \\\"seq6:0.00014)0.180:0.00015,(Seq1:0.00014,s2:0.00014)0.528:1.0466);\\\")\\r\\n\\r\\n tips_to_keep = [\\\"S5\\\", \\\"Seq1\\\", \\\"s2\\\"]\\r\\n expected = [\\\"S7\\\", \\\"S3\\\", \\\"seq6\\\"]\\r\\n self.assertItemsEqual(negate_tips_to_keep(tips_to_keep, t), expected)\\r\\n\\r\\n tips_to_keep = [\\\"S5\\\", \\\"Seq1\\\"]\\r\\n expected = [\\\"S7\\\", \\\"S3\\\", \\\"seq6\\\", \\\"s2\\\"]\\r\\n self.assertItemsEqual(negate_tips_to_keep(tips_to_keep, t), expected)\\r\\n\\r\\n tips_to_keep = []\\r\\n expected = [\\\"S7\\\", \\\"S3\\\", \\\"seq6\\\", \\\"s2\\\", \\\"S5\\\", \\\"Seq1\\\"]\\r\\n self.assertItemsEqual(negate_tips_to_keep(tips_to_keep, t), expected)\\r\\n\\r\\n tips_to_keep = [\\\"S7\\\", \\\"S3\\\", \\\"seq6\\\", \\\"s2\\\", \\\"S5\\\", \\\"Seq1\\\"]\\r\\n expected = []\\r\\n self.assertItemsEqual(negate_tips_to_keep(tips_to_keep, t), expected)\",\n \"def check_canonical(g):\\n if not is_separated(g):\\n raise ValueError(\\\"Non-separated grammar was given\\\")\\n\\n nonts = nonterminals(g)\\n\\n broken_rules = set()\\n\\n ends = {nont: set() for nont in nonts}\\n counts = {nont: 0 for nont in nonts}\\n\\n for prod in g.productions():\\n ends[prod.lhs()].add(prod.rhs()[-1])\\n counts[prod.lhs()] += 1\\n\\n for item in prod.rhs():\\n if item == g.start():\\n broken_rules.add(1)\\n\\n for end in ends.values():\\n if len(end) == 1:\\n if is_nonterminal(end.pop()):\\n broken_rules.add(6)\\n else:\\n broken_rules.add(4)\\n\\n for nont, num in counts.items():\\n if nont == g.start():\\n continue\\n\\n if num == 1:\\n broken_rules.add(3)\\n\\n trash1 = unproductive(g)\\n trash2 = unreachable(g)\\n\\n if trash1 or trash2:\\n broken_rules.add(2)\\n\\n for n1, n2 in itertools.combinations(nonts, 2):\\n if nonterm_equal(g, n1, n2):\\n broken_rules.add(5)\\n\\n return broken_rules\",\n \"def test_heuristic_abort(self):\\n graph = {}\\n for u in self.complete:\\n graph[u] = set()\\n for v in self.complete[u]:\\n if u != v: # ignore self-loop\\n graph[u].add(v)\\n\\n deg_heuristic = MinDegreeHeuristic(graph)\\n node = deg_heuristic.best_node(graph)\\n if node is None:\\n pass\\n else:\\n assert False\",\n \"def test_block_bad_signature(self):\\n pass\",\n \"def filter_some_usages(EN):\\n bad_markers = [\\n # 'ecclesiastical', actually not a good idea:\\n # reachtaire\\n # - rector (ecclesiastical)\\n # - master of ceremonies\\n ]\\n ret = '\\\\n'.join([line for line in EN.split('\\\\n') if\\n (not line.endswith(')')\\n or\\n line.rsplit('(', 1)[1].rstrip(')')\\n not in bad_markers)])\\n if ret:\\n return ret\\n return EN\",\n \"def reject(self):\\n self.new_rom = None\\n self.new_reductor = None\",\n \"def test_invalid_overprovision_value(self):\\n command_line = [\\\"pool\\\", \\\"overprovision\\\", \\\"thispool\\\", \\\"1.2\\\"]\\n for prefix in [[], [\\\"-propagate\\\"]]:\\n self.check_system_exit(prefix + command_line, _PARSE_ERROR)\",\n \"def unusedFromKDOTDataPreparation():\",\n \"def test_case_05_not_legal_triangle(self):\\n self.__assert_equals_test_case([(4, 6, 11)], 'NotATriangle')\",\n \"def test_mark_all_OR_predecessors_dead(self):\\n F = FaultDiagnosis(\\\"tests/TOY_graph.csv\\\")\\n F.simulate_element_perturbation([\\\"8\\\", \\\"15\\\"])\\n survived_nodes_mark = nx.get_node_attributes(F.G, 'mark')\\n\\n mark_all_OR_predecessors_dead = {\\n '1': '1',\\n '2': '2',\\n '3': '3',\\n '4': '4',\\n '5': '5'\\n }\\n\\n self.assertDictEqual(\\n mark_all_OR_predecessors_dead,\\n survived_nodes_mark,\\n msg=\\\"MARK failure: all OR predecessors dead\\\")\",\n \"def test_fail_signed_in_wrong_order(self):\\n # Swap the signatures from the first and second keys.\\n # Note that the keys have security level of 3, so we need to swap\\n # out a total of 6 signatures.\\n sig_1_1 = self.bundle[1].signature_message_fragment\\n sig_1_2 = self.bundle[2].signature_message_fragment\\n sig_1_3 = self.bundle[3].signature_message_fragment\\n\\n sig_2_1 = self.bundle[4].signature_message_fragment\\n sig_2_2 = self.bundle[5].signature_message_fragment\\n sig_2_3 = self.bundle[6].signature_message_fragment\\n\\n self.bundle[1].signature_message_fragment = sig_2_1\\n self.bundle[2].signature_message_fragment = sig_2_2\\n self.bundle[3].signature_message_fragment = sig_2_3\\n\\n self.bundle[4].signature_message_fragment = sig_1_1\\n self.bundle[5].signature_message_fragment = sig_1_2\\n self.bundle[6].signature_message_fragment = sig_1_3\\n\\n validator = BundleValidator(self.bundle)\\n\\n self.assertFalse(validator.is_valid())\\n\\n self.assertListEqual(\\n validator.errors,\\n\\n [\\n 'Transaction 1 has invalid signature (using 8 fragments).',\\n ],\\n )\",\n \"def __eliminate_unused_constraits (self, objects):\\n result = []\\n for c in self.constraints_:\\n if c [0] in objects and c [1] in objects:\\n result.append (c)\\n\\n return result\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67994744","0.5958347","0.5583729","0.5497606","0.54252285","0.54134977","0.53917265","0.53915894","0.53751105","0.53494143","0.53485787","0.5343248","0.5343216","0.53384286","0.5323294","0.5297185","0.5291411","0.52887464","0.5273759","0.5243703","0.52368015","0.5216658","0.5214974","0.52129567","0.5207504","0.52067095","0.52059996","0.5198885","0.51921374","0.51851195","0.5170005","0.5168752","0.51602995","0.5146614","0.51400197","0.5122444","0.5118202","0.5109533","0.5106572","0.5101549","0.50914806","0.50712615","0.5066726","0.5065884","0.5034874","0.5034874","0.5034874","0.5028246","0.5021224","0.500627","0.50020915","0.49962646","0.49921164","0.49907815","0.4978422","0.49730694","0.4963848","0.49587452","0.49571538","0.49540332","0.4938657","0.4924031","0.49206716","0.4910158","0.4903441","0.4901376","0.4896516","0.48955765","0.48938903","0.4888983","0.48837322","0.48836434","0.4879291","0.48683658","0.48626375","0.48558304","0.48491797","0.48481908","0.48427138","0.4838914","0.4832985","0.48304164","0.48285562","0.4824232","0.48204783","0.4817906","0.4809234","0.48066613","0.4799421","0.47930953","0.4789976","0.47871166","0.47828612","0.47819713","0.47816426","0.47721747","0.47689673","0.47664788","0.4763652","0.47621733"],"string":"[\n \"0.67994744\",\n \"0.5958347\",\n \"0.5583729\",\n \"0.5497606\",\n \"0.54252285\",\n \"0.54134977\",\n \"0.53917265\",\n \"0.53915894\",\n \"0.53751105\",\n \"0.53494143\",\n \"0.53485787\",\n \"0.5343248\",\n \"0.5343216\",\n \"0.53384286\",\n \"0.5323294\",\n \"0.5297185\",\n \"0.5291411\",\n \"0.52887464\",\n \"0.5273759\",\n \"0.5243703\",\n \"0.52368015\",\n \"0.5216658\",\n \"0.5214974\",\n \"0.52129567\",\n \"0.5207504\",\n \"0.52067095\",\n \"0.52059996\",\n \"0.5198885\",\n \"0.51921374\",\n \"0.51851195\",\n \"0.5170005\",\n \"0.5168752\",\n \"0.51602995\",\n \"0.5146614\",\n \"0.51400197\",\n \"0.5122444\",\n \"0.5118202\",\n \"0.5109533\",\n \"0.5106572\",\n \"0.5101549\",\n \"0.50914806\",\n \"0.50712615\",\n \"0.5066726\",\n \"0.5065884\",\n \"0.5034874\",\n \"0.5034874\",\n \"0.5034874\",\n \"0.5028246\",\n \"0.5021224\",\n \"0.500627\",\n \"0.50020915\",\n \"0.49962646\",\n \"0.49921164\",\n \"0.49907815\",\n \"0.4978422\",\n \"0.49730694\",\n \"0.4963848\",\n \"0.49587452\",\n \"0.49571538\",\n \"0.49540332\",\n \"0.4938657\",\n \"0.4924031\",\n \"0.49206716\",\n \"0.4910158\",\n \"0.4903441\",\n \"0.4901376\",\n \"0.4896516\",\n \"0.48955765\",\n \"0.48938903\",\n \"0.4888983\",\n \"0.48837322\",\n \"0.48836434\",\n \"0.4879291\",\n \"0.48683658\",\n \"0.48626375\",\n \"0.48558304\",\n \"0.48491797\",\n \"0.48481908\",\n \"0.48427138\",\n \"0.4838914\",\n \"0.4832985\",\n \"0.48304164\",\n \"0.48285562\",\n \"0.4824232\",\n \"0.48204783\",\n \"0.4817906\",\n \"0.4809234\",\n \"0.48066613\",\n \"0.4799421\",\n \"0.47930953\",\n \"0.4789976\",\n \"0.47871166\",\n \"0.47828612\",\n \"0.47819713\",\n \"0.47816426\",\n \"0.47721747\",\n \"0.47689673\",\n \"0.47664788\",\n \"0.4763652\",\n \"0.47621733\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6198813"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":8784,"cells":{"query":{"kind":"string","value":"Marshal information deom the selected chainParts to create a"},"document":{"kind":"string","value":"def _make_simple_label(chain_parts):\n \n if not _select_simple_chainparts(chain_parts):\n msg = 'Jet Configuration error: '\\\n 'chain fails substring selection: not \"simple\" '\n\n raise NotImplementedError(msg)\n \n label = 'simple(['\n for cp in chain_parts:\n smcstr = str(cp['smc'])\n jvtstr = str(cp['jvt'])\n if smcstr == 'nosmc':\n smcstr = ''\n for i in range(int(cp['multiplicity'])):\n # condition_str = '(%set,%s,%s)' % (str(cp['threshold']),\n # str(cp['etaRange']),\n # smcstr,)\n condition_str = '(%set,%s' % (str(cp['threshold']),\n str(cp['etaRange']),)\n if smcstr: # Run 2 chains have \"INF\" in the SMC substring\n condition_str += ',%s)' % smcstr.replace('INF','')\n elif jvtstr:\n condition_str += ',%s)' % jvtstr\n else:\n condition_str += ')'\n label += condition_str\n label += '])'\n return label"},"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 makeBinaryChains():\n\t\n\t# retrieve the binding partner specifications\n\t(maxsize,types) = getTypes()\n\t\n\t# Do some basic argument checking for this model\n\tif (len(types) < 2):\n\t\tprint \"Number of defined types must equal two for binary chain calculations.\"\n\t\treturn\n\tif (maxsize == 0):\n\t\tprint \"Must specify a valid maximum number for one or more components.\"\n\t\treturn\n\n\tallChains = []\n\tnewChainsA = [[]]\n\tnewChainsB = []\n\t\n\ttypeA = types[0]\n\ttypeB = types[1]\n\t\n\t# start the chain with a single type A component\n\taddComponent(newChainsA[0],typeA,0,0)\n\n\tdepth = 0\n\tfor n in range(maxsize):\n\t\tdepth+=1\n\t\t\n\t\t# go through all the chains created last iteration and append B components\n\t\tnewChainsB = []\n\t\tfor thisChain in newChainsA:\n\n\t\t\t# get a list of new available sites in the provided chain\n\t\t\t# by setting depth -1, we will only add to components added last round\n\t\t\topenSites = makeSiteList(thisChain,typeB,depth-1)\n\t\t\t\n\t\t\t# make all the descendants from the current chain and append them to the pool\n\t\t\tif (n == 0) and (typeA['sym']): #if the starting binder is symmetric, no need to start chains at all its sites\n\t\t\t\tnewChainsB = newChainsB + fillSites(openSites,thisChain,typeB,-1)\n\t\t\telse:\n\t\t\t\tnewChainsB = newChainsB + fillSites(openSites,thisChain,typeB,depth)\n\t\t\n\t\tprint('n:'+str(n)+', '+str(len(newChainsB))+ ' chains created at depth '+str(depth))\n\t\t\n\t\tallChains = allChains + newChainsB\n\t\t\n\t\tdepth+=1\n\t\t\n\t\t# add an additional component to all the previously modified chains\n\t\tnewChainsA = []\n\t\tfor thisChain in newChainsB:\n\n\t\t\topenSites = makeSiteList(thisChain,typeA,depth-1)\n\t\t\tnewChainsA = newChainsA + fillSites(openSites,thisChain,typeA,depth)\n\t\t\t\n\t\tprint('n:'+str(n)+', '+str(len(newChainsA))+ ' chains created at depth '+str(depth))\n\t\t\n\t\tallChains = allChains + newChainsA\n\n\treturn allChains","def serialize(self):\n return pickle.dumps([block.serialize() for block in self.chain])","def _encode_structure(self):\n pass","def _encode_structure(self):\n pass","def marshal(self):\n ...","def __rechaindict__(c):\n from TriggerMenu.menu.DictFromChainName import DictFromChainName\n dfcn = DictFromChainName()\n\n pl1 = []\n for pch in c['chainParts']:\n pl1.append(pch['L1item'])\n\n newname = c['chainName'].replace('dv_','').replace('TestChain','j')\n nchlist = [ newname ,c['chainCounter'],c['L1item'],pl1,c['stream'],\n c['groups'],c['EBstep'] ]\n \n return dfcn.getChainDict(nchlist)","def add_chain_to_model(chain, model, atoms):\n\n if chain[\"type\"] == \"polymer\" or chain[\"type\"] == \"branched\":\n polymer = {\n \"internal_id\": chain[\"internal_id\"], \"sequence\": chain[\"sequence\"],\n \"helices\": [], \"strands\": [], \"residues\": {}\n }\n for i, group in enumerate(chain[\"groups\"], start=1):\n add_het_to_dict(group, chain, atoms, polymer[\"residues\"], number=i)\n add_ss_to_chain(polymer)\n model[\"polymer\"][chain[\"id\"]] = polymer\n else:\n for group in chain[\"groups\"]:\n add_het_to_dict(group, chain, atoms, model[chain[\"type\"]])","def _serialise(self):\n # TODO (M Foley)\n pass","def pack(self):\n data = {\n 'name': self._name,\n 'piece': self._piece,\n 'pos': self._pos,\n 'cash': self._cash,\n 'properties': []\n }\n\n for i in self._properties:\n data['properties'].append({'name': i.name, 'value': i.value})\n\n return data","def marshal(self):\n raise NotImplementedError","def adapt_chain(chain):\n type_chain = check_type(chain)\n name = chain.id\n if type_chain == \"nucleic_acid\":\n new_chain = Bio.PDB.Chain.Chain(name)\n chain = copy.copy(chain)\n for residue in chain:\n new_chain.add(residue.copy())\n\n for residue in new_chain:\n for atom in residue:\n if atom.id == \"C1'\":\n atom.id = \"CA\"\n residue.add(atom.copy())\n return new_chain\n else:\n return chain","def create_from_segments(self, segment, origin=0):\r\n n = origin\r\n if segment[origin]['T'] != 'soma': # if it's a soma, only one compartment\r\n while (len(segment[n]['children']) == 1) and (segment[n]['T'] != 'soma'): # Go to the end of the branch\r\n n += 1\r\n # End of branch\r\n branch = segment[origin:n + 1]\r\n # Set attributes\r\n self.diameter, self.length, self.area, self.x, self.y, self.z = \\\r\n zip(*[(seg['diameter'], seg['length'], seg['area'], seg['x'], seg['y'], seg['z']) for seg in branch])\r\n self.diameter, self.length, self.area, self.x, self.y, self.z = array(self.diameter), array(self.length), \\\r\n array(self.area), array(self.x), array(self.y), array(self.z)\r\n self.type = segment[n]['T'] # normally same type for all compartments in the branch\r\n # Create children (list)\r\n self.children = [Morphology().create_from_segments(segment, origin=c) for c in segment[n]['children']]\r\n # Create dictionary of names (enumerates children from number 1)\r\n for i, child in enumerate(self.children):\r\n self._namedkid[str(i + 1)] = child\r\n # Name the child if possible\r\n if child.type in ['soma', 'axon', 'dendrite']:\r\n if child.type in self._namedkid:\r\n self._namedkid[child.type] = None # two children with the same name: erase (see next block)\r\n else:\r\n self._namedkid[child.type] = child\r\n # Erase useless names\r\n for k in self._namedkid.keys():\r\n if self._namedkid[k] is None:\r\n del self._namedkid[k]\r\n # If two kids, name them L (left) and R (right)\r\n if len(self.children) == 2:\r\n self._namedkid['L'] = self._namedkid['1']\r\n self._namedkid['R'] = self._namedkid['2']\r\n return self","def save_chain(self):\n pprint('saving to file named bc_file.txt')\n with open('ddos_bc_file.txt', 'w') as output:\n output.write(serializer.serialize(self.chain))","def make_mixture_info(parts, operation='+'):\n # type: (List[ModelInfo], str) -> ModelInfo\n # Build new parameter list\n combined_pars = []\n\n # When creating a mixture model that is a sum of product models (ie (1*2)+(3*4))\n # the parameters for models 1 & 2 will be prefixed with A & B respectively,\n # but so will the parameters for models 3 & 4. We need to rename models 3 & 4\n # so that they are prefixed with C & D to avoid overlap of parameter names.\n used_prefixes = []\n for part in parts:\n if part.composition and part.composition[0] == 'mixture':\n i = 0\n for submodel in part.composition[1]:\n npars = len(submodel.parameters.kernel_parameters)\n # List of params of one of the constituent models of part\n submodel_pars = part.parameters.kernel_parameters[i:i+npars]\n # Prefix of the constituent model\n prefix = submodel_pars[0].name[0]\n if prefix not in used_prefixes: # Haven't seen this prefix so far\n used_prefixes.append(prefix)\n i += npars\n continue\n # TODO: don't modify submodel --- it may be used elsewhere\n # Existing code probably doesn't keep a handle on the model\n # parts so its probably okay, but it's possible that a mix\n # on user defined mixture models models will change the\n # parameters used for the parts in the GUI. Even worse if the\n # same plugin is used twice. For example, twosphere.py\n # contains sphere+sphere and you create twosphere+twosphere.\n while prefix in used_prefixes:\n # This prefix has been already used, so change it to the\n # next letter that hasn't been used\n prefix = chr(ord(prefix) + 1)\n used_prefixes.append(prefix)\n prefix += \"_\"\n # Update the parameters of this constituent model to use the\n # new prefix\n for par in submodel_pars:\n # Strip {prefix}_ using par.name[2:], etc.\n # TODO: fails for AB_scale\n par.id = prefix + par.id[2:]\n par.name = prefix + par.name[2:]\n if par.length_control is not None:\n par.length_control = prefix + par.length_control[2:]\n i += npars\n\n for part in parts:\n # Parameter prefix per model, A_, B_, ...\n # Note that prefix must also be applied to id and length_control\n # to support vector parameters\n prefix = ''\n if not part.composition or part.composition[0] == 'product':\n # Model isn't a composition model, so its parameters don't have a\n # a prefix. Add the next available prefix\n prefix = chr(ord('A')+len(used_prefixes))\n used_prefixes.append(prefix)\n prefix += '_'\n\n if operation == '+':\n # If model is a sum model, each constituent model gets its own scale parameter\n scale_prefix = prefix\n if prefix == '' and getattr(part, \"operation\", '') == '*':\n # `part` is a composition product model. Find the prefixes of\n # its parameters to form a new prefix for the scale.\n # For example, a model with A*B*C will have ABC_scale.\n sub_prefixes = []\n for param in part.parameters.kernel_parameters:\n # Prefix of constituent model\n sub_prefix = param.id.split('_')[0]\n if sub_prefix not in sub_prefixes:\n sub_prefixes.append(sub_prefix)\n # Concatenate sub_prefixes to form prefix for the scale\n scale_prefix = ''.join(sub_prefixes) + '_'\n scale = Parameter(scale_prefix + 'scale', default=1.0,\n description=\"model intensity for \" + part.name)\n combined_pars.append(scale)\n for p in part.parameters.kernel_parameters:\n p = copy(p)\n p.name = prefix + p.name\n p.id = prefix + p.id\n if p.length_control is not None:\n p.length_control = prefix + p.length_control\n combined_pars.append(p)\n parameters = ParameterTable(combined_pars)\n # Allow for the scenario in which each component has all its PD parameters\n # active simultaneously. details.make_details() will throw an error if\n # too many are used from any one component.\n parameters.max_pd = sum(part.parameters.max_pd for part in parts)\n\n def random():\n \"\"\"Random set of model parameters for mixture model\"\"\"\n combined_pars = {}\n for k, part in enumerate(parts):\n prefix = chr(ord('A')+k) + '_'\n pars = part.random()\n combined_pars.update((prefix+k, v) for k, v in pars.items())\n return combined_pars\n\n model_info = ModelInfo()\n model_info.id = operation.join(part.id for part in parts)\n model_info.operation = operation\n model_info.name = '(' + operation.join(part.name for part in parts) + ')'\n model_info.filename = None\n model_info.title = 'Mixture model with ' + model_info.name\n model_info.description = model_info.title\n model_info.docs = model_info.title\n model_info.category = \"custom\"\n model_info.parameters = parameters\n model_info.random = random\n #model_info.single = any(part['single'] for part in parts)\n model_info.structure_factor = False\n #model_info.tests = []\n #model_info.source = []\n # Remember the component info blocks so we can build the model\n model_info.composition = ('mixture', parts)\n return model_info","def writeBlocks(self):\n dataFile = open(\"chain.txt\", \"w\")\n chainData = []\n for eachBlock in self.chain:\n chainData.append(eachBlock.__dict__)\n dataFile.write(json.dumps(chainData, indent=4))\n dataFile.close()","def construct_fragments(self):\n for frag_dict in self.fragment_dict_list:\n try:\n chain = self.model[frag_dict[\"chain_id\"]]\n frag = chain[frag_dict[\"frag_id\"]]\n except KeyError:\n self.add_fragment(frag_dict, None)\n continue\n\n self.add_fragment(frag_dict, frag)","def _pack(self):\n pass","def pack_goods(self, by=None):","def pack_goods(self, by=None):","def createInnerRepresentation(self):\n\n for idx, single_block in enumerate(self._block_list):\n del self._to_be_processed[:]\n del self._metastring_rest[:]\n self._metastring_rest.append(self._metastring[idx])\n self.addMetastringPointer(single_block)","def create(data):\n \n return Part(\n part_id = data['part_num'],\n category_id = data['part_cat_id'],\n external_ids = data.get('external_ids', {}),\n name = data['name'],\n year_from = data.get('year_from', None),\n year_to = data.get('year_to', None),\n url = data.get('part_url', None),\n img_url = data.get('part_img_url', None),\n print_of = data.get('print_of', None),\n prints = data.get('prints', []),\n molds = data.get('molds', []),\n alternates = data.get('alternates', []))","def assemble_parts(self):\n self.parts['whole'] = self.output\n self.parts['encoding'] = self.document.settings.output_encoding\n self.parts['version'] = docutils.__version__","def serialize(self):","def _marshal(self, pieces):\n payload = b''.join(pieces)\n return struct.pack('>BHI', self.frame_type, self.channel_number,\n len(payload)) + payload + bytes((spec.FRAME_END,))","def _blob(self):\n self.__rewrite_sldIdLst()\n # # at least the following needs to be added before using\n # # _reltype_ordering again for Presentation\n # self.__rewrite_notesMasterIdLst()\n # self.__rewrite_handoutMasterIdLst()\n # self.__rewrite_sldMasterIdLst()\n return super(Presentation, self)._blob","def get_structure(self):\n return self.chain.model.structure","def marshal(self):\n return self._marshal(list())","def marshal(self):\n return self._marshal([self.fragment])","def chainsetup(filename, cation, facets, operation, end_radii, nradii,\n adensity):\n\n # Load the Cage from the file\n try:\n # If that fails, try other file formats supported by pymatgen\n anion = Cage.from_file(filename)\n except ValueError:\n # If that fails, try the VASP POSCAR format\n anion = Cage.from_poscar(filename)\n\n # Center the anion around the origin\n anion.center()\n\n # Find the chain edges, i.e. the paths between the edge sharing facets of\n # the chain of non-equivalent facets.\n anion.find_surface_facets(ignore=IGNORE)\n\n if not facets == tuple:\n chosen_facets = [anion.facets[index] for index in facets]\n edges = anion.find_noneq_chain_links(chosen_facets)\n else:\n edges = anion.find_noneq_chain_links()\n\n total_mol = anion.copy()\n\n chain_dir = 'chain_' + operation\n try:\n os.mkdir(chain_dir)\n except FileExistsError:\n pass\n\n # For each edge, set up the calculation input files\n edge_number = 1\n\n for edge in edges:\n\n # Set up the edge directory\n edge_dir = os.path.join(chain_dir, \"edge\" + str(edge_number))\n\n while os.path.exists(edge_dir):\n edge_number += 1\n edge_dir = os.path.join(chain_dir, \"edge\" + str(edge_number))\n\n os.mkdir(edge_dir)\n\n # Write out the molecule and path facets to the edge directory\n anion.to(fmt=\"json\", filename=os.path.join(edge_dir, \"molecule.json\"))\n edge[0].to(fmt=\"json\", filename=os.path.join(edge_dir,\n \"init_facet.json\"))\n edge[1].to(fmt=\"json\", filename=os.path.join(edge_dir,\n \"final_facet.json\"))\n\n # Get copies so the originals aren't mutated\n edge_mol = anion.copy()\n facet1 = edge[0].copy()\n facet2 = edge[1].copy()\n\n if edge == edges[-1]:\n remove_endline = False\n else:\n remove_endline = True\n\n # Set up the landscape\n landscape = set_up_edge_landscape(facet1, facet2,\n endpoint_radii=end_radii,\n number_of_radii=nradii,\n angle_density=adensity,\n remove_endline=remove_endline)\n\n # Get the molecule for each landscape point\n molecules = set_up_molecules(edge_mol, landscape, cation)\n\n # Set up an xyz file to visualize the edge and total landscape\n for point in landscape.points:\n try:\n total_mol.append(pmg.Specie(cation, 1), point,\n validate_proximity=False)\n edge_mol.append(pmg.Specie(cation, 1), point,\n validate_proximity=False)\n except ValueError:\n pass\n\n edge_mol.to(fmt=\"xyz\", filename=os.path.join(edge_dir, \"edge.xyz\"))\n\n # In case the molecules must be optimized, add the constraints and\n # optimization setup (DRIVER)\n if operation == \"optimize\":\n far_facet = anion.find_farthest_facet(landscape.center)\n constraints = find_constraints(anion, far_facet.sites)\n constraints['fix atom'] += ' ' + str(len(anion.sites) + 1)\n ALT_SETUP['constraints'] = constraints\n ALT_SETUP[\"driver\"] = DRIVER_SETUP\n\n # Set up the task for the calculations\n tasks = [nwchem.NwTask(molecules[0].charge, None, BASIS,\n theory=\"dft\",\n operation=operation,\n theory_directives=THEORY_SETUP,\n alternate_directives=ALT_SETUP)]\n\n # Set up the input files\n study = Study(molecules, tasks)\n study.set_up_input(edge_dir, sort_comp=False,\n geometry_options=GEO_SETUP)\n\n edge_number += 1\n\n # Set up an xyz file with all the paths\n total_mol.to(fmt=\"xyz\", filename=os.path.join(chain_dir, \"total_mol.xyz\"))","def build_serializer(self):\n self._add_child_elements_recursive(self.get_root_element())","def add_chain_signature(\n self, prop: str, key: JWK, alg: Optional[AlgorithmName] = None,\n header: Optional[JsonObject] = None) -> None:\n top_level_signature = self._payload.get(prop)\n for k in top_level_signature.keys():\n if k != _CHAIN:\n del top_level_signature[k]\n chain = top_level_signature.get(_CHAIN, [])\n self._add_signature(prop, key, alg, header,\n lambda h: {_CHAIN: chain + [h]},\n lambda h: (self._payload\n .setdefault(prop, {})\n .setdefault(_CHAIN, [])\n .append(h)))","def trip_chain(self):\n pass","def __init__(self, objects=()):\n\n vtk.vtkPropAssembly.__init__(self)\n\n self.name = \"\"\n self.created = \"\"\n self.trail = None\n self.trail_points = []\n self.trail_segment_size = 0\n self.trail_offset = None\n self.shadows = []\n self.info = {}\n self.rendered_at = set()\n self.transform = None\n self.scalarbar = None\n\n for a in vedo.utils.flatten(objects):\n if a:\n self.AddPart(a)\n\n self.PickableOff()","def parse_part(self):\n parts = []\n for part in re.split(r'\\*\\*\\* ([A-Z- ]+) \\*\\*\\*', self.hand_file): # return [ 'part1', 'splitter1', 'part2',..\n parts.append(part)\n\n for i in range(0, len(parts)):\n if i == 0:\n self.part_dict['HEADER'] = parts[i]\n if i % 2 != 0: # number is odd\n self.part_dict[parts[i]] = parts[i + 1]","def read_chain(self, _id):\n chain_def = {'class' : 'chain', 'type' : ''}\n for i in self.config_reader.options(_id):\n chain_def[i] = self.config_reader.get(_id, i)\n logging.debug(\"Registering chain %s\", _id)\n self.instances.register(_id,chain_def,self.create_chain)","def marshal_departments(result):\n return result","def dump_parts(self, io):\n\n # XXX refactor with Tempita\n title = \"Parts created by the docutils writer '%s'\" % self.strategy.name\n io.say(title + os.linesep)\n io.say(len(title) * '-')\n io.say(2 * os.linesep)\n io.say('Part keys: ' + 2 * os.linesep)\n\n parts = self.publish_parts(io)\n io.say(os.linesep.join(sorted(parts.keys())))\n io.say(2 * os.linesep)\n for part in parts:\n io.say(\"Value of part '%s':%s\" % (part, os.linesep))\n io.say(parts[part].encode('utf-8') + os.linesep)\n io.say(80*'-'+os.linesep)\n io.say(os.linesep)","def addChain(self, chain):\n\n\t\tself.chain.append(chain)\n\t\tchain.parentMolecule = self","def normalize_chain(cls, chain):\n\n if isinstance(chain, cls):\n chain = (chain,)\n return tuple(x for x in chain if x is not None)","def serialize(self):\n return {\n 'id': self.id,\n 'name': self.name,\n 'ingredients': self.ingredients,\n 'directions': self.directions,\n 'type': self.type,\n }","def toPartners(self):\n num_bases = len(self) #number of bases\n result = [None] * len(self) #array of None, one for each base\n stack = []\n start = self.StartSymbols\n end = self.EndSymbols\n for i, symbol in enumerate(self):\n if symbol in start: #open a pair\n stack.append(i)\n elif symbol in end: #close a pair\n curr = stack.pop() #return and delete last element\n result[i] = curr #make i pair with the last element...\n result[curr] = i #...and the last element pair with i\n \n #test whether there are any open pairs left unaccounted for \n if stack:\n raise IndexError, \\\n \"Too many open pairs in structure:\\n%s\" % self\n return Partners(result)","def __init__(self, fab=None, heavy_chains=None, light_chains=None, names=None):\n # check if it's a Chain object\n if heavy_chains is None and light_chains is None and fab is None:\n raise ValueError('Provide a list of Chain objects or an ChainCollection object')\n\n # check if fab object is a list and if all object are abpytools.Fab objects\n if isinstance(fab, list) and all(isinstance(fab_i, Fab) for fab_i in fab):\n self._fab = fab\n self._light_chains = ChainCollection([x[0] for x in self._fab])\n self._heavy_chains = ChainCollection([x[1] for x in self._fab])\n\n if fab is None and (heavy_chains is not None and light_chains is not None):\n\n if isinstance(heavy_chains, list):\n self._heavy_chains = ChainCollection(antibody_objects=heavy_chains)\n\n elif isinstance(heavy_chains, ChainCollection):\n self._heavy_chains = heavy_chains\n\n else:\n raise ValueError('Provide a list of Chain objects or an ChainCollection object')\n\n if isinstance(light_chains, list):\n self._light_chains = ChainCollection(antibody_objects=light_chains)\n\n elif isinstance(light_chains, ChainCollection):\n self._light_chains = light_chains\n\n else:\n raise ValueError('Provide a list of Chain objects or an ChainCollection object')\n\n if len(self._light_chains.loading_status()) == 0:\n self._light_chains.load()\n\n if len(self._heavy_chains.loading_status()) == 0:\n self._heavy_chains.load()\n\n if self._light_chains.n_ab != self._heavy_chains.n_ab:\n raise ValueError('Number of heavy chains must be the same of light chains')\n\n if isinstance(names, list) and all(isinstance(name, str) for name in names):\n if len(names) == self._heavy_chains.n_ab:\n self._names = names\n else:\n raise ValueError(\n 'Length of name list must be the same as length of heavy_chains/light chains lists')\n\n elif names is None:\n self._names = ['{} - {}'.format(heavy, light) for heavy, light in zip(self._heavy_chains.names,\n self._light_chains.names)]\n\n else:\n raise ValueError(\"Names expected a list of strings, instead got {}\".format(type(names)))\n\n self._n_ab = self._light_chains.n_ab\n self._pair_sequences = [heavy + light for light, heavy in zip(self._heavy_chains.sequences,\n self._light_chains.sequences)]\n\n # keep the name of the heavy and light chains internally to keep everything in the right order\n self._internal_heavy_name = self._heavy_chains.names\n self._internal_light_name = self._light_chains.names","def get_serializer(self, *args, **kwargs):\n kwargs['part_detail'] = True\n kwargs['location_detail'] = True\n kwargs['supplier_part_detail'] = True\n kwargs['context'] = self.get_serializer_context()\n\n return self.serializer_class(*args, **kwargs)","def _encode_supplement(self):","def _encode_supplement(self):","def partid2nids(self, partid, ntype): # -> None:\n ...","def serialize(self, data):","def from_binary(self, d):\n p = MsgCertificateChainDep._parser.parse(d)\n for n in self.__class__.__slots__:\n setattr(self, n, getattr(p, n))","def __init__(self, chain_instance, *args, **kwargs):\n protocol_logger('Intializing protocol processor')\n self.chain_instance = chain_instance","def build_parts_from_dict(self, data, skip_power_controls=False):\n \n # Validate Objects information.\n if \"Objects\" not in data:\n return\n\n # Start creating parts.\n parts = []\n for part_data in data[\"Objects\"]:\n part = part_data[\"ObjectID\"].replace(\"^\", \"\")\n timestamp = part_data[\"Timestamp\"]\n user_data = part_data[\"UserData\"]\n part_position = part_data[\"Position\"]\n up_vec = part_data[\"Up\"]\n at_vec = part_data[\"At\"]\n # Build the item.\n item = self.build_item(\n part,\n timestamp,\n user_data,\n part_position,\n up_vec,\n at_vec,\n skip_power_controls\n )\n parts.append(item)\n\n return parts","def preparing(fasta_list, pdb_dict):\n for item1 in fasta_list:\n matchObj = re.search( '^(.*)_([a-zA-Z0-9])$', item1[0])\n fasta1= item1[1]\n if matchObj:\n original_name1= matchObj.group(1)\n original_structure1=pdb_dict[original_name1]\n chain_1= matchObj.group(2) \n yield fasta1, [original_structure1, chain_1]","def _get_chain_repr(self, chain):\n chain_repr = []\n for module in chain:\n if isinstance(module, collections.Iterable): # module is a chain\n chain_repr.append(self._get_chain_repr(module))\n elif hasattr(module, 'process'): # module is an object\n chain_repr.extend(\n (str(module.__class__), repr(vars(module))))\n else: # module is a function\n if isinstance(module, partial): # partial function\n chain_repr.extend((str(module.__class__), repr(module.func),\n repr(module.keywords)))\n else:\n chain_repr.append(repr(module))\n return ' '.join(chain_repr)","def _make_partitionsTest_label(chain_parts):\n\n assert len(chain_parts) == 1\n scenario = chain_parts[0]['hypoScenario']\n \n assert scenario == 'partitionsTest'\n\n \n\n return \"\"\"\n partgen(\n [(20et, 0eta320)]\n \n simple([(40et, 0eta320) (50et, 0eta320)])\n simple([(35et, 0eta240) (55et, 0eta240)])\n )\"\"\"","def __init__(self):\n self.chain = [Block.genesis()]","def partid2nids(self, partid, ntype=...):\n ...","def partid2nids(self, partid, ntype=...):\n ...","def serialize(self, root):","def _decode(self, parts: typing.List[int]) -> typing.Dict:\n info = {field.name: field.decode(parts[i]) for i, field in enumerate(self.fields)}\n return info","def compose(self):\r\n return_lib = self.other\r\n return_lib.update({\r\n 'ID' : self.id,\r\n 'Name' : self.name,\r\n 'Alias' : self.alias,\r\n 'Parent' : self.parent,\r\n 'Target' : self.target,\r\n 'Gap' : self.gap,\r\n 'Derives_from' : self.derives_from,\r\n 'Note' : self.note,\r\n 'Dbxref' : self.dbxref,\r\n 'Ontology_term' : self.ontology_term,\r\n 'Is_circular' : self.is_circular,\r\n 'allele' : ','.join([a.strip() for a in self.allele])\r\n })\r\n if self.discovered != None:\r\n if self.discovered:\r\n return_lib[self.discovered_key] = self.enabled[0]\r\n else:\r\n return_lib[self.discovered_key] = self.disabled[0]\r\n if self.validated != None:\r\n if self.validated:\r\n return_lib[self.validated_key] = self.enabled[0]\r\n else:\r\n return_lib[self.validated_key] = self.disabled[0]\r\n if self.active != None:\r\n if self.active:\r\n return_lib[self.active_key] = self.disabled[0]\r\n else:\r\n return_lib[self.active_key] = self.enabled[0]\r\n for i,item in enumerate(self.history):\r\n return_lib[\"{}_{}\".format(self.history_key,i)] = ','.join(item)\r\n return_str = ';'.join([key + '=' + value for key, value in return_lib.items() if value])\r\n return return_str","def _encode_parts(self, messages, encode_empty=False):\n if messages or encode_empty:\n return self.signer.sign_object(\n messages, serializer=MessagePartGatherSerializer, compress=True\n )","def _create_chain(class_type_list, kwargs_list):\n chain = None # module with preprocessing chain\n modules = [] # list of modules (not connected via preprocessing)\n for i, pre_id in enumerate(class_type_list):\n chain = CModule.create(\n pre_id, preprocess=chain, **kwargs_list[i])\n modules.append(CModule.create(pre_id, **kwargs_list[i]))\n return chain, modules","def skeleton_getHandleChain(self, typeModifier = None, jointHelpers = True, mOrientHelper = None):\n _short = self.mNode\n _str_func = 'skeleton_getHandleChain'\n #start = time.clock()\t\n log.debug(cgmGEN.logString_start(_str_func))\n \n mRigNull = self.moduleTarget.rigNull\n ml_fkJoints = mRigNull.msgList_get('fkJoints')\n \n if not ml_fkJoints:\n log.debug(\"|{0}| >> Generating handleJoints\".format(_str_func))\n \n ml_formHandles = self.msgList_get('formHandles',asMeta = True)\n if not ml_formHandles:\n raise ValueError,\"No formHandles connected\" \n \n ml_prerigHandles = self.msgList_get('prerigHandles',asMeta = True)\n if not ml_prerigHandles:\n raise ValueError,\"No prerigHandles connected\"\n \n if mOrientHelper is None:\n mOrientHelper = ml_formHandles[0].orientHelper or ml_prerigHandles[0].orientHelper\n \n #_d = skeleton_getCreateDict(self)\n #pprint.pprint(_d)\n l_pos = []\n for mObj in ml_prerigHandles:\n l_pos.append(mObj.p_position)\n \n ml_fkJoints = COREJOINTS.build_chain(posList = l_pos,\n axisAim='z+',\n axisUp='y+',\n parent=True,\n worldUpAxis= mOrientHelper.getAxisVector('y+'))\n \n for i,mJnt in enumerate(ml_fkJoints):\n mJnt.doCopyNameTagsFromObject(ml_prerigHandles[i].mNode, ignore = ['cgmType'])\n if not typeModifier:\n mJnt.doName()\n \n if typeModifier:\n for mJnt in ml_fkJoints:\n mJnt.addAttr('cgmTypeModifier',typeModifier,attrType='string',lock=True)\n mJnt.addAttr('cgmType','frame',attrType='string',lock=True) \n mJnt.doName()\n \n ml_fkJoints[0].p_parent = False\n else:\n log.debug(\"|{0}| >> Found fkJoints\".format(_str_func))\n \n #log.debug(\"%s >> Time >> = %0.3f seconds \" % (_str_func,(time.clock()-start)) + \"-\"*75)\t\n return ml_fkJoints","def serialize(self):\n pass","def __store_part(self, definition, pnum, multisubtype):\n pnum = \"1\" if pnum is None else pnum\n params = {\n \"pnum\": pnum,\n \"params\": definition[2],\n \"cid\": definition[3],\n \"description\": definition[4],\n \"encoding\": definition[5],\n \"size\": definition[6]\n }\n mtype = definition[0].lower()\n subtype = definition[1].lower()\n ftype = \"%s/%s\" % (definition[0].lower(), subtype)\n if ftype in (\"text/plain\", \"text/html\"):\n if subtype not in self.contents:\n self.contents[subtype] = [params]\n else:\n self.contents[subtype].append(params)\n return\n elif multisubtype in [\"related\"]:\n self.inlines[params[\"cid\"].strip(\"<>\")] = params\n return\n\n params[\"Content-Type\"] = ftype\n if len(definition) > 7:\n extensions = [\"md5\", \"disposition\", \"language\", \"location\"]\n if mtype == \"text\":\n extensions = [\"textlines\"] + extensions\n elif ftype == \"message/rfc822\":\n extensions = [\n \"envelopestruct\",\n \"bodystruct\",\n \"textlines\"] + extensions\n for idx, value in enumerate(definition[7:]):\n params[extensions[idx]] = value\n\n self.attachments += [params]","def serialize(self):\n return {\n 'name' : self.name,\n 'ingredients' : self.ingredients,\n 'id' : self.id,\n 'preparation' : self.preparation,\n 'image' : self.image,\n }","def serialize(self, pipe, pid):\n for trsp in self.transports:\n pipe.send(trsp.__class__)\n trsp.serialize(pipe, pid)","def save_data(self):\n try:\n with open('blockchain-{}.txt'.format(self.node_id), mode='w') as f:\n saveable_chain = [block.__dict__ for block in [Block(block_el.index, block_el.previous_hash, \n [tx.__dict__ for tx in block_el.transactions], \n [tx.__dict__ for tx in block_el.chipsactions],\n [tx.__dict__ for tx in block_el.messsactions],\n block_el.proof, block_el.timestamp) for block_el in self.__chain]]\n f.write(json.dumps(saveable_chain))\n f.write('\\n')\n saveable_tx = [tx.__dict__ for tx in self.__open_transactions]\n f.write(json.dumps(saveable_tx))\n f.write('\\n')\n saveable_chip = [tx.__dict__ for tx in self.__open_chipsactions]\n f.write(json.dumps(saveable_chip))\n f.write('\\n')\n saveable_chip = [tx.__dict__ for tx in self.__open_messsactions]\n f.write(json.dumps(saveable_chip))\n f.write('\\n')\n f.write(json.dumps(list(self.__peer_nodes)))\n except IOError:\n print('Saving failed!')","def to_binary(self):\n c = containerize(exclude_fields(self))\n self.payload = MsgCertificateChainDep._parser.build(c)\n return self.pack()","def _make_information_storable( self, data ):\n\t\tpass","def create_chain_instances(self):\n for section in self.config_reader.sections():\n self.read_chain(section)","def chain():\n chain_identifier, url = get_vars(request, [\"id\", \"data\"])\n info('chain=%s' % chain_identifier)\n chain = LAPPS_SERVICE_CHAINS.get_chain(chain_identifier)\n info('source-url=%s' % url)\n data = requests.get(url).text\n result = chain.run({\n \"discriminator\": \"http://vocab.lappsgrid.org/ns/media/text\", \n \"payload\": data})\n info(\"discriminator=%s\" % result.get('discriminator'))\n return render_template(\"chain.html\",\n chain=chain,\n fname=url,\n result=result,\n builder=HtmlBuilder())","def create(data):\n \n return Partlist(\n list_id = data['id'],\n name = data['name'],\n pieces = data['num_parts'])","def make_drs_tree(self):\n pass","def produce_chain_dict (inPath, outPath):\n with open(inPath, 'r') as fin:\n chainIDs = list(fin.read().split())\n chains = {}\n for chainid in chainIDs:\n pdbid = (chainid[ : chainid.find('_') ] if '_' in chainid else chainid)\n if pdbid in chains:\n chains[pdbid].add(chainid)\n else:\n chains[pdbid] = {chainid}\n with open(outPath, 'wb') as fOut:\n pickle.dump(chains, fOut)","def wire_chains(self):\n allChains = self.instances.getAllChainInstances()\n for chain in allChains:\n logging.debug(\"%s\", chain)\n allChains[chain].setup_event_path()","def setPartsToRegister(self, parts):\n internals.blpapi_ServiceRegistrationOptions_setPartsToRegister(\n self.__handle, parts)","def _encode(self, boxes, anchors):\n pass","def __init__(self):\n self.chain = {}\n self.blocks = {}\n self.blocks_spending_input = {}\n self.blocks_containing_tx = {}\n self.all_transactions = {}","def trans_setup():\n # slot7 slot6 slot5 slot4 slot3 slot2 slot1 <------ beam direction (slot 8 is currently B-fiber only)\n # Be Be Be Be Be Be Be lens material\n # 1.5 1.5 0.5 0.5 0.5 0.5 0.5 lens radius [mm]\n # 1 1 5 8 4 2 1 number of lenses\n lens_R=[0.5,0.5,0.5,0.5,0.5,1.5,1.5]\n lens_mat=['Be','Be','Be','Be','Be','Be','Be']\n lens_N=[1,2,4,8,5,1,1]\n trans_pos=[35.2,35.8]\n return {'lens_material':lens_mat,'lens_number':lens_N,'lens_radius':lens_R,'trans_position':trans_pos}","def prepare_order(acct, order):\n myaddr = (acct.address).lower()\n order[\"makerAddress\"] = myaddr\n order_struct = jsdict_order_to_struct(order) \n sig = _sign_order(acct, order_struct)\n order_struct[\"signature\"] = sig\n js_order = order_to_jsdict(order_struct)\n js_order[\"exchangeAddress\"] = exchangeAddress\n return js_order","def _finishConstruction(self, obj):\n return obj","def _finishConstruction(self, obj):\n return obj","def json(self):\n blocks = [block.to_json() for block in self.chain[1:]]\n return json.dumps({'blocks': blocks})","def pdbChain_to_mdtrajChainid_li(chain,seg_to_chain,struc):\n chain = chain.upper()\n chain_segments=[seg for seg,chainval in seg_to_chain.items() if chainval==chain]\n if chain_segments:\n structable, bonds=struc.topology.to_dataframe()\n chainid_li=[]\n for segname in chain_segments:\n seg_chainid_li=structable.loc[structable['segmentID'] == segname].chainID.unique()\n chainid_li+=list(seg_chainid_li)\n chainid_li=list(set(chainid_li))\n return chainid_li\n else:\n return False","def genereate_echo_picklist(self):\n sample_names = []\n sample_wells = []\n indices = {'i5 name': {}, 'i5 plate': {}, 'i5 sequence': {},\n 'i5 well': {}, 'i7 name': {}, 'i7 plate': {},\n 'i7 sequence': {}, 'i7 well': {}, 'index combo': {},\n 'index combo seq': {}}\n\n for idx, well in enumerate(chain.from_iterable(self.plates[0].layout)):\n # Add the sample well\n sample_wells.append(well.well_id)\n # Get the sample name - we need to go back to the SampleComposition\n lib_comp = well.composition\n sample_comp = lib_comp.normalized_gdna_composition\\\n .gdna_composition.sample_composition\n sample_names.append(sample_comp.content)\n # Retrieve all the information about the indices\n i5_comp = lib_comp.i5_composition.primer_set_composition\n i5_well = i5_comp.container\n indices['i5 name'][idx] = i5_comp.external_id\n indices['i5 plate'][idx] = i5_well.plate.external_id\n indices['i5 sequence'][idx] = i5_comp.barcode\n indices['i5 well'][idx] = i5_well.well_id\n\n i7_comp = lib_comp.i7_composition.primer_set_composition\n i7_well = i7_comp.container\n indices['i7 name'][idx] = i7_comp.external_id\n indices['i7 plate'][idx] = i7_well.plate.external_id\n indices['i7 sequence'][idx] = i7_comp.barcode\n indices['i7 well'][idx] = i7_well.well_id\n\n indices['index combo seq'][idx] = '%s%s' % (\n indices['i5 sequence'][idx], indices['i7 sequence'][idx])\n\n sample_names = np.asarray(sample_names)\n sample_wells = np.asarray(sample_wells)\n indices = pd.DataFrame(indices)\n\n return LibraryPrepShotgunProcess._format_picklist(\n sample_names, sample_wells, indices)","def marshal(self):\n pieces = self.properties.encode()\n pieces.insert(\n 0, struct.pack('>HxxQ', self.properties.INDEX, self.body_size))\n return self._marshal(pieces)","def init(self):\n\n logger.info(mm_chain.ackn_str)\n self.acknowledgements = mm_chain.ackn_str\n self.references = mm_chain.refs['chain']\n\n return","def __init__(self):\n self.unconfirmed_transactions = [] \n self.chain = []\n self.create_genesis_block()","def connectPart(self,\n hsNondes: list,\n part: Union[TransPart, ChoicesOfFrameParts],\n en: Union[RtlSignal, bool],\n exclusiveEn: Optional[RtlSignal]=hBit(1)):\n busVld = self.dataIn.valid\n tToIntf = self.dataOut._fieldsToInterfaces\n\n if isinstance(part, ChoicesOfFrameParts):\n parentIntf = tToIntf[part.origin.parent.origin]\n try:\n sel = self._tmpRegsForSelect[parentIntf]\n except KeyError:\n sel = HsBuilder(self, parentIntf._select).buff().end\n self._tmpRegsForSelect[parentIntf] = sel\n unionGroup = ExclusieveListOfHsNodes(sel)\n\n # for unions\n for choice in part:\n # connect data signals of choices and collect info about\n # streams\n intfOfChoice = tToIntf[choice.tmpl.origin]\n selIndex, isSelected, isSelectValid = self.choiceIsSelected(\n intfOfChoice)\n _exclusiveEn = isSelectValid & isSelected & exclusiveEn\n\n unionMemberPart = ListOfOutNodeInfos()\n for p in choice:\n self.connectPart(unionMemberPart, p, en, _exclusiveEn)\n unionGroup.append(selIndex, unionMemberPart)\n\n hsNondes.append(unionGroup)\n\n if part.isLastPart():\n # synchronization of reading from _select register for unions\n selNode = InNodeInfo(sel, en)\n else:\n selNode = InNodeReadOnlyInfo(sel, en)\n hsNondes.append(selNode)\n return\n\n if part.isPadding:\n return\n\n fPartSig = self.getInDataSignal(part)\n fieldInfo = part.tmpl.origin\n\n try:\n signalsOfParts = self._signalsOfParts[part.tmpl]\n except KeyError:\n signalsOfParts = []\n self._signalsOfParts[part.tmpl] = signalsOfParts\n\n if part.isLastPart():\n # connect all parts in this group to output stream\n signalsOfParts.append(fPartSig)\n intf = self.dataOut._fieldsToInterfaces[fieldInfo]\n intf.data(self.byteOrderCare(\n Concat(\n *reversed(signalsOfParts)\n ))\n )\n on = OutNodeInfo(self, intf, en, exclusiveEn)\n hsNondes.append(on)\n else:\n dataVld = busVld & en & exclusiveEn\n # part is in some word as last part, we have to store its value to register\n # until the last part arrive\n fPartReg = self._reg(\"%s_part_%d\" % (fieldInfo.name,\n len(signalsOfParts)),\n fPartSig._dtype)\n If(dataVld,\n fPartReg(fPartSig)\n )\n signalsOfParts.append(fPartReg)","def build_item(\n self,\n part,\n timestamp=1539023700,\n userdata=0,\n position=[0, 0, 0],\n up_vec=[0, 1, 0],\n at_vec=[0, 0, 1],\n skip_power_controls=False):\n # Get the obj path.\n item = self.retrieve_part(part)\n\n # Lock Everything if it's the BASE_FLAG or U_POWERLINE.\n # BASE_FLAG can break things if user moves it around.\n # As it acts as the \"origin\" of the base.\n locked_parts = [\"BASE_FLAG\", \"U_POWERLINE\", \"U_PIPELINE\", \"U_PORTALLINE\"]\n line_parts = [\"U_POWERLINE\", \"U_PIPELINE\", \"U_PORTALLINE\"]\n if part in locked_parts:\n item.lock_location[0] = True\n item.lock_location[1] = True\n item.lock_location[2] = True\n item.lock_rotation[0] = True\n item.lock_rotation[1] = True\n item.lock_rotation[2] = True\n item.lock_scale[0] = True\n item.lock_scale[1] = True\n item.lock_scale[2] = True\n \n # Add custom attributes.\n item[\"ObjectID\"] = part\n item[\"SnapID\"] = part\n item[\"Timestamp\"] = timestamp\n item[\"belongs_to_preset\"] = False\n # Add an order flag to retain order when generating data..\n item[\"Order\"] = self.part_order\n self.part_order += 1\n # Apply Colour\n is_powerline = part in line_parts\n is_pipeline = part in [\"U_PIPELINE\"]\n material.assign_material(\n item,\n userdata,\n powerline=is_powerline,\n pipeline=is_pipeline\n )\n\n # Move\n utils.move_to(item, position=position, up=up_vec, at=at_vec)\n\n # If the object is a powerline, we should create additional controls\n # for it.\n if is_powerline and not skip_power_controls:\n power.create_power_controls(item)\n # Select the new object.\n item.select_set(True)\n return item","def nid2partid(self, nids, ntype=...):\n ...","def nid2partid(self, nids, ntype=...):\n ...","def test_hierarchy_perceived_information_propagation(self):\n from openff.toolkit._tests.create_molecules import (\n dipeptide_hierarchy_added as create_dipeptide,\n )\n\n dipeptide_hierarchy_perceived = create_dipeptide()\n\n for atom in dipeptide_hierarchy_perceived.atoms:\n atom.metadata[\"chain_id\"] = \"A\"\n assert (\"A\", \"1\", \" \", \"ACE\") != dipeptide_hierarchy_perceived.residues[\n 0\n ].identifier\n dipeptide_hierarchy_perceived.update_hierarchy_schemes()\n assert (\"A\", \"1\", \" \", \"ACE\") == dipeptide_hierarchy_perceived.residues[\n 0\n ].identifier","def createInnerRepresentation(self):\n\n while self._metastring_rest:\n self.addMetastringPointer(self._metastring_rest.pop(0))","def _serialize(self, state, handle):\n raise NotImplementedError","def serialize(cleaned_data):\n result = cleaned_data.copy()\n for fieldname in Step1Data.REFERENCE_FIELDS_NAMES:\n if result[fieldname]:\n result[fieldname] = result[fieldname].pk\n result[\"data\"] = result[\"data\"].isoformat()\n # print \"serialize to:\", result\n return result","def encode(self):\r\n # Create dict from attributes. Maintain added order\r\n #jd = {'txpk': collections.OrderedDict()}\r\n jd = {'txpk':{}}\r\n\r\n for key in self.keys:\r\n val = getattr(self, key)\r\n\r\n if val is not None:\r\n if key == 'data':\r\n jd['txpk'][key] = val.decode('utf-8')\r\n else:\r\n jd['txpk'][key] = val\r\n #print('key',key)\r\n #print('valtype',type(val),val) \r\n #print(jd)\r\n \r\n return dumps(jd, separators=(',', ':'))","async def b_chain() -> dict:\n authority_chain = await chain.consensus()\n return {\"chain\": authority_chain[\"chain\"]}","def _create_chained_picking(self, cr, uid, pick_name, picking, purchase_type, move, context=None):\n res = super(stock_move, self)._create_chained_picking(cr, uid, pick_name, picking, purchase_type, move, context=context)\n if picking.purchase_id:\n self.pool.get('stock.picking').write(cr, uid, [res], {'purchase_id': picking.purchase_id.id})\n self.pool.get('stock.picking').write(cr, uid, [res], {'invoice_state': picking.invoice_state})\n return res","def fetchParts(jdb, melId, instrument, signature):\n chorusDict = collections.OrderedDict()\n bs = jdb.beats(melId)\n formId = ''\n for b in bs:\n beat = Beat(*b[1:])\n if not beat.chorus in chorusDict:\n chorus = Section(u'CHORUS', beat.onset, None, beat.chorus)\n chorusDict[beat.chorus] = chorus\n chorus = chorusDict[beat.chorus]\n if (beat.form != ''):\n formId = beat.form\n if not formId in chorus.children:\n form = Section(u'FORM', beat.onset, None, formId)\n chorus.children[formId] = form\n form = chorus.children[formId]\n form.beats.append(beat)\n #print [c.value for c in chorusDict.values()]\n return makeParts(chorusDict.values(), instrument, jdb.shiftTime(melId), int(signature.split('/')[0]))","def serialize(self):\n\t\treturn { 'type': self.type, 'parameters' : self.parameters}"],"string":"[\n \"def makeBinaryChains():\\n\\t\\n\\t# retrieve the binding partner specifications\\n\\t(maxsize,types) = getTypes()\\n\\t\\n\\t# Do some basic argument checking for this model\\n\\tif (len(types) < 2):\\n\\t\\tprint \\\"Number of defined types must equal two for binary chain calculations.\\\"\\n\\t\\treturn\\n\\tif (maxsize == 0):\\n\\t\\tprint \\\"Must specify a valid maximum number for one or more components.\\\"\\n\\t\\treturn\\n\\n\\tallChains = []\\n\\tnewChainsA = [[]]\\n\\tnewChainsB = []\\n\\t\\n\\ttypeA = types[0]\\n\\ttypeB = types[1]\\n\\t\\n\\t# start the chain with a single type A component\\n\\taddComponent(newChainsA[0],typeA,0,0)\\n\\n\\tdepth = 0\\n\\tfor n in range(maxsize):\\n\\t\\tdepth+=1\\n\\t\\t\\n\\t\\t# go through all the chains created last iteration and append B components\\n\\t\\tnewChainsB = []\\n\\t\\tfor thisChain in newChainsA:\\n\\n\\t\\t\\t# get a list of new available sites in the provided chain\\n\\t\\t\\t# by setting depth -1, we will only add to components added last round\\n\\t\\t\\topenSites = makeSiteList(thisChain,typeB,depth-1)\\n\\t\\t\\t\\n\\t\\t\\t# make all the descendants from the current chain and append them to the pool\\n\\t\\t\\tif (n == 0) and (typeA['sym']): #if the starting binder is symmetric, no need to start chains at all its sites\\n\\t\\t\\t\\tnewChainsB = newChainsB + fillSites(openSites,thisChain,typeB,-1)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tnewChainsB = newChainsB + fillSites(openSites,thisChain,typeB,depth)\\n\\t\\t\\n\\t\\tprint('n:'+str(n)+', '+str(len(newChainsB))+ ' chains created at depth '+str(depth))\\n\\t\\t\\n\\t\\tallChains = allChains + newChainsB\\n\\t\\t\\n\\t\\tdepth+=1\\n\\t\\t\\n\\t\\t# add an additional component to all the previously modified chains\\n\\t\\tnewChainsA = []\\n\\t\\tfor thisChain in newChainsB:\\n\\n\\t\\t\\topenSites = makeSiteList(thisChain,typeA,depth-1)\\n\\t\\t\\tnewChainsA = newChainsA + fillSites(openSites,thisChain,typeA,depth)\\n\\t\\t\\t\\n\\t\\tprint('n:'+str(n)+', '+str(len(newChainsA))+ ' chains created at depth '+str(depth))\\n\\t\\t\\n\\t\\tallChains = allChains + newChainsA\\n\\n\\treturn allChains\",\n \"def serialize(self):\\n return pickle.dumps([block.serialize() for block in self.chain])\",\n \"def _encode_structure(self):\\n pass\",\n \"def _encode_structure(self):\\n pass\",\n \"def marshal(self):\\n ...\",\n \"def __rechaindict__(c):\\n from TriggerMenu.menu.DictFromChainName import DictFromChainName\\n dfcn = DictFromChainName()\\n\\n pl1 = []\\n for pch in c['chainParts']:\\n pl1.append(pch['L1item'])\\n\\n newname = c['chainName'].replace('dv_','').replace('TestChain','j')\\n nchlist = [ newname ,c['chainCounter'],c['L1item'],pl1,c['stream'],\\n c['groups'],c['EBstep'] ]\\n \\n return dfcn.getChainDict(nchlist)\",\n \"def add_chain_to_model(chain, model, atoms):\\n\\n if chain[\\\"type\\\"] == \\\"polymer\\\" or chain[\\\"type\\\"] == \\\"branched\\\":\\n polymer = {\\n \\\"internal_id\\\": chain[\\\"internal_id\\\"], \\\"sequence\\\": chain[\\\"sequence\\\"],\\n \\\"helices\\\": [], \\\"strands\\\": [], \\\"residues\\\": {}\\n }\\n for i, group in enumerate(chain[\\\"groups\\\"], start=1):\\n add_het_to_dict(group, chain, atoms, polymer[\\\"residues\\\"], number=i)\\n add_ss_to_chain(polymer)\\n model[\\\"polymer\\\"][chain[\\\"id\\\"]] = polymer\\n else:\\n for group in chain[\\\"groups\\\"]:\\n add_het_to_dict(group, chain, atoms, model[chain[\\\"type\\\"]])\",\n \"def _serialise(self):\\n # TODO (M Foley)\\n pass\",\n \"def pack(self):\\n data = {\\n 'name': self._name,\\n 'piece': self._piece,\\n 'pos': self._pos,\\n 'cash': self._cash,\\n 'properties': []\\n }\\n\\n for i in self._properties:\\n data['properties'].append({'name': i.name, 'value': i.value})\\n\\n return data\",\n \"def marshal(self):\\n raise NotImplementedError\",\n \"def adapt_chain(chain):\\n type_chain = check_type(chain)\\n name = chain.id\\n if type_chain == \\\"nucleic_acid\\\":\\n new_chain = Bio.PDB.Chain.Chain(name)\\n chain = copy.copy(chain)\\n for residue in chain:\\n new_chain.add(residue.copy())\\n\\n for residue in new_chain:\\n for atom in residue:\\n if atom.id == \\\"C1'\\\":\\n atom.id = \\\"CA\\\"\\n residue.add(atom.copy())\\n return new_chain\\n else:\\n return chain\",\n \"def create_from_segments(self, segment, origin=0):\\r\\n n = origin\\r\\n if segment[origin]['T'] != 'soma': # if it's a soma, only one compartment\\r\\n while (len(segment[n]['children']) == 1) and (segment[n]['T'] != 'soma'): # Go to the end of the branch\\r\\n n += 1\\r\\n # End of branch\\r\\n branch = segment[origin:n + 1]\\r\\n # Set attributes\\r\\n self.diameter, self.length, self.area, self.x, self.y, self.z = \\\\\\r\\n zip(*[(seg['diameter'], seg['length'], seg['area'], seg['x'], seg['y'], seg['z']) for seg in branch])\\r\\n self.diameter, self.length, self.area, self.x, self.y, self.z = array(self.diameter), array(self.length), \\\\\\r\\n array(self.area), array(self.x), array(self.y), array(self.z)\\r\\n self.type = segment[n]['T'] # normally same type for all compartments in the branch\\r\\n # Create children (list)\\r\\n self.children = [Morphology().create_from_segments(segment, origin=c) for c in segment[n]['children']]\\r\\n # Create dictionary of names (enumerates children from number 1)\\r\\n for i, child in enumerate(self.children):\\r\\n self._namedkid[str(i + 1)] = child\\r\\n # Name the child if possible\\r\\n if child.type in ['soma', 'axon', 'dendrite']:\\r\\n if child.type in self._namedkid:\\r\\n self._namedkid[child.type] = None # two children with the same name: erase (see next block)\\r\\n else:\\r\\n self._namedkid[child.type] = child\\r\\n # Erase useless names\\r\\n for k in self._namedkid.keys():\\r\\n if self._namedkid[k] is None:\\r\\n del self._namedkid[k]\\r\\n # If two kids, name them L (left) and R (right)\\r\\n if len(self.children) == 2:\\r\\n self._namedkid['L'] = self._namedkid['1']\\r\\n self._namedkid['R'] = self._namedkid['2']\\r\\n return self\",\n \"def save_chain(self):\\n pprint('saving to file named bc_file.txt')\\n with open('ddos_bc_file.txt', 'w') as output:\\n output.write(serializer.serialize(self.chain))\",\n \"def make_mixture_info(parts, operation='+'):\\n # type: (List[ModelInfo], str) -> ModelInfo\\n # Build new parameter list\\n combined_pars = []\\n\\n # When creating a mixture model that is a sum of product models (ie (1*2)+(3*4))\\n # the parameters for models 1 & 2 will be prefixed with A & B respectively,\\n # but so will the parameters for models 3 & 4. We need to rename models 3 & 4\\n # so that they are prefixed with C & D to avoid overlap of parameter names.\\n used_prefixes = []\\n for part in parts:\\n if part.composition and part.composition[0] == 'mixture':\\n i = 0\\n for submodel in part.composition[1]:\\n npars = len(submodel.parameters.kernel_parameters)\\n # List of params of one of the constituent models of part\\n submodel_pars = part.parameters.kernel_parameters[i:i+npars]\\n # Prefix of the constituent model\\n prefix = submodel_pars[0].name[0]\\n if prefix not in used_prefixes: # Haven't seen this prefix so far\\n used_prefixes.append(prefix)\\n i += npars\\n continue\\n # TODO: don't modify submodel --- it may be used elsewhere\\n # Existing code probably doesn't keep a handle on the model\\n # parts so its probably okay, but it's possible that a mix\\n # on user defined mixture models models will change the\\n # parameters used for the parts in the GUI. Even worse if the\\n # same plugin is used twice. For example, twosphere.py\\n # contains sphere+sphere and you create twosphere+twosphere.\\n while prefix in used_prefixes:\\n # This prefix has been already used, so change it to the\\n # next letter that hasn't been used\\n prefix = chr(ord(prefix) + 1)\\n used_prefixes.append(prefix)\\n prefix += \\\"_\\\"\\n # Update the parameters of this constituent model to use the\\n # new prefix\\n for par in submodel_pars:\\n # Strip {prefix}_ using par.name[2:], etc.\\n # TODO: fails for AB_scale\\n par.id = prefix + par.id[2:]\\n par.name = prefix + par.name[2:]\\n if par.length_control is not None:\\n par.length_control = prefix + par.length_control[2:]\\n i += npars\\n\\n for part in parts:\\n # Parameter prefix per model, A_, B_, ...\\n # Note that prefix must also be applied to id and length_control\\n # to support vector parameters\\n prefix = ''\\n if not part.composition or part.composition[0] == 'product':\\n # Model isn't a composition model, so its parameters don't have a\\n # a prefix. Add the next available prefix\\n prefix = chr(ord('A')+len(used_prefixes))\\n used_prefixes.append(prefix)\\n prefix += '_'\\n\\n if operation == '+':\\n # If model is a sum model, each constituent model gets its own scale parameter\\n scale_prefix = prefix\\n if prefix == '' and getattr(part, \\\"operation\\\", '') == '*':\\n # `part` is a composition product model. Find the prefixes of\\n # its parameters to form a new prefix for the scale.\\n # For example, a model with A*B*C will have ABC_scale.\\n sub_prefixes = []\\n for param in part.parameters.kernel_parameters:\\n # Prefix of constituent model\\n sub_prefix = param.id.split('_')[0]\\n if sub_prefix not in sub_prefixes:\\n sub_prefixes.append(sub_prefix)\\n # Concatenate sub_prefixes to form prefix for the scale\\n scale_prefix = ''.join(sub_prefixes) + '_'\\n scale = Parameter(scale_prefix + 'scale', default=1.0,\\n description=\\\"model intensity for \\\" + part.name)\\n combined_pars.append(scale)\\n for p in part.parameters.kernel_parameters:\\n p = copy(p)\\n p.name = prefix + p.name\\n p.id = prefix + p.id\\n if p.length_control is not None:\\n p.length_control = prefix + p.length_control\\n combined_pars.append(p)\\n parameters = ParameterTable(combined_pars)\\n # Allow for the scenario in which each component has all its PD parameters\\n # active simultaneously. details.make_details() will throw an error if\\n # too many are used from any one component.\\n parameters.max_pd = sum(part.parameters.max_pd for part in parts)\\n\\n def random():\\n \\\"\\\"\\\"Random set of model parameters for mixture model\\\"\\\"\\\"\\n combined_pars = {}\\n for k, part in enumerate(parts):\\n prefix = chr(ord('A')+k) + '_'\\n pars = part.random()\\n combined_pars.update((prefix+k, v) for k, v in pars.items())\\n return combined_pars\\n\\n model_info = ModelInfo()\\n model_info.id = operation.join(part.id for part in parts)\\n model_info.operation = operation\\n model_info.name = '(' + operation.join(part.name for part in parts) + ')'\\n model_info.filename = None\\n model_info.title = 'Mixture model with ' + model_info.name\\n model_info.description = model_info.title\\n model_info.docs = model_info.title\\n model_info.category = \\\"custom\\\"\\n model_info.parameters = parameters\\n model_info.random = random\\n #model_info.single = any(part['single'] for part in parts)\\n model_info.structure_factor = False\\n #model_info.tests = []\\n #model_info.source = []\\n # Remember the component info blocks so we can build the model\\n model_info.composition = ('mixture', parts)\\n return model_info\",\n \"def writeBlocks(self):\\n dataFile = open(\\\"chain.txt\\\", \\\"w\\\")\\n chainData = []\\n for eachBlock in self.chain:\\n chainData.append(eachBlock.__dict__)\\n dataFile.write(json.dumps(chainData, indent=4))\\n dataFile.close()\",\n \"def construct_fragments(self):\\n for frag_dict in self.fragment_dict_list:\\n try:\\n chain = self.model[frag_dict[\\\"chain_id\\\"]]\\n frag = chain[frag_dict[\\\"frag_id\\\"]]\\n except KeyError:\\n self.add_fragment(frag_dict, None)\\n continue\\n\\n self.add_fragment(frag_dict, frag)\",\n \"def _pack(self):\\n pass\",\n \"def pack_goods(self, by=None):\",\n \"def pack_goods(self, by=None):\",\n \"def createInnerRepresentation(self):\\n\\n for idx, single_block in enumerate(self._block_list):\\n del self._to_be_processed[:]\\n del self._metastring_rest[:]\\n self._metastring_rest.append(self._metastring[idx])\\n self.addMetastringPointer(single_block)\",\n \"def create(data):\\n \\n return Part(\\n part_id = data['part_num'],\\n category_id = data['part_cat_id'],\\n external_ids = data.get('external_ids', {}),\\n name = data['name'],\\n year_from = data.get('year_from', None),\\n year_to = data.get('year_to', None),\\n url = data.get('part_url', None),\\n img_url = data.get('part_img_url', None),\\n print_of = data.get('print_of', None),\\n prints = data.get('prints', []),\\n molds = data.get('molds', []),\\n alternates = data.get('alternates', []))\",\n \"def assemble_parts(self):\\n self.parts['whole'] = self.output\\n self.parts['encoding'] = self.document.settings.output_encoding\\n self.parts['version'] = docutils.__version__\",\n \"def serialize(self):\",\n \"def _marshal(self, pieces):\\n payload = b''.join(pieces)\\n return struct.pack('>BHI', self.frame_type, self.channel_number,\\n len(payload)) + payload + bytes((spec.FRAME_END,))\",\n \"def _blob(self):\\n self.__rewrite_sldIdLst()\\n # # at least the following needs to be added before using\\n # # _reltype_ordering again for Presentation\\n # self.__rewrite_notesMasterIdLst()\\n # self.__rewrite_handoutMasterIdLst()\\n # self.__rewrite_sldMasterIdLst()\\n return super(Presentation, self)._blob\",\n \"def get_structure(self):\\n return self.chain.model.structure\",\n \"def marshal(self):\\n return self._marshal(list())\",\n \"def marshal(self):\\n return self._marshal([self.fragment])\",\n \"def chainsetup(filename, cation, facets, operation, end_radii, nradii,\\n adensity):\\n\\n # Load the Cage from the file\\n try:\\n # If that fails, try other file formats supported by pymatgen\\n anion = Cage.from_file(filename)\\n except ValueError:\\n # If that fails, try the VASP POSCAR format\\n anion = Cage.from_poscar(filename)\\n\\n # Center the anion around the origin\\n anion.center()\\n\\n # Find the chain edges, i.e. the paths between the edge sharing facets of\\n # the chain of non-equivalent facets.\\n anion.find_surface_facets(ignore=IGNORE)\\n\\n if not facets == tuple:\\n chosen_facets = [anion.facets[index] for index in facets]\\n edges = anion.find_noneq_chain_links(chosen_facets)\\n else:\\n edges = anion.find_noneq_chain_links()\\n\\n total_mol = anion.copy()\\n\\n chain_dir = 'chain_' + operation\\n try:\\n os.mkdir(chain_dir)\\n except FileExistsError:\\n pass\\n\\n # For each edge, set up the calculation input files\\n edge_number = 1\\n\\n for edge in edges:\\n\\n # Set up the edge directory\\n edge_dir = os.path.join(chain_dir, \\\"edge\\\" + str(edge_number))\\n\\n while os.path.exists(edge_dir):\\n edge_number += 1\\n edge_dir = os.path.join(chain_dir, \\\"edge\\\" + str(edge_number))\\n\\n os.mkdir(edge_dir)\\n\\n # Write out the molecule and path facets to the edge directory\\n anion.to(fmt=\\\"json\\\", filename=os.path.join(edge_dir, \\\"molecule.json\\\"))\\n edge[0].to(fmt=\\\"json\\\", filename=os.path.join(edge_dir,\\n \\\"init_facet.json\\\"))\\n edge[1].to(fmt=\\\"json\\\", filename=os.path.join(edge_dir,\\n \\\"final_facet.json\\\"))\\n\\n # Get copies so the originals aren't mutated\\n edge_mol = anion.copy()\\n facet1 = edge[0].copy()\\n facet2 = edge[1].copy()\\n\\n if edge == edges[-1]:\\n remove_endline = False\\n else:\\n remove_endline = True\\n\\n # Set up the landscape\\n landscape = set_up_edge_landscape(facet1, facet2,\\n endpoint_radii=end_radii,\\n number_of_radii=nradii,\\n angle_density=adensity,\\n remove_endline=remove_endline)\\n\\n # Get the molecule for each landscape point\\n molecules = set_up_molecules(edge_mol, landscape, cation)\\n\\n # Set up an xyz file to visualize the edge and total landscape\\n for point in landscape.points:\\n try:\\n total_mol.append(pmg.Specie(cation, 1), point,\\n validate_proximity=False)\\n edge_mol.append(pmg.Specie(cation, 1), point,\\n validate_proximity=False)\\n except ValueError:\\n pass\\n\\n edge_mol.to(fmt=\\\"xyz\\\", filename=os.path.join(edge_dir, \\\"edge.xyz\\\"))\\n\\n # In case the molecules must be optimized, add the constraints and\\n # optimization setup (DRIVER)\\n if operation == \\\"optimize\\\":\\n far_facet = anion.find_farthest_facet(landscape.center)\\n constraints = find_constraints(anion, far_facet.sites)\\n constraints['fix atom'] += ' ' + str(len(anion.sites) + 1)\\n ALT_SETUP['constraints'] = constraints\\n ALT_SETUP[\\\"driver\\\"] = DRIVER_SETUP\\n\\n # Set up the task for the calculations\\n tasks = [nwchem.NwTask(molecules[0].charge, None, BASIS,\\n theory=\\\"dft\\\",\\n operation=operation,\\n theory_directives=THEORY_SETUP,\\n alternate_directives=ALT_SETUP)]\\n\\n # Set up the input files\\n study = Study(molecules, tasks)\\n study.set_up_input(edge_dir, sort_comp=False,\\n geometry_options=GEO_SETUP)\\n\\n edge_number += 1\\n\\n # Set up an xyz file with all the paths\\n total_mol.to(fmt=\\\"xyz\\\", filename=os.path.join(chain_dir, \\\"total_mol.xyz\\\"))\",\n \"def build_serializer(self):\\n self._add_child_elements_recursive(self.get_root_element())\",\n \"def add_chain_signature(\\n self, prop: str, key: JWK, alg: Optional[AlgorithmName] = None,\\n header: Optional[JsonObject] = None) -> None:\\n top_level_signature = self._payload.get(prop)\\n for k in top_level_signature.keys():\\n if k != _CHAIN:\\n del top_level_signature[k]\\n chain = top_level_signature.get(_CHAIN, [])\\n self._add_signature(prop, key, alg, header,\\n lambda h: {_CHAIN: chain + [h]},\\n lambda h: (self._payload\\n .setdefault(prop, {})\\n .setdefault(_CHAIN, [])\\n .append(h)))\",\n \"def trip_chain(self):\\n pass\",\n \"def __init__(self, objects=()):\\n\\n vtk.vtkPropAssembly.__init__(self)\\n\\n self.name = \\\"\\\"\\n self.created = \\\"\\\"\\n self.trail = None\\n self.trail_points = []\\n self.trail_segment_size = 0\\n self.trail_offset = None\\n self.shadows = []\\n self.info = {}\\n self.rendered_at = set()\\n self.transform = None\\n self.scalarbar = None\\n\\n for a in vedo.utils.flatten(objects):\\n if a:\\n self.AddPart(a)\\n\\n self.PickableOff()\",\n \"def parse_part(self):\\n parts = []\\n for part in re.split(r'\\\\*\\\\*\\\\* ([A-Z- ]+) \\\\*\\\\*\\\\*', self.hand_file): # return [ 'part1', 'splitter1', 'part2',..\\n parts.append(part)\\n\\n for i in range(0, len(parts)):\\n if i == 0:\\n self.part_dict['HEADER'] = parts[i]\\n if i % 2 != 0: # number is odd\\n self.part_dict[parts[i]] = parts[i + 1]\",\n \"def read_chain(self, _id):\\n chain_def = {'class' : 'chain', 'type' : ''}\\n for i in self.config_reader.options(_id):\\n chain_def[i] = self.config_reader.get(_id, i)\\n logging.debug(\\\"Registering chain %s\\\", _id)\\n self.instances.register(_id,chain_def,self.create_chain)\",\n \"def marshal_departments(result):\\n return result\",\n \"def dump_parts(self, io):\\n\\n # XXX refactor with Tempita\\n title = \\\"Parts created by the docutils writer '%s'\\\" % self.strategy.name\\n io.say(title + os.linesep)\\n io.say(len(title) * '-')\\n io.say(2 * os.linesep)\\n io.say('Part keys: ' + 2 * os.linesep)\\n\\n parts = self.publish_parts(io)\\n io.say(os.linesep.join(sorted(parts.keys())))\\n io.say(2 * os.linesep)\\n for part in parts:\\n io.say(\\\"Value of part '%s':%s\\\" % (part, os.linesep))\\n io.say(parts[part].encode('utf-8') + os.linesep)\\n io.say(80*'-'+os.linesep)\\n io.say(os.linesep)\",\n \"def addChain(self, chain):\\n\\n\\t\\tself.chain.append(chain)\\n\\t\\tchain.parentMolecule = self\",\n \"def normalize_chain(cls, chain):\\n\\n if isinstance(chain, cls):\\n chain = (chain,)\\n return tuple(x for x in chain if x is not None)\",\n \"def serialize(self):\\n return {\\n 'id': self.id,\\n 'name': self.name,\\n 'ingredients': self.ingredients,\\n 'directions': self.directions,\\n 'type': self.type,\\n }\",\n \"def toPartners(self):\\n num_bases = len(self) #number of bases\\n result = [None] * len(self) #array of None, one for each base\\n stack = []\\n start = self.StartSymbols\\n end = self.EndSymbols\\n for i, symbol in enumerate(self):\\n if symbol in start: #open a pair\\n stack.append(i)\\n elif symbol in end: #close a pair\\n curr = stack.pop() #return and delete last element\\n result[i] = curr #make i pair with the last element...\\n result[curr] = i #...and the last element pair with i\\n \\n #test whether there are any open pairs left unaccounted for \\n if stack:\\n raise IndexError, \\\\\\n \\\"Too many open pairs in structure:\\\\n%s\\\" % self\\n return Partners(result)\",\n \"def __init__(self, fab=None, heavy_chains=None, light_chains=None, names=None):\\n # check if it's a Chain object\\n if heavy_chains is None and light_chains is None and fab is None:\\n raise ValueError('Provide a list of Chain objects or an ChainCollection object')\\n\\n # check if fab object is a list and if all object are abpytools.Fab objects\\n if isinstance(fab, list) and all(isinstance(fab_i, Fab) for fab_i in fab):\\n self._fab = fab\\n self._light_chains = ChainCollection([x[0] for x in self._fab])\\n self._heavy_chains = ChainCollection([x[1] for x in self._fab])\\n\\n if fab is None and (heavy_chains is not None and light_chains is not None):\\n\\n if isinstance(heavy_chains, list):\\n self._heavy_chains = ChainCollection(antibody_objects=heavy_chains)\\n\\n elif isinstance(heavy_chains, ChainCollection):\\n self._heavy_chains = heavy_chains\\n\\n else:\\n raise ValueError('Provide a list of Chain objects or an ChainCollection object')\\n\\n if isinstance(light_chains, list):\\n self._light_chains = ChainCollection(antibody_objects=light_chains)\\n\\n elif isinstance(light_chains, ChainCollection):\\n self._light_chains = light_chains\\n\\n else:\\n raise ValueError('Provide a list of Chain objects or an ChainCollection object')\\n\\n if len(self._light_chains.loading_status()) == 0:\\n self._light_chains.load()\\n\\n if len(self._heavy_chains.loading_status()) == 0:\\n self._heavy_chains.load()\\n\\n if self._light_chains.n_ab != self._heavy_chains.n_ab:\\n raise ValueError('Number of heavy chains must be the same of light chains')\\n\\n if isinstance(names, list) and all(isinstance(name, str) for name in names):\\n if len(names) == self._heavy_chains.n_ab:\\n self._names = names\\n else:\\n raise ValueError(\\n 'Length of name list must be the same as length of heavy_chains/light chains lists')\\n\\n elif names is None:\\n self._names = ['{} - {}'.format(heavy, light) for heavy, light in zip(self._heavy_chains.names,\\n self._light_chains.names)]\\n\\n else:\\n raise ValueError(\\\"Names expected a list of strings, instead got {}\\\".format(type(names)))\\n\\n self._n_ab = self._light_chains.n_ab\\n self._pair_sequences = [heavy + light for light, heavy in zip(self._heavy_chains.sequences,\\n self._light_chains.sequences)]\\n\\n # keep the name of the heavy and light chains internally to keep everything in the right order\\n self._internal_heavy_name = self._heavy_chains.names\\n self._internal_light_name = self._light_chains.names\",\n \"def get_serializer(self, *args, **kwargs):\\n kwargs['part_detail'] = True\\n kwargs['location_detail'] = True\\n kwargs['supplier_part_detail'] = True\\n kwargs['context'] = self.get_serializer_context()\\n\\n return self.serializer_class(*args, **kwargs)\",\n \"def _encode_supplement(self):\",\n \"def _encode_supplement(self):\",\n \"def partid2nids(self, partid, ntype): # -> None:\\n ...\",\n \"def serialize(self, data):\",\n \"def from_binary(self, d):\\n p = MsgCertificateChainDep._parser.parse(d)\\n for n in self.__class__.__slots__:\\n setattr(self, n, getattr(p, n))\",\n \"def __init__(self, chain_instance, *args, **kwargs):\\n protocol_logger('Intializing protocol processor')\\n self.chain_instance = chain_instance\",\n \"def build_parts_from_dict(self, data, skip_power_controls=False):\\n \\n # Validate Objects information.\\n if \\\"Objects\\\" not in data:\\n return\\n\\n # Start creating parts.\\n parts = []\\n for part_data in data[\\\"Objects\\\"]:\\n part = part_data[\\\"ObjectID\\\"].replace(\\\"^\\\", \\\"\\\")\\n timestamp = part_data[\\\"Timestamp\\\"]\\n user_data = part_data[\\\"UserData\\\"]\\n part_position = part_data[\\\"Position\\\"]\\n up_vec = part_data[\\\"Up\\\"]\\n at_vec = part_data[\\\"At\\\"]\\n # Build the item.\\n item = self.build_item(\\n part,\\n timestamp,\\n user_data,\\n part_position,\\n up_vec,\\n at_vec,\\n skip_power_controls\\n )\\n parts.append(item)\\n\\n return parts\",\n \"def preparing(fasta_list, pdb_dict):\\n for item1 in fasta_list:\\n matchObj = re.search( '^(.*)_([a-zA-Z0-9])$', item1[0])\\n fasta1= item1[1]\\n if matchObj:\\n original_name1= matchObj.group(1)\\n original_structure1=pdb_dict[original_name1]\\n chain_1= matchObj.group(2) \\n yield fasta1, [original_structure1, chain_1]\",\n \"def _get_chain_repr(self, chain):\\n chain_repr = []\\n for module in chain:\\n if isinstance(module, collections.Iterable): # module is a chain\\n chain_repr.append(self._get_chain_repr(module))\\n elif hasattr(module, 'process'): # module is an object\\n chain_repr.extend(\\n (str(module.__class__), repr(vars(module))))\\n else: # module is a function\\n if isinstance(module, partial): # partial function\\n chain_repr.extend((str(module.__class__), repr(module.func),\\n repr(module.keywords)))\\n else:\\n chain_repr.append(repr(module))\\n return ' '.join(chain_repr)\",\n \"def _make_partitionsTest_label(chain_parts):\\n\\n assert len(chain_parts) == 1\\n scenario = chain_parts[0]['hypoScenario']\\n \\n assert scenario == 'partitionsTest'\\n\\n \\n\\n return \\\"\\\"\\\"\\n partgen(\\n [(20et, 0eta320)]\\n \\n simple([(40et, 0eta320) (50et, 0eta320)])\\n simple([(35et, 0eta240) (55et, 0eta240)])\\n )\\\"\\\"\\\"\",\n \"def __init__(self):\\n self.chain = [Block.genesis()]\",\n \"def partid2nids(self, partid, ntype=...):\\n ...\",\n \"def partid2nids(self, partid, ntype=...):\\n ...\",\n \"def serialize(self, root):\",\n \"def _decode(self, parts: typing.List[int]) -> typing.Dict:\\n info = {field.name: field.decode(parts[i]) for i, field in enumerate(self.fields)}\\n return info\",\n \"def compose(self):\\r\\n return_lib = self.other\\r\\n return_lib.update({\\r\\n 'ID' : self.id,\\r\\n 'Name' : self.name,\\r\\n 'Alias' : self.alias,\\r\\n 'Parent' : self.parent,\\r\\n 'Target' : self.target,\\r\\n 'Gap' : self.gap,\\r\\n 'Derives_from' : self.derives_from,\\r\\n 'Note' : self.note,\\r\\n 'Dbxref' : self.dbxref,\\r\\n 'Ontology_term' : self.ontology_term,\\r\\n 'Is_circular' : self.is_circular,\\r\\n 'allele' : ','.join([a.strip() for a in self.allele])\\r\\n })\\r\\n if self.discovered != None:\\r\\n if self.discovered:\\r\\n return_lib[self.discovered_key] = self.enabled[0]\\r\\n else:\\r\\n return_lib[self.discovered_key] = self.disabled[0]\\r\\n if self.validated != None:\\r\\n if self.validated:\\r\\n return_lib[self.validated_key] = self.enabled[0]\\r\\n else:\\r\\n return_lib[self.validated_key] = self.disabled[0]\\r\\n if self.active != None:\\r\\n if self.active:\\r\\n return_lib[self.active_key] = self.disabled[0]\\r\\n else:\\r\\n return_lib[self.active_key] = self.enabled[0]\\r\\n for i,item in enumerate(self.history):\\r\\n return_lib[\\\"{}_{}\\\".format(self.history_key,i)] = ','.join(item)\\r\\n return_str = ';'.join([key + '=' + value for key, value in return_lib.items() if value])\\r\\n return return_str\",\n \"def _encode_parts(self, messages, encode_empty=False):\\n if messages or encode_empty:\\n return self.signer.sign_object(\\n messages, serializer=MessagePartGatherSerializer, compress=True\\n )\",\n \"def _create_chain(class_type_list, kwargs_list):\\n chain = None # module with preprocessing chain\\n modules = [] # list of modules (not connected via preprocessing)\\n for i, pre_id in enumerate(class_type_list):\\n chain = CModule.create(\\n pre_id, preprocess=chain, **kwargs_list[i])\\n modules.append(CModule.create(pre_id, **kwargs_list[i]))\\n return chain, modules\",\n \"def skeleton_getHandleChain(self, typeModifier = None, jointHelpers = True, mOrientHelper = None):\\n _short = self.mNode\\n _str_func = 'skeleton_getHandleChain'\\n #start = time.clock()\\t\\n log.debug(cgmGEN.logString_start(_str_func))\\n \\n mRigNull = self.moduleTarget.rigNull\\n ml_fkJoints = mRigNull.msgList_get('fkJoints')\\n \\n if not ml_fkJoints:\\n log.debug(\\\"|{0}| >> Generating handleJoints\\\".format(_str_func))\\n \\n ml_formHandles = self.msgList_get('formHandles',asMeta = True)\\n if not ml_formHandles:\\n raise ValueError,\\\"No formHandles connected\\\" \\n \\n ml_prerigHandles = self.msgList_get('prerigHandles',asMeta = True)\\n if not ml_prerigHandles:\\n raise ValueError,\\\"No prerigHandles connected\\\"\\n \\n if mOrientHelper is None:\\n mOrientHelper = ml_formHandles[0].orientHelper or ml_prerigHandles[0].orientHelper\\n \\n #_d = skeleton_getCreateDict(self)\\n #pprint.pprint(_d)\\n l_pos = []\\n for mObj in ml_prerigHandles:\\n l_pos.append(mObj.p_position)\\n \\n ml_fkJoints = COREJOINTS.build_chain(posList = l_pos,\\n axisAim='z+',\\n axisUp='y+',\\n parent=True,\\n worldUpAxis= mOrientHelper.getAxisVector('y+'))\\n \\n for i,mJnt in enumerate(ml_fkJoints):\\n mJnt.doCopyNameTagsFromObject(ml_prerigHandles[i].mNode, ignore = ['cgmType'])\\n if not typeModifier:\\n mJnt.doName()\\n \\n if typeModifier:\\n for mJnt in ml_fkJoints:\\n mJnt.addAttr('cgmTypeModifier',typeModifier,attrType='string',lock=True)\\n mJnt.addAttr('cgmType','frame',attrType='string',lock=True) \\n mJnt.doName()\\n \\n ml_fkJoints[0].p_parent = False\\n else:\\n log.debug(\\\"|{0}| >> Found fkJoints\\\".format(_str_func))\\n \\n #log.debug(\\\"%s >> Time >> = %0.3f seconds \\\" % (_str_func,(time.clock()-start)) + \\\"-\\\"*75)\\t\\n return ml_fkJoints\",\n \"def serialize(self):\\n pass\",\n \"def __store_part(self, definition, pnum, multisubtype):\\n pnum = \\\"1\\\" if pnum is None else pnum\\n params = {\\n \\\"pnum\\\": pnum,\\n \\\"params\\\": definition[2],\\n \\\"cid\\\": definition[3],\\n \\\"description\\\": definition[4],\\n \\\"encoding\\\": definition[5],\\n \\\"size\\\": definition[6]\\n }\\n mtype = definition[0].lower()\\n subtype = definition[1].lower()\\n ftype = \\\"%s/%s\\\" % (definition[0].lower(), subtype)\\n if ftype in (\\\"text/plain\\\", \\\"text/html\\\"):\\n if subtype not in self.contents:\\n self.contents[subtype] = [params]\\n else:\\n self.contents[subtype].append(params)\\n return\\n elif multisubtype in [\\\"related\\\"]:\\n self.inlines[params[\\\"cid\\\"].strip(\\\"<>\\\")] = params\\n return\\n\\n params[\\\"Content-Type\\\"] = ftype\\n if len(definition) > 7:\\n extensions = [\\\"md5\\\", \\\"disposition\\\", \\\"language\\\", \\\"location\\\"]\\n if mtype == \\\"text\\\":\\n extensions = [\\\"textlines\\\"] + extensions\\n elif ftype == \\\"message/rfc822\\\":\\n extensions = [\\n \\\"envelopestruct\\\",\\n \\\"bodystruct\\\",\\n \\\"textlines\\\"] + extensions\\n for idx, value in enumerate(definition[7:]):\\n params[extensions[idx]] = value\\n\\n self.attachments += [params]\",\n \"def serialize(self):\\n return {\\n 'name' : self.name,\\n 'ingredients' : self.ingredients,\\n 'id' : self.id,\\n 'preparation' : self.preparation,\\n 'image' : self.image,\\n }\",\n \"def serialize(self, pipe, pid):\\n for trsp in self.transports:\\n pipe.send(trsp.__class__)\\n trsp.serialize(pipe, pid)\",\n \"def save_data(self):\\n try:\\n with open('blockchain-{}.txt'.format(self.node_id), mode='w') as f:\\n saveable_chain = [block.__dict__ for block in [Block(block_el.index, block_el.previous_hash, \\n [tx.__dict__ for tx in block_el.transactions], \\n [tx.__dict__ for tx in block_el.chipsactions],\\n [tx.__dict__ for tx in block_el.messsactions],\\n block_el.proof, block_el.timestamp) for block_el in self.__chain]]\\n f.write(json.dumps(saveable_chain))\\n f.write('\\\\n')\\n saveable_tx = [tx.__dict__ for tx in self.__open_transactions]\\n f.write(json.dumps(saveable_tx))\\n f.write('\\\\n')\\n saveable_chip = [tx.__dict__ for tx in self.__open_chipsactions]\\n f.write(json.dumps(saveable_chip))\\n f.write('\\\\n')\\n saveable_chip = [tx.__dict__ for tx in self.__open_messsactions]\\n f.write(json.dumps(saveable_chip))\\n f.write('\\\\n')\\n f.write(json.dumps(list(self.__peer_nodes)))\\n except IOError:\\n print('Saving failed!')\",\n \"def to_binary(self):\\n c = containerize(exclude_fields(self))\\n self.payload = MsgCertificateChainDep._parser.build(c)\\n return self.pack()\",\n \"def _make_information_storable( self, data ):\\n\\t\\tpass\",\n \"def create_chain_instances(self):\\n for section in self.config_reader.sections():\\n self.read_chain(section)\",\n \"def chain():\\n chain_identifier, url = get_vars(request, [\\\"id\\\", \\\"data\\\"])\\n info('chain=%s' % chain_identifier)\\n chain = LAPPS_SERVICE_CHAINS.get_chain(chain_identifier)\\n info('source-url=%s' % url)\\n data = requests.get(url).text\\n result = chain.run({\\n \\\"discriminator\\\": \\\"http://vocab.lappsgrid.org/ns/media/text\\\", \\n \\\"payload\\\": data})\\n info(\\\"discriminator=%s\\\" % result.get('discriminator'))\\n return render_template(\\\"chain.html\\\",\\n chain=chain,\\n fname=url,\\n result=result,\\n builder=HtmlBuilder())\",\n \"def create(data):\\n \\n return Partlist(\\n list_id = data['id'],\\n name = data['name'],\\n pieces = data['num_parts'])\",\n \"def make_drs_tree(self):\\n pass\",\n \"def produce_chain_dict (inPath, outPath):\\n with open(inPath, 'r') as fin:\\n chainIDs = list(fin.read().split())\\n chains = {}\\n for chainid in chainIDs:\\n pdbid = (chainid[ : chainid.find('_') ] if '_' in chainid else chainid)\\n if pdbid in chains:\\n chains[pdbid].add(chainid)\\n else:\\n chains[pdbid] = {chainid}\\n with open(outPath, 'wb') as fOut:\\n pickle.dump(chains, fOut)\",\n \"def wire_chains(self):\\n allChains = self.instances.getAllChainInstances()\\n for chain in allChains:\\n logging.debug(\\\"%s\\\", chain)\\n allChains[chain].setup_event_path()\",\n \"def setPartsToRegister(self, parts):\\n internals.blpapi_ServiceRegistrationOptions_setPartsToRegister(\\n self.__handle, parts)\",\n \"def _encode(self, boxes, anchors):\\n pass\",\n \"def __init__(self):\\n self.chain = {}\\n self.blocks = {}\\n self.blocks_spending_input = {}\\n self.blocks_containing_tx = {}\\n self.all_transactions = {}\",\n \"def trans_setup():\\n # slot7 slot6 slot5 slot4 slot3 slot2 slot1 <------ beam direction (slot 8 is currently B-fiber only)\\n # Be Be Be Be Be Be Be lens material\\n # 1.5 1.5 0.5 0.5 0.5 0.5 0.5 lens radius [mm]\\n # 1 1 5 8 4 2 1 number of lenses\\n lens_R=[0.5,0.5,0.5,0.5,0.5,1.5,1.5]\\n lens_mat=['Be','Be','Be','Be','Be','Be','Be']\\n lens_N=[1,2,4,8,5,1,1]\\n trans_pos=[35.2,35.8]\\n return {'lens_material':lens_mat,'lens_number':lens_N,'lens_radius':lens_R,'trans_position':trans_pos}\",\n \"def prepare_order(acct, order):\\n myaddr = (acct.address).lower()\\n order[\\\"makerAddress\\\"] = myaddr\\n order_struct = jsdict_order_to_struct(order) \\n sig = _sign_order(acct, order_struct)\\n order_struct[\\\"signature\\\"] = sig\\n js_order = order_to_jsdict(order_struct)\\n js_order[\\\"exchangeAddress\\\"] = exchangeAddress\\n return js_order\",\n \"def _finishConstruction(self, obj):\\n return obj\",\n \"def _finishConstruction(self, obj):\\n return obj\",\n \"def json(self):\\n blocks = [block.to_json() for block in self.chain[1:]]\\n return json.dumps({'blocks': blocks})\",\n \"def pdbChain_to_mdtrajChainid_li(chain,seg_to_chain,struc):\\n chain = chain.upper()\\n chain_segments=[seg for seg,chainval in seg_to_chain.items() if chainval==chain]\\n if chain_segments:\\n structable, bonds=struc.topology.to_dataframe()\\n chainid_li=[]\\n for segname in chain_segments:\\n seg_chainid_li=structable.loc[structable['segmentID'] == segname].chainID.unique()\\n chainid_li+=list(seg_chainid_li)\\n chainid_li=list(set(chainid_li))\\n return chainid_li\\n else:\\n return False\",\n \"def genereate_echo_picklist(self):\\n sample_names = []\\n sample_wells = []\\n indices = {'i5 name': {}, 'i5 plate': {}, 'i5 sequence': {},\\n 'i5 well': {}, 'i7 name': {}, 'i7 plate': {},\\n 'i7 sequence': {}, 'i7 well': {}, 'index combo': {},\\n 'index combo seq': {}}\\n\\n for idx, well in enumerate(chain.from_iterable(self.plates[0].layout)):\\n # Add the sample well\\n sample_wells.append(well.well_id)\\n # Get the sample name - we need to go back to the SampleComposition\\n lib_comp = well.composition\\n sample_comp = lib_comp.normalized_gdna_composition\\\\\\n .gdna_composition.sample_composition\\n sample_names.append(sample_comp.content)\\n # Retrieve all the information about the indices\\n i5_comp = lib_comp.i5_composition.primer_set_composition\\n i5_well = i5_comp.container\\n indices['i5 name'][idx] = i5_comp.external_id\\n indices['i5 plate'][idx] = i5_well.plate.external_id\\n indices['i5 sequence'][idx] = i5_comp.barcode\\n indices['i5 well'][idx] = i5_well.well_id\\n\\n i7_comp = lib_comp.i7_composition.primer_set_composition\\n i7_well = i7_comp.container\\n indices['i7 name'][idx] = i7_comp.external_id\\n indices['i7 plate'][idx] = i7_well.plate.external_id\\n indices['i7 sequence'][idx] = i7_comp.barcode\\n indices['i7 well'][idx] = i7_well.well_id\\n\\n indices['index combo seq'][idx] = '%s%s' % (\\n indices['i5 sequence'][idx], indices['i7 sequence'][idx])\\n\\n sample_names = np.asarray(sample_names)\\n sample_wells = np.asarray(sample_wells)\\n indices = pd.DataFrame(indices)\\n\\n return LibraryPrepShotgunProcess._format_picklist(\\n sample_names, sample_wells, indices)\",\n \"def marshal(self):\\n pieces = self.properties.encode()\\n pieces.insert(\\n 0, struct.pack('>HxxQ', self.properties.INDEX, self.body_size))\\n return self._marshal(pieces)\",\n \"def init(self):\\n\\n logger.info(mm_chain.ackn_str)\\n self.acknowledgements = mm_chain.ackn_str\\n self.references = mm_chain.refs['chain']\\n\\n return\",\n \"def __init__(self):\\n self.unconfirmed_transactions = [] \\n self.chain = []\\n self.create_genesis_block()\",\n \"def connectPart(self,\\n hsNondes: list,\\n part: Union[TransPart, ChoicesOfFrameParts],\\n en: Union[RtlSignal, bool],\\n exclusiveEn: Optional[RtlSignal]=hBit(1)):\\n busVld = self.dataIn.valid\\n tToIntf = self.dataOut._fieldsToInterfaces\\n\\n if isinstance(part, ChoicesOfFrameParts):\\n parentIntf = tToIntf[part.origin.parent.origin]\\n try:\\n sel = self._tmpRegsForSelect[parentIntf]\\n except KeyError:\\n sel = HsBuilder(self, parentIntf._select).buff().end\\n self._tmpRegsForSelect[parentIntf] = sel\\n unionGroup = ExclusieveListOfHsNodes(sel)\\n\\n # for unions\\n for choice in part:\\n # connect data signals of choices and collect info about\\n # streams\\n intfOfChoice = tToIntf[choice.tmpl.origin]\\n selIndex, isSelected, isSelectValid = self.choiceIsSelected(\\n intfOfChoice)\\n _exclusiveEn = isSelectValid & isSelected & exclusiveEn\\n\\n unionMemberPart = ListOfOutNodeInfos()\\n for p in choice:\\n self.connectPart(unionMemberPart, p, en, _exclusiveEn)\\n unionGroup.append(selIndex, unionMemberPart)\\n\\n hsNondes.append(unionGroup)\\n\\n if part.isLastPart():\\n # synchronization of reading from _select register for unions\\n selNode = InNodeInfo(sel, en)\\n else:\\n selNode = InNodeReadOnlyInfo(sel, en)\\n hsNondes.append(selNode)\\n return\\n\\n if part.isPadding:\\n return\\n\\n fPartSig = self.getInDataSignal(part)\\n fieldInfo = part.tmpl.origin\\n\\n try:\\n signalsOfParts = self._signalsOfParts[part.tmpl]\\n except KeyError:\\n signalsOfParts = []\\n self._signalsOfParts[part.tmpl] = signalsOfParts\\n\\n if part.isLastPart():\\n # connect all parts in this group to output stream\\n signalsOfParts.append(fPartSig)\\n intf = self.dataOut._fieldsToInterfaces[fieldInfo]\\n intf.data(self.byteOrderCare(\\n Concat(\\n *reversed(signalsOfParts)\\n ))\\n )\\n on = OutNodeInfo(self, intf, en, exclusiveEn)\\n hsNondes.append(on)\\n else:\\n dataVld = busVld & en & exclusiveEn\\n # part is in some word as last part, we have to store its value to register\\n # until the last part arrive\\n fPartReg = self._reg(\\\"%s_part_%d\\\" % (fieldInfo.name,\\n len(signalsOfParts)),\\n fPartSig._dtype)\\n If(dataVld,\\n fPartReg(fPartSig)\\n )\\n signalsOfParts.append(fPartReg)\",\n \"def build_item(\\n self,\\n part,\\n timestamp=1539023700,\\n userdata=0,\\n position=[0, 0, 0],\\n up_vec=[0, 1, 0],\\n at_vec=[0, 0, 1],\\n skip_power_controls=False):\\n # Get the obj path.\\n item = self.retrieve_part(part)\\n\\n # Lock Everything if it's the BASE_FLAG or U_POWERLINE.\\n # BASE_FLAG can break things if user moves it around.\\n # As it acts as the \\\"origin\\\" of the base.\\n locked_parts = [\\\"BASE_FLAG\\\", \\\"U_POWERLINE\\\", \\\"U_PIPELINE\\\", \\\"U_PORTALLINE\\\"]\\n line_parts = [\\\"U_POWERLINE\\\", \\\"U_PIPELINE\\\", \\\"U_PORTALLINE\\\"]\\n if part in locked_parts:\\n item.lock_location[0] = True\\n item.lock_location[1] = True\\n item.lock_location[2] = True\\n item.lock_rotation[0] = True\\n item.lock_rotation[1] = True\\n item.lock_rotation[2] = True\\n item.lock_scale[0] = True\\n item.lock_scale[1] = True\\n item.lock_scale[2] = True\\n \\n # Add custom attributes.\\n item[\\\"ObjectID\\\"] = part\\n item[\\\"SnapID\\\"] = part\\n item[\\\"Timestamp\\\"] = timestamp\\n item[\\\"belongs_to_preset\\\"] = False\\n # Add an order flag to retain order when generating data..\\n item[\\\"Order\\\"] = self.part_order\\n self.part_order += 1\\n # Apply Colour\\n is_powerline = part in line_parts\\n is_pipeline = part in [\\\"U_PIPELINE\\\"]\\n material.assign_material(\\n item,\\n userdata,\\n powerline=is_powerline,\\n pipeline=is_pipeline\\n )\\n\\n # Move\\n utils.move_to(item, position=position, up=up_vec, at=at_vec)\\n\\n # If the object is a powerline, we should create additional controls\\n # for it.\\n if is_powerline and not skip_power_controls:\\n power.create_power_controls(item)\\n # Select the new object.\\n item.select_set(True)\\n return item\",\n \"def nid2partid(self, nids, ntype=...):\\n ...\",\n \"def nid2partid(self, nids, ntype=...):\\n ...\",\n \"def test_hierarchy_perceived_information_propagation(self):\\n from openff.toolkit._tests.create_molecules import (\\n dipeptide_hierarchy_added as create_dipeptide,\\n )\\n\\n dipeptide_hierarchy_perceived = create_dipeptide()\\n\\n for atom in dipeptide_hierarchy_perceived.atoms:\\n atom.metadata[\\\"chain_id\\\"] = \\\"A\\\"\\n assert (\\\"A\\\", \\\"1\\\", \\\" \\\", \\\"ACE\\\") != dipeptide_hierarchy_perceived.residues[\\n 0\\n ].identifier\\n dipeptide_hierarchy_perceived.update_hierarchy_schemes()\\n assert (\\\"A\\\", \\\"1\\\", \\\" \\\", \\\"ACE\\\") == dipeptide_hierarchy_perceived.residues[\\n 0\\n ].identifier\",\n \"def createInnerRepresentation(self):\\n\\n while self._metastring_rest:\\n self.addMetastringPointer(self._metastring_rest.pop(0))\",\n \"def _serialize(self, state, handle):\\n raise NotImplementedError\",\n \"def serialize(cleaned_data):\\n result = cleaned_data.copy()\\n for fieldname in Step1Data.REFERENCE_FIELDS_NAMES:\\n if result[fieldname]:\\n result[fieldname] = result[fieldname].pk\\n result[\\\"data\\\"] = result[\\\"data\\\"].isoformat()\\n # print \\\"serialize to:\\\", result\\n return result\",\n \"def encode(self):\\r\\n # Create dict from attributes. Maintain added order\\r\\n #jd = {'txpk': collections.OrderedDict()}\\r\\n jd = {'txpk':{}}\\r\\n\\r\\n for key in self.keys:\\r\\n val = getattr(self, key)\\r\\n\\r\\n if val is not None:\\r\\n if key == 'data':\\r\\n jd['txpk'][key] = val.decode('utf-8')\\r\\n else:\\r\\n jd['txpk'][key] = val\\r\\n #print('key',key)\\r\\n #print('valtype',type(val),val) \\r\\n #print(jd)\\r\\n \\r\\n return dumps(jd, separators=(',', ':'))\",\n \"async def b_chain() -> dict:\\n authority_chain = await chain.consensus()\\n return {\\\"chain\\\": authority_chain[\\\"chain\\\"]}\",\n \"def _create_chained_picking(self, cr, uid, pick_name, picking, purchase_type, move, context=None):\\n res = super(stock_move, self)._create_chained_picking(cr, uid, pick_name, picking, purchase_type, move, context=context)\\n if picking.purchase_id:\\n self.pool.get('stock.picking').write(cr, uid, [res], {'purchase_id': picking.purchase_id.id})\\n self.pool.get('stock.picking').write(cr, uid, [res], {'invoice_state': picking.invoice_state})\\n return res\",\n \"def fetchParts(jdb, melId, instrument, signature):\\n chorusDict = collections.OrderedDict()\\n bs = jdb.beats(melId)\\n formId = ''\\n for b in bs:\\n beat = Beat(*b[1:])\\n if not beat.chorus in chorusDict:\\n chorus = Section(u'CHORUS', beat.onset, None, beat.chorus)\\n chorusDict[beat.chorus] = chorus\\n chorus = chorusDict[beat.chorus]\\n if (beat.form != ''):\\n formId = beat.form\\n if not formId in chorus.children:\\n form = Section(u'FORM', beat.onset, None, formId)\\n chorus.children[formId] = form\\n form = chorus.children[formId]\\n form.beats.append(beat)\\n #print [c.value for c in chorusDict.values()]\\n return makeParts(chorusDict.values(), instrument, jdb.shiftTime(melId), int(signature.split('/')[0]))\",\n \"def serialize(self):\\n\\t\\treturn { 'type': self.type, 'parameters' : self.parameters}\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5191058","0.516895","0.5164095","0.5164095","0.50821406","0.5015414","0.50149983","0.49796292","0.49461022","0.49153453","0.48709112","0.48381686","0.483411","0.48162767","0.48084295","0.4796053","0.4777216","0.4726833","0.4726833","0.47081837","0.46883693","0.46671337","0.4659657","0.46214417","0.4620025","0.46192482","0.46013826","0.4593191","0.4578713","0.45755225","0.45629892","0.4562384","0.45505276","0.45496094","0.45312953","0.4530276","0.44867477","0.44717628","0.44700804","0.44686908","0.4464296","0.44605577","0.445083","0.44423646","0.44423646","0.44404605","0.44372246","0.44330332","0.4432397","0.44275826","0.4422517","0.4420428","0.44194275","0.44129044","0.44119993","0.44119993","0.44106048","0.4409376","0.44068092","0.44056058","0.44040802","0.44017375","0.4398603","0.4398233","0.43976173","0.43958825","0.43893126","0.43872815","0.43871835","0.4382691","0.4382665","0.43800005","0.437984","0.43758628","0.4373381","0.43725127","0.43637726","0.43602848","0.43537498","0.43526798","0.43526134","0.43526134","0.43515876","0.43513954","0.43512222","0.43434176","0.4340548","0.43402886","0.43324253","0.43324223","0.43310797","0.43310797","0.43297496","0.4321092","0.43161824","0.43142584","0.43115595","0.43098602","0.43076512","0.43067062","0.43060982"],"string":"[\n \"0.5191058\",\n \"0.516895\",\n \"0.5164095\",\n \"0.5164095\",\n \"0.50821406\",\n \"0.5015414\",\n \"0.50149983\",\n \"0.49796292\",\n \"0.49461022\",\n \"0.49153453\",\n \"0.48709112\",\n \"0.48381686\",\n \"0.483411\",\n \"0.48162767\",\n \"0.48084295\",\n \"0.4796053\",\n \"0.4777216\",\n \"0.4726833\",\n \"0.4726833\",\n \"0.47081837\",\n \"0.46883693\",\n \"0.46671337\",\n \"0.4659657\",\n \"0.46214417\",\n \"0.4620025\",\n \"0.46192482\",\n \"0.46013826\",\n \"0.4593191\",\n \"0.4578713\",\n \"0.45755225\",\n \"0.45629892\",\n \"0.4562384\",\n \"0.45505276\",\n \"0.45496094\",\n \"0.45312953\",\n \"0.4530276\",\n \"0.44867477\",\n \"0.44717628\",\n \"0.44700804\",\n \"0.44686908\",\n \"0.4464296\",\n \"0.44605577\",\n \"0.445083\",\n \"0.44423646\",\n \"0.44423646\",\n \"0.44404605\",\n \"0.44372246\",\n \"0.44330332\",\n \"0.4432397\",\n \"0.44275826\",\n \"0.4422517\",\n \"0.4420428\",\n \"0.44194275\",\n \"0.44129044\",\n \"0.44119993\",\n \"0.44119993\",\n \"0.44106048\",\n \"0.4409376\",\n \"0.44068092\",\n \"0.44056058\",\n \"0.44040802\",\n \"0.44017375\",\n \"0.4398603\",\n \"0.4398233\",\n \"0.43976173\",\n \"0.43958825\",\n \"0.43893126\",\n \"0.43872815\",\n \"0.43871835\",\n \"0.4382691\",\n \"0.4382665\",\n \"0.43800005\",\n \"0.437984\",\n \"0.43758628\",\n \"0.4373381\",\n \"0.43725127\",\n \"0.43637726\",\n \"0.43602848\",\n \"0.43537498\",\n \"0.43526798\",\n \"0.43526134\",\n \"0.43526134\",\n \"0.43515876\",\n \"0.43513954\",\n \"0.43512222\",\n \"0.43434176\",\n \"0.4340548\",\n \"0.43402886\",\n \"0.43324253\",\n \"0.43324223\",\n \"0.43310797\",\n \"0.43310797\",\n \"0.43297496\",\n \"0.4321092\",\n \"0.43161824\",\n \"0.43142584\",\n \"0.43115595\",\n \"0.43098602\",\n \"0.43076512\",\n \"0.43067062\",\n \"0.43060982\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":8785,"cells":{"query":{"kind":"string","value":"Marshal information deom the selected chainParts to create a 'simple_partition' label."},"document":{"kind":"string","value":"def _make_simple_partition_label(chain_dict):\n\n cps = chain_dict['chainParts']\n if not (_select_simple_chainparts(cps)):\n raise NotImplementedError(\n 'chain fails substring selection: not \"simple\": %s' % (\n chain_dict['chainName']))\n \n label = 'simplepartition(['\n for cp in cps:\n smcstr = str(cp['smc'])\n if smcstr == 'nosmc':\n smcstr = ''\n for i in range(int(cp['multiplicity'])):\n # condition_str = '(%set,%s,%s)' % (str(cp['threshold']),\n # str(cp['etaRange']),\n # smcstr,)\n condition_str = '(%set,%s' % (str(cp['threshold']),\n str(cp['etaRange']),)\n if smcstr:\n condition_str += ',%s)'\n else:\n condition_str += ')'\n label += condition_str\n label += '])'\n return label"},"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 _make_partitionsTest_label(chain_parts):\n\n assert len(chain_parts) == 1\n scenario = chain_parts[0]['hypoScenario']\n \n assert scenario == 'partitionsTest'\n\n \n\n return \"\"\"\n partgen(\n [(20et, 0eta320)]\n \n simple([(40et, 0eta320) (50et, 0eta320)])\n simple([(35et, 0eta240) (55et, 0eta240)])\n )\"\"\"","def provide_partition_info(self):\n self.partition_info = True","def __str__(self) -> str:\n return str(self.my_partition)","def _make_simple_label(chain_parts):\n \n if not _select_simple_chainparts(chain_parts):\n msg = 'Jet Configuration error: '\\\n 'chain fails substring selection: not \"simple\" '\n\n raise NotImplementedError(msg)\n \n label = 'simple(['\n for cp in chain_parts:\n smcstr = str(cp['smc'])\n jvtstr = str(cp['jvt'])\n if smcstr == 'nosmc':\n smcstr = ''\n for i in range(int(cp['multiplicity'])):\n # condition_str = '(%set,%s,%s)' % (str(cp['threshold']),\n # str(cp['etaRange']),\n # smcstr,)\n condition_str = '(%set,%s' % (str(cp['threshold']),\n str(cp['etaRange']),)\n if smcstr: # Run 2 chains have \"INF\" in the SMC substring\n condition_str += ',%s)' % smcstr.replace('INF','')\n elif jvtstr:\n condition_str += ',%s)' % jvtstr\n else:\n condition_str += ')'\n label += condition_str\n label += '])'\n return label","def FormatPartition(self, partition):\n\n fstab = self.fstab\n if fstab:\n p = fstab[partition]\n self.script.append('format(\"%s\", \"%s\", %s, \"%s\", \"%s\");' %\n (p.fs_type, common.PARTITION_TYPES[p.fs_type],\n self._GetSlotSuffixDeviceForEntry(p),\n p.length, p.mount_point))","def __str__(self):\n \n return \"Part ID: %s, %s\" % (self.part_id, self.name)","def create(self, disk):\n logging.info('Adding type %d partition to disk image: %s' % (self.type, disk.filename))\n run_cmd('parted', '--script', '--', disk.filename, 'mkpart', 'primary', self.parted_fstype(), self.begin, self.end)","def print_partition(t, par=[]):\n\n if is_leaf(t):\n if label(t) == True:\n print(' + '.join(par))\n else:\n left, right = branches(t)[0], branches(t)[1]\n print_partition(left, [str(label(t))] + par)\n print_partition(right, par)\n #print(\"total partitions: \", str(count_leaves(t)))","def partid2nids(self, partid, ntype=...):\n ...","def partid2nids(self, partid, ntype=...):\n ...","def _setPartedPartition(self, partition):\n log_method_call(self, self.name)\n\n if partition is not None and not isinstance(partition, parted.Partition):\n raise ValueError(\"partition must be None or a parted.Partition instance\")\n\n log.debug(\"device %s new partedPartition %s\", self.name, partition)\n self._partedPartition = partition\n self.updateName()","def dump_parts(self, io):\n\n # XXX refactor with Tempita\n title = \"Parts created by the docutils writer '%s'\" % self.strategy.name\n io.say(title + os.linesep)\n io.say(len(title) * '-')\n io.say(2 * os.linesep)\n io.say('Part keys: ' + 2 * os.linesep)\n\n parts = self.publish_parts(io)\n io.say(os.linesep.join(sorted(parts.keys())))\n io.say(2 * os.linesep)\n for part in parts:\n io.say(\"Value of part '%s':%s\" % (part, os.linesep))\n io.say(parts[part].encode('utf-8') + os.linesep)\n io.say(80*'-'+os.linesep)\n io.say(os.linesep)","def _make_simple_comb_label(chain_dict):\n\n cps = chain_dict['chainParts']\n if not (_select_simple_chainparts(cps)):\n raise NotImplementedError(\n 'chain fails substring selection: not \"simple\": %s' % (\n chain_dict['chainName']))\n \n simple_strs = []\n\n for cp in cps:\n print(cp)\n simple_strs.append(_make_simple_label([cp]))\n\n label = 'combgen([(%d)]' % len(cps)\n for s in simple_strs:\n label += ' %s ' % s\n label += ')'\n return label","def partid(self): # -> Unknown:\n ...","def get_partition():\n if selection is None:\n warning(\"You need to pick something first.\")\n return\n if not selection.obj_type in ['partition']:\n warning(\"You need to partition the selection first.\")\n return\n res = askItems([['property',[1]]],\n caption='Partition property')\n if res:\n prop = res['property']\n getPartition(selection,prop)\n highlightPartitions(selection)","def _wrap_partitions(self, partitions):\n return [\n self.partition_type(object_id, length, width, ip)\n for (object_id, length, width, ip) in zip(*[iter(partitions)] * 4)\n ]","def bootpart(disks):\n return path_to_partition(disks, '/boot/foo')","def choose_partition():\n # Ask the user wether the partitions should be taken from the original partitions, or from the home-made partitions\n file_name = selector([\"The original partition given by the instructor\", \"The homemade partition file\"], [\"ORIGINAL\", \"HOMEMADE\"])\n\n # Open the corresponding file\n if file_name == \"1\" or file_name == \"ORIGINAL\":\n file = open(\"./assets/partitions.txt\", \"r\")\n elif file_name == \"2\" or file_name == \"HOMEMADE\":\n file = open(\"./assets/homemade_partitions.txt\", \"r\")\n\n skip_lines(-1)\n\n # Print all song's names in the partitions\n lines = file.readlines()\n file.close()\n for i in range(0, len(lines), 2):\n print(lines[i][:-1])\n\n # Ask the user to choose for a song\n song_index = choose_number(len(lines) / 2)\n\n # Get the corresponding song's partition and convert notes to Note instances\n partition = lines[song_index * 2 - 1][:-1].replace(' ', '')\n raw_notes = get_notes_from_line(partition)\n parsed_notes = [Note(note) for note in raw_notes]\n return parsed_notes","def partid2nids(self, partid, ntype): # -> None:\n ...","def create(data):\n \n return Part(\n part_id = data['part_num'],\n category_id = data['part_cat_id'],\n external_ids = data.get('external_ids', {}),\n name = data['name'],\n year_from = data.get('year_from', None),\n year_to = data.get('year_to', None),\n url = data.get('part_url', None),\n img_url = data.get('part_img_url', None),\n print_of = data.get('print_of', None),\n prints = data.get('prints', []),\n molds = data.get('molds', []),\n alternates = data.get('alternates', []))","def _wrap_partitions(self, partitions):\n return [\n self.partition_type(future, length, width, ip)\n for (future, length, width, ip) in zip(*[iter(partitions)] * 4)\n ]","def parse_part(self):\n parts = []\n for part in re.split(r'\\*\\*\\* ([A-Z- ]+) \\*\\*\\*', self.hand_file): # return [ 'part1', 'splitter1', 'part2',..\n parts.append(part)\n\n for i in range(0, len(parts)):\n if i == 0:\n self.part_dict['HEADER'] = parts[i]\n if i % 2 != 0: # number is odd\n self.part_dict[parts[i]] = parts[i + 1]","def preCommitFixup(self):\n log_method_call(self, self.name)\n if not self.exists or not self.disklabelSupported:\n return\n\n # find the correct partition on the original parted.Disk since the\n # name/number we're now using may no longer match\n _disklabel = self.disk.originalFormat\n\n if self.isExtended:\n # getPartitionBySector doesn't work on extended partitions\n _partition = _disklabel.extendedPartition\n log.debug(\"extended lookup found partition %s\",\n devicePathToName(getattr(_partition, \"path\", None) or \"(none)\"))\n else:\n # lookup the partition by sector to avoid the renumbering\n # nonsense entirely\n _sector = self.partedPartition.geometry.start\n _partition = _disklabel.partedDisk.getPartitionBySector(_sector)\n log.debug(\"sector-based lookup found partition %s\",\n devicePathToName(getattr(_partition, \"path\", None) or \"(none)\"))\n\n self.partedPartition = _partition","def prep_disk_for_formatting(disk=None):\n disk['Format Warnings'] = '\\n'\n width = len(str(len(disk['Partitions'])))\n\n # Bail early\n if disk is None:\n raise Exception('Disk not provided.')\n\n # Set boot method and partition table type\n disk['Use GPT'] = True\n if (get_boot_mode() == 'UEFI'):\n if (not ask(\"Setup Windows to use UEFI booting?\")):\n disk['Use GPT'] = False\n else:\n if (ask(\"Setup Windows to use BIOS/Legacy booting?\")):\n disk['Use GPT'] = False\n\n # Set Display and Warning Strings\n if len(disk['Partitions']) == 0:\n disk['Format Warnings'] += 'No partitions found\\n'\n for partition in disk['Partitions']:\n display = '{size} {fs}'.format(\n num = partition['Number'],\n width = width,\n size = partition['Size'],\n fs = partition['FileSystem'])\n\n if is_bad_partition(partition):\n # Set display string using partition description & OS type\n display += '\\t\\t{q}{name}{q}\\t{desc} ({os})'.format(\n display = display,\n q = '\"' if partition['Name'] != '' else '',\n name = partition['Name'],\n desc = partition['Description'],\n os = partition['OS'])\n else:\n # List space used instead of partition description & OS type\n display += ' (Used: {used})\\t{q}{name}{q}'.format(\n used = partition['Used Space'],\n q = '\"' if partition['Name'] != '' else '',\n name = partition['Name'])\n # For all partitions\n partition['Display String'] = display","def parse_partition(partition):\n partition_data = partition.split(\":\")\n if len(partition_data) != 2:\n raise ValueError(\"Partitions line parts format is 'size:mount'\")\n return partition_data","def nid2partid(self, nids, ntype): # -> None:\n ...","def nid2partid(self, nids, ntype=...):\n ...","def nid2partid(self, nids, ntype=...):\n ...","def usableparts(self):\n # First get the partition type-id for all hard disk partitions\n partid = {}\n for pline in self.fdiskl():\n partid[pline[0]] = pline[4]\n ups = {}\n for s in self.xlist(\"get-blkinfo\")[1]:\n mo = re.match(r'(/dev/[^:]*):(?: LABEL=\"([^\"]*)\")?(?:'\n ' UUID=\"([^\"]*)\")?(?: TYPE=\"([^\"]*)\")?', s)\n if mo:\n dev, label, uuid, fstype = mo.groups()\n if fstype in (None, \"linux_raid_member\", \"LVM2_member\"):\n continue\n if dev.startswith(\"/dev/loop\"):\n continue\n rem = None\n if dev.startswith(\"/dev/sd\"):\n if partid.get(dev) == \"fd\":\n # This test seems to be necessary because blkid\n # sometimes returns an fs-type, rather than\n # linux_raid_member\", for the the first device\n # in a formatted raid array\n continue\n rem = self.xlist(\"removable\", dev)[1][0].strip() == \"1\"\n ups[dev] = (fstype, label, uuid, rem)\n return ups","def partition_pair_to_spart(part_pair):\n part_star = list(part_pair[0])\n part_circ_star = list(part_pair[1])\n add_zeros = len(part_circ_star) - len(part_star)\n if add_zeros != 0:\n new_star = part_star + [0]\n else:\n new_star = part_star\n diff_list = [a - b for a, b in zip(part_circ_star, new_star)]\n fermionic_parts = []\n bosonic_parts = []\n for k in range(len(diff_list)):\n if diff_list[k] == 0:\n bosonic_parts += [part_circ_star[k]]\n elif diff_list[k] == 1:\n fermionic_parts += [new_star[k]]\n else:\n raise Exception(\"This should not happen.\")\n # sparts = Superpartitions()\n return _Superpartitions([fermionic_parts, bosonic_parts])","def newpart(self, device, primary, ncyls, swap=False):\n # This is a simple partitioning tool, which only supports\n # adding partitions sequentially, with all primary partitions\n # being before the extended partition, so once a logical\n # partition has been added, it is not possible to add further\n # primary ones.\n di = DiskInfo(device)\n pmax = 0 # Record highest partition number\n lim = -1 # Used for seeking last used cylinder\n exp = 0 # Number of extended partition\n ex0, ex1 = 0, -1 # Extended partition start and end\n log0, log1 = 0, -1 # Start and end of area used by logical partitions\n for p in di.parts:\n pn = int(p[0][len(device):])\n scyl, ecyl = p[1:3]\n if pn <= 4:\n if exp:\n run_error(_(\"Not supported: primary partition (%s%d)\\n\"\n \"has higher partition number than extended \"\n \"partition\") % (device, pn))\n return \"\"\n if scyl <= lim:\n run_error(_(\"Partitions must be ordered on the device.\\n\"\n \"%s%d is out of order.\") % (device, pn))\n return \"\"\n if p[3] in (\"5\", \"f\"):\n # extended\n exp = pn\n ex0, ex1 = scyl, ecyl\n continue\n pmax = pn\n lim = ecyl\n\n startcyl = lim + 1\n endcyl = lim + ncyls\n if endcyl >= di.drvcyls:\n run_error(_(\"Too little space at end of drive for new partition\"))\n return \"\"\n if exp and (pmax <= 4):\n # Remove the extended partition, which is empty anyway\n if not self.rmpart(device, exp):\n return \"\"\n pmax = exp - 1\n if primary:\n if pmax >= 4:\n run_error(_(\"Cannot add primary partition to %s\") % device)\n return \"\"\n t = \"primary\"\n else:\n t = \"logical\"\n if pmax > 4:\n # resize extended partition\n if not self.xcheck(\"resizepart\", device, str(exp),\n str(ex0), str(endcyl),\n onfail=_(\"Couldn't resize extended partition %s%d\")\n % (device, exp)):\n return False\n else:\n # create extended partition\n if not self.xcheck(\"newpart\", device,\n str(startcyl), str(endcyl), \"extended\",\n onfail=_(\"Couldn't create extended partition on %s\")\n % device):\n return False\n if pmax < 4:\n pmax = 4\n\n if self.xcheck(\"newpart\", device, str(startcyl), str(endcyl),\n t, \"linux-swap\" if swap else \"ext2\"):\n return \"%s%d\" % (device, pmax + 1)\n else:\n run_error(_(\"Couldn't add new partition to %s\") % device)\n return \"\"","def get_partitioning(disk):\n\n #TODO\n return \"Unknown\"","def partition(self):\n return self.tag(\"partition\")","def _encode_structure(self):\n pass","def _encode_structure(self):\n pass","def _get_partition_list(self):\n raise NotImplementedError('Must be implemented in subclasses.')","def _map_part_plnt(entry):\n dmt_entry = {}\n part_type = config.part_type_mapping.get(entry[config.classkey], 'P')\n\n dmt_entry['Plant'] = config.plant\n dmt_entry['PrimWhse'] = config.prim_whse\n dmt_entry['SourceType'] = part_type\n\n return dmt_entry","def _make_combinationsTest_label(chain_parts):\n\n assert len(chain_parts) == 1\n scenario = chain_parts[0]['hypoScenario']\n \n assert scenario == 'combinationsTest'\n\n \n\n return \"\"\"\n combgen(\n [(2)(20et, 0eta320)]\n \n simple([(40et, 0eta320) (50et, 0eta320)])\n simple([(35et, 0eta240) (55et, 0eta240)])\n )\"\"\"","def get_partition_cfg(partition_type: str) -> Dict:\n raise NotImplementedError('Not supported yet.')","def create(data):\n \n return Partlist(\n list_id = data['id'],\n name = data['name'],\n pieces = data['num_parts'])","def partition_selection():\n if selection is None:\n warning(\"You need to pick something first.\")\n return\n if not selection.obj_type in ['actor','element']:\n warning(\"You need to pick actors or elements.\")\n return\n for A in GD.canvas.actors:\n if not A.atype() == 'TriSurface':\n warning(\"Currently I can only partition TriSurfaces.\" )\n return\n partitionCollection(selection)\n highlightPartitions(selection)","def get_partition_cfg(partition_type: str, **kwargs) -> Dict:\n raise NotImplementedError","def createPartition(self, mp, mtype, fs, size, vg, nr):\n startSector = 0\n endSector = 0\n\n # primary partition: calculate the space according instructions below\n if mtype == 'Pri':\n\n # calculate the start sector\n startSector = self.__primaryStartPoint\n\n # calculate the end sector\n sectorLen = startSector + int(size * MEGABYTE / float(self.__sectorSize))\n endSector = sectorLen - 1\n self.__primaryStartPoint = sectorLen\n\n # decrease disk size\n self.__diskSize -= size\n\n # extended partition: update primary and logical pointers\n # when a extended partition is given, its size is not taken into account\n elif mtype == 'Ext':\n\n # calculate the start sector\n startSector = self.__primaryStartPoint\n\n # calculate end sector pointer\n endSector = int(self.__diskSize * MEGABYTE / float(self.__sectorSize)) + startSector - 1\n if endSector > MAX_SECTOR_POSSIBLE:\n endSector = MAX_SECTOR_POSSIBLE\n\n self.__extEndSector = endSector\n\n # decrease disk size\n self.__diskSize -= EXTENT_SIZE - 1\n\n # logical partition: calculate the space according instructions below\n elif mtype == 'Log':\n\n # FIXME, need to improve\n # just for zkvm without extended partition\n self.__extEndSector = endSector\n # refresh start sector pointer\n startSector = self.__primaryStartPoint + self.__sectorOffset\n\n if size == ALL_AVAILABLE:\n endSector = self.__extEndSector\n size = self.__diskSize - 1\n self.__diskSize = 0\n\n else: \n # calculate end sector pointer\n sectorLen = startSector + int(size * MEGABYTE / float(self.__sectorSize))\n endSector = sectorLen - 1\n self.__primaryStartPoint = sectorLen\n\n # decrease disk size\n self.__diskSize -= size\n\n\n part = {}\n part['command'] = 'create:partition'\n part['id'] = \"%s-part%s\" % (self.__diskId, str(nr))\n part['name'] = self.__disk + str(nr)\n part['mount_point'] = mp\n part['type'] = mtype\n part['fs'] = fs\n part['multipath'] = self.__hasMultipath\n part['raid_name'] = None\n part['disk_name'] = '/dev/%s' % self.__disk\n part['size'] = size\n part['vg'] = vg\n part['nr'] = nr\n part['format'] = True\n part['start'] = startSector\n part['end'] = endSector\n\n if self.__hasMultipath:\n part['disk_name'] = '/dev/mapper/%s' % self.__disk\n\n # extended partition: do not format\n if mtype == 'Ext':\n part['format'] = False\n\n return part","def partitionData(data, labels, partition):\n\treturn [s[partition] for s in data], labels[partition]","def part_id(self):\n ...","def split(self):\n out = []\n if self.section != \"\":\n out.append(self.section)\n out.append(self.topic)\n if self.sub_topic != \"\":\n out.append(self.sub_topic)\n if self.cutter != \"\":\n out.append(self.cutter)\n if self.version != 0:\n out.append(\"v.\" + str(self.version))\n if self.year != 0:\n out.append(str(self.year) + self.work_letter)\n if self.other != \"\":\n out.append(self.other)\n if self.copy != 0:\n out.append(\"c.\" + str(self.copy))\n return out","def partid(self): # -> None:\n ...","def partition_network(self, *args):\n Blockade.blockade_create_partition(*args)","def assemble_parts(self):\n self.parts['whole'] = self.output\n self.parts['encoding'] = self.document.settings.output_encoding\n self.parts['version'] = docutils.__version__","def create_from_segments(self, segment, origin=0):\r\n n = origin\r\n if segment[origin]['T'] != 'soma': # if it's a soma, only one compartment\r\n while (len(segment[n]['children']) == 1) and (segment[n]['T'] != 'soma'): # Go to the end of the branch\r\n n += 1\r\n # End of branch\r\n branch = segment[origin:n + 1]\r\n # Set attributes\r\n self.diameter, self.length, self.area, self.x, self.y, self.z = \\\r\n zip(*[(seg['diameter'], seg['length'], seg['area'], seg['x'], seg['y'], seg['z']) for seg in branch])\r\n self.diameter, self.length, self.area, self.x, self.y, self.z = array(self.diameter), array(self.length), \\\r\n array(self.area), array(self.x), array(self.y), array(self.z)\r\n self.type = segment[n]['T'] # normally same type for all compartments in the branch\r\n # Create children (list)\r\n self.children = [Morphology().create_from_segments(segment, origin=c) for c in segment[n]['children']]\r\n # Create dictionary of names (enumerates children from number 1)\r\n for i, child in enumerate(self.children):\r\n self._namedkid[str(i + 1)] = child\r\n # Name the child if possible\r\n if child.type in ['soma', 'axon', 'dendrite']:\r\n if child.type in self._namedkid:\r\n self._namedkid[child.type] = None # two children with the same name: erase (see next block)\r\n else:\r\n self._namedkid[child.type] = child\r\n # Erase useless names\r\n for k in self._namedkid.keys():\r\n if self._namedkid[k] is None:\r\n del self._namedkid[k]\r\n # If two kids, name them L (left) and R (right)\r\n if len(self.children) == 2:\r\n self._namedkid['L'] = self._namedkid['1']\r\n self._namedkid['R'] = self._namedkid['2']\r\n return self","def create_partition(mesh,polygons,enforce_exact=False):","def get_partname(self):\n return '{0:03.0f}{1}'.format(self.lon1, self.part)","def build_output_partitions(cls, name='inputTablePartitions', output_name='output'):\n obj = cls(name)\n obj.exporter = 'get_output_table_partition'\n obj.output_name = output_name\n return obj","def build_parts(self, simple_sentence, kana_sentence):\r\n parts = parse_simple_sentence_into_parts(simple_sentence)\r\n \r\n remaining_sentence = kana_sentence\r\n \r\n for i, part in enumerate(parts):\r\n if part.kanji:\r\n if i+1 == len(parts):\r\n part.kana = remaining_sentence\r\n else:\r\n start_of_next_part = remaining_sentence.find(parts[i+1].kana)\r\n part.kana = remaining_sentence[:start_of_next_part]\r\n remaining_sentence = remaining_sentence[start_of_next_part:]\r\n else:\r\n remaining_sentence = remaining_sentence.replace(part.kana, '', 1)\r\n \r\n return parts","def test_create_part(self):\n pass","def make_mixture_info(parts, operation='+'):\n # type: (List[ModelInfo], str) -> ModelInfo\n # Build new parameter list\n combined_pars = []\n\n # When creating a mixture model that is a sum of product models (ie (1*2)+(3*4))\n # the parameters for models 1 & 2 will be prefixed with A & B respectively,\n # but so will the parameters for models 3 & 4. We need to rename models 3 & 4\n # so that they are prefixed with C & D to avoid overlap of parameter names.\n used_prefixes = []\n for part in parts:\n if part.composition and part.composition[0] == 'mixture':\n i = 0\n for submodel in part.composition[1]:\n npars = len(submodel.parameters.kernel_parameters)\n # List of params of one of the constituent models of part\n submodel_pars = part.parameters.kernel_parameters[i:i+npars]\n # Prefix of the constituent model\n prefix = submodel_pars[0].name[0]\n if prefix not in used_prefixes: # Haven't seen this prefix so far\n used_prefixes.append(prefix)\n i += npars\n continue\n # TODO: don't modify submodel --- it may be used elsewhere\n # Existing code probably doesn't keep a handle on the model\n # parts so its probably okay, but it's possible that a mix\n # on user defined mixture models models will change the\n # parameters used for the parts in the GUI. Even worse if the\n # same plugin is used twice. For example, twosphere.py\n # contains sphere+sphere and you create twosphere+twosphere.\n while prefix in used_prefixes:\n # This prefix has been already used, so change it to the\n # next letter that hasn't been used\n prefix = chr(ord(prefix) + 1)\n used_prefixes.append(prefix)\n prefix += \"_\"\n # Update the parameters of this constituent model to use the\n # new prefix\n for par in submodel_pars:\n # Strip {prefix}_ using par.name[2:], etc.\n # TODO: fails for AB_scale\n par.id = prefix + par.id[2:]\n par.name = prefix + par.name[2:]\n if par.length_control is not None:\n par.length_control = prefix + par.length_control[2:]\n i += npars\n\n for part in parts:\n # Parameter prefix per model, A_, B_, ...\n # Note that prefix must also be applied to id and length_control\n # to support vector parameters\n prefix = ''\n if not part.composition or part.composition[0] == 'product':\n # Model isn't a composition model, so its parameters don't have a\n # a prefix. Add the next available prefix\n prefix = chr(ord('A')+len(used_prefixes))\n used_prefixes.append(prefix)\n prefix += '_'\n\n if operation == '+':\n # If model is a sum model, each constituent model gets its own scale parameter\n scale_prefix = prefix\n if prefix == '' and getattr(part, \"operation\", '') == '*':\n # `part` is a composition product model. Find the prefixes of\n # its parameters to form a new prefix for the scale.\n # For example, a model with A*B*C will have ABC_scale.\n sub_prefixes = []\n for param in part.parameters.kernel_parameters:\n # Prefix of constituent model\n sub_prefix = param.id.split('_')[0]\n if sub_prefix not in sub_prefixes:\n sub_prefixes.append(sub_prefix)\n # Concatenate sub_prefixes to form prefix for the scale\n scale_prefix = ''.join(sub_prefixes) + '_'\n scale = Parameter(scale_prefix + 'scale', default=1.0,\n description=\"model intensity for \" + part.name)\n combined_pars.append(scale)\n for p in part.parameters.kernel_parameters:\n p = copy(p)\n p.name = prefix + p.name\n p.id = prefix + p.id\n if p.length_control is not None:\n p.length_control = prefix + p.length_control\n combined_pars.append(p)\n parameters = ParameterTable(combined_pars)\n # Allow for the scenario in which each component has all its PD parameters\n # active simultaneously. details.make_details() will throw an error if\n # too many are used from any one component.\n parameters.max_pd = sum(part.parameters.max_pd for part in parts)\n\n def random():\n \"\"\"Random set of model parameters for mixture model\"\"\"\n combined_pars = {}\n for k, part in enumerate(parts):\n prefix = chr(ord('A')+k) + '_'\n pars = part.random()\n combined_pars.update((prefix+k, v) for k, v in pars.items())\n return combined_pars\n\n model_info = ModelInfo()\n model_info.id = operation.join(part.id for part in parts)\n model_info.operation = operation\n model_info.name = '(' + operation.join(part.name for part in parts) + ')'\n model_info.filename = None\n model_info.title = 'Mixture model with ' + model_info.name\n model_info.description = model_info.title\n model_info.docs = model_info.title\n model_info.category = \"custom\"\n model_info.parameters = parameters\n model_info.random = random\n #model_info.single = any(part['single'] for part in parts)\n model_info.structure_factor = False\n #model_info.tests = []\n #model_info.source = []\n # Remember the component info blocks so we can build the model\n model_info.composition = ('mixture', parts)\n return model_info","def create_net_partition(self, body=None):\r\n return self.post(self.net_partitions_path, body=body)","def list_partitions(self, partitioning):\n return []","def gen_partition_statement(partition_tuples, target_root, run_id=None):\n if run_id is not None:\n partition_tuples = [('run_id', run_id)] + partition_tuples\n # todo: part_a1, part_a2, part_b, part_c, part_what? you lost me.\n part_a1 = \", \".join(\n [\"{label}='{value}'\".format(label=i[0], value=i[1]) for i in partition_tuples]\n )\n part_a2 = \"/\".join(\n [\"{label}={value}\".format(label=i[0], value=i[1]) for i in partition_tuples]\n )\n part_b = \"partition ({partitions_str})\".format(partitions_str=part_a1)\n part_c = \"location '{location}'\".format(location=os.path.join(target_root, part_a2))\n return part_b + ' ' + part_c","def get_partition(self, partid):\n #TODO(zhengda) add implementation later.","def get_partition(self, partid):\n #TODO(zhengda) add implementation later.","def set_partition(self, partition=0):\n if not isinstance(partition, int):\n raise TypeError('partition must be an integer')\n if partition <= 0:\n raise ValueError('partition must be positive')\n if self.connected:\n self.producer.send(\"PART:\"+str(partition))","def do_prepare_partition(cls, part, source_params, creator, cr_workdir,\n oe_builddir, bootimg_dir, kernel_dir, rootfs_dir,\n native_sysroot):\n logger.debug(\"SourcePlugin: do_prepare_partition: part: %s\", part)","def partition_description(self) -> pulumi.Output[Optional[Any]]:\n return pulumi.get(self, \"partition_description\")","def names_to_parts(self, pnames, must_exist=True):\n meta = self.mesh.meta\n for pname in pnames:\n part = meta.get_part(pname, must_exist)\n yield part","def do_stage_partition(cls, part, source_params, creator, cr_workdir,\n oe_builddir, bootimg_dir, kernel_dir,\n native_sysroot):\n logger.debug(\"SourcePlugin: do_stage_partition: part: %s\", part)","def defineTasks(self,partition):\n recv_slots = partition.recvSlices()\n strm_slots = partition.streamSlices()\n recvNodes = partition.recvNodesFromSlots()\n strmNodes = partition.streamNodesFromSlots()\n opt = '/'+self.manager.hostName()+'/'+partition.manager.name()+'/'+partition.name+'/'\n cl0 = '/Class0'+opt\n cl1 = '/Class1'+opt\n\n partition.setDataSources([])\n tasks = []\n pn = self.partitionName()\n print '---------------------- Partition name is:',pn\n for i in xrange(len(recv_slots)):\n slot = recv_slots[i]\n node = slot[:slot.find(':')]\n sub_farm = 'SF%02d'%(i,)\n short_name = sub_farm+'_SND' # Keep this name to ensure storageMon is working!\n task = pn+'_'+node+'_'+short_name\n tasks.append(node+'/'+task+'/'+short_name+'/RecStorageSend'+cl1+'(\"'+sub_farm+'\",'+str(i)+',)')\n partition.setRecvSenders(tasks)\n tasks = []\n for i in xrange(len(strm_slots)):\n slot = strm_slots[i]\n node = slot[:slot.find(':')]\n sub_farm = 'SF%02d'%(i,)\n short_name = sub_farm+'_HLT' # Keep this name to ensure storageMon is working!\n task = pn+'_'+node+'_'+short_name\n tasks.append(node+'/'+task+'/'+short_name+'/RecStorageRecv'+cl1+'(\"'+sub_farm+'\",'+str(i)+',)')\n partition.setStreamReceivers(tasks)\n cnt = 0\n tasks = []\n infra = []\n for j in recvNodes:\n for itm in self.rcvInfra.data:\n i,cl=itm.split('/')\n infra.append(j+'/'+pn+'_'+j+'_'+i+'/'+i+'/'+i+'/'+cl+opt+'(\"'+str(cnt)+'\",)')\n cnt = cnt + 1\n partition.setRecvInfrastructure(infra)\n partition.setRecvReceivers(tasks)\n cnt = 0\n tasks = []\n infra = []\n for j in strmNodes:\n for itm in self.strInfra.data:\n i,cl=itm.split('/')\n infra.append(j+'/'+pn+'_'+j+'_'+i+'/'+i+'/'+i+'/'+cl+opt+'(\"'+str(cnt)+'\",)')\n cnt = cnt + 1\n partition.setStreamInfrastructure(infra)\n partition.setStreamSenders(tasks)\n if partition.saveTasks():\n tasks = partition.collectTasks(tasks={},with_data_sources=0)\n return tasks\n return None","def to_partid(self, id_tensor):\n ...","def test_splitPartiesOnlyOneParty(self):\n parties_str = \"Applicant Tenant(s): Tabata A, Caio N\"\n expected = {\n \"applicant\": [{\"role\": \"tenant\", \"name\": \"tabata a\"},\n {\"role\": \"tenant\", \"name\": \"caio n\"}],\n \"respondent\": []\n }\n result = split_parties.splitCaseParties('adjudication', parties_str)\n self.assertEqual(expected, result)","def export_part_list(self, filetype='xlsx'):\n if filetype == 'csv':\n enum = 48649\n else:\n enum = 48642\n path = self.export_dir.joinpath(self.partcode).joinpath('part_list.xlsx')\n self.doc.Sheets(1).PartsLists(1).Export(str(path), enum)","def do_configure_partition(cls, part, source_params, creator, cr_workdir,\n oe_builddir, bootimg_dir, kernel_dir,\n native_sysroot):\n logger.debug(\"SourcePlugin: do_configure_partition: part: %s\", part)","def get_partition_info(disk, host_disk):\n\n volume = \"/dev/\"+disk\n DISKINFO[volume] = {}\n DISKINFO[volume][\"Name\"] = volume\n DISKINFO[volume][\"Type\"] = \"Partition\"\n DISKINFO[volume][\"HostDevice\"] = host_disk\n DISKINFO[volume][\"Partitions\"] = []\n DISKINFO[host_disk][\"Partitions\"].append(volume)\n DISKINFO[volume][\"Vendor\"] = get_vendor(disk)\n DISKINFO[volume][\"Product\"] = \"Host Device: \"+DISKINFO[host_disk][\"Product\"]\n DISKINFO[volume][\"RawCapacity\"], DISKINFO[volume][\"Capacity\"] = get_capacity()\n DISKINFO[volume][\"Description\"] = get_description(disk)\n DISKINFO[volume][\"Flags\"] = get_capabilities(disk)\n DISKINFO[volume][\"FileSystem\"] = get_file_system(disk)\n DISKINFO[volume][\"Partitioning\"] = \"N/A\"\n DISKINFO[volume][\"UUID\"] = get_uuid(disk)\n DISKINFO[volume][\"ID\"] = get_id(disk)\n DISKINFO[volume][\"BootRecord\"], DISKINFO[volume][\"BootRecordStrings\"] = get_boot_record(disk)\n\n return volume","def fillQuickList():\n global quickList\n cmd = \"/sbin/blkid\"\n proc = subprocess.Popen(cmd.split(), stdout=subprocess.PIPE)\n for line in proc.stdout:\n line = line.replace(':', '').strip()\n propList = line.split()\n devName = label = uuid = fsType = ''\n devName = propList[0]\n for property in propList:\n if property.startswith('UUID'):\n uuid = property.replace('UUID=', '').replace('\"', '')\n quickList[devName] = uuid","def getPartitionNameByUUID(part):\n global quickList\n part = part.replace('UUID=', '')\n if len(quickList) == 0:\n fillQuickList()\n for devName, uuid in quickList.items():\n if uuid == part:\n return devName\n return ''","def test_get_parts(self):\n pass","def genereate_echo_picklist(self):\n sample_names = []\n sample_wells = []\n indices = {'i5 name': {}, 'i5 plate': {}, 'i5 sequence': {},\n 'i5 well': {}, 'i7 name': {}, 'i7 plate': {},\n 'i7 sequence': {}, 'i7 well': {}, 'index combo': {},\n 'index combo seq': {}}\n\n for idx, well in enumerate(chain.from_iterable(self.plates[0].layout)):\n # Add the sample well\n sample_wells.append(well.well_id)\n # Get the sample name - we need to go back to the SampleComposition\n lib_comp = well.composition\n sample_comp = lib_comp.normalized_gdna_composition\\\n .gdna_composition.sample_composition\n sample_names.append(sample_comp.content)\n # Retrieve all the information about the indices\n i5_comp = lib_comp.i5_composition.primer_set_composition\n i5_well = i5_comp.container\n indices['i5 name'][idx] = i5_comp.external_id\n indices['i5 plate'][idx] = i5_well.plate.external_id\n indices['i5 sequence'][idx] = i5_comp.barcode\n indices['i5 well'][idx] = i5_well.well_id\n\n i7_comp = lib_comp.i7_composition.primer_set_composition\n i7_well = i7_comp.container\n indices['i7 name'][idx] = i7_comp.external_id\n indices['i7 plate'][idx] = i7_well.plate.external_id\n indices['i7 sequence'][idx] = i7_comp.barcode\n indices['i7 well'][idx] = i7_well.well_id\n\n indices['index combo seq'][idx] = '%s%s' % (\n indices['i5 sequence'][idx], indices['i7 sequence'][idx])\n\n sample_names = np.asarray(sample_names)\n sample_wells = np.asarray(sample_wells)\n indices = pd.DataFrame(indices)\n\n return LibraryPrepShotgunProcess._format_picklist(\n sample_names, sample_wells, indices)","def process_new_subpart(notice, amd_label, par):\n subpart_changes = {}\n subpart_xml = find_subpart(par)\n subpart = reg_text.build_subpart(amd_label.label[0], subpart_xml)\n\n for change in changes.create_subpart_amendment(subpart):\n subpart_changes.update(change)\n return subpart_changes","def partition(self) -> pulumi.Output[Optional[str]]:\n return pulumi.get(self, \"partition\")","def __get_partition__(self, account, container, obj, part_shift):\n \n key = hash_path(account, container, obj, raw_digest=True)\n part = unpack_from('>I', key)[0] >> part_shift\n return part","def get_partfstype(self, part):\n t = self.xlist(\"get-blkinfo\", part, \"TYPE\")\n return t[1][0] if t[0] and (len(t[1]) != 0) else \"\"","def insert_parts(self, parts):\r\n self.board.insert_parts(parts)\r\n self.set_changed(parts)","def __init__(self, section, config):\n self.disk = section.getSectionName()\n\n # Grab our partition map\n # If it doesn't exist, complain loudly\n self.diskLabelConfig = None\n for map in config.Partitions.PartitionMap:\n if (section.partitionmap.lower() == map.getSectionName()):\n # Set up the disk labels. Always s1!\n self.diskLabelConfig = DiskLabelConfig(map, self.disk + 's1')\n break","def chainDict2jetLabel(chain_dict):\n\n # suported scenarios \n router = {\n 'simple': _make_simple_label,\n 'HT': _make_ht_label,\n 'vbenf': _make_vbenf_label,\n 'dijet': _make_dijet_label,\n 'combinationsTest': _make_combinationsTest_label,\n 'partitionsTest': _make_partitionsTest_label,\n }\n\n # chain_part - scenario association\n cp_sorter = {}\n for k in router: cp_sorter[k] = []\n\n for cp in chain_dict['chainParts']:\n if cp['signature'] != 'Jet' and cp['signature'] != 'Bjet': \n continue\n for k in cp_sorter:\n if cp['hypoScenario'].startswith(k):\n cp_sorter[k].append(cp)\n break\n\n # obtain labels by scenario.\n labels = []\n for k, chain_parts in cp_sorter.items():\n if chain_parts: labels.append(router[k](chain_parts))\n\n assert labels\n nlabels = len(labels)\n if nlabels == 1: return labels[0]\n if nlabels == 2:\n alabel = \"\"\"\\\nand([]\n %s\n %s)\"\"\" % (tuple(labels))\n return alabel\n\n # more than 2 labels is not expected\n assert False","def partid(self): # -> int:\n ...","def convert_partitions_to_list(partition):\n parts = list()\n for part in partition:\n parts.append(part)\n return parts","def nodeSeparate(self,compInfo, ifSub, subname, subcktName,numNodesSub):\n node = []\n nodeTemp = []\n nodeDic = {}\n pinInit = 'Modelica.Electrical.Analog.Interfaces.Pin '\n pinProtectedInit = 'Modelica.Electrical.Analog.Interfaces.Pin '\n protectedNode = []\n print \"CompInfo coming to nodeSeparate function: compInfo\",compInfo\n \n #Removing '[' and ']' from compInfo for Digital node\n for i in range(0,len(compInfo),1):\n compInfo[i] = compInfo[i].replace(\"[\",\"\").replace(\"]\",\"\")\n \n \n for eachline in compInfo:\n words = eachline.split()\n if eachline[0] in ['m', 'e', 'g', 't','M','E','G','T']:\n nodeTemp.append(words[1])\n nodeTemp.append(words[2])\n nodeTemp.append(words[3])\n nodeTemp.append(words[4])\n elif eachline[0] in ['q', 'j','J','Q']:\n nodeTemp.append(words[1])\n nodeTemp.append(words[2])\n nodeTemp.append(words[3])\n elif eachline[0]=='x' or eachline[0]=='X':\n templine = eachline.split()\n for i in range(0,len(templine),1):\n if templine[i] in subcktName:\n point = i \n nodeTemp.extend(words[1:point])\n else:\n nodeTemp.append(words[1])\n nodeTemp.append(words[2])\n for i in nodeTemp:\n if i not in node:\n node.append(i)\n \n for i in range(0, len(node),1):\n nodeDic[node[i]] = 'n' + node[i]\n if ifSub == '0':\n if i != len(node)-1:\n pinInit = pinInit + nodeDic[node[i]] + ', '\n else:\n pinInit = pinInit + nodeDic[node[i]]\n else:\n nonprotectedNode = self.getSubInterface(subname, numNodesSub) \n if node[i] in nonprotectedNode:\n continue\n else:\n protectedNode.append(node[i])\n if ifSub == '1':\n if len(nonprotectedNode) > 0:\n for i in range(0, len(nonprotectedNode),1):\n if i != len(nonprotectedNode)-1:\n pinProtectedInit = pinProtectedInit + nodeDic[nonprotectedNode[i]] + ','\n else:\n pinProtectedInit = pinProtectedInit + nodeDic[nonprotectedNode[i]]\n if len(protectedNode) > 0:\n for i in range(0, len(protectedNode),1):\n if i != len(protectedNode)-1: \n pinInit = pinInit + nodeDic[protectedNode[i]] + ','\n else:\n pinInit = pinInit + nodeDic[protectedNode[i]]\n pinInit = pinInit + ';'\n pinProtectedInit = pinProtectedInit + ';'\n print \"Node---->\",node\n print \"nodeDic----->\",nodeDic\n print \"PinInit----->\",pinInit\n print \"pinProtectedinit--->\",pinProtectedInit\n return node, nodeDic, pinInit, pinProtectedInit","def get_partition_details(disk, partition):\n details = {}\n script = [\n 'select disk {}'.format(disk['Number']),\n 'select partition {}'.format(partition['Number']),\n 'detail partition']\n\n # Diskpart details\n try:\n # Run script\n result = run_diskpart(script)\n except subprocess.CalledProcessError:\n pass\n else:\n # Get volume letter or RAW status\n output = result.stdout.decode().strip()\n tmp = re.search(r'Volume\\s+\\d+\\s+(\\w|RAW)\\s+', output)\n if tmp:\n if tmp.group(1).upper() == 'RAW':\n details['FileSystem'] = RAW\n else:\n details['Letter'] = tmp.group(1)\n # Remove empty lines from output\n tmp = [s.strip() for s in output.splitlines() if s.strip() != '']\n # Split each line on ':' skipping those without ':'\n tmp = [s.split(':') for s in tmp if ':' in s]\n # Add key/value pairs to the details variable and return dict\n details.update({key.strip(): value.strip() for (key, value) in tmp})\n\n # Get MBR type / GPT GUID for extra details on \"Unknown\" partitions\n guid = PARTITION_UIDS.get(details.get('Type').upper(), {})\n if guid:\n details.update({\n 'Description': guid.get('Description', '')[:29],\n 'OS': guid.get('OS', 'Unknown')[:27]})\n\n if 'Letter' in details:\n # Disk usage\n try:\n tmp = psutil.disk_usage('{}:\\\\'.format(details['Letter']))\n except OSError as err:\n details['FileSystem'] = 'Unknown'\n details['Error'] = err.strerror\n else:\n details['Used Space'] = human_readable_size(tmp.used)\n\n # fsutil details\n cmd = [\n 'fsutil',\n 'fsinfo',\n 'volumeinfo',\n '{}:'.format(details['Letter'])\n ]\n try:\n result = run_program(cmd)\n except subprocess.CalledProcessError:\n pass\n else:\n output = result.stdout.decode().strip()\n # Remove empty lines from output\n tmp = [s.strip() for s in output.splitlines() if s.strip() != '']\n # Add \"Feature\" lines\n details['File System Features'] = [s.strip() for s in tmp\n if ':' not in s]\n # Split each line on ':' skipping those without ':'\n tmp = [s.split(':') for s in tmp if ':' in s]\n # Add key/value pairs to the details variable and return dict\n details.update({key.strip(): value.strip() for (key, value) in tmp})\n\n # Set Volume Name\n details['Name'] = details.get('Volume Name', '')\n\n # Set FileSystem Type\n if details.get('FileSystem', '') not in ['RAW', 'Unknown']:\n details['FileSystem'] = details.get('File System Name', 'Unknown')\n\n return details","def test_splitPartiesStringWithoutDivider(self):\n parties_str = \"Appellant: Denise O'B Respondent: Eugene D, Mary C\"\n expected = {\n \"applicant\": [{\"name\": \"denise o'b\"}],\n \"respondent\": [{\"name\": \"eugene d\"},\n {\"name\": \"mary c\"}]\n }\n result = split_parties.splitCaseParties(\"tribunal\", parties_str)\n self.assertEqual(expected, result)","def voices_in_part (part):\n part.interpret ()\n part.extract_voices ()\n voices = part.get_voices ()\n part_info = part.get_staff_attributes ()\n\n return (voices, part_info)","def __init__(self, *elems, **kwargs) -> None:\r\n self.sequence = tuple(kwargs['partition']) if kwargs.get('partition') else elems","def partition_book(self):\n ...","def _record_specific_partition(r_d, numnodes, cur):\n # No partitioning has been specified. Create the appropriate entries.\n if r_d['partmtd'] == 0:\n for i in range(1, numnodes + 1):\n Database.execute(cur, 'UPDATE dtables '\n 'SET partmtd = 0 '\n 'WHERE nodeid = ? AND tname = ?',\n ErrorHandle.raise_handler, (i, r_d['tname']))\n\n # Range partitioning has been specified. Create the appropriate entries.\n elif r_d['partmtd'] == 1:\n for i in range(1, numnodes + 1):\n Database.execute(cur, 'UPDATE dtables '\n 'SET partcol = ?, partparam1 = ?, '\n 'partparam2 = ?, partmtd = 1 '\n 'WHERE nodeid = ? AND tname = ?',\n ErrorHandle.raise_handler,\n (r_d['partcol'], r_d['param1'][i - 1], r_d['param2'][i - 1], i,\n r_d['tname']))\n\n # Hash partitioning has been specified. Create the appropriate entries.\n elif r_d['partmtd'] == 2:\n for i in range(1, numnodes + 1):\n Database.execute(cur, 'UPDATE dtables '\n 'SET partcol = ?, partparam1 = ?, partmtd = 2 '\n 'WHERE nodeid = ? AND tname = ?',\n ErrorHandle.raise_handler,\n (r_d['partcol'], r_d['param1'], i, r_d['tname']))","def get_body_part_names(self):\n self.x_cols, self.y_cols, self.p_cols = [], [], []\n for bp in self.body_parts_lst:\n self.x_cols.append(f\"{bp}_x\")\n self.y_cols.append(f\"{bp}_y\")\n self.p_cols.append(f\"{bp}_p\")","def on_add_clicked(self,button):\n\t\tself.list_partitions.add_partition()","def true_partition(self):\n if 'NA' in self.mothers or 'NA' in self.fathers:\n warn('Warning: one or more individuals has at least one parent of unkown identity.')\n warn('All such individuals will be assigned to the same sibship group.')\n\n # concatenate mother and father names to create a vector of parent pairs.\n #parentage = np.array([str(self.mothers[o]) + '/' + str(self.fathers[o]) for o in range(noffs)])\n possible_families = np.unique(self.parents) # get a list of all unique parent pairs\n\n partitions = np.zeros(self.size).astype('int') # empty vector of zeros.\n for o in range(self.nfamilies):\n # for every possible family label individuals with an identical integer.\n partitions[self.parents == possible_families[o]] += o\n\n return partitions","def mkswap(self, partition, check):\n args = [partition]\n if check:\n args.insert(0, \"-c\")\n return self.xlist(\"swap-format\", *args)[0]","def partid2nids(self, partid):\n return self._partid2nids[partid]","def label_block_get_serializer(get_info):\n serializer = sl_mpls_pb2.SLMplsLabelBlockGetMsg()\n if \"start_label\" in get_info:\n serializer.Key.StartLabel = get_info[\"start_label\"]\n if \"block_size\" in get_info:\n serializer.Key.LabelBlockSize = get_info[\"block_size\"]\n if \"count\" in get_info:\n serializer.EntriesCount = get_info[\"count\"]\n if \"get_next\" in get_info:\n serializer.GetNext = (get_info[\"get_next\"] != 0)\n return serializer","def probe(self):\n log_method_call(self, self.name, exists=self.exists)\n if not self.exists or not self.disklabelSupported:\n return\n\n self._size = Size(self.partedPartition.getLength(unit=\"B\"))\n self.targetSize = self._size\n\n self._partType = self.partedPartition.type\n\n self._bootable = self.getFlag(parted.PARTITION_BOOT)","def draw_partition(self, box, context, bounding_box):\n assert self.canvas\n\n cr = context.cairo\n cr.set_line_width(box.style(\"line-width\"))\n\n if self.subject and not self.subject.isDimension and self._toplevel:\n cr.move_to(0, 0)\n cr.line_to(bounding_box.width, 0)\n\n h = self._header_size[1]\n\n # draw outside lines if this item is toplevel partition\n if self._toplevel:\n cr.move_to(0, bounding_box.height)\n cr.line_to(0, h)\n cr.line_to(bounding_box.width, h)\n cr.line_to(bounding_box.width, bounding_box.height)\n\n if self._subpart:\n # header line for all subparitions\n hd = h + self._hdmax\n cr.move_to(0, hd)\n cr.line_to(bounding_box.width, hd)\n\n if self._subpart:\n # draw inside lines for all children but last one\n dp = 0\n for sl in self.canvas.get_children(self)[:-1]:\n dp += sl.width\n cr.move_to(dp, h)\n cr.line_to(dp, bounding_box.height)\n\n cr.stroke()\n\n if context.hovered or context.dropzone:\n cr.save()\n cr.set_dash((1.0, 5.0), 0)\n cr.set_line_width(1.0)\n cr.rectangle(0, 0, bounding_box.width, bounding_box.height)\n draw_highlight(context)\n cr.stroke()\n cr.restore()"],"string":"[\n \"def _make_partitionsTest_label(chain_parts):\\n\\n assert len(chain_parts) == 1\\n scenario = chain_parts[0]['hypoScenario']\\n \\n assert scenario == 'partitionsTest'\\n\\n \\n\\n return \\\"\\\"\\\"\\n partgen(\\n [(20et, 0eta320)]\\n \\n simple([(40et, 0eta320) (50et, 0eta320)])\\n simple([(35et, 0eta240) (55et, 0eta240)])\\n )\\\"\\\"\\\"\",\n \"def provide_partition_info(self):\\n self.partition_info = True\",\n \"def __str__(self) -> str:\\n return str(self.my_partition)\",\n \"def _make_simple_label(chain_parts):\\n \\n if not _select_simple_chainparts(chain_parts):\\n msg = 'Jet Configuration error: '\\\\\\n 'chain fails substring selection: not \\\"simple\\\" '\\n\\n raise NotImplementedError(msg)\\n \\n label = 'simple(['\\n for cp in chain_parts:\\n smcstr = str(cp['smc'])\\n jvtstr = str(cp['jvt'])\\n if smcstr == 'nosmc':\\n smcstr = ''\\n for i in range(int(cp['multiplicity'])):\\n # condition_str = '(%set,%s,%s)' % (str(cp['threshold']),\\n # str(cp['etaRange']),\\n # smcstr,)\\n condition_str = '(%set,%s' % (str(cp['threshold']),\\n str(cp['etaRange']),)\\n if smcstr: # Run 2 chains have \\\"INF\\\" in the SMC substring\\n condition_str += ',%s)' % smcstr.replace('INF','')\\n elif jvtstr:\\n condition_str += ',%s)' % jvtstr\\n else:\\n condition_str += ')'\\n label += condition_str\\n label += '])'\\n return label\",\n \"def FormatPartition(self, partition):\\n\\n fstab = self.fstab\\n if fstab:\\n p = fstab[partition]\\n self.script.append('format(\\\"%s\\\", \\\"%s\\\", %s, \\\"%s\\\", \\\"%s\\\");' %\\n (p.fs_type, common.PARTITION_TYPES[p.fs_type],\\n self._GetSlotSuffixDeviceForEntry(p),\\n p.length, p.mount_point))\",\n \"def __str__(self):\\n \\n return \\\"Part ID: %s, %s\\\" % (self.part_id, self.name)\",\n \"def create(self, disk):\\n logging.info('Adding type %d partition to disk image: %s' % (self.type, disk.filename))\\n run_cmd('parted', '--script', '--', disk.filename, 'mkpart', 'primary', self.parted_fstype(), self.begin, self.end)\",\n \"def print_partition(t, par=[]):\\n\\n if is_leaf(t):\\n if label(t) == True:\\n print(' + '.join(par))\\n else:\\n left, right = branches(t)[0], branches(t)[1]\\n print_partition(left, [str(label(t))] + par)\\n print_partition(right, par)\\n #print(\\\"total partitions: \\\", str(count_leaves(t)))\",\n \"def partid2nids(self, partid, ntype=...):\\n ...\",\n \"def partid2nids(self, partid, ntype=...):\\n ...\",\n \"def _setPartedPartition(self, partition):\\n log_method_call(self, self.name)\\n\\n if partition is not None and not isinstance(partition, parted.Partition):\\n raise ValueError(\\\"partition must be None or a parted.Partition instance\\\")\\n\\n log.debug(\\\"device %s new partedPartition %s\\\", self.name, partition)\\n self._partedPartition = partition\\n self.updateName()\",\n \"def dump_parts(self, io):\\n\\n # XXX refactor with Tempita\\n title = \\\"Parts created by the docutils writer '%s'\\\" % self.strategy.name\\n io.say(title + os.linesep)\\n io.say(len(title) * '-')\\n io.say(2 * os.linesep)\\n io.say('Part keys: ' + 2 * os.linesep)\\n\\n parts = self.publish_parts(io)\\n io.say(os.linesep.join(sorted(parts.keys())))\\n io.say(2 * os.linesep)\\n for part in parts:\\n io.say(\\\"Value of part '%s':%s\\\" % (part, os.linesep))\\n io.say(parts[part].encode('utf-8') + os.linesep)\\n io.say(80*'-'+os.linesep)\\n io.say(os.linesep)\",\n \"def _make_simple_comb_label(chain_dict):\\n\\n cps = chain_dict['chainParts']\\n if not (_select_simple_chainparts(cps)):\\n raise NotImplementedError(\\n 'chain fails substring selection: not \\\"simple\\\": %s' % (\\n chain_dict['chainName']))\\n \\n simple_strs = []\\n\\n for cp in cps:\\n print(cp)\\n simple_strs.append(_make_simple_label([cp]))\\n\\n label = 'combgen([(%d)]' % len(cps)\\n for s in simple_strs:\\n label += ' %s ' % s\\n label += ')'\\n return label\",\n \"def partid(self): # -> Unknown:\\n ...\",\n \"def get_partition():\\n if selection is None:\\n warning(\\\"You need to pick something first.\\\")\\n return\\n if not selection.obj_type in ['partition']:\\n warning(\\\"You need to partition the selection first.\\\")\\n return\\n res = askItems([['property',[1]]],\\n caption='Partition property')\\n if res:\\n prop = res['property']\\n getPartition(selection,prop)\\n highlightPartitions(selection)\",\n \"def _wrap_partitions(self, partitions):\\n return [\\n self.partition_type(object_id, length, width, ip)\\n for (object_id, length, width, ip) in zip(*[iter(partitions)] * 4)\\n ]\",\n \"def bootpart(disks):\\n return path_to_partition(disks, '/boot/foo')\",\n \"def choose_partition():\\n # Ask the user wether the partitions should be taken from the original partitions, or from the home-made partitions\\n file_name = selector([\\\"The original partition given by the instructor\\\", \\\"The homemade partition file\\\"], [\\\"ORIGINAL\\\", \\\"HOMEMADE\\\"])\\n\\n # Open the corresponding file\\n if file_name == \\\"1\\\" or file_name == \\\"ORIGINAL\\\":\\n file = open(\\\"./assets/partitions.txt\\\", \\\"r\\\")\\n elif file_name == \\\"2\\\" or file_name == \\\"HOMEMADE\\\":\\n file = open(\\\"./assets/homemade_partitions.txt\\\", \\\"r\\\")\\n\\n skip_lines(-1)\\n\\n # Print all song's names in the partitions\\n lines = file.readlines()\\n file.close()\\n for i in range(0, len(lines), 2):\\n print(lines[i][:-1])\\n\\n # Ask the user to choose for a song\\n song_index = choose_number(len(lines) / 2)\\n\\n # Get the corresponding song's partition and convert notes to Note instances\\n partition = lines[song_index * 2 - 1][:-1].replace(' ', '')\\n raw_notes = get_notes_from_line(partition)\\n parsed_notes = [Note(note) for note in raw_notes]\\n return parsed_notes\",\n \"def partid2nids(self, partid, ntype): # -> None:\\n ...\",\n \"def create(data):\\n \\n return Part(\\n part_id = data['part_num'],\\n category_id = data['part_cat_id'],\\n external_ids = data.get('external_ids', {}),\\n name = data['name'],\\n year_from = data.get('year_from', None),\\n year_to = data.get('year_to', None),\\n url = data.get('part_url', None),\\n img_url = data.get('part_img_url', None),\\n print_of = data.get('print_of', None),\\n prints = data.get('prints', []),\\n molds = data.get('molds', []),\\n alternates = data.get('alternates', []))\",\n \"def _wrap_partitions(self, partitions):\\n return [\\n self.partition_type(future, length, width, ip)\\n for (future, length, width, ip) in zip(*[iter(partitions)] * 4)\\n ]\",\n \"def parse_part(self):\\n parts = []\\n for part in re.split(r'\\\\*\\\\*\\\\* ([A-Z- ]+) \\\\*\\\\*\\\\*', self.hand_file): # return [ 'part1', 'splitter1', 'part2',..\\n parts.append(part)\\n\\n for i in range(0, len(parts)):\\n if i == 0:\\n self.part_dict['HEADER'] = parts[i]\\n if i % 2 != 0: # number is odd\\n self.part_dict[parts[i]] = parts[i + 1]\",\n \"def preCommitFixup(self):\\n log_method_call(self, self.name)\\n if not self.exists or not self.disklabelSupported:\\n return\\n\\n # find the correct partition on the original parted.Disk since the\\n # name/number we're now using may no longer match\\n _disklabel = self.disk.originalFormat\\n\\n if self.isExtended:\\n # getPartitionBySector doesn't work on extended partitions\\n _partition = _disklabel.extendedPartition\\n log.debug(\\\"extended lookup found partition %s\\\",\\n devicePathToName(getattr(_partition, \\\"path\\\", None) or \\\"(none)\\\"))\\n else:\\n # lookup the partition by sector to avoid the renumbering\\n # nonsense entirely\\n _sector = self.partedPartition.geometry.start\\n _partition = _disklabel.partedDisk.getPartitionBySector(_sector)\\n log.debug(\\\"sector-based lookup found partition %s\\\",\\n devicePathToName(getattr(_partition, \\\"path\\\", None) or \\\"(none)\\\"))\\n\\n self.partedPartition = _partition\",\n \"def prep_disk_for_formatting(disk=None):\\n disk['Format Warnings'] = '\\\\n'\\n width = len(str(len(disk['Partitions'])))\\n\\n # Bail early\\n if disk is None:\\n raise Exception('Disk not provided.')\\n\\n # Set boot method and partition table type\\n disk['Use GPT'] = True\\n if (get_boot_mode() == 'UEFI'):\\n if (not ask(\\\"Setup Windows to use UEFI booting?\\\")):\\n disk['Use GPT'] = False\\n else:\\n if (ask(\\\"Setup Windows to use BIOS/Legacy booting?\\\")):\\n disk['Use GPT'] = False\\n\\n # Set Display and Warning Strings\\n if len(disk['Partitions']) == 0:\\n disk['Format Warnings'] += 'No partitions found\\\\n'\\n for partition in disk['Partitions']:\\n display = '{size} {fs}'.format(\\n num = partition['Number'],\\n width = width,\\n size = partition['Size'],\\n fs = partition['FileSystem'])\\n\\n if is_bad_partition(partition):\\n # Set display string using partition description & OS type\\n display += '\\\\t\\\\t{q}{name}{q}\\\\t{desc} ({os})'.format(\\n display = display,\\n q = '\\\"' if partition['Name'] != '' else '',\\n name = partition['Name'],\\n desc = partition['Description'],\\n os = partition['OS'])\\n else:\\n # List space used instead of partition description & OS type\\n display += ' (Used: {used})\\\\t{q}{name}{q}'.format(\\n used = partition['Used Space'],\\n q = '\\\"' if partition['Name'] != '' else '',\\n name = partition['Name'])\\n # For all partitions\\n partition['Display String'] = display\",\n \"def parse_partition(partition):\\n partition_data = partition.split(\\\":\\\")\\n if len(partition_data) != 2:\\n raise ValueError(\\\"Partitions line parts format is 'size:mount'\\\")\\n return partition_data\",\n \"def nid2partid(self, nids, ntype): # -> None:\\n ...\",\n \"def nid2partid(self, nids, ntype=...):\\n ...\",\n \"def nid2partid(self, nids, ntype=...):\\n ...\",\n \"def usableparts(self):\\n # First get the partition type-id for all hard disk partitions\\n partid = {}\\n for pline in self.fdiskl():\\n partid[pline[0]] = pline[4]\\n ups = {}\\n for s in self.xlist(\\\"get-blkinfo\\\")[1]:\\n mo = re.match(r'(/dev/[^:]*):(?: LABEL=\\\"([^\\\"]*)\\\")?(?:'\\n ' UUID=\\\"([^\\\"]*)\\\")?(?: TYPE=\\\"([^\\\"]*)\\\")?', s)\\n if mo:\\n dev, label, uuid, fstype = mo.groups()\\n if fstype in (None, \\\"linux_raid_member\\\", \\\"LVM2_member\\\"):\\n continue\\n if dev.startswith(\\\"/dev/loop\\\"):\\n continue\\n rem = None\\n if dev.startswith(\\\"/dev/sd\\\"):\\n if partid.get(dev) == \\\"fd\\\":\\n # This test seems to be necessary because blkid\\n # sometimes returns an fs-type, rather than\\n # linux_raid_member\\\", for the the first device\\n # in a formatted raid array\\n continue\\n rem = self.xlist(\\\"removable\\\", dev)[1][0].strip() == \\\"1\\\"\\n ups[dev] = (fstype, label, uuid, rem)\\n return ups\",\n \"def partition_pair_to_spart(part_pair):\\n part_star = list(part_pair[0])\\n part_circ_star = list(part_pair[1])\\n add_zeros = len(part_circ_star) - len(part_star)\\n if add_zeros != 0:\\n new_star = part_star + [0]\\n else:\\n new_star = part_star\\n diff_list = [a - b for a, b in zip(part_circ_star, new_star)]\\n fermionic_parts = []\\n bosonic_parts = []\\n for k in range(len(diff_list)):\\n if diff_list[k] == 0:\\n bosonic_parts += [part_circ_star[k]]\\n elif diff_list[k] == 1:\\n fermionic_parts += [new_star[k]]\\n else:\\n raise Exception(\\\"This should not happen.\\\")\\n # sparts = Superpartitions()\\n return _Superpartitions([fermionic_parts, bosonic_parts])\",\n \"def newpart(self, device, primary, ncyls, swap=False):\\n # This is a simple partitioning tool, which only supports\\n # adding partitions sequentially, with all primary partitions\\n # being before the extended partition, so once a logical\\n # partition has been added, it is not possible to add further\\n # primary ones.\\n di = DiskInfo(device)\\n pmax = 0 # Record highest partition number\\n lim = -1 # Used for seeking last used cylinder\\n exp = 0 # Number of extended partition\\n ex0, ex1 = 0, -1 # Extended partition start and end\\n log0, log1 = 0, -1 # Start and end of area used by logical partitions\\n for p in di.parts:\\n pn = int(p[0][len(device):])\\n scyl, ecyl = p[1:3]\\n if pn <= 4:\\n if exp:\\n run_error(_(\\\"Not supported: primary partition (%s%d)\\\\n\\\"\\n \\\"has higher partition number than extended \\\"\\n \\\"partition\\\") % (device, pn))\\n return \\\"\\\"\\n if scyl <= lim:\\n run_error(_(\\\"Partitions must be ordered on the device.\\\\n\\\"\\n \\\"%s%d is out of order.\\\") % (device, pn))\\n return \\\"\\\"\\n if p[3] in (\\\"5\\\", \\\"f\\\"):\\n # extended\\n exp = pn\\n ex0, ex1 = scyl, ecyl\\n continue\\n pmax = pn\\n lim = ecyl\\n\\n startcyl = lim + 1\\n endcyl = lim + ncyls\\n if endcyl >= di.drvcyls:\\n run_error(_(\\\"Too little space at end of drive for new partition\\\"))\\n return \\\"\\\"\\n if exp and (pmax <= 4):\\n # Remove the extended partition, which is empty anyway\\n if not self.rmpart(device, exp):\\n return \\\"\\\"\\n pmax = exp - 1\\n if primary:\\n if pmax >= 4:\\n run_error(_(\\\"Cannot add primary partition to %s\\\") % device)\\n return \\\"\\\"\\n t = \\\"primary\\\"\\n else:\\n t = \\\"logical\\\"\\n if pmax > 4:\\n # resize extended partition\\n if not self.xcheck(\\\"resizepart\\\", device, str(exp),\\n str(ex0), str(endcyl),\\n onfail=_(\\\"Couldn't resize extended partition %s%d\\\")\\n % (device, exp)):\\n return False\\n else:\\n # create extended partition\\n if not self.xcheck(\\\"newpart\\\", device,\\n str(startcyl), str(endcyl), \\\"extended\\\",\\n onfail=_(\\\"Couldn't create extended partition on %s\\\")\\n % device):\\n return False\\n if pmax < 4:\\n pmax = 4\\n\\n if self.xcheck(\\\"newpart\\\", device, str(startcyl), str(endcyl),\\n t, \\\"linux-swap\\\" if swap else \\\"ext2\\\"):\\n return \\\"%s%d\\\" % (device, pmax + 1)\\n else:\\n run_error(_(\\\"Couldn't add new partition to %s\\\") % device)\\n return \\\"\\\"\",\n \"def get_partitioning(disk):\\n\\n #TODO\\n return \\\"Unknown\\\"\",\n \"def partition(self):\\n return self.tag(\\\"partition\\\")\",\n \"def _encode_structure(self):\\n pass\",\n \"def _encode_structure(self):\\n pass\",\n \"def _get_partition_list(self):\\n raise NotImplementedError('Must be implemented in subclasses.')\",\n \"def _map_part_plnt(entry):\\n dmt_entry = {}\\n part_type = config.part_type_mapping.get(entry[config.classkey], 'P')\\n\\n dmt_entry['Plant'] = config.plant\\n dmt_entry['PrimWhse'] = config.prim_whse\\n dmt_entry['SourceType'] = part_type\\n\\n return dmt_entry\",\n \"def _make_combinationsTest_label(chain_parts):\\n\\n assert len(chain_parts) == 1\\n scenario = chain_parts[0]['hypoScenario']\\n \\n assert scenario == 'combinationsTest'\\n\\n \\n\\n return \\\"\\\"\\\"\\n combgen(\\n [(2)(20et, 0eta320)]\\n \\n simple([(40et, 0eta320) (50et, 0eta320)])\\n simple([(35et, 0eta240) (55et, 0eta240)])\\n )\\\"\\\"\\\"\",\n \"def get_partition_cfg(partition_type: str) -> Dict:\\n raise NotImplementedError('Not supported yet.')\",\n \"def create(data):\\n \\n return Partlist(\\n list_id = data['id'],\\n name = data['name'],\\n pieces = data['num_parts'])\",\n \"def partition_selection():\\n if selection is None:\\n warning(\\\"You need to pick something first.\\\")\\n return\\n if not selection.obj_type in ['actor','element']:\\n warning(\\\"You need to pick actors or elements.\\\")\\n return\\n for A in GD.canvas.actors:\\n if not A.atype() == 'TriSurface':\\n warning(\\\"Currently I can only partition TriSurfaces.\\\" )\\n return\\n partitionCollection(selection)\\n highlightPartitions(selection)\",\n \"def get_partition_cfg(partition_type: str, **kwargs) -> Dict:\\n raise NotImplementedError\",\n \"def createPartition(self, mp, mtype, fs, size, vg, nr):\\n startSector = 0\\n endSector = 0\\n\\n # primary partition: calculate the space according instructions below\\n if mtype == 'Pri':\\n\\n # calculate the start sector\\n startSector = self.__primaryStartPoint\\n\\n # calculate the end sector\\n sectorLen = startSector + int(size * MEGABYTE / float(self.__sectorSize))\\n endSector = sectorLen - 1\\n self.__primaryStartPoint = sectorLen\\n\\n # decrease disk size\\n self.__diskSize -= size\\n\\n # extended partition: update primary and logical pointers\\n # when a extended partition is given, its size is not taken into account\\n elif mtype == 'Ext':\\n\\n # calculate the start sector\\n startSector = self.__primaryStartPoint\\n\\n # calculate end sector pointer\\n endSector = int(self.__diskSize * MEGABYTE / float(self.__sectorSize)) + startSector - 1\\n if endSector > MAX_SECTOR_POSSIBLE:\\n endSector = MAX_SECTOR_POSSIBLE\\n\\n self.__extEndSector = endSector\\n\\n # decrease disk size\\n self.__diskSize -= EXTENT_SIZE - 1\\n\\n # logical partition: calculate the space according instructions below\\n elif mtype == 'Log':\\n\\n # FIXME, need to improve\\n # just for zkvm without extended partition\\n self.__extEndSector = endSector\\n # refresh start sector pointer\\n startSector = self.__primaryStartPoint + self.__sectorOffset\\n\\n if size == ALL_AVAILABLE:\\n endSector = self.__extEndSector\\n size = self.__diskSize - 1\\n self.__diskSize = 0\\n\\n else: \\n # calculate end sector pointer\\n sectorLen = startSector + int(size * MEGABYTE / float(self.__sectorSize))\\n endSector = sectorLen - 1\\n self.__primaryStartPoint = sectorLen\\n\\n # decrease disk size\\n self.__diskSize -= size\\n\\n\\n part = {}\\n part['command'] = 'create:partition'\\n part['id'] = \\\"%s-part%s\\\" % (self.__diskId, str(nr))\\n part['name'] = self.__disk + str(nr)\\n part['mount_point'] = mp\\n part['type'] = mtype\\n part['fs'] = fs\\n part['multipath'] = self.__hasMultipath\\n part['raid_name'] = None\\n part['disk_name'] = '/dev/%s' % self.__disk\\n part['size'] = size\\n part['vg'] = vg\\n part['nr'] = nr\\n part['format'] = True\\n part['start'] = startSector\\n part['end'] = endSector\\n\\n if self.__hasMultipath:\\n part['disk_name'] = '/dev/mapper/%s' % self.__disk\\n\\n # extended partition: do not format\\n if mtype == 'Ext':\\n part['format'] = False\\n\\n return part\",\n \"def partitionData(data, labels, partition):\\n\\treturn [s[partition] for s in data], labels[partition]\",\n \"def part_id(self):\\n ...\",\n \"def split(self):\\n out = []\\n if self.section != \\\"\\\":\\n out.append(self.section)\\n out.append(self.topic)\\n if self.sub_topic != \\\"\\\":\\n out.append(self.sub_topic)\\n if self.cutter != \\\"\\\":\\n out.append(self.cutter)\\n if self.version != 0:\\n out.append(\\\"v.\\\" + str(self.version))\\n if self.year != 0:\\n out.append(str(self.year) + self.work_letter)\\n if self.other != \\\"\\\":\\n out.append(self.other)\\n if self.copy != 0:\\n out.append(\\\"c.\\\" + str(self.copy))\\n return out\",\n \"def partid(self): # -> None:\\n ...\",\n \"def partition_network(self, *args):\\n Blockade.blockade_create_partition(*args)\",\n \"def assemble_parts(self):\\n self.parts['whole'] = self.output\\n self.parts['encoding'] = self.document.settings.output_encoding\\n self.parts['version'] = docutils.__version__\",\n \"def create_from_segments(self, segment, origin=0):\\r\\n n = origin\\r\\n if segment[origin]['T'] != 'soma': # if it's a soma, only one compartment\\r\\n while (len(segment[n]['children']) == 1) and (segment[n]['T'] != 'soma'): # Go to the end of the branch\\r\\n n += 1\\r\\n # End of branch\\r\\n branch = segment[origin:n + 1]\\r\\n # Set attributes\\r\\n self.diameter, self.length, self.area, self.x, self.y, self.z = \\\\\\r\\n zip(*[(seg['diameter'], seg['length'], seg['area'], seg['x'], seg['y'], seg['z']) for seg in branch])\\r\\n self.diameter, self.length, self.area, self.x, self.y, self.z = array(self.diameter), array(self.length), \\\\\\r\\n array(self.area), array(self.x), array(self.y), array(self.z)\\r\\n self.type = segment[n]['T'] # normally same type for all compartments in the branch\\r\\n # Create children (list)\\r\\n self.children = [Morphology().create_from_segments(segment, origin=c) for c in segment[n]['children']]\\r\\n # Create dictionary of names (enumerates children from number 1)\\r\\n for i, child in enumerate(self.children):\\r\\n self._namedkid[str(i + 1)] = child\\r\\n # Name the child if possible\\r\\n if child.type in ['soma', 'axon', 'dendrite']:\\r\\n if child.type in self._namedkid:\\r\\n self._namedkid[child.type] = None # two children with the same name: erase (see next block)\\r\\n else:\\r\\n self._namedkid[child.type] = child\\r\\n # Erase useless names\\r\\n for k in self._namedkid.keys():\\r\\n if self._namedkid[k] is None:\\r\\n del self._namedkid[k]\\r\\n # If two kids, name them L (left) and R (right)\\r\\n if len(self.children) == 2:\\r\\n self._namedkid['L'] = self._namedkid['1']\\r\\n self._namedkid['R'] = self._namedkid['2']\\r\\n return self\",\n \"def create_partition(mesh,polygons,enforce_exact=False):\",\n \"def get_partname(self):\\n return '{0:03.0f}{1}'.format(self.lon1, self.part)\",\n \"def build_output_partitions(cls, name='inputTablePartitions', output_name='output'):\\n obj = cls(name)\\n obj.exporter = 'get_output_table_partition'\\n obj.output_name = output_name\\n return obj\",\n \"def build_parts(self, simple_sentence, kana_sentence):\\r\\n parts = parse_simple_sentence_into_parts(simple_sentence)\\r\\n \\r\\n remaining_sentence = kana_sentence\\r\\n \\r\\n for i, part in enumerate(parts):\\r\\n if part.kanji:\\r\\n if i+1 == len(parts):\\r\\n part.kana = remaining_sentence\\r\\n else:\\r\\n start_of_next_part = remaining_sentence.find(parts[i+1].kana)\\r\\n part.kana = remaining_sentence[:start_of_next_part]\\r\\n remaining_sentence = remaining_sentence[start_of_next_part:]\\r\\n else:\\r\\n remaining_sentence = remaining_sentence.replace(part.kana, '', 1)\\r\\n \\r\\n return parts\",\n \"def test_create_part(self):\\n pass\",\n \"def make_mixture_info(parts, operation='+'):\\n # type: (List[ModelInfo], str) -> ModelInfo\\n # Build new parameter list\\n combined_pars = []\\n\\n # When creating a mixture model that is a sum of product models (ie (1*2)+(3*4))\\n # the parameters for models 1 & 2 will be prefixed with A & B respectively,\\n # but so will the parameters for models 3 & 4. We need to rename models 3 & 4\\n # so that they are prefixed with C & D to avoid overlap of parameter names.\\n used_prefixes = []\\n for part in parts:\\n if part.composition and part.composition[0] == 'mixture':\\n i = 0\\n for submodel in part.composition[1]:\\n npars = len(submodel.parameters.kernel_parameters)\\n # List of params of one of the constituent models of part\\n submodel_pars = part.parameters.kernel_parameters[i:i+npars]\\n # Prefix of the constituent model\\n prefix = submodel_pars[0].name[0]\\n if prefix not in used_prefixes: # Haven't seen this prefix so far\\n used_prefixes.append(prefix)\\n i += npars\\n continue\\n # TODO: don't modify submodel --- it may be used elsewhere\\n # Existing code probably doesn't keep a handle on the model\\n # parts so its probably okay, but it's possible that a mix\\n # on user defined mixture models models will change the\\n # parameters used for the parts in the GUI. Even worse if the\\n # same plugin is used twice. For example, twosphere.py\\n # contains sphere+sphere and you create twosphere+twosphere.\\n while prefix in used_prefixes:\\n # This prefix has been already used, so change it to the\\n # next letter that hasn't been used\\n prefix = chr(ord(prefix) + 1)\\n used_prefixes.append(prefix)\\n prefix += \\\"_\\\"\\n # Update the parameters of this constituent model to use the\\n # new prefix\\n for par in submodel_pars:\\n # Strip {prefix}_ using par.name[2:], etc.\\n # TODO: fails for AB_scale\\n par.id = prefix + par.id[2:]\\n par.name = prefix + par.name[2:]\\n if par.length_control is not None:\\n par.length_control = prefix + par.length_control[2:]\\n i += npars\\n\\n for part in parts:\\n # Parameter prefix per model, A_, B_, ...\\n # Note that prefix must also be applied to id and length_control\\n # to support vector parameters\\n prefix = ''\\n if not part.composition or part.composition[0] == 'product':\\n # Model isn't a composition model, so its parameters don't have a\\n # a prefix. Add the next available prefix\\n prefix = chr(ord('A')+len(used_prefixes))\\n used_prefixes.append(prefix)\\n prefix += '_'\\n\\n if operation == '+':\\n # If model is a sum model, each constituent model gets its own scale parameter\\n scale_prefix = prefix\\n if prefix == '' and getattr(part, \\\"operation\\\", '') == '*':\\n # `part` is a composition product model. Find the prefixes of\\n # its parameters to form a new prefix for the scale.\\n # For example, a model with A*B*C will have ABC_scale.\\n sub_prefixes = []\\n for param in part.parameters.kernel_parameters:\\n # Prefix of constituent model\\n sub_prefix = param.id.split('_')[0]\\n if sub_prefix not in sub_prefixes:\\n sub_prefixes.append(sub_prefix)\\n # Concatenate sub_prefixes to form prefix for the scale\\n scale_prefix = ''.join(sub_prefixes) + '_'\\n scale = Parameter(scale_prefix + 'scale', default=1.0,\\n description=\\\"model intensity for \\\" + part.name)\\n combined_pars.append(scale)\\n for p in part.parameters.kernel_parameters:\\n p = copy(p)\\n p.name = prefix + p.name\\n p.id = prefix + p.id\\n if p.length_control is not None:\\n p.length_control = prefix + p.length_control\\n combined_pars.append(p)\\n parameters = ParameterTable(combined_pars)\\n # Allow for the scenario in which each component has all its PD parameters\\n # active simultaneously. details.make_details() will throw an error if\\n # too many are used from any one component.\\n parameters.max_pd = sum(part.parameters.max_pd for part in parts)\\n\\n def random():\\n \\\"\\\"\\\"Random set of model parameters for mixture model\\\"\\\"\\\"\\n combined_pars = {}\\n for k, part in enumerate(parts):\\n prefix = chr(ord('A')+k) + '_'\\n pars = part.random()\\n combined_pars.update((prefix+k, v) for k, v in pars.items())\\n return combined_pars\\n\\n model_info = ModelInfo()\\n model_info.id = operation.join(part.id for part in parts)\\n model_info.operation = operation\\n model_info.name = '(' + operation.join(part.name for part in parts) + ')'\\n model_info.filename = None\\n model_info.title = 'Mixture model with ' + model_info.name\\n model_info.description = model_info.title\\n model_info.docs = model_info.title\\n model_info.category = \\\"custom\\\"\\n model_info.parameters = parameters\\n model_info.random = random\\n #model_info.single = any(part['single'] for part in parts)\\n model_info.structure_factor = False\\n #model_info.tests = []\\n #model_info.source = []\\n # Remember the component info blocks so we can build the model\\n model_info.composition = ('mixture', parts)\\n return model_info\",\n \"def create_net_partition(self, body=None):\\r\\n return self.post(self.net_partitions_path, body=body)\",\n \"def list_partitions(self, partitioning):\\n return []\",\n \"def gen_partition_statement(partition_tuples, target_root, run_id=None):\\n if run_id is not None:\\n partition_tuples = [('run_id', run_id)] + partition_tuples\\n # todo: part_a1, part_a2, part_b, part_c, part_what? you lost me.\\n part_a1 = \\\", \\\".join(\\n [\\\"{label}='{value}'\\\".format(label=i[0], value=i[1]) for i in partition_tuples]\\n )\\n part_a2 = \\\"/\\\".join(\\n [\\\"{label}={value}\\\".format(label=i[0], value=i[1]) for i in partition_tuples]\\n )\\n part_b = \\\"partition ({partitions_str})\\\".format(partitions_str=part_a1)\\n part_c = \\\"location '{location}'\\\".format(location=os.path.join(target_root, part_a2))\\n return part_b + ' ' + part_c\",\n \"def get_partition(self, partid):\\n #TODO(zhengda) add implementation later.\",\n \"def get_partition(self, partid):\\n #TODO(zhengda) add implementation later.\",\n \"def set_partition(self, partition=0):\\n if not isinstance(partition, int):\\n raise TypeError('partition must be an integer')\\n if partition <= 0:\\n raise ValueError('partition must be positive')\\n if self.connected:\\n self.producer.send(\\\"PART:\\\"+str(partition))\",\n \"def do_prepare_partition(cls, part, source_params, creator, cr_workdir,\\n oe_builddir, bootimg_dir, kernel_dir, rootfs_dir,\\n native_sysroot):\\n logger.debug(\\\"SourcePlugin: do_prepare_partition: part: %s\\\", part)\",\n \"def partition_description(self) -> pulumi.Output[Optional[Any]]:\\n return pulumi.get(self, \\\"partition_description\\\")\",\n \"def names_to_parts(self, pnames, must_exist=True):\\n meta = self.mesh.meta\\n for pname in pnames:\\n part = meta.get_part(pname, must_exist)\\n yield part\",\n \"def do_stage_partition(cls, part, source_params, creator, cr_workdir,\\n oe_builddir, bootimg_dir, kernel_dir,\\n native_sysroot):\\n logger.debug(\\\"SourcePlugin: do_stage_partition: part: %s\\\", part)\",\n \"def defineTasks(self,partition):\\n recv_slots = partition.recvSlices()\\n strm_slots = partition.streamSlices()\\n recvNodes = partition.recvNodesFromSlots()\\n strmNodes = partition.streamNodesFromSlots()\\n opt = '/'+self.manager.hostName()+'/'+partition.manager.name()+'/'+partition.name+'/'\\n cl0 = '/Class0'+opt\\n cl1 = '/Class1'+opt\\n\\n partition.setDataSources([])\\n tasks = []\\n pn = self.partitionName()\\n print '---------------------- Partition name is:',pn\\n for i in xrange(len(recv_slots)):\\n slot = recv_slots[i]\\n node = slot[:slot.find(':')]\\n sub_farm = 'SF%02d'%(i,)\\n short_name = sub_farm+'_SND' # Keep this name to ensure storageMon is working!\\n task = pn+'_'+node+'_'+short_name\\n tasks.append(node+'/'+task+'/'+short_name+'/RecStorageSend'+cl1+'(\\\"'+sub_farm+'\\\",'+str(i)+',)')\\n partition.setRecvSenders(tasks)\\n tasks = []\\n for i in xrange(len(strm_slots)):\\n slot = strm_slots[i]\\n node = slot[:slot.find(':')]\\n sub_farm = 'SF%02d'%(i,)\\n short_name = sub_farm+'_HLT' # Keep this name to ensure storageMon is working!\\n task = pn+'_'+node+'_'+short_name\\n tasks.append(node+'/'+task+'/'+short_name+'/RecStorageRecv'+cl1+'(\\\"'+sub_farm+'\\\",'+str(i)+',)')\\n partition.setStreamReceivers(tasks)\\n cnt = 0\\n tasks = []\\n infra = []\\n for j in recvNodes:\\n for itm in self.rcvInfra.data:\\n i,cl=itm.split('/')\\n infra.append(j+'/'+pn+'_'+j+'_'+i+'/'+i+'/'+i+'/'+cl+opt+'(\\\"'+str(cnt)+'\\\",)')\\n cnt = cnt + 1\\n partition.setRecvInfrastructure(infra)\\n partition.setRecvReceivers(tasks)\\n cnt = 0\\n tasks = []\\n infra = []\\n for j in strmNodes:\\n for itm in self.strInfra.data:\\n i,cl=itm.split('/')\\n infra.append(j+'/'+pn+'_'+j+'_'+i+'/'+i+'/'+i+'/'+cl+opt+'(\\\"'+str(cnt)+'\\\",)')\\n cnt = cnt + 1\\n partition.setStreamInfrastructure(infra)\\n partition.setStreamSenders(tasks)\\n if partition.saveTasks():\\n tasks = partition.collectTasks(tasks={},with_data_sources=0)\\n return tasks\\n return None\",\n \"def to_partid(self, id_tensor):\\n ...\",\n \"def test_splitPartiesOnlyOneParty(self):\\n parties_str = \\\"Applicant Tenant(s): Tabata A, Caio N\\\"\\n expected = {\\n \\\"applicant\\\": [{\\\"role\\\": \\\"tenant\\\", \\\"name\\\": \\\"tabata a\\\"},\\n {\\\"role\\\": \\\"tenant\\\", \\\"name\\\": \\\"caio n\\\"}],\\n \\\"respondent\\\": []\\n }\\n result = split_parties.splitCaseParties('adjudication', parties_str)\\n self.assertEqual(expected, result)\",\n \"def export_part_list(self, filetype='xlsx'):\\n if filetype == 'csv':\\n enum = 48649\\n else:\\n enum = 48642\\n path = self.export_dir.joinpath(self.partcode).joinpath('part_list.xlsx')\\n self.doc.Sheets(1).PartsLists(1).Export(str(path), enum)\",\n \"def do_configure_partition(cls, part, source_params, creator, cr_workdir,\\n oe_builddir, bootimg_dir, kernel_dir,\\n native_sysroot):\\n logger.debug(\\\"SourcePlugin: do_configure_partition: part: %s\\\", part)\",\n \"def get_partition_info(disk, host_disk):\\n\\n volume = \\\"/dev/\\\"+disk\\n DISKINFO[volume] = {}\\n DISKINFO[volume][\\\"Name\\\"] = volume\\n DISKINFO[volume][\\\"Type\\\"] = \\\"Partition\\\"\\n DISKINFO[volume][\\\"HostDevice\\\"] = host_disk\\n DISKINFO[volume][\\\"Partitions\\\"] = []\\n DISKINFO[host_disk][\\\"Partitions\\\"].append(volume)\\n DISKINFO[volume][\\\"Vendor\\\"] = get_vendor(disk)\\n DISKINFO[volume][\\\"Product\\\"] = \\\"Host Device: \\\"+DISKINFO[host_disk][\\\"Product\\\"]\\n DISKINFO[volume][\\\"RawCapacity\\\"], DISKINFO[volume][\\\"Capacity\\\"] = get_capacity()\\n DISKINFO[volume][\\\"Description\\\"] = get_description(disk)\\n DISKINFO[volume][\\\"Flags\\\"] = get_capabilities(disk)\\n DISKINFO[volume][\\\"FileSystem\\\"] = get_file_system(disk)\\n DISKINFO[volume][\\\"Partitioning\\\"] = \\\"N/A\\\"\\n DISKINFO[volume][\\\"UUID\\\"] = get_uuid(disk)\\n DISKINFO[volume][\\\"ID\\\"] = get_id(disk)\\n DISKINFO[volume][\\\"BootRecord\\\"], DISKINFO[volume][\\\"BootRecordStrings\\\"] = get_boot_record(disk)\\n\\n return volume\",\n \"def fillQuickList():\\n global quickList\\n cmd = \\\"/sbin/blkid\\\"\\n proc = subprocess.Popen(cmd.split(), stdout=subprocess.PIPE)\\n for line in proc.stdout:\\n line = line.replace(':', '').strip()\\n propList = line.split()\\n devName = label = uuid = fsType = ''\\n devName = propList[0]\\n for property in propList:\\n if property.startswith('UUID'):\\n uuid = property.replace('UUID=', '').replace('\\\"', '')\\n quickList[devName] = uuid\",\n \"def getPartitionNameByUUID(part):\\n global quickList\\n part = part.replace('UUID=', '')\\n if len(quickList) == 0:\\n fillQuickList()\\n for devName, uuid in quickList.items():\\n if uuid == part:\\n return devName\\n return ''\",\n \"def test_get_parts(self):\\n pass\",\n \"def genereate_echo_picklist(self):\\n sample_names = []\\n sample_wells = []\\n indices = {'i5 name': {}, 'i5 plate': {}, 'i5 sequence': {},\\n 'i5 well': {}, 'i7 name': {}, 'i7 plate': {},\\n 'i7 sequence': {}, 'i7 well': {}, 'index combo': {},\\n 'index combo seq': {}}\\n\\n for idx, well in enumerate(chain.from_iterable(self.plates[0].layout)):\\n # Add the sample well\\n sample_wells.append(well.well_id)\\n # Get the sample name - we need to go back to the SampleComposition\\n lib_comp = well.composition\\n sample_comp = lib_comp.normalized_gdna_composition\\\\\\n .gdna_composition.sample_composition\\n sample_names.append(sample_comp.content)\\n # Retrieve all the information about the indices\\n i5_comp = lib_comp.i5_composition.primer_set_composition\\n i5_well = i5_comp.container\\n indices['i5 name'][idx] = i5_comp.external_id\\n indices['i5 plate'][idx] = i5_well.plate.external_id\\n indices['i5 sequence'][idx] = i5_comp.barcode\\n indices['i5 well'][idx] = i5_well.well_id\\n\\n i7_comp = lib_comp.i7_composition.primer_set_composition\\n i7_well = i7_comp.container\\n indices['i7 name'][idx] = i7_comp.external_id\\n indices['i7 plate'][idx] = i7_well.plate.external_id\\n indices['i7 sequence'][idx] = i7_comp.barcode\\n indices['i7 well'][idx] = i7_well.well_id\\n\\n indices['index combo seq'][idx] = '%s%s' % (\\n indices['i5 sequence'][idx], indices['i7 sequence'][idx])\\n\\n sample_names = np.asarray(sample_names)\\n sample_wells = np.asarray(sample_wells)\\n indices = pd.DataFrame(indices)\\n\\n return LibraryPrepShotgunProcess._format_picklist(\\n sample_names, sample_wells, indices)\",\n \"def process_new_subpart(notice, amd_label, par):\\n subpart_changes = {}\\n subpart_xml = find_subpart(par)\\n subpart = reg_text.build_subpart(amd_label.label[0], subpart_xml)\\n\\n for change in changes.create_subpart_amendment(subpart):\\n subpart_changes.update(change)\\n return subpart_changes\",\n \"def partition(self) -> pulumi.Output[Optional[str]]:\\n return pulumi.get(self, \\\"partition\\\")\",\n \"def __get_partition__(self, account, container, obj, part_shift):\\n \\n key = hash_path(account, container, obj, raw_digest=True)\\n part = unpack_from('>I', key)[0] >> part_shift\\n return part\",\n \"def get_partfstype(self, part):\\n t = self.xlist(\\\"get-blkinfo\\\", part, \\\"TYPE\\\")\\n return t[1][0] if t[0] and (len(t[1]) != 0) else \\\"\\\"\",\n \"def insert_parts(self, parts):\\r\\n self.board.insert_parts(parts)\\r\\n self.set_changed(parts)\",\n \"def __init__(self, section, config):\\n self.disk = section.getSectionName()\\n\\n # Grab our partition map\\n # If it doesn't exist, complain loudly\\n self.diskLabelConfig = None\\n for map in config.Partitions.PartitionMap:\\n if (section.partitionmap.lower() == map.getSectionName()):\\n # Set up the disk labels. Always s1!\\n self.diskLabelConfig = DiskLabelConfig(map, self.disk + 's1')\\n break\",\n \"def chainDict2jetLabel(chain_dict):\\n\\n # suported scenarios \\n router = {\\n 'simple': _make_simple_label,\\n 'HT': _make_ht_label,\\n 'vbenf': _make_vbenf_label,\\n 'dijet': _make_dijet_label,\\n 'combinationsTest': _make_combinationsTest_label,\\n 'partitionsTest': _make_partitionsTest_label,\\n }\\n\\n # chain_part - scenario association\\n cp_sorter = {}\\n for k in router: cp_sorter[k] = []\\n\\n for cp in chain_dict['chainParts']:\\n if cp['signature'] != 'Jet' and cp['signature'] != 'Bjet': \\n continue\\n for k in cp_sorter:\\n if cp['hypoScenario'].startswith(k):\\n cp_sorter[k].append(cp)\\n break\\n\\n # obtain labels by scenario.\\n labels = []\\n for k, chain_parts in cp_sorter.items():\\n if chain_parts: labels.append(router[k](chain_parts))\\n\\n assert labels\\n nlabels = len(labels)\\n if nlabels == 1: return labels[0]\\n if nlabels == 2:\\n alabel = \\\"\\\"\\\"\\\\\\nand([]\\n %s\\n %s)\\\"\\\"\\\" % (tuple(labels))\\n return alabel\\n\\n # more than 2 labels is not expected\\n assert False\",\n \"def partid(self): # -> int:\\n ...\",\n \"def convert_partitions_to_list(partition):\\n parts = list()\\n for part in partition:\\n parts.append(part)\\n return parts\",\n \"def nodeSeparate(self,compInfo, ifSub, subname, subcktName,numNodesSub):\\n node = []\\n nodeTemp = []\\n nodeDic = {}\\n pinInit = 'Modelica.Electrical.Analog.Interfaces.Pin '\\n pinProtectedInit = 'Modelica.Electrical.Analog.Interfaces.Pin '\\n protectedNode = []\\n print \\\"CompInfo coming to nodeSeparate function: compInfo\\\",compInfo\\n \\n #Removing '[' and ']' from compInfo for Digital node\\n for i in range(0,len(compInfo),1):\\n compInfo[i] = compInfo[i].replace(\\\"[\\\",\\\"\\\").replace(\\\"]\\\",\\\"\\\")\\n \\n \\n for eachline in compInfo:\\n words = eachline.split()\\n if eachline[0] in ['m', 'e', 'g', 't','M','E','G','T']:\\n nodeTemp.append(words[1])\\n nodeTemp.append(words[2])\\n nodeTemp.append(words[3])\\n nodeTemp.append(words[4])\\n elif eachline[0] in ['q', 'j','J','Q']:\\n nodeTemp.append(words[1])\\n nodeTemp.append(words[2])\\n nodeTemp.append(words[3])\\n elif eachline[0]=='x' or eachline[0]=='X':\\n templine = eachline.split()\\n for i in range(0,len(templine),1):\\n if templine[i] in subcktName:\\n point = i \\n nodeTemp.extend(words[1:point])\\n else:\\n nodeTemp.append(words[1])\\n nodeTemp.append(words[2])\\n for i in nodeTemp:\\n if i not in node:\\n node.append(i)\\n \\n for i in range(0, len(node),1):\\n nodeDic[node[i]] = 'n' + node[i]\\n if ifSub == '0':\\n if i != len(node)-1:\\n pinInit = pinInit + nodeDic[node[i]] + ', '\\n else:\\n pinInit = pinInit + nodeDic[node[i]]\\n else:\\n nonprotectedNode = self.getSubInterface(subname, numNodesSub) \\n if node[i] in nonprotectedNode:\\n continue\\n else:\\n protectedNode.append(node[i])\\n if ifSub == '1':\\n if len(nonprotectedNode) > 0:\\n for i in range(0, len(nonprotectedNode),1):\\n if i != len(nonprotectedNode)-1:\\n pinProtectedInit = pinProtectedInit + nodeDic[nonprotectedNode[i]] + ','\\n else:\\n pinProtectedInit = pinProtectedInit + nodeDic[nonprotectedNode[i]]\\n if len(protectedNode) > 0:\\n for i in range(0, len(protectedNode),1):\\n if i != len(protectedNode)-1: \\n pinInit = pinInit + nodeDic[protectedNode[i]] + ','\\n else:\\n pinInit = pinInit + nodeDic[protectedNode[i]]\\n pinInit = pinInit + ';'\\n pinProtectedInit = pinProtectedInit + ';'\\n print \\\"Node---->\\\",node\\n print \\\"nodeDic----->\\\",nodeDic\\n print \\\"PinInit----->\\\",pinInit\\n print \\\"pinProtectedinit--->\\\",pinProtectedInit\\n return node, nodeDic, pinInit, pinProtectedInit\",\n \"def get_partition_details(disk, partition):\\n details = {}\\n script = [\\n 'select disk {}'.format(disk['Number']),\\n 'select partition {}'.format(partition['Number']),\\n 'detail partition']\\n\\n # Diskpart details\\n try:\\n # Run script\\n result = run_diskpart(script)\\n except subprocess.CalledProcessError:\\n pass\\n else:\\n # Get volume letter or RAW status\\n output = result.stdout.decode().strip()\\n tmp = re.search(r'Volume\\\\s+\\\\d+\\\\s+(\\\\w|RAW)\\\\s+', output)\\n if tmp:\\n if tmp.group(1).upper() == 'RAW':\\n details['FileSystem'] = RAW\\n else:\\n details['Letter'] = tmp.group(1)\\n # Remove empty lines from output\\n tmp = [s.strip() for s in output.splitlines() if s.strip() != '']\\n # Split each line on ':' skipping those without ':'\\n tmp = [s.split(':') for s in tmp if ':' in s]\\n # Add key/value pairs to the details variable and return dict\\n details.update({key.strip(): value.strip() for (key, value) in tmp})\\n\\n # Get MBR type / GPT GUID for extra details on \\\"Unknown\\\" partitions\\n guid = PARTITION_UIDS.get(details.get('Type').upper(), {})\\n if guid:\\n details.update({\\n 'Description': guid.get('Description', '')[:29],\\n 'OS': guid.get('OS', 'Unknown')[:27]})\\n\\n if 'Letter' in details:\\n # Disk usage\\n try:\\n tmp = psutil.disk_usage('{}:\\\\\\\\'.format(details['Letter']))\\n except OSError as err:\\n details['FileSystem'] = 'Unknown'\\n details['Error'] = err.strerror\\n else:\\n details['Used Space'] = human_readable_size(tmp.used)\\n\\n # fsutil details\\n cmd = [\\n 'fsutil',\\n 'fsinfo',\\n 'volumeinfo',\\n '{}:'.format(details['Letter'])\\n ]\\n try:\\n result = run_program(cmd)\\n except subprocess.CalledProcessError:\\n pass\\n else:\\n output = result.stdout.decode().strip()\\n # Remove empty lines from output\\n tmp = [s.strip() for s in output.splitlines() if s.strip() != '']\\n # Add \\\"Feature\\\" lines\\n details['File System Features'] = [s.strip() for s in tmp\\n if ':' not in s]\\n # Split each line on ':' skipping those without ':'\\n tmp = [s.split(':') for s in tmp if ':' in s]\\n # Add key/value pairs to the details variable and return dict\\n details.update({key.strip(): value.strip() for (key, value) in tmp})\\n\\n # Set Volume Name\\n details['Name'] = details.get('Volume Name', '')\\n\\n # Set FileSystem Type\\n if details.get('FileSystem', '') not in ['RAW', 'Unknown']:\\n details['FileSystem'] = details.get('File System Name', 'Unknown')\\n\\n return details\",\n \"def test_splitPartiesStringWithoutDivider(self):\\n parties_str = \\\"Appellant: Denise O'B Respondent: Eugene D, Mary C\\\"\\n expected = {\\n \\\"applicant\\\": [{\\\"name\\\": \\\"denise o'b\\\"}],\\n \\\"respondent\\\": [{\\\"name\\\": \\\"eugene d\\\"},\\n {\\\"name\\\": \\\"mary c\\\"}]\\n }\\n result = split_parties.splitCaseParties(\\\"tribunal\\\", parties_str)\\n self.assertEqual(expected, result)\",\n \"def voices_in_part (part):\\n part.interpret ()\\n part.extract_voices ()\\n voices = part.get_voices ()\\n part_info = part.get_staff_attributes ()\\n\\n return (voices, part_info)\",\n \"def __init__(self, *elems, **kwargs) -> None:\\r\\n self.sequence = tuple(kwargs['partition']) if kwargs.get('partition') else elems\",\n \"def partition_book(self):\\n ...\",\n \"def _record_specific_partition(r_d, numnodes, cur):\\n # No partitioning has been specified. Create the appropriate entries.\\n if r_d['partmtd'] == 0:\\n for i in range(1, numnodes + 1):\\n Database.execute(cur, 'UPDATE dtables '\\n 'SET partmtd = 0 '\\n 'WHERE nodeid = ? AND tname = ?',\\n ErrorHandle.raise_handler, (i, r_d['tname']))\\n\\n # Range partitioning has been specified. Create the appropriate entries.\\n elif r_d['partmtd'] == 1:\\n for i in range(1, numnodes + 1):\\n Database.execute(cur, 'UPDATE dtables '\\n 'SET partcol = ?, partparam1 = ?, '\\n 'partparam2 = ?, partmtd = 1 '\\n 'WHERE nodeid = ? AND tname = ?',\\n ErrorHandle.raise_handler,\\n (r_d['partcol'], r_d['param1'][i - 1], r_d['param2'][i - 1], i,\\n r_d['tname']))\\n\\n # Hash partitioning has been specified. Create the appropriate entries.\\n elif r_d['partmtd'] == 2:\\n for i in range(1, numnodes + 1):\\n Database.execute(cur, 'UPDATE dtables '\\n 'SET partcol = ?, partparam1 = ?, partmtd = 2 '\\n 'WHERE nodeid = ? AND tname = ?',\\n ErrorHandle.raise_handler,\\n (r_d['partcol'], r_d['param1'], i, r_d['tname']))\",\n \"def get_body_part_names(self):\\n self.x_cols, self.y_cols, self.p_cols = [], [], []\\n for bp in self.body_parts_lst:\\n self.x_cols.append(f\\\"{bp}_x\\\")\\n self.y_cols.append(f\\\"{bp}_y\\\")\\n self.p_cols.append(f\\\"{bp}_p\\\")\",\n \"def on_add_clicked(self,button):\\n\\t\\tself.list_partitions.add_partition()\",\n \"def true_partition(self):\\n if 'NA' in self.mothers or 'NA' in self.fathers:\\n warn('Warning: one or more individuals has at least one parent of unkown identity.')\\n warn('All such individuals will be assigned to the same sibship group.')\\n\\n # concatenate mother and father names to create a vector of parent pairs.\\n #parentage = np.array([str(self.mothers[o]) + '/' + str(self.fathers[o]) for o in range(noffs)])\\n possible_families = np.unique(self.parents) # get a list of all unique parent pairs\\n\\n partitions = np.zeros(self.size).astype('int') # empty vector of zeros.\\n for o in range(self.nfamilies):\\n # for every possible family label individuals with an identical integer.\\n partitions[self.parents == possible_families[o]] += o\\n\\n return partitions\",\n \"def mkswap(self, partition, check):\\n args = [partition]\\n if check:\\n args.insert(0, \\\"-c\\\")\\n return self.xlist(\\\"swap-format\\\", *args)[0]\",\n \"def partid2nids(self, partid):\\n return self._partid2nids[partid]\",\n \"def label_block_get_serializer(get_info):\\n serializer = sl_mpls_pb2.SLMplsLabelBlockGetMsg()\\n if \\\"start_label\\\" in get_info:\\n serializer.Key.StartLabel = get_info[\\\"start_label\\\"]\\n if \\\"block_size\\\" in get_info:\\n serializer.Key.LabelBlockSize = get_info[\\\"block_size\\\"]\\n if \\\"count\\\" in get_info:\\n serializer.EntriesCount = get_info[\\\"count\\\"]\\n if \\\"get_next\\\" in get_info:\\n serializer.GetNext = (get_info[\\\"get_next\\\"] != 0)\\n return serializer\",\n \"def probe(self):\\n log_method_call(self, self.name, exists=self.exists)\\n if not self.exists or not self.disklabelSupported:\\n return\\n\\n self._size = Size(self.partedPartition.getLength(unit=\\\"B\\\"))\\n self.targetSize = self._size\\n\\n self._partType = self.partedPartition.type\\n\\n self._bootable = self.getFlag(parted.PARTITION_BOOT)\",\n \"def draw_partition(self, box, context, bounding_box):\\n assert self.canvas\\n\\n cr = context.cairo\\n cr.set_line_width(box.style(\\\"line-width\\\"))\\n\\n if self.subject and not self.subject.isDimension and self._toplevel:\\n cr.move_to(0, 0)\\n cr.line_to(bounding_box.width, 0)\\n\\n h = self._header_size[1]\\n\\n # draw outside lines if this item is toplevel partition\\n if self._toplevel:\\n cr.move_to(0, bounding_box.height)\\n cr.line_to(0, h)\\n cr.line_to(bounding_box.width, h)\\n cr.line_to(bounding_box.width, bounding_box.height)\\n\\n if self._subpart:\\n # header line for all subparitions\\n hd = h + self._hdmax\\n cr.move_to(0, hd)\\n cr.line_to(bounding_box.width, hd)\\n\\n if self._subpart:\\n # draw inside lines for all children but last one\\n dp = 0\\n for sl in self.canvas.get_children(self)[:-1]:\\n dp += sl.width\\n cr.move_to(dp, h)\\n cr.line_to(dp, bounding_box.height)\\n\\n cr.stroke()\\n\\n if context.hovered or context.dropzone:\\n cr.save()\\n cr.set_dash((1.0, 5.0), 0)\\n cr.set_line_width(1.0)\\n cr.rectangle(0, 0, bounding_box.width, bounding_box.height)\\n draw_highlight(context)\\n cr.stroke()\\n cr.restore()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.65343463","0.53522164","0.52719545","0.52471644","0.51894504","0.5177348","0.5096431","0.5087608","0.4973218","0.4973218","0.4970022","0.4951215","0.49493623","0.49468526","0.49310818","0.492718","0.49157664","0.49112102","0.49103266","0.48851392","0.4877146","0.48584715","0.48566926","0.48450437","0.48346877","0.482512","0.4820094","0.4820094","0.47875524","0.47756955","0.47598547","0.47330543","0.47265384","0.4719906","0.4719906","0.46988344","0.46983254","0.46896246","0.46693867","0.46632653","0.46558505","0.46128348","0.46121785","0.46105745","0.46092212","0.46080282","0.46048173","0.4574543","0.45707077","0.45687282","0.45561484","0.45477712","0.45349917","0.4528485","0.4522739","0.45122588","0.44895494","0.44875002","0.44862923","0.44753525","0.44753525","0.4475197","0.446557","0.44547406","0.4451641","0.44513708","0.44402844","0.4428629","0.44193205","0.44138128","0.44039822","0.43905866","0.43837956","0.43809974","0.4378019","0.43777174","0.43745434","0.43745103","0.4366638","0.4362995","0.43581665","0.4347518","0.43441078","0.4343912","0.43435016","0.43427646","0.43418676","0.43268716","0.43181443","0.4316197","0.43119234","0.43058017","0.43017617","0.42950252","0.42902675","0.42888504","0.4285727","0.4285506","0.42787486","0.42769438"],"string":"[\n \"0.65343463\",\n \"0.53522164\",\n \"0.52719545\",\n \"0.52471644\",\n \"0.51894504\",\n \"0.5177348\",\n \"0.5096431\",\n \"0.5087608\",\n \"0.4973218\",\n \"0.4973218\",\n \"0.4970022\",\n \"0.4951215\",\n \"0.49493623\",\n \"0.49468526\",\n \"0.49310818\",\n \"0.492718\",\n \"0.49157664\",\n \"0.49112102\",\n \"0.49103266\",\n \"0.48851392\",\n \"0.4877146\",\n \"0.48584715\",\n \"0.48566926\",\n \"0.48450437\",\n \"0.48346877\",\n \"0.482512\",\n \"0.4820094\",\n \"0.4820094\",\n \"0.47875524\",\n \"0.47756955\",\n \"0.47598547\",\n \"0.47330543\",\n \"0.47265384\",\n \"0.4719906\",\n \"0.4719906\",\n \"0.46988344\",\n \"0.46983254\",\n \"0.46896246\",\n \"0.46693867\",\n \"0.46632653\",\n \"0.46558505\",\n \"0.46128348\",\n \"0.46121785\",\n \"0.46105745\",\n \"0.46092212\",\n \"0.46080282\",\n \"0.46048173\",\n \"0.4574543\",\n \"0.45707077\",\n \"0.45687282\",\n \"0.45561484\",\n \"0.45477712\",\n \"0.45349917\",\n \"0.4528485\",\n \"0.4522739\",\n \"0.45122588\",\n \"0.44895494\",\n \"0.44875002\",\n \"0.44862923\",\n \"0.44753525\",\n \"0.44753525\",\n \"0.4475197\",\n \"0.446557\",\n \"0.44547406\",\n \"0.4451641\",\n \"0.44513708\",\n \"0.44402844\",\n \"0.4428629\",\n \"0.44193205\",\n \"0.44138128\",\n \"0.44039822\",\n \"0.43905866\",\n \"0.43837956\",\n \"0.43809974\",\n \"0.4378019\",\n \"0.43777174\",\n \"0.43745434\",\n \"0.43745103\",\n \"0.4366638\",\n \"0.4362995\",\n \"0.43581665\",\n \"0.4347518\",\n \"0.43441078\",\n \"0.4343912\",\n \"0.43435016\",\n \"0.43427646\",\n \"0.43418676\",\n \"0.43268716\",\n \"0.43181443\",\n \"0.4316197\",\n \"0.43119234\",\n \"0.43058017\",\n \"0.43017617\",\n \"0.42950252\",\n \"0.42902675\",\n \"0.42888504\",\n \"0.4285727\",\n \"0.4285506\",\n \"0.42787486\",\n \"0.42769438\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6581646"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":8786,"cells":{"query":{"kind":"string","value":"Marshal information deom the selected chainParts to create a"},"document":{"kind":"string","value":"def _make_simple_comb_label(chain_dict):\n\n cps = chain_dict['chainParts']\n if not (_select_simple_chainparts(cps)):\n raise NotImplementedError(\n 'chain fails substring selection: not \"simple\": %s' % (\n chain_dict['chainName']))\n \n simple_strs = []\n\n for cp in cps:\n print(cp)\n simple_strs.append(_make_simple_label([cp]))\n\n label = 'combgen([(%d)]' % len(cps)\n for s in simple_strs:\n label += ' %s ' % s\n label += ')'\n return label"},"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 makeBinaryChains():\n\t\n\t# retrieve the binding partner specifications\n\t(maxsize,types) = getTypes()\n\t\n\t# Do some basic argument checking for this model\n\tif (len(types) < 2):\n\t\tprint \"Number of defined types must equal two for binary chain calculations.\"\n\t\treturn\n\tif (maxsize == 0):\n\t\tprint \"Must specify a valid maximum number for one or more components.\"\n\t\treturn\n\n\tallChains = []\n\tnewChainsA = [[]]\n\tnewChainsB = []\n\t\n\ttypeA = types[0]\n\ttypeB = types[1]\n\t\n\t# start the chain with a single type A component\n\taddComponent(newChainsA[0],typeA,0,0)\n\n\tdepth = 0\n\tfor n in range(maxsize):\n\t\tdepth+=1\n\t\t\n\t\t# go through all the chains created last iteration and append B components\n\t\tnewChainsB = []\n\t\tfor thisChain in newChainsA:\n\n\t\t\t# get a list of new available sites in the provided chain\n\t\t\t# by setting depth -1, we will only add to components added last round\n\t\t\topenSites = makeSiteList(thisChain,typeB,depth-1)\n\t\t\t\n\t\t\t# make all the descendants from the current chain and append them to the pool\n\t\t\tif (n == 0) and (typeA['sym']): #if the starting binder is symmetric, no need to start chains at all its sites\n\t\t\t\tnewChainsB = newChainsB + fillSites(openSites,thisChain,typeB,-1)\n\t\t\telse:\n\t\t\t\tnewChainsB = newChainsB + fillSites(openSites,thisChain,typeB,depth)\n\t\t\n\t\tprint('n:'+str(n)+', '+str(len(newChainsB))+ ' chains created at depth '+str(depth))\n\t\t\n\t\tallChains = allChains + newChainsB\n\t\t\n\t\tdepth+=1\n\t\t\n\t\t# add an additional component to all the previously modified chains\n\t\tnewChainsA = []\n\t\tfor thisChain in newChainsB:\n\n\t\t\topenSites = makeSiteList(thisChain,typeA,depth-1)\n\t\t\tnewChainsA = newChainsA + fillSites(openSites,thisChain,typeA,depth)\n\t\t\t\n\t\tprint('n:'+str(n)+', '+str(len(newChainsA))+ ' chains created at depth '+str(depth))\n\t\t\n\t\tallChains = allChains + newChainsA\n\n\treturn allChains","def serialize(self):\n return pickle.dumps([block.serialize() for block in self.chain])","def _encode_structure(self):\n pass","def _encode_structure(self):\n pass","def marshal(self):\n ...","def add_chain_to_model(chain, model, atoms):\n\n if chain[\"type\"] == \"polymer\" or chain[\"type\"] == \"branched\":\n polymer = {\n \"internal_id\": chain[\"internal_id\"], \"sequence\": chain[\"sequence\"],\n \"helices\": [], \"strands\": [], \"residues\": {}\n }\n for i, group in enumerate(chain[\"groups\"], start=1):\n add_het_to_dict(group, chain, atoms, polymer[\"residues\"], number=i)\n add_ss_to_chain(polymer)\n model[\"polymer\"][chain[\"id\"]] = polymer\n else:\n for group in chain[\"groups\"]:\n add_het_to_dict(group, chain, atoms, model[chain[\"type\"]])","def __rechaindict__(c):\n from TriggerMenu.menu.DictFromChainName import DictFromChainName\n dfcn = DictFromChainName()\n\n pl1 = []\n for pch in c['chainParts']:\n pl1.append(pch['L1item'])\n\n newname = c['chainName'].replace('dv_','').replace('TestChain','j')\n nchlist = [ newname ,c['chainCounter'],c['L1item'],pl1,c['stream'],\n c['groups'],c['EBstep'] ]\n \n return dfcn.getChainDict(nchlist)","def _serialise(self):\n # TODO (M Foley)\n pass","def pack(self):\n data = {\n 'name': self._name,\n 'piece': self._piece,\n 'pos': self._pos,\n 'cash': self._cash,\n 'properties': []\n }\n\n for i in self._properties:\n data['properties'].append({'name': i.name, 'value': i.value})\n\n return data","def marshal(self):\n raise NotImplementedError","def adapt_chain(chain):\n type_chain = check_type(chain)\n name = chain.id\n if type_chain == \"nucleic_acid\":\n new_chain = Bio.PDB.Chain.Chain(name)\n chain = copy.copy(chain)\n for residue in chain:\n new_chain.add(residue.copy())\n\n for residue in new_chain:\n for atom in residue:\n if atom.id == \"C1'\":\n atom.id = \"CA\"\n residue.add(atom.copy())\n return new_chain\n else:\n return chain","def create_from_segments(self, segment, origin=0):\r\n n = origin\r\n if segment[origin]['T'] != 'soma': # if it's a soma, only one compartment\r\n while (len(segment[n]['children']) == 1) and (segment[n]['T'] != 'soma'): # Go to the end of the branch\r\n n += 1\r\n # End of branch\r\n branch = segment[origin:n + 1]\r\n # Set attributes\r\n self.diameter, self.length, self.area, self.x, self.y, self.z = \\\r\n zip(*[(seg['diameter'], seg['length'], seg['area'], seg['x'], seg['y'], seg['z']) for seg in branch])\r\n self.diameter, self.length, self.area, self.x, self.y, self.z = array(self.diameter), array(self.length), \\\r\n array(self.area), array(self.x), array(self.y), array(self.z)\r\n self.type = segment[n]['T'] # normally same type for all compartments in the branch\r\n # Create children (list)\r\n self.children = [Morphology().create_from_segments(segment, origin=c) for c in segment[n]['children']]\r\n # Create dictionary of names (enumerates children from number 1)\r\n for i, child in enumerate(self.children):\r\n self._namedkid[str(i + 1)] = child\r\n # Name the child if possible\r\n if child.type in ['soma', 'axon', 'dendrite']:\r\n if child.type in self._namedkid:\r\n self._namedkid[child.type] = None # two children with the same name: erase (see next block)\r\n else:\r\n self._namedkid[child.type] = child\r\n # Erase useless names\r\n for k in self._namedkid.keys():\r\n if self._namedkid[k] is None:\r\n del self._namedkid[k]\r\n # If two kids, name them L (left) and R (right)\r\n if len(self.children) == 2:\r\n self._namedkid['L'] = self._namedkid['1']\r\n self._namedkid['R'] = self._namedkid['2']\r\n return self","def save_chain(self):\n pprint('saving to file named bc_file.txt')\n with open('ddos_bc_file.txt', 'w') as output:\n output.write(serializer.serialize(self.chain))","def make_mixture_info(parts, operation='+'):\n # type: (List[ModelInfo], str) -> ModelInfo\n # Build new parameter list\n combined_pars = []\n\n # When creating a mixture model that is a sum of product models (ie (1*2)+(3*4))\n # the parameters for models 1 & 2 will be prefixed with A & B respectively,\n # but so will the parameters for models 3 & 4. We need to rename models 3 & 4\n # so that they are prefixed with C & D to avoid overlap of parameter names.\n used_prefixes = []\n for part in parts:\n if part.composition and part.composition[0] == 'mixture':\n i = 0\n for submodel in part.composition[1]:\n npars = len(submodel.parameters.kernel_parameters)\n # List of params of one of the constituent models of part\n submodel_pars = part.parameters.kernel_parameters[i:i+npars]\n # Prefix of the constituent model\n prefix = submodel_pars[0].name[0]\n if prefix not in used_prefixes: # Haven't seen this prefix so far\n used_prefixes.append(prefix)\n i += npars\n continue\n # TODO: don't modify submodel --- it may be used elsewhere\n # Existing code probably doesn't keep a handle on the model\n # parts so its probably okay, but it's possible that a mix\n # on user defined mixture models models will change the\n # parameters used for the parts in the GUI. Even worse if the\n # same plugin is used twice. For example, twosphere.py\n # contains sphere+sphere and you create twosphere+twosphere.\n while prefix in used_prefixes:\n # This prefix has been already used, so change it to the\n # next letter that hasn't been used\n prefix = chr(ord(prefix) + 1)\n used_prefixes.append(prefix)\n prefix += \"_\"\n # Update the parameters of this constituent model to use the\n # new prefix\n for par in submodel_pars:\n # Strip {prefix}_ using par.name[2:], etc.\n # TODO: fails for AB_scale\n par.id = prefix + par.id[2:]\n par.name = prefix + par.name[2:]\n if par.length_control is not None:\n par.length_control = prefix + par.length_control[2:]\n i += npars\n\n for part in parts:\n # Parameter prefix per model, A_, B_, ...\n # Note that prefix must also be applied to id and length_control\n # to support vector parameters\n prefix = ''\n if not part.composition or part.composition[0] == 'product':\n # Model isn't a composition model, so its parameters don't have a\n # a prefix. Add the next available prefix\n prefix = chr(ord('A')+len(used_prefixes))\n used_prefixes.append(prefix)\n prefix += '_'\n\n if operation == '+':\n # If model is a sum model, each constituent model gets its own scale parameter\n scale_prefix = prefix\n if prefix == '' and getattr(part, \"operation\", '') == '*':\n # `part` is a composition product model. Find the prefixes of\n # its parameters to form a new prefix for the scale.\n # For example, a model with A*B*C will have ABC_scale.\n sub_prefixes = []\n for param in part.parameters.kernel_parameters:\n # Prefix of constituent model\n sub_prefix = param.id.split('_')[0]\n if sub_prefix not in sub_prefixes:\n sub_prefixes.append(sub_prefix)\n # Concatenate sub_prefixes to form prefix for the scale\n scale_prefix = ''.join(sub_prefixes) + '_'\n scale = Parameter(scale_prefix + 'scale', default=1.0,\n description=\"model intensity for \" + part.name)\n combined_pars.append(scale)\n for p in part.parameters.kernel_parameters:\n p = copy(p)\n p.name = prefix + p.name\n p.id = prefix + p.id\n if p.length_control is not None:\n p.length_control = prefix + p.length_control\n combined_pars.append(p)\n parameters = ParameterTable(combined_pars)\n # Allow for the scenario in which each component has all its PD parameters\n # active simultaneously. details.make_details() will throw an error if\n # too many are used from any one component.\n parameters.max_pd = sum(part.parameters.max_pd for part in parts)\n\n def random():\n \"\"\"Random set of model parameters for mixture model\"\"\"\n combined_pars = {}\n for k, part in enumerate(parts):\n prefix = chr(ord('A')+k) + '_'\n pars = part.random()\n combined_pars.update((prefix+k, v) for k, v in pars.items())\n return combined_pars\n\n model_info = ModelInfo()\n model_info.id = operation.join(part.id for part in parts)\n model_info.operation = operation\n model_info.name = '(' + operation.join(part.name for part in parts) + ')'\n model_info.filename = None\n model_info.title = 'Mixture model with ' + model_info.name\n model_info.description = model_info.title\n model_info.docs = model_info.title\n model_info.category = \"custom\"\n model_info.parameters = parameters\n model_info.random = random\n #model_info.single = any(part['single'] for part in parts)\n model_info.structure_factor = False\n #model_info.tests = []\n #model_info.source = []\n # Remember the component info blocks so we can build the model\n model_info.composition = ('mixture', parts)\n return model_info","def writeBlocks(self):\n dataFile = open(\"chain.txt\", \"w\")\n chainData = []\n for eachBlock in self.chain:\n chainData.append(eachBlock.__dict__)\n dataFile.write(json.dumps(chainData, indent=4))\n dataFile.close()","def construct_fragments(self):\n for frag_dict in self.fragment_dict_list:\n try:\n chain = self.model[frag_dict[\"chain_id\"]]\n frag = chain[frag_dict[\"frag_id\"]]\n except KeyError:\n self.add_fragment(frag_dict, None)\n continue\n\n self.add_fragment(frag_dict, frag)","def _pack(self):\n pass","def pack_goods(self, by=None):","def pack_goods(self, by=None):","def createInnerRepresentation(self):\n\n for idx, single_block in enumerate(self._block_list):\n del self._to_be_processed[:]\n del self._metastring_rest[:]\n self._metastring_rest.append(self._metastring[idx])\n self.addMetastringPointer(single_block)","def create(data):\n \n return Part(\n part_id = data['part_num'],\n category_id = data['part_cat_id'],\n external_ids = data.get('external_ids', {}),\n name = data['name'],\n year_from = data.get('year_from', None),\n year_to = data.get('year_to', None),\n url = data.get('part_url', None),\n img_url = data.get('part_img_url', None),\n print_of = data.get('print_of', None),\n prints = data.get('prints', []),\n molds = data.get('molds', []),\n alternates = data.get('alternates', []))","def assemble_parts(self):\n self.parts['whole'] = self.output\n self.parts['encoding'] = self.document.settings.output_encoding\n self.parts['version'] = docutils.__version__","def serialize(self):","def _marshal(self, pieces):\n payload = b''.join(pieces)\n return struct.pack('>BHI', self.frame_type, self.channel_number,\n len(payload)) + payload + bytes((spec.FRAME_END,))","def _blob(self):\n self.__rewrite_sldIdLst()\n # # at least the following needs to be added before using\n # # _reltype_ordering again for Presentation\n # self.__rewrite_notesMasterIdLst()\n # self.__rewrite_handoutMasterIdLst()\n # self.__rewrite_sldMasterIdLst()\n return super(Presentation, self)._blob","def get_structure(self):\n return self.chain.model.structure","def marshal(self):\n return self._marshal(list())","def marshal(self):\n return self._marshal([self.fragment])","def build_serializer(self):\n self._add_child_elements_recursive(self.get_root_element())","def chainsetup(filename, cation, facets, operation, end_radii, nradii,\n adensity):\n\n # Load the Cage from the file\n try:\n # If that fails, try other file formats supported by pymatgen\n anion = Cage.from_file(filename)\n except ValueError:\n # If that fails, try the VASP POSCAR format\n anion = Cage.from_poscar(filename)\n\n # Center the anion around the origin\n anion.center()\n\n # Find the chain edges, i.e. the paths between the edge sharing facets of\n # the chain of non-equivalent facets.\n anion.find_surface_facets(ignore=IGNORE)\n\n if not facets == tuple:\n chosen_facets = [anion.facets[index] for index in facets]\n edges = anion.find_noneq_chain_links(chosen_facets)\n else:\n edges = anion.find_noneq_chain_links()\n\n total_mol = anion.copy()\n\n chain_dir = 'chain_' + operation\n try:\n os.mkdir(chain_dir)\n except FileExistsError:\n pass\n\n # For each edge, set up the calculation input files\n edge_number = 1\n\n for edge in edges:\n\n # Set up the edge directory\n edge_dir = os.path.join(chain_dir, \"edge\" + str(edge_number))\n\n while os.path.exists(edge_dir):\n edge_number += 1\n edge_dir = os.path.join(chain_dir, \"edge\" + str(edge_number))\n\n os.mkdir(edge_dir)\n\n # Write out the molecule and path facets to the edge directory\n anion.to(fmt=\"json\", filename=os.path.join(edge_dir, \"molecule.json\"))\n edge[0].to(fmt=\"json\", filename=os.path.join(edge_dir,\n \"init_facet.json\"))\n edge[1].to(fmt=\"json\", filename=os.path.join(edge_dir,\n \"final_facet.json\"))\n\n # Get copies so the originals aren't mutated\n edge_mol = anion.copy()\n facet1 = edge[0].copy()\n facet2 = edge[1].copy()\n\n if edge == edges[-1]:\n remove_endline = False\n else:\n remove_endline = True\n\n # Set up the landscape\n landscape = set_up_edge_landscape(facet1, facet2,\n endpoint_radii=end_radii,\n number_of_radii=nradii,\n angle_density=adensity,\n remove_endline=remove_endline)\n\n # Get the molecule for each landscape point\n molecules = set_up_molecules(edge_mol, landscape, cation)\n\n # Set up an xyz file to visualize the edge and total landscape\n for point in landscape.points:\n try:\n total_mol.append(pmg.Specie(cation, 1), point,\n validate_proximity=False)\n edge_mol.append(pmg.Specie(cation, 1), point,\n validate_proximity=False)\n except ValueError:\n pass\n\n edge_mol.to(fmt=\"xyz\", filename=os.path.join(edge_dir, \"edge.xyz\"))\n\n # In case the molecules must be optimized, add the constraints and\n # optimization setup (DRIVER)\n if operation == \"optimize\":\n far_facet = anion.find_farthest_facet(landscape.center)\n constraints = find_constraints(anion, far_facet.sites)\n constraints['fix atom'] += ' ' + str(len(anion.sites) + 1)\n ALT_SETUP['constraints'] = constraints\n ALT_SETUP[\"driver\"] = DRIVER_SETUP\n\n # Set up the task for the calculations\n tasks = [nwchem.NwTask(molecules[0].charge, None, BASIS,\n theory=\"dft\",\n operation=operation,\n theory_directives=THEORY_SETUP,\n alternate_directives=ALT_SETUP)]\n\n # Set up the input files\n study = Study(molecules, tasks)\n study.set_up_input(edge_dir, sort_comp=False,\n geometry_options=GEO_SETUP)\n\n edge_number += 1\n\n # Set up an xyz file with all the paths\n total_mol.to(fmt=\"xyz\", filename=os.path.join(chain_dir, \"total_mol.xyz\"))","def add_chain_signature(\n self, prop: str, key: JWK, alg: Optional[AlgorithmName] = None,\n header: Optional[JsonObject] = None) -> None:\n top_level_signature = self._payload.get(prop)\n for k in top_level_signature.keys():\n if k != _CHAIN:\n del top_level_signature[k]\n chain = top_level_signature.get(_CHAIN, [])\n self._add_signature(prop, key, alg, header,\n lambda h: {_CHAIN: chain + [h]},\n lambda h: (self._payload\n .setdefault(prop, {})\n .setdefault(_CHAIN, [])\n .append(h)))","def trip_chain(self):\n pass","def __init__(self, objects=()):\n\n vtk.vtkPropAssembly.__init__(self)\n\n self.name = \"\"\n self.created = \"\"\n self.trail = None\n self.trail_points = []\n self.trail_segment_size = 0\n self.trail_offset = None\n self.shadows = []\n self.info = {}\n self.rendered_at = set()\n self.transform = None\n self.scalarbar = None\n\n for a in vedo.utils.flatten(objects):\n if a:\n self.AddPart(a)\n\n self.PickableOff()","def parse_part(self):\n parts = []\n for part in re.split(r'\\*\\*\\* ([A-Z- ]+) \\*\\*\\*', self.hand_file): # return [ 'part1', 'splitter1', 'part2',..\n parts.append(part)\n\n for i in range(0, len(parts)):\n if i == 0:\n self.part_dict['HEADER'] = parts[i]\n if i % 2 != 0: # number is odd\n self.part_dict[parts[i]] = parts[i + 1]","def marshal_departments(result):\n return result","def read_chain(self, _id):\n chain_def = {'class' : 'chain', 'type' : ''}\n for i in self.config_reader.options(_id):\n chain_def[i] = self.config_reader.get(_id, i)\n logging.debug(\"Registering chain %s\", _id)\n self.instances.register(_id,chain_def,self.create_chain)","def dump_parts(self, io):\n\n # XXX refactor with Tempita\n title = \"Parts created by the docutils writer '%s'\" % self.strategy.name\n io.say(title + os.linesep)\n io.say(len(title) * '-')\n io.say(2 * os.linesep)\n io.say('Part keys: ' + 2 * os.linesep)\n\n parts = self.publish_parts(io)\n io.say(os.linesep.join(sorted(parts.keys())))\n io.say(2 * os.linesep)\n for part in parts:\n io.say(\"Value of part '%s':%s\" % (part, os.linesep))\n io.say(parts[part].encode('utf-8') + os.linesep)\n io.say(80*'-'+os.linesep)\n io.say(os.linesep)","def serialize(self):\n return {\n 'id': self.id,\n 'name': self.name,\n 'ingredients': self.ingredients,\n 'directions': self.directions,\n 'type': self.type,\n }","def addChain(self, chain):\n\n\t\tself.chain.append(chain)\n\t\tchain.parentMolecule = self","def normalize_chain(cls, chain):\n\n if isinstance(chain, cls):\n chain = (chain,)\n return tuple(x for x in chain if x is not None)","def toPartners(self):\n num_bases = len(self) #number of bases\n result = [None] * len(self) #array of None, one for each base\n stack = []\n start = self.StartSymbols\n end = self.EndSymbols\n for i, symbol in enumerate(self):\n if symbol in start: #open a pair\n stack.append(i)\n elif symbol in end: #close a pair\n curr = stack.pop() #return and delete last element\n result[i] = curr #make i pair with the last element...\n result[curr] = i #...and the last element pair with i\n \n #test whether there are any open pairs left unaccounted for \n if stack:\n raise IndexError, \\\n \"Too many open pairs in structure:\\n%s\" % self\n return Partners(result)","def __init__(self, fab=None, heavy_chains=None, light_chains=None, names=None):\n # check if it's a Chain object\n if heavy_chains is None and light_chains is None and fab is None:\n raise ValueError('Provide a list of Chain objects or an ChainCollection object')\n\n # check if fab object is a list and if all object are abpytools.Fab objects\n if isinstance(fab, list) and all(isinstance(fab_i, Fab) for fab_i in fab):\n self._fab = fab\n self._light_chains = ChainCollection([x[0] for x in self._fab])\n self._heavy_chains = ChainCollection([x[1] for x in self._fab])\n\n if fab is None and (heavy_chains is not None and light_chains is not None):\n\n if isinstance(heavy_chains, list):\n self._heavy_chains = ChainCollection(antibody_objects=heavy_chains)\n\n elif isinstance(heavy_chains, ChainCollection):\n self._heavy_chains = heavy_chains\n\n else:\n raise ValueError('Provide a list of Chain objects or an ChainCollection object')\n\n if isinstance(light_chains, list):\n self._light_chains = ChainCollection(antibody_objects=light_chains)\n\n elif isinstance(light_chains, ChainCollection):\n self._light_chains = light_chains\n\n else:\n raise ValueError('Provide a list of Chain objects or an ChainCollection object')\n\n if len(self._light_chains.loading_status()) == 0:\n self._light_chains.load()\n\n if len(self._heavy_chains.loading_status()) == 0:\n self._heavy_chains.load()\n\n if self._light_chains.n_ab != self._heavy_chains.n_ab:\n raise ValueError('Number of heavy chains must be the same of light chains')\n\n if isinstance(names, list) and all(isinstance(name, str) for name in names):\n if len(names) == self._heavy_chains.n_ab:\n self._names = names\n else:\n raise ValueError(\n 'Length of name list must be the same as length of heavy_chains/light chains lists')\n\n elif names is None:\n self._names = ['{} - {}'.format(heavy, light) for heavy, light in zip(self._heavy_chains.names,\n self._light_chains.names)]\n\n else:\n raise ValueError(\"Names expected a list of strings, instead got {}\".format(type(names)))\n\n self._n_ab = self._light_chains.n_ab\n self._pair_sequences = [heavy + light for light, heavy in zip(self._heavy_chains.sequences,\n self._light_chains.sequences)]\n\n # keep the name of the heavy and light chains internally to keep everything in the right order\n self._internal_heavy_name = self._heavy_chains.names\n self._internal_light_name = self._light_chains.names","def get_serializer(self, *args, **kwargs):\n kwargs['part_detail'] = True\n kwargs['location_detail'] = True\n kwargs['supplier_part_detail'] = True\n kwargs['context'] = self.get_serializer_context()\n\n return self.serializer_class(*args, **kwargs)","def _encode_supplement(self):","def _encode_supplement(self):","def serialize(self, data):","def partid2nids(self, partid, ntype): # -> None:\n ...","def from_binary(self, d):\n p = MsgCertificateChainDep._parser.parse(d)\n for n in self.__class__.__slots__:\n setattr(self, n, getattr(p, n))","def __init__(self, chain_instance, *args, **kwargs):\n protocol_logger('Intializing protocol processor')\n self.chain_instance = chain_instance","def build_parts_from_dict(self, data, skip_power_controls=False):\n \n # Validate Objects information.\n if \"Objects\" not in data:\n return\n\n # Start creating parts.\n parts = []\n for part_data in data[\"Objects\"]:\n part = part_data[\"ObjectID\"].replace(\"^\", \"\")\n timestamp = part_data[\"Timestamp\"]\n user_data = part_data[\"UserData\"]\n part_position = part_data[\"Position\"]\n up_vec = part_data[\"Up\"]\n at_vec = part_data[\"At\"]\n # Build the item.\n item = self.build_item(\n part,\n timestamp,\n user_data,\n part_position,\n up_vec,\n at_vec,\n skip_power_controls\n )\n parts.append(item)\n\n return parts","def preparing(fasta_list, pdb_dict):\n for item1 in fasta_list:\n matchObj = re.search( '^(.*)_([a-zA-Z0-9])$', item1[0])\n fasta1= item1[1]\n if matchObj:\n original_name1= matchObj.group(1)\n original_structure1=pdb_dict[original_name1]\n chain_1= matchObj.group(2) \n yield fasta1, [original_structure1, chain_1]","def _make_partitionsTest_label(chain_parts):\n\n assert len(chain_parts) == 1\n scenario = chain_parts[0]['hypoScenario']\n \n assert scenario == 'partitionsTest'\n\n \n\n return \"\"\"\n partgen(\n [(20et, 0eta320)]\n \n simple([(40et, 0eta320) (50et, 0eta320)])\n simple([(35et, 0eta240) (55et, 0eta240)])\n )\"\"\"","def _get_chain_repr(self, chain):\n chain_repr = []\n for module in chain:\n if isinstance(module, collections.Iterable): # module is a chain\n chain_repr.append(self._get_chain_repr(module))\n elif hasattr(module, 'process'): # module is an object\n chain_repr.extend(\n (str(module.__class__), repr(vars(module))))\n else: # module is a function\n if isinstance(module, partial): # partial function\n chain_repr.extend((str(module.__class__), repr(module.func),\n repr(module.keywords)))\n else:\n chain_repr.append(repr(module))\n return ' '.join(chain_repr)","def serialize(self, root):","def partid2nids(self, partid, ntype=...):\n ...","def partid2nids(self, partid, ntype=...):\n ...","def _decode(self, parts: typing.List[int]) -> typing.Dict:\n info = {field.name: field.decode(parts[i]) for i, field in enumerate(self.fields)}\n return info","def __init__(self):\n self.chain = [Block.genesis()]","def compose(self):\r\n return_lib = self.other\r\n return_lib.update({\r\n 'ID' : self.id,\r\n 'Name' : self.name,\r\n 'Alias' : self.alias,\r\n 'Parent' : self.parent,\r\n 'Target' : self.target,\r\n 'Gap' : self.gap,\r\n 'Derives_from' : self.derives_from,\r\n 'Note' : self.note,\r\n 'Dbxref' : self.dbxref,\r\n 'Ontology_term' : self.ontology_term,\r\n 'Is_circular' : self.is_circular,\r\n 'allele' : ','.join([a.strip() for a in self.allele])\r\n })\r\n if self.discovered != None:\r\n if self.discovered:\r\n return_lib[self.discovered_key] = self.enabled[0]\r\n else:\r\n return_lib[self.discovered_key] = self.disabled[0]\r\n if self.validated != None:\r\n if self.validated:\r\n return_lib[self.validated_key] = self.enabled[0]\r\n else:\r\n return_lib[self.validated_key] = self.disabled[0]\r\n if self.active != None:\r\n if self.active:\r\n return_lib[self.active_key] = self.disabled[0]\r\n else:\r\n return_lib[self.active_key] = self.enabled[0]\r\n for i,item in enumerate(self.history):\r\n return_lib[\"{}_{}\".format(self.history_key,i)] = ','.join(item)\r\n return_str = ';'.join([key + '=' + value for key, value in return_lib.items() if value])\r\n return return_str","def _encode_parts(self, messages, encode_empty=False):\n if messages or encode_empty:\n return self.signer.sign_object(\n messages, serializer=MessagePartGatherSerializer, compress=True\n )","def serialize(self):\n pass","def _create_chain(class_type_list, kwargs_list):\n chain = None # module with preprocessing chain\n modules = [] # list of modules (not connected via preprocessing)\n for i, pre_id in enumerate(class_type_list):\n chain = CModule.create(\n pre_id, preprocess=chain, **kwargs_list[i])\n modules.append(CModule.create(pre_id, **kwargs_list[i]))\n return chain, modules","def __store_part(self, definition, pnum, multisubtype):\n pnum = \"1\" if pnum is None else pnum\n params = {\n \"pnum\": pnum,\n \"params\": definition[2],\n \"cid\": definition[3],\n \"description\": definition[4],\n \"encoding\": definition[5],\n \"size\": definition[6]\n }\n mtype = definition[0].lower()\n subtype = definition[1].lower()\n ftype = \"%s/%s\" % (definition[0].lower(), subtype)\n if ftype in (\"text/plain\", \"text/html\"):\n if subtype not in self.contents:\n self.contents[subtype] = [params]\n else:\n self.contents[subtype].append(params)\n return\n elif multisubtype in [\"related\"]:\n self.inlines[params[\"cid\"].strip(\"<>\")] = params\n return\n\n params[\"Content-Type\"] = ftype\n if len(definition) > 7:\n extensions = [\"md5\", \"disposition\", \"language\", \"location\"]\n if mtype == \"text\":\n extensions = [\"textlines\"] + extensions\n elif ftype == \"message/rfc822\":\n extensions = [\n \"envelopestruct\",\n \"bodystruct\",\n \"textlines\"] + extensions\n for idx, value in enumerate(definition[7:]):\n params[extensions[idx]] = value\n\n self.attachments += [params]","def serialize(self):\n return {\n 'name' : self.name,\n 'ingredients' : self.ingredients,\n 'id' : self.id,\n 'preparation' : self.preparation,\n 'image' : self.image,\n }","def skeleton_getHandleChain(self, typeModifier = None, jointHelpers = True, mOrientHelper = None):\n _short = self.mNode\n _str_func = 'skeleton_getHandleChain'\n #start = time.clock()\t\n log.debug(cgmGEN.logString_start(_str_func))\n \n mRigNull = self.moduleTarget.rigNull\n ml_fkJoints = mRigNull.msgList_get('fkJoints')\n \n if not ml_fkJoints:\n log.debug(\"|{0}| >> Generating handleJoints\".format(_str_func))\n \n ml_formHandles = self.msgList_get('formHandles',asMeta = True)\n if not ml_formHandles:\n raise ValueError,\"No formHandles connected\" \n \n ml_prerigHandles = self.msgList_get('prerigHandles',asMeta = True)\n if not ml_prerigHandles:\n raise ValueError,\"No prerigHandles connected\"\n \n if mOrientHelper is None:\n mOrientHelper = ml_formHandles[0].orientHelper or ml_prerigHandles[0].orientHelper\n \n #_d = skeleton_getCreateDict(self)\n #pprint.pprint(_d)\n l_pos = []\n for mObj in ml_prerigHandles:\n l_pos.append(mObj.p_position)\n \n ml_fkJoints = COREJOINTS.build_chain(posList = l_pos,\n axisAim='z+',\n axisUp='y+',\n parent=True,\n worldUpAxis= mOrientHelper.getAxisVector('y+'))\n \n for i,mJnt in enumerate(ml_fkJoints):\n mJnt.doCopyNameTagsFromObject(ml_prerigHandles[i].mNode, ignore = ['cgmType'])\n if not typeModifier:\n mJnt.doName()\n \n if typeModifier:\n for mJnt in ml_fkJoints:\n mJnt.addAttr('cgmTypeModifier',typeModifier,attrType='string',lock=True)\n mJnt.addAttr('cgmType','frame',attrType='string',lock=True) \n mJnt.doName()\n \n ml_fkJoints[0].p_parent = False\n else:\n log.debug(\"|{0}| >> Found fkJoints\".format(_str_func))\n \n #log.debug(\"%s >> Time >> = %0.3f seconds \" % (_str_func,(time.clock()-start)) + \"-\"*75)\t\n return ml_fkJoints","def serialize(self, pipe, pid):\n for trsp in self.transports:\n pipe.send(trsp.__class__)\n trsp.serialize(pipe, pid)","def _make_information_storable( self, data ):\n\t\tpass","def save_data(self):\n try:\n with open('blockchain-{}.txt'.format(self.node_id), mode='w') as f:\n saveable_chain = [block.__dict__ for block in [Block(block_el.index, block_el.previous_hash, \n [tx.__dict__ for tx in block_el.transactions], \n [tx.__dict__ for tx in block_el.chipsactions],\n [tx.__dict__ for tx in block_el.messsactions],\n block_el.proof, block_el.timestamp) for block_el in self.__chain]]\n f.write(json.dumps(saveable_chain))\n f.write('\\n')\n saveable_tx = [tx.__dict__ for tx in self.__open_transactions]\n f.write(json.dumps(saveable_tx))\n f.write('\\n')\n saveable_chip = [tx.__dict__ for tx in self.__open_chipsactions]\n f.write(json.dumps(saveable_chip))\n f.write('\\n')\n saveable_chip = [tx.__dict__ for tx in self.__open_messsactions]\n f.write(json.dumps(saveable_chip))\n f.write('\\n')\n f.write(json.dumps(list(self.__peer_nodes)))\n except IOError:\n print('Saving failed!')","def to_binary(self):\n c = containerize(exclude_fields(self))\n self.payload = MsgCertificateChainDep._parser.build(c)\n return self.pack()","def create_chain_instances(self):\n for section in self.config_reader.sections():\n self.read_chain(section)","def make_drs_tree(self):\n pass","def create(data):\n \n return Partlist(\n list_id = data['id'],\n name = data['name'],\n pieces = data['num_parts'])","def chain():\n chain_identifier, url = get_vars(request, [\"id\", \"data\"])\n info('chain=%s' % chain_identifier)\n chain = LAPPS_SERVICE_CHAINS.get_chain(chain_identifier)\n info('source-url=%s' % url)\n data = requests.get(url).text\n result = chain.run({\n \"discriminator\": \"http://vocab.lappsgrid.org/ns/media/text\", \n \"payload\": data})\n info(\"discriminator=%s\" % result.get('discriminator'))\n return render_template(\"chain.html\",\n chain=chain,\n fname=url,\n result=result,\n builder=HtmlBuilder())","def setPartsToRegister(self, parts):\n internals.blpapi_ServiceRegistrationOptions_setPartsToRegister(\n self.__handle, parts)","def produce_chain_dict (inPath, outPath):\n with open(inPath, 'r') as fin:\n chainIDs = list(fin.read().split())\n chains = {}\n for chainid in chainIDs:\n pdbid = (chainid[ : chainid.find('_') ] if '_' in chainid else chainid)\n if pdbid in chains:\n chains[pdbid].add(chainid)\n else:\n chains[pdbid] = {chainid}\n with open(outPath, 'wb') as fOut:\n pickle.dump(chains, fOut)","def wire_chains(self):\n allChains = self.instances.getAllChainInstances()\n for chain in allChains:\n logging.debug(\"%s\", chain)\n allChains[chain].setup_event_path()","def _encode(self, boxes, anchors):\n pass","def __init__(self):\n self.chain = {}\n self.blocks = {}\n self.blocks_spending_input = {}\n self.blocks_containing_tx = {}\n self.all_transactions = {}","def prepare_order(acct, order):\n myaddr = (acct.address).lower()\n order[\"makerAddress\"] = myaddr\n order_struct = jsdict_order_to_struct(order) \n sig = _sign_order(acct, order_struct)\n order_struct[\"signature\"] = sig\n js_order = order_to_jsdict(order_struct)\n js_order[\"exchangeAddress\"] = exchangeAddress\n return js_order","def trans_setup():\n # slot7 slot6 slot5 slot4 slot3 slot2 slot1 <------ beam direction (slot 8 is currently B-fiber only)\n # Be Be Be Be Be Be Be lens material\n # 1.5 1.5 0.5 0.5 0.5 0.5 0.5 lens radius [mm]\n # 1 1 5 8 4 2 1 number of lenses\n lens_R=[0.5,0.5,0.5,0.5,0.5,1.5,1.5]\n lens_mat=['Be','Be','Be','Be','Be','Be','Be']\n lens_N=[1,2,4,8,5,1,1]\n trans_pos=[35.2,35.8]\n return {'lens_material':lens_mat,'lens_number':lens_N,'lens_radius':lens_R,'trans_position':trans_pos}","def _finishConstruction(self, obj):\n return obj","def _finishConstruction(self, obj):\n return obj","def genereate_echo_picklist(self):\n sample_names = []\n sample_wells = []\n indices = {'i5 name': {}, 'i5 plate': {}, 'i5 sequence': {},\n 'i5 well': {}, 'i7 name': {}, 'i7 plate': {},\n 'i7 sequence': {}, 'i7 well': {}, 'index combo': {},\n 'index combo seq': {}}\n\n for idx, well in enumerate(chain.from_iterable(self.plates[0].layout)):\n # Add the sample well\n sample_wells.append(well.well_id)\n # Get the sample name - we need to go back to the SampleComposition\n lib_comp = well.composition\n sample_comp = lib_comp.normalized_gdna_composition\\\n .gdna_composition.sample_composition\n sample_names.append(sample_comp.content)\n # Retrieve all the information about the indices\n i5_comp = lib_comp.i5_composition.primer_set_composition\n i5_well = i5_comp.container\n indices['i5 name'][idx] = i5_comp.external_id\n indices['i5 plate'][idx] = i5_well.plate.external_id\n indices['i5 sequence'][idx] = i5_comp.barcode\n indices['i5 well'][idx] = i5_well.well_id\n\n i7_comp = lib_comp.i7_composition.primer_set_composition\n i7_well = i7_comp.container\n indices['i7 name'][idx] = i7_comp.external_id\n indices['i7 plate'][idx] = i7_well.plate.external_id\n indices['i7 sequence'][idx] = i7_comp.barcode\n indices['i7 well'][idx] = i7_well.well_id\n\n indices['index combo seq'][idx] = '%s%s' % (\n indices['i5 sequence'][idx], indices['i7 sequence'][idx])\n\n sample_names = np.asarray(sample_names)\n sample_wells = np.asarray(sample_wells)\n indices = pd.DataFrame(indices)\n\n return LibraryPrepShotgunProcess._format_picklist(\n sample_names, sample_wells, indices)","def json(self):\n blocks = [block.to_json() for block in self.chain[1:]]\n return json.dumps({'blocks': blocks})","def pdbChain_to_mdtrajChainid_li(chain,seg_to_chain,struc):\n chain = chain.upper()\n chain_segments=[seg for seg,chainval in seg_to_chain.items() if chainval==chain]\n if chain_segments:\n structable, bonds=struc.topology.to_dataframe()\n chainid_li=[]\n for segname in chain_segments:\n seg_chainid_li=structable.loc[structable['segmentID'] == segname].chainID.unique()\n chainid_li+=list(seg_chainid_li)\n chainid_li=list(set(chainid_li))\n return chainid_li\n else:\n return False","def marshal(self):\n pieces = self.properties.encode()\n pieces.insert(\n 0, struct.pack('>HxxQ', self.properties.INDEX, self.body_size))\n return self._marshal(pieces)","def init(self):\n\n logger.info(mm_chain.ackn_str)\n self.acknowledgements = mm_chain.ackn_str\n self.references = mm_chain.refs['chain']\n\n return","def __init__(self):\n self.unconfirmed_transactions = [] \n self.chain = []\n self.create_genesis_block()","def build_item(\n self,\n part,\n timestamp=1539023700,\n userdata=0,\n position=[0, 0, 0],\n up_vec=[0, 1, 0],\n at_vec=[0, 0, 1],\n skip_power_controls=False):\n # Get the obj path.\n item = self.retrieve_part(part)\n\n # Lock Everything if it's the BASE_FLAG or U_POWERLINE.\n # BASE_FLAG can break things if user moves it around.\n # As it acts as the \"origin\" of the base.\n locked_parts = [\"BASE_FLAG\", \"U_POWERLINE\", \"U_PIPELINE\", \"U_PORTALLINE\"]\n line_parts = [\"U_POWERLINE\", \"U_PIPELINE\", \"U_PORTALLINE\"]\n if part in locked_parts:\n item.lock_location[0] = True\n item.lock_location[1] = True\n item.lock_location[2] = True\n item.lock_rotation[0] = True\n item.lock_rotation[1] = True\n item.lock_rotation[2] = True\n item.lock_scale[0] = True\n item.lock_scale[1] = True\n item.lock_scale[2] = True\n \n # Add custom attributes.\n item[\"ObjectID\"] = part\n item[\"SnapID\"] = part\n item[\"Timestamp\"] = timestamp\n item[\"belongs_to_preset\"] = False\n # Add an order flag to retain order when generating data..\n item[\"Order\"] = self.part_order\n self.part_order += 1\n # Apply Colour\n is_powerline = part in line_parts\n is_pipeline = part in [\"U_PIPELINE\"]\n material.assign_material(\n item,\n userdata,\n powerline=is_powerline,\n pipeline=is_pipeline\n )\n\n # Move\n utils.move_to(item, position=position, up=up_vec, at=at_vec)\n\n # If the object is a powerline, we should create additional controls\n # for it.\n if is_powerline and not skip_power_controls:\n power.create_power_controls(item)\n # Select the new object.\n item.select_set(True)\n return item","def connectPart(self,\n hsNondes: list,\n part: Union[TransPart, ChoicesOfFrameParts],\n en: Union[RtlSignal, bool],\n exclusiveEn: Optional[RtlSignal]=hBit(1)):\n busVld = self.dataIn.valid\n tToIntf = self.dataOut._fieldsToInterfaces\n\n if isinstance(part, ChoicesOfFrameParts):\n parentIntf = tToIntf[part.origin.parent.origin]\n try:\n sel = self._tmpRegsForSelect[parentIntf]\n except KeyError:\n sel = HsBuilder(self, parentIntf._select).buff().end\n self._tmpRegsForSelect[parentIntf] = sel\n unionGroup = ExclusieveListOfHsNodes(sel)\n\n # for unions\n for choice in part:\n # connect data signals of choices and collect info about\n # streams\n intfOfChoice = tToIntf[choice.tmpl.origin]\n selIndex, isSelected, isSelectValid = self.choiceIsSelected(\n intfOfChoice)\n _exclusiveEn = isSelectValid & isSelected & exclusiveEn\n\n unionMemberPart = ListOfOutNodeInfos()\n for p in choice:\n self.connectPart(unionMemberPart, p, en, _exclusiveEn)\n unionGroup.append(selIndex, unionMemberPart)\n\n hsNondes.append(unionGroup)\n\n if part.isLastPart():\n # synchronization of reading from _select register for unions\n selNode = InNodeInfo(sel, en)\n else:\n selNode = InNodeReadOnlyInfo(sel, en)\n hsNondes.append(selNode)\n return\n\n if part.isPadding:\n return\n\n fPartSig = self.getInDataSignal(part)\n fieldInfo = part.tmpl.origin\n\n try:\n signalsOfParts = self._signalsOfParts[part.tmpl]\n except KeyError:\n signalsOfParts = []\n self._signalsOfParts[part.tmpl] = signalsOfParts\n\n if part.isLastPart():\n # connect all parts in this group to output stream\n signalsOfParts.append(fPartSig)\n intf = self.dataOut._fieldsToInterfaces[fieldInfo]\n intf.data(self.byteOrderCare(\n Concat(\n *reversed(signalsOfParts)\n ))\n )\n on = OutNodeInfo(self, intf, en, exclusiveEn)\n hsNondes.append(on)\n else:\n dataVld = busVld & en & exclusiveEn\n # part is in some word as last part, we have to store its value to register\n # until the last part arrive\n fPartReg = self._reg(\"%s_part_%d\" % (fieldInfo.name,\n len(signalsOfParts)),\n fPartSig._dtype)\n If(dataVld,\n fPartReg(fPartSig)\n )\n signalsOfParts.append(fPartReg)","def nid2partid(self, nids, ntype=...):\n ...","def nid2partid(self, nids, ntype=...):\n ...","def test_hierarchy_perceived_information_propagation(self):\n from openff.toolkit._tests.create_molecules import (\n dipeptide_hierarchy_added as create_dipeptide,\n )\n\n dipeptide_hierarchy_perceived = create_dipeptide()\n\n for atom in dipeptide_hierarchy_perceived.atoms:\n atom.metadata[\"chain_id\"] = \"A\"\n assert (\"A\", \"1\", \" \", \"ACE\") != dipeptide_hierarchy_perceived.residues[\n 0\n ].identifier\n dipeptide_hierarchy_perceived.update_hierarchy_schemes()\n assert (\"A\", \"1\", \" \", \"ACE\") == dipeptide_hierarchy_perceived.residues[\n 0\n ].identifier","def createInnerRepresentation(self):\n\n while self._metastring_rest:\n self.addMetastringPointer(self._metastring_rest.pop(0))","def _serialize(self, state, handle):\n raise NotImplementedError","def serialize(cleaned_data):\n result = cleaned_data.copy()\n for fieldname in Step1Data.REFERENCE_FIELDS_NAMES:\n if result[fieldname]:\n result[fieldname] = result[fieldname].pk\n result[\"data\"] = result[\"data\"].isoformat()\n # print \"serialize to:\", result\n return result","def encode(self):\r\n # Create dict from attributes. Maintain added order\r\n #jd = {'txpk': collections.OrderedDict()}\r\n jd = {'txpk':{}}\r\n\r\n for key in self.keys:\r\n val = getattr(self, key)\r\n\r\n if val is not None:\r\n if key == 'data':\r\n jd['txpk'][key] = val.decode('utf-8')\r\n else:\r\n jd['txpk'][key] = val\r\n #print('key',key)\r\n #print('valtype',type(val),val) \r\n #print(jd)\r\n \r\n return dumps(jd, separators=(',', ':'))","def serialize(self):\n\t\treturn { 'type': self.type, 'parameters' : self.parameters}","async def b_chain() -> dict:\n authority_chain = await chain.consensus()\n return {\"chain\": authority_chain[\"chain\"]}","def _create_chained_picking(self, cr, uid, pick_name, picking, purchase_type, move, context=None):\n res = super(stock_move, self)._create_chained_picking(cr, uid, pick_name, picking, purchase_type, move, context=context)\n if picking.purchase_id:\n self.pool.get('stock.picking').write(cr, uid, [res], {'purchase_id': picking.purchase_id.id})\n self.pool.get('stock.picking').write(cr, uid, [res], {'invoice_state': picking.invoice_state})\n return res","def nid2partid(self, nids, ntype): # -> None:\n ..."],"string":"[\n \"def makeBinaryChains():\\n\\t\\n\\t# retrieve the binding partner specifications\\n\\t(maxsize,types) = getTypes()\\n\\t\\n\\t# Do some basic argument checking for this model\\n\\tif (len(types) < 2):\\n\\t\\tprint \\\"Number of defined types must equal two for binary chain calculations.\\\"\\n\\t\\treturn\\n\\tif (maxsize == 0):\\n\\t\\tprint \\\"Must specify a valid maximum number for one or more components.\\\"\\n\\t\\treturn\\n\\n\\tallChains = []\\n\\tnewChainsA = [[]]\\n\\tnewChainsB = []\\n\\t\\n\\ttypeA = types[0]\\n\\ttypeB = types[1]\\n\\t\\n\\t# start the chain with a single type A component\\n\\taddComponent(newChainsA[0],typeA,0,0)\\n\\n\\tdepth = 0\\n\\tfor n in range(maxsize):\\n\\t\\tdepth+=1\\n\\t\\t\\n\\t\\t# go through all the chains created last iteration and append B components\\n\\t\\tnewChainsB = []\\n\\t\\tfor thisChain in newChainsA:\\n\\n\\t\\t\\t# get a list of new available sites in the provided chain\\n\\t\\t\\t# by setting depth -1, we will only add to components added last round\\n\\t\\t\\topenSites = makeSiteList(thisChain,typeB,depth-1)\\n\\t\\t\\t\\n\\t\\t\\t# make all the descendants from the current chain and append them to the pool\\n\\t\\t\\tif (n == 0) and (typeA['sym']): #if the starting binder is symmetric, no need to start chains at all its sites\\n\\t\\t\\t\\tnewChainsB = newChainsB + fillSites(openSites,thisChain,typeB,-1)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tnewChainsB = newChainsB + fillSites(openSites,thisChain,typeB,depth)\\n\\t\\t\\n\\t\\tprint('n:'+str(n)+', '+str(len(newChainsB))+ ' chains created at depth '+str(depth))\\n\\t\\t\\n\\t\\tallChains = allChains + newChainsB\\n\\t\\t\\n\\t\\tdepth+=1\\n\\t\\t\\n\\t\\t# add an additional component to all the previously modified chains\\n\\t\\tnewChainsA = []\\n\\t\\tfor thisChain in newChainsB:\\n\\n\\t\\t\\topenSites = makeSiteList(thisChain,typeA,depth-1)\\n\\t\\t\\tnewChainsA = newChainsA + fillSites(openSites,thisChain,typeA,depth)\\n\\t\\t\\t\\n\\t\\tprint('n:'+str(n)+', '+str(len(newChainsA))+ ' chains created at depth '+str(depth))\\n\\t\\t\\n\\t\\tallChains = allChains + newChainsA\\n\\n\\treturn allChains\",\n \"def serialize(self):\\n return pickle.dumps([block.serialize() for block in self.chain])\",\n \"def _encode_structure(self):\\n pass\",\n \"def _encode_structure(self):\\n pass\",\n \"def marshal(self):\\n ...\",\n \"def add_chain_to_model(chain, model, atoms):\\n\\n if chain[\\\"type\\\"] == \\\"polymer\\\" or chain[\\\"type\\\"] == \\\"branched\\\":\\n polymer = {\\n \\\"internal_id\\\": chain[\\\"internal_id\\\"], \\\"sequence\\\": chain[\\\"sequence\\\"],\\n \\\"helices\\\": [], \\\"strands\\\": [], \\\"residues\\\": {}\\n }\\n for i, group in enumerate(chain[\\\"groups\\\"], start=1):\\n add_het_to_dict(group, chain, atoms, polymer[\\\"residues\\\"], number=i)\\n add_ss_to_chain(polymer)\\n model[\\\"polymer\\\"][chain[\\\"id\\\"]] = polymer\\n else:\\n for group in chain[\\\"groups\\\"]:\\n add_het_to_dict(group, chain, atoms, model[chain[\\\"type\\\"]])\",\n \"def __rechaindict__(c):\\n from TriggerMenu.menu.DictFromChainName import DictFromChainName\\n dfcn = DictFromChainName()\\n\\n pl1 = []\\n for pch in c['chainParts']:\\n pl1.append(pch['L1item'])\\n\\n newname = c['chainName'].replace('dv_','').replace('TestChain','j')\\n nchlist = [ newname ,c['chainCounter'],c['L1item'],pl1,c['stream'],\\n c['groups'],c['EBstep'] ]\\n \\n return dfcn.getChainDict(nchlist)\",\n \"def _serialise(self):\\n # TODO (M Foley)\\n pass\",\n \"def pack(self):\\n data = {\\n 'name': self._name,\\n 'piece': self._piece,\\n 'pos': self._pos,\\n 'cash': self._cash,\\n 'properties': []\\n }\\n\\n for i in self._properties:\\n data['properties'].append({'name': i.name, 'value': i.value})\\n\\n return data\",\n \"def marshal(self):\\n raise NotImplementedError\",\n \"def adapt_chain(chain):\\n type_chain = check_type(chain)\\n name = chain.id\\n if type_chain == \\\"nucleic_acid\\\":\\n new_chain = Bio.PDB.Chain.Chain(name)\\n chain = copy.copy(chain)\\n for residue in chain:\\n new_chain.add(residue.copy())\\n\\n for residue in new_chain:\\n for atom in residue:\\n if atom.id == \\\"C1'\\\":\\n atom.id = \\\"CA\\\"\\n residue.add(atom.copy())\\n return new_chain\\n else:\\n return chain\",\n \"def create_from_segments(self, segment, origin=0):\\r\\n n = origin\\r\\n if segment[origin]['T'] != 'soma': # if it's a soma, only one compartment\\r\\n while (len(segment[n]['children']) == 1) and (segment[n]['T'] != 'soma'): # Go to the end of the branch\\r\\n n += 1\\r\\n # End of branch\\r\\n branch = segment[origin:n + 1]\\r\\n # Set attributes\\r\\n self.diameter, self.length, self.area, self.x, self.y, self.z = \\\\\\r\\n zip(*[(seg['diameter'], seg['length'], seg['area'], seg['x'], seg['y'], seg['z']) for seg in branch])\\r\\n self.diameter, self.length, self.area, self.x, self.y, self.z = array(self.diameter), array(self.length), \\\\\\r\\n array(self.area), array(self.x), array(self.y), array(self.z)\\r\\n self.type = segment[n]['T'] # normally same type for all compartments in the branch\\r\\n # Create children (list)\\r\\n self.children = [Morphology().create_from_segments(segment, origin=c) for c in segment[n]['children']]\\r\\n # Create dictionary of names (enumerates children from number 1)\\r\\n for i, child in enumerate(self.children):\\r\\n self._namedkid[str(i + 1)] = child\\r\\n # Name the child if possible\\r\\n if child.type in ['soma', 'axon', 'dendrite']:\\r\\n if child.type in self._namedkid:\\r\\n self._namedkid[child.type] = None # two children with the same name: erase (see next block)\\r\\n else:\\r\\n self._namedkid[child.type] = child\\r\\n # Erase useless names\\r\\n for k in self._namedkid.keys():\\r\\n if self._namedkid[k] is None:\\r\\n del self._namedkid[k]\\r\\n # If two kids, name them L (left) and R (right)\\r\\n if len(self.children) == 2:\\r\\n self._namedkid['L'] = self._namedkid['1']\\r\\n self._namedkid['R'] = self._namedkid['2']\\r\\n return self\",\n \"def save_chain(self):\\n pprint('saving to file named bc_file.txt')\\n with open('ddos_bc_file.txt', 'w') as output:\\n output.write(serializer.serialize(self.chain))\",\n \"def make_mixture_info(parts, operation='+'):\\n # type: (List[ModelInfo], str) -> ModelInfo\\n # Build new parameter list\\n combined_pars = []\\n\\n # When creating a mixture model that is a sum of product models (ie (1*2)+(3*4))\\n # the parameters for models 1 & 2 will be prefixed with A & B respectively,\\n # but so will the parameters for models 3 & 4. We need to rename models 3 & 4\\n # so that they are prefixed with C & D to avoid overlap of parameter names.\\n used_prefixes = []\\n for part in parts:\\n if part.composition and part.composition[0] == 'mixture':\\n i = 0\\n for submodel in part.composition[1]:\\n npars = len(submodel.parameters.kernel_parameters)\\n # List of params of one of the constituent models of part\\n submodel_pars = part.parameters.kernel_parameters[i:i+npars]\\n # Prefix of the constituent model\\n prefix = submodel_pars[0].name[0]\\n if prefix not in used_prefixes: # Haven't seen this prefix so far\\n used_prefixes.append(prefix)\\n i += npars\\n continue\\n # TODO: don't modify submodel --- it may be used elsewhere\\n # Existing code probably doesn't keep a handle on the model\\n # parts so its probably okay, but it's possible that a mix\\n # on user defined mixture models models will change the\\n # parameters used for the parts in the GUI. Even worse if the\\n # same plugin is used twice. For example, twosphere.py\\n # contains sphere+sphere and you create twosphere+twosphere.\\n while prefix in used_prefixes:\\n # This prefix has been already used, so change it to the\\n # next letter that hasn't been used\\n prefix = chr(ord(prefix) + 1)\\n used_prefixes.append(prefix)\\n prefix += \\\"_\\\"\\n # Update the parameters of this constituent model to use the\\n # new prefix\\n for par in submodel_pars:\\n # Strip {prefix}_ using par.name[2:], etc.\\n # TODO: fails for AB_scale\\n par.id = prefix + par.id[2:]\\n par.name = prefix + par.name[2:]\\n if par.length_control is not None:\\n par.length_control = prefix + par.length_control[2:]\\n i += npars\\n\\n for part in parts:\\n # Parameter prefix per model, A_, B_, ...\\n # Note that prefix must also be applied to id and length_control\\n # to support vector parameters\\n prefix = ''\\n if not part.composition or part.composition[0] == 'product':\\n # Model isn't a composition model, so its parameters don't have a\\n # a prefix. Add the next available prefix\\n prefix = chr(ord('A')+len(used_prefixes))\\n used_prefixes.append(prefix)\\n prefix += '_'\\n\\n if operation == '+':\\n # If model is a sum model, each constituent model gets its own scale parameter\\n scale_prefix = prefix\\n if prefix == '' and getattr(part, \\\"operation\\\", '') == '*':\\n # `part` is a composition product model. Find the prefixes of\\n # its parameters to form a new prefix for the scale.\\n # For example, a model with A*B*C will have ABC_scale.\\n sub_prefixes = []\\n for param in part.parameters.kernel_parameters:\\n # Prefix of constituent model\\n sub_prefix = param.id.split('_')[0]\\n if sub_prefix not in sub_prefixes:\\n sub_prefixes.append(sub_prefix)\\n # Concatenate sub_prefixes to form prefix for the scale\\n scale_prefix = ''.join(sub_prefixes) + '_'\\n scale = Parameter(scale_prefix + 'scale', default=1.0,\\n description=\\\"model intensity for \\\" + part.name)\\n combined_pars.append(scale)\\n for p in part.parameters.kernel_parameters:\\n p = copy(p)\\n p.name = prefix + p.name\\n p.id = prefix + p.id\\n if p.length_control is not None:\\n p.length_control = prefix + p.length_control\\n combined_pars.append(p)\\n parameters = ParameterTable(combined_pars)\\n # Allow for the scenario in which each component has all its PD parameters\\n # active simultaneously. details.make_details() will throw an error if\\n # too many are used from any one component.\\n parameters.max_pd = sum(part.parameters.max_pd for part in parts)\\n\\n def random():\\n \\\"\\\"\\\"Random set of model parameters for mixture model\\\"\\\"\\\"\\n combined_pars = {}\\n for k, part in enumerate(parts):\\n prefix = chr(ord('A')+k) + '_'\\n pars = part.random()\\n combined_pars.update((prefix+k, v) for k, v in pars.items())\\n return combined_pars\\n\\n model_info = ModelInfo()\\n model_info.id = operation.join(part.id for part in parts)\\n model_info.operation = operation\\n model_info.name = '(' + operation.join(part.name for part in parts) + ')'\\n model_info.filename = None\\n model_info.title = 'Mixture model with ' + model_info.name\\n model_info.description = model_info.title\\n model_info.docs = model_info.title\\n model_info.category = \\\"custom\\\"\\n model_info.parameters = parameters\\n model_info.random = random\\n #model_info.single = any(part['single'] for part in parts)\\n model_info.structure_factor = False\\n #model_info.tests = []\\n #model_info.source = []\\n # Remember the component info blocks so we can build the model\\n model_info.composition = ('mixture', parts)\\n return model_info\",\n \"def writeBlocks(self):\\n dataFile = open(\\\"chain.txt\\\", \\\"w\\\")\\n chainData = []\\n for eachBlock in self.chain:\\n chainData.append(eachBlock.__dict__)\\n dataFile.write(json.dumps(chainData, indent=4))\\n dataFile.close()\",\n \"def construct_fragments(self):\\n for frag_dict in self.fragment_dict_list:\\n try:\\n chain = self.model[frag_dict[\\\"chain_id\\\"]]\\n frag = chain[frag_dict[\\\"frag_id\\\"]]\\n except KeyError:\\n self.add_fragment(frag_dict, None)\\n continue\\n\\n self.add_fragment(frag_dict, frag)\",\n \"def _pack(self):\\n pass\",\n \"def pack_goods(self, by=None):\",\n \"def pack_goods(self, by=None):\",\n \"def createInnerRepresentation(self):\\n\\n for idx, single_block in enumerate(self._block_list):\\n del self._to_be_processed[:]\\n del self._metastring_rest[:]\\n self._metastring_rest.append(self._metastring[idx])\\n self.addMetastringPointer(single_block)\",\n \"def create(data):\\n \\n return Part(\\n part_id = data['part_num'],\\n category_id = data['part_cat_id'],\\n external_ids = data.get('external_ids', {}),\\n name = data['name'],\\n year_from = data.get('year_from', None),\\n year_to = data.get('year_to', None),\\n url = data.get('part_url', None),\\n img_url = data.get('part_img_url', None),\\n print_of = data.get('print_of', None),\\n prints = data.get('prints', []),\\n molds = data.get('molds', []),\\n alternates = data.get('alternates', []))\",\n \"def assemble_parts(self):\\n self.parts['whole'] = self.output\\n self.parts['encoding'] = self.document.settings.output_encoding\\n self.parts['version'] = docutils.__version__\",\n \"def serialize(self):\",\n \"def _marshal(self, pieces):\\n payload = b''.join(pieces)\\n return struct.pack('>BHI', self.frame_type, self.channel_number,\\n len(payload)) + payload + bytes((spec.FRAME_END,))\",\n \"def _blob(self):\\n self.__rewrite_sldIdLst()\\n # # at least the following needs to be added before using\\n # # _reltype_ordering again for Presentation\\n # self.__rewrite_notesMasterIdLst()\\n # self.__rewrite_handoutMasterIdLst()\\n # self.__rewrite_sldMasterIdLst()\\n return super(Presentation, self)._blob\",\n \"def get_structure(self):\\n return self.chain.model.structure\",\n \"def marshal(self):\\n return self._marshal(list())\",\n \"def marshal(self):\\n return self._marshal([self.fragment])\",\n \"def build_serializer(self):\\n self._add_child_elements_recursive(self.get_root_element())\",\n \"def chainsetup(filename, cation, facets, operation, end_radii, nradii,\\n adensity):\\n\\n # Load the Cage from the file\\n try:\\n # If that fails, try other file formats supported by pymatgen\\n anion = Cage.from_file(filename)\\n except ValueError:\\n # If that fails, try the VASP POSCAR format\\n anion = Cage.from_poscar(filename)\\n\\n # Center the anion around the origin\\n anion.center()\\n\\n # Find the chain edges, i.e. the paths between the edge sharing facets of\\n # the chain of non-equivalent facets.\\n anion.find_surface_facets(ignore=IGNORE)\\n\\n if not facets == tuple:\\n chosen_facets = [anion.facets[index] for index in facets]\\n edges = anion.find_noneq_chain_links(chosen_facets)\\n else:\\n edges = anion.find_noneq_chain_links()\\n\\n total_mol = anion.copy()\\n\\n chain_dir = 'chain_' + operation\\n try:\\n os.mkdir(chain_dir)\\n except FileExistsError:\\n pass\\n\\n # For each edge, set up the calculation input files\\n edge_number = 1\\n\\n for edge in edges:\\n\\n # Set up the edge directory\\n edge_dir = os.path.join(chain_dir, \\\"edge\\\" + str(edge_number))\\n\\n while os.path.exists(edge_dir):\\n edge_number += 1\\n edge_dir = os.path.join(chain_dir, \\\"edge\\\" + str(edge_number))\\n\\n os.mkdir(edge_dir)\\n\\n # Write out the molecule and path facets to the edge directory\\n anion.to(fmt=\\\"json\\\", filename=os.path.join(edge_dir, \\\"molecule.json\\\"))\\n edge[0].to(fmt=\\\"json\\\", filename=os.path.join(edge_dir,\\n \\\"init_facet.json\\\"))\\n edge[1].to(fmt=\\\"json\\\", filename=os.path.join(edge_dir,\\n \\\"final_facet.json\\\"))\\n\\n # Get copies so the originals aren't mutated\\n edge_mol = anion.copy()\\n facet1 = edge[0].copy()\\n facet2 = edge[1].copy()\\n\\n if edge == edges[-1]:\\n remove_endline = False\\n else:\\n remove_endline = True\\n\\n # Set up the landscape\\n landscape = set_up_edge_landscape(facet1, facet2,\\n endpoint_radii=end_radii,\\n number_of_radii=nradii,\\n angle_density=adensity,\\n remove_endline=remove_endline)\\n\\n # Get the molecule for each landscape point\\n molecules = set_up_molecules(edge_mol, landscape, cation)\\n\\n # Set up an xyz file to visualize the edge and total landscape\\n for point in landscape.points:\\n try:\\n total_mol.append(pmg.Specie(cation, 1), point,\\n validate_proximity=False)\\n edge_mol.append(pmg.Specie(cation, 1), point,\\n validate_proximity=False)\\n except ValueError:\\n pass\\n\\n edge_mol.to(fmt=\\\"xyz\\\", filename=os.path.join(edge_dir, \\\"edge.xyz\\\"))\\n\\n # In case the molecules must be optimized, add the constraints and\\n # optimization setup (DRIVER)\\n if operation == \\\"optimize\\\":\\n far_facet = anion.find_farthest_facet(landscape.center)\\n constraints = find_constraints(anion, far_facet.sites)\\n constraints['fix atom'] += ' ' + str(len(anion.sites) + 1)\\n ALT_SETUP['constraints'] = constraints\\n ALT_SETUP[\\\"driver\\\"] = DRIVER_SETUP\\n\\n # Set up the task for the calculations\\n tasks = [nwchem.NwTask(molecules[0].charge, None, BASIS,\\n theory=\\\"dft\\\",\\n operation=operation,\\n theory_directives=THEORY_SETUP,\\n alternate_directives=ALT_SETUP)]\\n\\n # Set up the input files\\n study = Study(molecules, tasks)\\n study.set_up_input(edge_dir, sort_comp=False,\\n geometry_options=GEO_SETUP)\\n\\n edge_number += 1\\n\\n # Set up an xyz file with all the paths\\n total_mol.to(fmt=\\\"xyz\\\", filename=os.path.join(chain_dir, \\\"total_mol.xyz\\\"))\",\n \"def add_chain_signature(\\n self, prop: str, key: JWK, alg: Optional[AlgorithmName] = None,\\n header: Optional[JsonObject] = None) -> None:\\n top_level_signature = self._payload.get(prop)\\n for k in top_level_signature.keys():\\n if k != _CHAIN:\\n del top_level_signature[k]\\n chain = top_level_signature.get(_CHAIN, [])\\n self._add_signature(prop, key, alg, header,\\n lambda h: {_CHAIN: chain + [h]},\\n lambda h: (self._payload\\n .setdefault(prop, {})\\n .setdefault(_CHAIN, [])\\n .append(h)))\",\n \"def trip_chain(self):\\n pass\",\n \"def __init__(self, objects=()):\\n\\n vtk.vtkPropAssembly.__init__(self)\\n\\n self.name = \\\"\\\"\\n self.created = \\\"\\\"\\n self.trail = None\\n self.trail_points = []\\n self.trail_segment_size = 0\\n self.trail_offset = None\\n self.shadows = []\\n self.info = {}\\n self.rendered_at = set()\\n self.transform = None\\n self.scalarbar = None\\n\\n for a in vedo.utils.flatten(objects):\\n if a:\\n self.AddPart(a)\\n\\n self.PickableOff()\",\n \"def parse_part(self):\\n parts = []\\n for part in re.split(r'\\\\*\\\\*\\\\* ([A-Z- ]+) \\\\*\\\\*\\\\*', self.hand_file): # return [ 'part1', 'splitter1', 'part2',..\\n parts.append(part)\\n\\n for i in range(0, len(parts)):\\n if i == 0:\\n self.part_dict['HEADER'] = parts[i]\\n if i % 2 != 0: # number is odd\\n self.part_dict[parts[i]] = parts[i + 1]\",\n \"def marshal_departments(result):\\n return result\",\n \"def read_chain(self, _id):\\n chain_def = {'class' : 'chain', 'type' : ''}\\n for i in self.config_reader.options(_id):\\n chain_def[i] = self.config_reader.get(_id, i)\\n logging.debug(\\\"Registering chain %s\\\", _id)\\n self.instances.register(_id,chain_def,self.create_chain)\",\n \"def dump_parts(self, io):\\n\\n # XXX refactor with Tempita\\n title = \\\"Parts created by the docutils writer '%s'\\\" % self.strategy.name\\n io.say(title + os.linesep)\\n io.say(len(title) * '-')\\n io.say(2 * os.linesep)\\n io.say('Part keys: ' + 2 * os.linesep)\\n\\n parts = self.publish_parts(io)\\n io.say(os.linesep.join(sorted(parts.keys())))\\n io.say(2 * os.linesep)\\n for part in parts:\\n io.say(\\\"Value of part '%s':%s\\\" % (part, os.linesep))\\n io.say(parts[part].encode('utf-8') + os.linesep)\\n io.say(80*'-'+os.linesep)\\n io.say(os.linesep)\",\n \"def serialize(self):\\n return {\\n 'id': self.id,\\n 'name': self.name,\\n 'ingredients': self.ingredients,\\n 'directions': self.directions,\\n 'type': self.type,\\n }\",\n \"def addChain(self, chain):\\n\\n\\t\\tself.chain.append(chain)\\n\\t\\tchain.parentMolecule = self\",\n \"def normalize_chain(cls, chain):\\n\\n if isinstance(chain, cls):\\n chain = (chain,)\\n return tuple(x for x in chain if x is not None)\",\n \"def toPartners(self):\\n num_bases = len(self) #number of bases\\n result = [None] * len(self) #array of None, one for each base\\n stack = []\\n start = self.StartSymbols\\n end = self.EndSymbols\\n for i, symbol in enumerate(self):\\n if symbol in start: #open a pair\\n stack.append(i)\\n elif symbol in end: #close a pair\\n curr = stack.pop() #return and delete last element\\n result[i] = curr #make i pair with the last element...\\n result[curr] = i #...and the last element pair with i\\n \\n #test whether there are any open pairs left unaccounted for \\n if stack:\\n raise IndexError, \\\\\\n \\\"Too many open pairs in structure:\\\\n%s\\\" % self\\n return Partners(result)\",\n \"def __init__(self, fab=None, heavy_chains=None, light_chains=None, names=None):\\n # check if it's a Chain object\\n if heavy_chains is None and light_chains is None and fab is None:\\n raise ValueError('Provide a list of Chain objects or an ChainCollection object')\\n\\n # check if fab object is a list and if all object are abpytools.Fab objects\\n if isinstance(fab, list) and all(isinstance(fab_i, Fab) for fab_i in fab):\\n self._fab = fab\\n self._light_chains = ChainCollection([x[0] for x in self._fab])\\n self._heavy_chains = ChainCollection([x[1] for x in self._fab])\\n\\n if fab is None and (heavy_chains is not None and light_chains is not None):\\n\\n if isinstance(heavy_chains, list):\\n self._heavy_chains = ChainCollection(antibody_objects=heavy_chains)\\n\\n elif isinstance(heavy_chains, ChainCollection):\\n self._heavy_chains = heavy_chains\\n\\n else:\\n raise ValueError('Provide a list of Chain objects or an ChainCollection object')\\n\\n if isinstance(light_chains, list):\\n self._light_chains = ChainCollection(antibody_objects=light_chains)\\n\\n elif isinstance(light_chains, ChainCollection):\\n self._light_chains = light_chains\\n\\n else:\\n raise ValueError('Provide a list of Chain objects or an ChainCollection object')\\n\\n if len(self._light_chains.loading_status()) == 0:\\n self._light_chains.load()\\n\\n if len(self._heavy_chains.loading_status()) == 0:\\n self._heavy_chains.load()\\n\\n if self._light_chains.n_ab != self._heavy_chains.n_ab:\\n raise ValueError('Number of heavy chains must be the same of light chains')\\n\\n if isinstance(names, list) and all(isinstance(name, str) for name in names):\\n if len(names) == self._heavy_chains.n_ab:\\n self._names = names\\n else:\\n raise ValueError(\\n 'Length of name list must be the same as length of heavy_chains/light chains lists')\\n\\n elif names is None:\\n self._names = ['{} - {}'.format(heavy, light) for heavy, light in zip(self._heavy_chains.names,\\n self._light_chains.names)]\\n\\n else:\\n raise ValueError(\\\"Names expected a list of strings, instead got {}\\\".format(type(names)))\\n\\n self._n_ab = self._light_chains.n_ab\\n self._pair_sequences = [heavy + light for light, heavy in zip(self._heavy_chains.sequences,\\n self._light_chains.sequences)]\\n\\n # keep the name of the heavy and light chains internally to keep everything in the right order\\n self._internal_heavy_name = self._heavy_chains.names\\n self._internal_light_name = self._light_chains.names\",\n \"def get_serializer(self, *args, **kwargs):\\n kwargs['part_detail'] = True\\n kwargs['location_detail'] = True\\n kwargs['supplier_part_detail'] = True\\n kwargs['context'] = self.get_serializer_context()\\n\\n return self.serializer_class(*args, **kwargs)\",\n \"def _encode_supplement(self):\",\n \"def _encode_supplement(self):\",\n \"def serialize(self, data):\",\n \"def partid2nids(self, partid, ntype): # -> None:\\n ...\",\n \"def from_binary(self, d):\\n p = MsgCertificateChainDep._parser.parse(d)\\n for n in self.__class__.__slots__:\\n setattr(self, n, getattr(p, n))\",\n \"def __init__(self, chain_instance, *args, **kwargs):\\n protocol_logger('Intializing protocol processor')\\n self.chain_instance = chain_instance\",\n \"def build_parts_from_dict(self, data, skip_power_controls=False):\\n \\n # Validate Objects information.\\n if \\\"Objects\\\" not in data:\\n return\\n\\n # Start creating parts.\\n parts = []\\n for part_data in data[\\\"Objects\\\"]:\\n part = part_data[\\\"ObjectID\\\"].replace(\\\"^\\\", \\\"\\\")\\n timestamp = part_data[\\\"Timestamp\\\"]\\n user_data = part_data[\\\"UserData\\\"]\\n part_position = part_data[\\\"Position\\\"]\\n up_vec = part_data[\\\"Up\\\"]\\n at_vec = part_data[\\\"At\\\"]\\n # Build the item.\\n item = self.build_item(\\n part,\\n timestamp,\\n user_data,\\n part_position,\\n up_vec,\\n at_vec,\\n skip_power_controls\\n )\\n parts.append(item)\\n\\n return parts\",\n \"def preparing(fasta_list, pdb_dict):\\n for item1 in fasta_list:\\n matchObj = re.search( '^(.*)_([a-zA-Z0-9])$', item1[0])\\n fasta1= item1[1]\\n if matchObj:\\n original_name1= matchObj.group(1)\\n original_structure1=pdb_dict[original_name1]\\n chain_1= matchObj.group(2) \\n yield fasta1, [original_structure1, chain_1]\",\n \"def _make_partitionsTest_label(chain_parts):\\n\\n assert len(chain_parts) == 1\\n scenario = chain_parts[0]['hypoScenario']\\n \\n assert scenario == 'partitionsTest'\\n\\n \\n\\n return \\\"\\\"\\\"\\n partgen(\\n [(20et, 0eta320)]\\n \\n simple([(40et, 0eta320) (50et, 0eta320)])\\n simple([(35et, 0eta240) (55et, 0eta240)])\\n )\\\"\\\"\\\"\",\n \"def _get_chain_repr(self, chain):\\n chain_repr = []\\n for module in chain:\\n if isinstance(module, collections.Iterable): # module is a chain\\n chain_repr.append(self._get_chain_repr(module))\\n elif hasattr(module, 'process'): # module is an object\\n chain_repr.extend(\\n (str(module.__class__), repr(vars(module))))\\n else: # module is a function\\n if isinstance(module, partial): # partial function\\n chain_repr.extend((str(module.__class__), repr(module.func),\\n repr(module.keywords)))\\n else:\\n chain_repr.append(repr(module))\\n return ' '.join(chain_repr)\",\n \"def serialize(self, root):\",\n \"def partid2nids(self, partid, ntype=...):\\n ...\",\n \"def partid2nids(self, partid, ntype=...):\\n ...\",\n \"def _decode(self, parts: typing.List[int]) -> typing.Dict:\\n info = {field.name: field.decode(parts[i]) for i, field in enumerate(self.fields)}\\n return info\",\n \"def __init__(self):\\n self.chain = [Block.genesis()]\",\n \"def compose(self):\\r\\n return_lib = self.other\\r\\n return_lib.update({\\r\\n 'ID' : self.id,\\r\\n 'Name' : self.name,\\r\\n 'Alias' : self.alias,\\r\\n 'Parent' : self.parent,\\r\\n 'Target' : self.target,\\r\\n 'Gap' : self.gap,\\r\\n 'Derives_from' : self.derives_from,\\r\\n 'Note' : self.note,\\r\\n 'Dbxref' : self.dbxref,\\r\\n 'Ontology_term' : self.ontology_term,\\r\\n 'Is_circular' : self.is_circular,\\r\\n 'allele' : ','.join([a.strip() for a in self.allele])\\r\\n })\\r\\n if self.discovered != None:\\r\\n if self.discovered:\\r\\n return_lib[self.discovered_key] = self.enabled[0]\\r\\n else:\\r\\n return_lib[self.discovered_key] = self.disabled[0]\\r\\n if self.validated != None:\\r\\n if self.validated:\\r\\n return_lib[self.validated_key] = self.enabled[0]\\r\\n else:\\r\\n return_lib[self.validated_key] = self.disabled[0]\\r\\n if self.active != None:\\r\\n if self.active:\\r\\n return_lib[self.active_key] = self.disabled[0]\\r\\n else:\\r\\n return_lib[self.active_key] = self.enabled[0]\\r\\n for i,item in enumerate(self.history):\\r\\n return_lib[\\\"{}_{}\\\".format(self.history_key,i)] = ','.join(item)\\r\\n return_str = ';'.join([key + '=' + value for key, value in return_lib.items() if value])\\r\\n return return_str\",\n \"def _encode_parts(self, messages, encode_empty=False):\\n if messages or encode_empty:\\n return self.signer.sign_object(\\n messages, serializer=MessagePartGatherSerializer, compress=True\\n )\",\n \"def serialize(self):\\n pass\",\n \"def _create_chain(class_type_list, kwargs_list):\\n chain = None # module with preprocessing chain\\n modules = [] # list of modules (not connected via preprocessing)\\n for i, pre_id in enumerate(class_type_list):\\n chain = CModule.create(\\n pre_id, preprocess=chain, **kwargs_list[i])\\n modules.append(CModule.create(pre_id, **kwargs_list[i]))\\n return chain, modules\",\n \"def __store_part(self, definition, pnum, multisubtype):\\n pnum = \\\"1\\\" if pnum is None else pnum\\n params = {\\n \\\"pnum\\\": pnum,\\n \\\"params\\\": definition[2],\\n \\\"cid\\\": definition[3],\\n \\\"description\\\": definition[4],\\n \\\"encoding\\\": definition[5],\\n \\\"size\\\": definition[6]\\n }\\n mtype = definition[0].lower()\\n subtype = definition[1].lower()\\n ftype = \\\"%s/%s\\\" % (definition[0].lower(), subtype)\\n if ftype in (\\\"text/plain\\\", \\\"text/html\\\"):\\n if subtype not in self.contents:\\n self.contents[subtype] = [params]\\n else:\\n self.contents[subtype].append(params)\\n return\\n elif multisubtype in [\\\"related\\\"]:\\n self.inlines[params[\\\"cid\\\"].strip(\\\"<>\\\")] = params\\n return\\n\\n params[\\\"Content-Type\\\"] = ftype\\n if len(definition) > 7:\\n extensions = [\\\"md5\\\", \\\"disposition\\\", \\\"language\\\", \\\"location\\\"]\\n if mtype == \\\"text\\\":\\n extensions = [\\\"textlines\\\"] + extensions\\n elif ftype == \\\"message/rfc822\\\":\\n extensions = [\\n \\\"envelopestruct\\\",\\n \\\"bodystruct\\\",\\n \\\"textlines\\\"] + extensions\\n for idx, value in enumerate(definition[7:]):\\n params[extensions[idx]] = value\\n\\n self.attachments += [params]\",\n \"def serialize(self):\\n return {\\n 'name' : self.name,\\n 'ingredients' : self.ingredients,\\n 'id' : self.id,\\n 'preparation' : self.preparation,\\n 'image' : self.image,\\n }\",\n \"def skeleton_getHandleChain(self, typeModifier = None, jointHelpers = True, mOrientHelper = None):\\n _short = self.mNode\\n _str_func = 'skeleton_getHandleChain'\\n #start = time.clock()\\t\\n log.debug(cgmGEN.logString_start(_str_func))\\n \\n mRigNull = self.moduleTarget.rigNull\\n ml_fkJoints = mRigNull.msgList_get('fkJoints')\\n \\n if not ml_fkJoints:\\n log.debug(\\\"|{0}| >> Generating handleJoints\\\".format(_str_func))\\n \\n ml_formHandles = self.msgList_get('formHandles',asMeta = True)\\n if not ml_formHandles:\\n raise ValueError,\\\"No formHandles connected\\\" \\n \\n ml_prerigHandles = self.msgList_get('prerigHandles',asMeta = True)\\n if not ml_prerigHandles:\\n raise ValueError,\\\"No prerigHandles connected\\\"\\n \\n if mOrientHelper is None:\\n mOrientHelper = ml_formHandles[0].orientHelper or ml_prerigHandles[0].orientHelper\\n \\n #_d = skeleton_getCreateDict(self)\\n #pprint.pprint(_d)\\n l_pos = []\\n for mObj in ml_prerigHandles:\\n l_pos.append(mObj.p_position)\\n \\n ml_fkJoints = COREJOINTS.build_chain(posList = l_pos,\\n axisAim='z+',\\n axisUp='y+',\\n parent=True,\\n worldUpAxis= mOrientHelper.getAxisVector('y+'))\\n \\n for i,mJnt in enumerate(ml_fkJoints):\\n mJnt.doCopyNameTagsFromObject(ml_prerigHandles[i].mNode, ignore = ['cgmType'])\\n if not typeModifier:\\n mJnt.doName()\\n \\n if typeModifier:\\n for mJnt in ml_fkJoints:\\n mJnt.addAttr('cgmTypeModifier',typeModifier,attrType='string',lock=True)\\n mJnt.addAttr('cgmType','frame',attrType='string',lock=True) \\n mJnt.doName()\\n \\n ml_fkJoints[0].p_parent = False\\n else:\\n log.debug(\\\"|{0}| >> Found fkJoints\\\".format(_str_func))\\n \\n #log.debug(\\\"%s >> Time >> = %0.3f seconds \\\" % (_str_func,(time.clock()-start)) + \\\"-\\\"*75)\\t\\n return ml_fkJoints\",\n \"def serialize(self, pipe, pid):\\n for trsp in self.transports:\\n pipe.send(trsp.__class__)\\n trsp.serialize(pipe, pid)\",\n \"def _make_information_storable( self, data ):\\n\\t\\tpass\",\n \"def save_data(self):\\n try:\\n with open('blockchain-{}.txt'.format(self.node_id), mode='w') as f:\\n saveable_chain = [block.__dict__ for block in [Block(block_el.index, block_el.previous_hash, \\n [tx.__dict__ for tx in block_el.transactions], \\n [tx.__dict__ for tx in block_el.chipsactions],\\n [tx.__dict__ for tx in block_el.messsactions],\\n block_el.proof, block_el.timestamp) for block_el in self.__chain]]\\n f.write(json.dumps(saveable_chain))\\n f.write('\\\\n')\\n saveable_tx = [tx.__dict__ for tx in self.__open_transactions]\\n f.write(json.dumps(saveable_tx))\\n f.write('\\\\n')\\n saveable_chip = [tx.__dict__ for tx in self.__open_chipsactions]\\n f.write(json.dumps(saveable_chip))\\n f.write('\\\\n')\\n saveable_chip = [tx.__dict__ for tx in self.__open_messsactions]\\n f.write(json.dumps(saveable_chip))\\n f.write('\\\\n')\\n f.write(json.dumps(list(self.__peer_nodes)))\\n except IOError:\\n print('Saving failed!')\",\n \"def to_binary(self):\\n c = containerize(exclude_fields(self))\\n self.payload = MsgCertificateChainDep._parser.build(c)\\n return self.pack()\",\n \"def create_chain_instances(self):\\n for section in self.config_reader.sections():\\n self.read_chain(section)\",\n \"def make_drs_tree(self):\\n pass\",\n \"def create(data):\\n \\n return Partlist(\\n list_id = data['id'],\\n name = data['name'],\\n pieces = data['num_parts'])\",\n \"def chain():\\n chain_identifier, url = get_vars(request, [\\\"id\\\", \\\"data\\\"])\\n info('chain=%s' % chain_identifier)\\n chain = LAPPS_SERVICE_CHAINS.get_chain(chain_identifier)\\n info('source-url=%s' % url)\\n data = requests.get(url).text\\n result = chain.run({\\n \\\"discriminator\\\": \\\"http://vocab.lappsgrid.org/ns/media/text\\\", \\n \\\"payload\\\": data})\\n info(\\\"discriminator=%s\\\" % result.get('discriminator'))\\n return render_template(\\\"chain.html\\\",\\n chain=chain,\\n fname=url,\\n result=result,\\n builder=HtmlBuilder())\",\n \"def setPartsToRegister(self, parts):\\n internals.blpapi_ServiceRegistrationOptions_setPartsToRegister(\\n self.__handle, parts)\",\n \"def produce_chain_dict (inPath, outPath):\\n with open(inPath, 'r') as fin:\\n chainIDs = list(fin.read().split())\\n chains = {}\\n for chainid in chainIDs:\\n pdbid = (chainid[ : chainid.find('_') ] if '_' in chainid else chainid)\\n if pdbid in chains:\\n chains[pdbid].add(chainid)\\n else:\\n chains[pdbid] = {chainid}\\n with open(outPath, 'wb') as fOut:\\n pickle.dump(chains, fOut)\",\n \"def wire_chains(self):\\n allChains = self.instances.getAllChainInstances()\\n for chain in allChains:\\n logging.debug(\\\"%s\\\", chain)\\n allChains[chain].setup_event_path()\",\n \"def _encode(self, boxes, anchors):\\n pass\",\n \"def __init__(self):\\n self.chain = {}\\n self.blocks = {}\\n self.blocks_spending_input = {}\\n self.blocks_containing_tx = {}\\n self.all_transactions = {}\",\n \"def prepare_order(acct, order):\\n myaddr = (acct.address).lower()\\n order[\\\"makerAddress\\\"] = myaddr\\n order_struct = jsdict_order_to_struct(order) \\n sig = _sign_order(acct, order_struct)\\n order_struct[\\\"signature\\\"] = sig\\n js_order = order_to_jsdict(order_struct)\\n js_order[\\\"exchangeAddress\\\"] = exchangeAddress\\n return js_order\",\n \"def trans_setup():\\n # slot7 slot6 slot5 slot4 slot3 slot2 slot1 <------ beam direction (slot 8 is currently B-fiber only)\\n # Be Be Be Be Be Be Be lens material\\n # 1.5 1.5 0.5 0.5 0.5 0.5 0.5 lens radius [mm]\\n # 1 1 5 8 4 2 1 number of lenses\\n lens_R=[0.5,0.5,0.5,0.5,0.5,1.5,1.5]\\n lens_mat=['Be','Be','Be','Be','Be','Be','Be']\\n lens_N=[1,2,4,8,5,1,1]\\n trans_pos=[35.2,35.8]\\n return {'lens_material':lens_mat,'lens_number':lens_N,'lens_radius':lens_R,'trans_position':trans_pos}\",\n \"def _finishConstruction(self, obj):\\n return obj\",\n \"def _finishConstruction(self, obj):\\n return obj\",\n \"def genereate_echo_picklist(self):\\n sample_names = []\\n sample_wells = []\\n indices = {'i5 name': {}, 'i5 plate': {}, 'i5 sequence': {},\\n 'i5 well': {}, 'i7 name': {}, 'i7 plate': {},\\n 'i7 sequence': {}, 'i7 well': {}, 'index combo': {},\\n 'index combo seq': {}}\\n\\n for idx, well in enumerate(chain.from_iterable(self.plates[0].layout)):\\n # Add the sample well\\n sample_wells.append(well.well_id)\\n # Get the sample name - we need to go back to the SampleComposition\\n lib_comp = well.composition\\n sample_comp = lib_comp.normalized_gdna_composition\\\\\\n .gdna_composition.sample_composition\\n sample_names.append(sample_comp.content)\\n # Retrieve all the information about the indices\\n i5_comp = lib_comp.i5_composition.primer_set_composition\\n i5_well = i5_comp.container\\n indices['i5 name'][idx] = i5_comp.external_id\\n indices['i5 plate'][idx] = i5_well.plate.external_id\\n indices['i5 sequence'][idx] = i5_comp.barcode\\n indices['i5 well'][idx] = i5_well.well_id\\n\\n i7_comp = lib_comp.i7_composition.primer_set_composition\\n i7_well = i7_comp.container\\n indices['i7 name'][idx] = i7_comp.external_id\\n indices['i7 plate'][idx] = i7_well.plate.external_id\\n indices['i7 sequence'][idx] = i7_comp.barcode\\n indices['i7 well'][idx] = i7_well.well_id\\n\\n indices['index combo seq'][idx] = '%s%s' % (\\n indices['i5 sequence'][idx], indices['i7 sequence'][idx])\\n\\n sample_names = np.asarray(sample_names)\\n sample_wells = np.asarray(sample_wells)\\n indices = pd.DataFrame(indices)\\n\\n return LibraryPrepShotgunProcess._format_picklist(\\n sample_names, sample_wells, indices)\",\n \"def json(self):\\n blocks = [block.to_json() for block in self.chain[1:]]\\n return json.dumps({'blocks': blocks})\",\n \"def pdbChain_to_mdtrajChainid_li(chain,seg_to_chain,struc):\\n chain = chain.upper()\\n chain_segments=[seg for seg,chainval in seg_to_chain.items() if chainval==chain]\\n if chain_segments:\\n structable, bonds=struc.topology.to_dataframe()\\n chainid_li=[]\\n for segname in chain_segments:\\n seg_chainid_li=structable.loc[structable['segmentID'] == segname].chainID.unique()\\n chainid_li+=list(seg_chainid_li)\\n chainid_li=list(set(chainid_li))\\n return chainid_li\\n else:\\n return False\",\n \"def marshal(self):\\n pieces = self.properties.encode()\\n pieces.insert(\\n 0, struct.pack('>HxxQ', self.properties.INDEX, self.body_size))\\n return self._marshal(pieces)\",\n \"def init(self):\\n\\n logger.info(mm_chain.ackn_str)\\n self.acknowledgements = mm_chain.ackn_str\\n self.references = mm_chain.refs['chain']\\n\\n return\",\n \"def __init__(self):\\n self.unconfirmed_transactions = [] \\n self.chain = []\\n self.create_genesis_block()\",\n \"def build_item(\\n self,\\n part,\\n timestamp=1539023700,\\n userdata=0,\\n position=[0, 0, 0],\\n up_vec=[0, 1, 0],\\n at_vec=[0, 0, 1],\\n skip_power_controls=False):\\n # Get the obj path.\\n item = self.retrieve_part(part)\\n\\n # Lock Everything if it's the BASE_FLAG or U_POWERLINE.\\n # BASE_FLAG can break things if user moves it around.\\n # As it acts as the \\\"origin\\\" of the base.\\n locked_parts = [\\\"BASE_FLAG\\\", \\\"U_POWERLINE\\\", \\\"U_PIPELINE\\\", \\\"U_PORTALLINE\\\"]\\n line_parts = [\\\"U_POWERLINE\\\", \\\"U_PIPELINE\\\", \\\"U_PORTALLINE\\\"]\\n if part in locked_parts:\\n item.lock_location[0] = True\\n item.lock_location[1] = True\\n item.lock_location[2] = True\\n item.lock_rotation[0] = True\\n item.lock_rotation[1] = True\\n item.lock_rotation[2] = True\\n item.lock_scale[0] = True\\n item.lock_scale[1] = True\\n item.lock_scale[2] = True\\n \\n # Add custom attributes.\\n item[\\\"ObjectID\\\"] = part\\n item[\\\"SnapID\\\"] = part\\n item[\\\"Timestamp\\\"] = timestamp\\n item[\\\"belongs_to_preset\\\"] = False\\n # Add an order flag to retain order when generating data..\\n item[\\\"Order\\\"] = self.part_order\\n self.part_order += 1\\n # Apply Colour\\n is_powerline = part in line_parts\\n is_pipeline = part in [\\\"U_PIPELINE\\\"]\\n material.assign_material(\\n item,\\n userdata,\\n powerline=is_powerline,\\n pipeline=is_pipeline\\n )\\n\\n # Move\\n utils.move_to(item, position=position, up=up_vec, at=at_vec)\\n\\n # If the object is a powerline, we should create additional controls\\n # for it.\\n if is_powerline and not skip_power_controls:\\n power.create_power_controls(item)\\n # Select the new object.\\n item.select_set(True)\\n return item\",\n \"def connectPart(self,\\n hsNondes: list,\\n part: Union[TransPart, ChoicesOfFrameParts],\\n en: Union[RtlSignal, bool],\\n exclusiveEn: Optional[RtlSignal]=hBit(1)):\\n busVld = self.dataIn.valid\\n tToIntf = self.dataOut._fieldsToInterfaces\\n\\n if isinstance(part, ChoicesOfFrameParts):\\n parentIntf = tToIntf[part.origin.parent.origin]\\n try:\\n sel = self._tmpRegsForSelect[parentIntf]\\n except KeyError:\\n sel = HsBuilder(self, parentIntf._select).buff().end\\n self._tmpRegsForSelect[parentIntf] = sel\\n unionGroup = ExclusieveListOfHsNodes(sel)\\n\\n # for unions\\n for choice in part:\\n # connect data signals of choices and collect info about\\n # streams\\n intfOfChoice = tToIntf[choice.tmpl.origin]\\n selIndex, isSelected, isSelectValid = self.choiceIsSelected(\\n intfOfChoice)\\n _exclusiveEn = isSelectValid & isSelected & exclusiveEn\\n\\n unionMemberPart = ListOfOutNodeInfos()\\n for p in choice:\\n self.connectPart(unionMemberPart, p, en, _exclusiveEn)\\n unionGroup.append(selIndex, unionMemberPart)\\n\\n hsNondes.append(unionGroup)\\n\\n if part.isLastPart():\\n # synchronization of reading from _select register for unions\\n selNode = InNodeInfo(sel, en)\\n else:\\n selNode = InNodeReadOnlyInfo(sel, en)\\n hsNondes.append(selNode)\\n return\\n\\n if part.isPadding:\\n return\\n\\n fPartSig = self.getInDataSignal(part)\\n fieldInfo = part.tmpl.origin\\n\\n try:\\n signalsOfParts = self._signalsOfParts[part.tmpl]\\n except KeyError:\\n signalsOfParts = []\\n self._signalsOfParts[part.tmpl] = signalsOfParts\\n\\n if part.isLastPart():\\n # connect all parts in this group to output stream\\n signalsOfParts.append(fPartSig)\\n intf = self.dataOut._fieldsToInterfaces[fieldInfo]\\n intf.data(self.byteOrderCare(\\n Concat(\\n *reversed(signalsOfParts)\\n ))\\n )\\n on = OutNodeInfo(self, intf, en, exclusiveEn)\\n hsNondes.append(on)\\n else:\\n dataVld = busVld & en & exclusiveEn\\n # part is in some word as last part, we have to store its value to register\\n # until the last part arrive\\n fPartReg = self._reg(\\\"%s_part_%d\\\" % (fieldInfo.name,\\n len(signalsOfParts)),\\n fPartSig._dtype)\\n If(dataVld,\\n fPartReg(fPartSig)\\n )\\n signalsOfParts.append(fPartReg)\",\n \"def nid2partid(self, nids, ntype=...):\\n ...\",\n \"def nid2partid(self, nids, ntype=...):\\n ...\",\n \"def test_hierarchy_perceived_information_propagation(self):\\n from openff.toolkit._tests.create_molecules import (\\n dipeptide_hierarchy_added as create_dipeptide,\\n )\\n\\n dipeptide_hierarchy_perceived = create_dipeptide()\\n\\n for atom in dipeptide_hierarchy_perceived.atoms:\\n atom.metadata[\\\"chain_id\\\"] = \\\"A\\\"\\n assert (\\\"A\\\", \\\"1\\\", \\\" \\\", \\\"ACE\\\") != dipeptide_hierarchy_perceived.residues[\\n 0\\n ].identifier\\n dipeptide_hierarchy_perceived.update_hierarchy_schemes()\\n assert (\\\"A\\\", \\\"1\\\", \\\" \\\", \\\"ACE\\\") == dipeptide_hierarchy_perceived.residues[\\n 0\\n ].identifier\",\n \"def createInnerRepresentation(self):\\n\\n while self._metastring_rest:\\n self.addMetastringPointer(self._metastring_rest.pop(0))\",\n \"def _serialize(self, state, handle):\\n raise NotImplementedError\",\n \"def serialize(cleaned_data):\\n result = cleaned_data.copy()\\n for fieldname in Step1Data.REFERENCE_FIELDS_NAMES:\\n if result[fieldname]:\\n result[fieldname] = result[fieldname].pk\\n result[\\\"data\\\"] = result[\\\"data\\\"].isoformat()\\n # print \\\"serialize to:\\\", result\\n return result\",\n \"def encode(self):\\r\\n # Create dict from attributes. Maintain added order\\r\\n #jd = {'txpk': collections.OrderedDict()}\\r\\n jd = {'txpk':{}}\\r\\n\\r\\n for key in self.keys:\\r\\n val = getattr(self, key)\\r\\n\\r\\n if val is not None:\\r\\n if key == 'data':\\r\\n jd['txpk'][key] = val.decode('utf-8')\\r\\n else:\\r\\n jd['txpk'][key] = val\\r\\n #print('key',key)\\r\\n #print('valtype',type(val),val) \\r\\n #print(jd)\\r\\n \\r\\n return dumps(jd, separators=(',', ':'))\",\n \"def serialize(self):\\n\\t\\treturn { 'type': self.type, 'parameters' : self.parameters}\",\n \"async def b_chain() -> dict:\\n authority_chain = await chain.consensus()\\n return {\\\"chain\\\": authority_chain[\\\"chain\\\"]}\",\n \"def _create_chained_picking(self, cr, uid, pick_name, picking, purchase_type, move, context=None):\\n res = super(stock_move, self)._create_chained_picking(cr, uid, pick_name, picking, purchase_type, move, context=context)\\n if picking.purchase_id:\\n self.pool.get('stock.picking').write(cr, uid, [res], {'purchase_id': picking.purchase_id.id})\\n self.pool.get('stock.picking').write(cr, uid, [res], {'invoice_state': picking.invoice_state})\\n return res\",\n \"def nid2partid(self, nids, ntype): # -> None:\\n ...\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.51896733","0.5168605","0.51672775","0.51672775","0.50873256","0.5012869","0.50128603","0.49828157","0.49484867","0.49205998","0.48682296","0.48377433","0.48344752","0.4816704","0.48074743","0.47946405","0.47819698","0.47307587","0.47307587","0.470948","0.46880582","0.46699506","0.46636954","0.46246442","0.4621194","0.46177652","0.46041772","0.45956752","0.4576775","0.45758986","0.45601752","0.45586032","0.4549727","0.45488742","0.45300308","0.45288286","0.4488865","0.4470426","0.4468321","0.4466073","0.4463078","0.44562802","0.44518414","0.44456387","0.44456387","0.4441484","0.44412827","0.44327995","0.44320095","0.44278732","0.44207388","0.4416993","0.44162983","0.44130626","0.4412816","0.4412816","0.44112128","0.44095713","0.44080964","0.44070905","0.44025746","0.44005856","0.44004744","0.43999064","0.4399524","0.43966618","0.43935353","0.43906373","0.43881038","0.43804395","0.43796667","0.43787307","0.43772933","0.4374465","0.43730968","0.43709666","0.43663764","0.4359629","0.43542698","0.43533173","0.43529573","0.43529573","0.43516603","0.43495756","0.43490428","0.4346473","0.43393338","0.43390393","0.4333873","0.43316406","0.43314302","0.43314302","0.4328178","0.4322439","0.43209988","0.43155813","0.43155143","0.43092346","0.43080333","0.43078464","0.43056336"],"string":"[\n \"0.51896733\",\n \"0.5168605\",\n \"0.51672775\",\n \"0.51672775\",\n \"0.50873256\",\n \"0.5012869\",\n \"0.50128603\",\n \"0.49828157\",\n \"0.49484867\",\n \"0.49205998\",\n \"0.48682296\",\n \"0.48377433\",\n \"0.48344752\",\n \"0.4816704\",\n \"0.48074743\",\n \"0.47946405\",\n \"0.47819698\",\n \"0.47307587\",\n \"0.47307587\",\n \"0.470948\",\n \"0.46880582\",\n \"0.46699506\",\n \"0.46636954\",\n \"0.46246442\",\n \"0.4621194\",\n \"0.46177652\",\n \"0.46041772\",\n \"0.45956752\",\n \"0.4576775\",\n \"0.45758986\",\n \"0.45601752\",\n \"0.45586032\",\n \"0.4549727\",\n \"0.45488742\",\n \"0.45300308\",\n \"0.45288286\",\n \"0.4488865\",\n \"0.4470426\",\n \"0.4468321\",\n \"0.4466073\",\n \"0.4463078\",\n \"0.44562802\",\n \"0.44518414\",\n \"0.44456387\",\n \"0.44456387\",\n \"0.4441484\",\n \"0.44412827\",\n \"0.44327995\",\n \"0.44320095\",\n \"0.44278732\",\n \"0.44207388\",\n \"0.4416993\",\n \"0.44162983\",\n \"0.44130626\",\n \"0.4412816\",\n \"0.4412816\",\n \"0.44112128\",\n \"0.44095713\",\n \"0.44080964\",\n \"0.44070905\",\n \"0.44025746\",\n \"0.44005856\",\n \"0.44004744\",\n \"0.43999064\",\n \"0.4399524\",\n \"0.43966618\",\n \"0.43935353\",\n \"0.43906373\",\n \"0.43881038\",\n \"0.43804395\",\n \"0.43796667\",\n \"0.43787307\",\n \"0.43772933\",\n \"0.4374465\",\n \"0.43730968\",\n \"0.43709666\",\n \"0.43663764\",\n \"0.4359629\",\n \"0.43542698\",\n \"0.43533173\",\n \"0.43529573\",\n \"0.43529573\",\n \"0.43516603\",\n \"0.43495756\",\n \"0.43490428\",\n \"0.4346473\",\n \"0.43393338\",\n \"0.43390393\",\n \"0.4333873\",\n \"0.43316406\",\n \"0.43314302\",\n \"0.43314302\",\n \"0.4328178\",\n \"0.4322439\",\n \"0.43209988\",\n \"0.43155813\",\n \"0.43155143\",\n \"0.43092346\",\n \"0.43080333\",\n \"0.43078464\",\n \"0.43056336\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":8787,"cells":{"query":{"kind":"string","value":"Marshal information from the selected chainParts to create a vbenf label. Use a Reducer for elimination of unusable jets"},"document":{"kind":"string","value":"def _make_vbenf_label(chain_parts):\n\n # toy label for development: run simple and dijet independently.\n # simple makes Et cuts on two jets. Independently (sharing possible)\n # of jets choosean by simple, the dijet\n # scenario requires a dijet of mass > 900, and opening angle in phi > 2.6\n\n assert len(chain_parts) == 1\n scenario = chain_parts[0]['hypoScenario']\n assert scenario.startswith('vbenf')\n args = _args_from_scenario(scenario)\n if not args:\n return 'and([]simple([(50et)(70et)])combgen([(2)] dijet([(900djmass, 26djdphi)])))' \n arg_res = [\n re.compile(r'(?P<lo>\\d*)(?P<key>fbet)(?P<hi>\\d*)'),\n re.compile(r'(?P<lo>\\d*)(?P<key>mass)(?P<hi>\\d*)'),\n re.compile(r'(?P<lo>\\d*)(?P<key>et)(?P<hi>\\d*)'),\n ]\n\n defaults = {\n 'et': ('101', 'inf'),\n 'mass': ('800', 'inf'),\n 'fbet': ('501', 'inf'),\n }\n\n argvals = {}\n while args:\n assert len(args) == len(arg_res)\n arg = args.pop()\n for r in arg_res:\n m = r.match(arg)\n if m is not None:\n arg_res.remove(r)\n gd = m.groupdict()\n key = gd['key']\n try:\n lo = float(gd['lo'])\n except ValueError:\n lo = defaults[key][0]\n argvals[key+'lo'] = lo \n try:\n hi = float(gd['hi'])\n except ValueError:\n hi = defaults[key][1]\n argvals[key+'hi'] = hi\n\n assert len(args) == len(arg_res)\n assert len(args) == 0\n\n return \"\"\"\n and\n (\n []\n simple\n (\n [(%(etlo).0fet, 500neta)(%(etlo).0fet, peta500)]\n )\n combgen\n (\n [(10et, 0eta320)]\n dijet\n (\n [(%(masslo).0fdjmass, 26djdphi)]\n ) \n simple\n (\n [(10et, 0eta320)(20et, 0eta320)]\n )\n )\n )\"\"\" % argvals"},"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 chainDict2jetLabel(chain_dict):\n\n # suported scenarios \n router = {\n 'simple': _make_simple_label,\n 'HT': _make_ht_label,\n 'vbenf': _make_vbenf_label,\n 'dijet': _make_dijet_label,\n 'combinationsTest': _make_combinationsTest_label,\n 'partitionsTest': _make_partitionsTest_label,\n }\n\n # chain_part - scenario association\n cp_sorter = {}\n for k in router: cp_sorter[k] = []\n\n for cp in chain_dict['chainParts']:\n if cp['signature'] != 'Jet' and cp['signature'] != 'Bjet': \n continue\n for k in cp_sorter:\n if cp['hypoScenario'].startswith(k):\n cp_sorter[k].append(cp)\n break\n\n # obtain labels by scenario.\n labels = []\n for k, chain_parts in cp_sorter.items():\n if chain_parts: labels.append(router[k](chain_parts))\n\n assert labels\n nlabels = len(labels)\n if nlabels == 1: return labels[0]\n if nlabels == 2:\n alabel = \"\"\"\\\nand([]\n %s\n %s)\"\"\" % (tuple(labels))\n return alabel\n\n # more than 2 labels is not expected\n assert False","def _make_partitionsTest_label(chain_parts):\n\n assert len(chain_parts) == 1\n scenario = chain_parts[0]['hypoScenario']\n \n assert scenario == 'partitionsTest'\n\n \n\n return \"\"\"\n partgen(\n [(20et, 0eta320)]\n \n simple([(40et, 0eta320) (50et, 0eta320)])\n simple([(35et, 0eta240) (55et, 0eta240)])\n )\"\"\"","def _make_simple_label(chain_parts):\n \n if not _select_simple_chainparts(chain_parts):\n msg = 'Jet Configuration error: '\\\n 'chain fails substring selection: not \"simple\" '\n\n raise NotImplementedError(msg)\n \n label = 'simple(['\n for cp in chain_parts:\n smcstr = str(cp['smc'])\n jvtstr = str(cp['jvt'])\n if smcstr == 'nosmc':\n smcstr = ''\n for i in range(int(cp['multiplicity'])):\n # condition_str = '(%set,%s,%s)' % (str(cp['threshold']),\n # str(cp['etaRange']),\n # smcstr,)\n condition_str = '(%set,%s' % (str(cp['threshold']),\n str(cp['etaRange']),)\n if smcstr: # Run 2 chains have \"INF\" in the SMC substring\n condition_str += ',%s)' % smcstr.replace('INF','')\n elif jvtstr:\n condition_str += ',%s)' % jvtstr\n else:\n condition_str += ')'\n label += condition_str\n label += '])'\n return label","def _make_simple_partition_label(chain_dict):\n\n cps = chain_dict['chainParts']\n if not (_select_simple_chainparts(cps)):\n raise NotImplementedError(\n 'chain fails substring selection: not \"simple\": %s' % (\n chain_dict['chainName']))\n \n label = 'simplepartition(['\n for cp in cps:\n smcstr = str(cp['smc'])\n if smcstr == 'nosmc':\n smcstr = ''\n for i in range(int(cp['multiplicity'])):\n # condition_str = '(%set,%s,%s)' % (str(cp['threshold']),\n # str(cp['etaRange']),\n # smcstr,)\n condition_str = '(%set,%s' % (str(cp['threshold']),\n str(cp['etaRange']),)\n if smcstr:\n condition_str += ',%s)'\n else:\n condition_str += ')'\n label += condition_str\n label += '])'\n return label","def _text_write_preprocess(self):\n self.check()\n\n max_name_len = np.max([len(name) for name in self.name])\n fieldtypes = [\"U\" + str(max_name_len), \"f8\", \"f8\"]\n comp_names = self._get_lon_lat_component_names()\n frame_obj = self._get_frame_obj()\n frame_desc_str = _get_frame_desc_str(frame_obj)\n\n component_fieldnames = []\n for comp_name in comp_names:\n # This will add e.g. ra_J2000 and dec_J2000 for FK5\n component_fieldnames.append(comp_name + \"_\" + frame_desc_str)\n fieldnames = [\"source_id\"] + component_fieldnames\n stokes_names = [\"I\", \"Q\", \"U\", \"V\"]\n fieldshapes = [()] * 3\n\n if self.stokes_error is not None:\n stokes_error_names = [(f\"{k}_error\") for k in [\"I\", \"Q\", \"U\", \"V\"]]\n\n n_stokes = 0\n stokes_keep = []\n for si, total in enumerate(np.nansum(self.stokes.to(\"Jy\"), axis=(1, 2))):\n if total > 0:\n fieldnames.append(stokes_names[si])\n fieldshapes.append((self.Nfreqs,))\n fieldtypes.append(\"f8\")\n if self.stokes_error is not None:\n fieldnames.append(stokes_error_names[si])\n fieldshapes.append((self.Nfreqs,))\n fieldtypes.append(\"f8\")\n n_stokes += 1\n stokes_keep.append(total > 0)\n\n assert n_stokes >= 1, \"No components with nonzero flux.\"\n\n if self.freq_array is not None:\n if self.spectral_type == \"subband\":\n fieldnames.append(\"subband_frequency\")\n else:\n fieldnames.append(\"frequency\")\n fieldtypes.append(\"f8\")\n fieldshapes.extend([(self.Nfreqs,)])\n elif self.reference_frequency is not None:\n fieldnames.extend([(\"reference_frequency\")])\n fieldtypes.extend([\"f8\"])\n fieldshapes.extend([()] * n_stokes + [()])\n if self.spectral_index is not None:\n fieldnames.append(\"spectral_index\")\n fieldtypes.append(\"f8\")\n fieldshapes.append(())\n\n if hasattr(self, \"_rise_lst\"):\n fieldnames.append(\"rise_lst\")\n fieldtypes.append(\"f8\")\n fieldshapes.append(())\n\n if hasattr(self, \"_set_lst\"):\n fieldnames.append(\"set_lst\")\n fieldtypes.append(\"f8\")\n fieldshapes.append(())\n\n dt = np.dtype(list(zip(fieldnames, fieldtypes, fieldshapes)))\n\n arr = np.empty(self.Ncomponents, dtype=dt)\n arr[\"source_id\"] = self.name\n\n for comp_ind, comp in enumerate(comp_names):\n arr[component_fieldnames[comp_ind]] = getattr(self.skycoord, comp).deg\n\n for ii in range(4):\n if stokes_keep[ii]:\n arr[stokes_names[ii]] = self.stokes[ii].T.to(\"Jy\").value\n if self.stokes_error is not None:\n arr[stokes_error_names[ii]] = self.stokes_error[ii].T.to(\"Jy\").value\n\n if self.freq_array is not None:\n if self.spectral_type == \"subband\":\n arr[\"subband_frequency\"] = self.freq_array.to(\"Hz\").value\n else:\n arr[\"frequency\"] = self.freq_array.to(\"Hz\").value\n elif self.reference_frequency is not None:\n arr[\"reference_frequency\"] = self.reference_frequency.to(\"Hz\").value\n if self.spectral_index is not None:\n arr[\"spectral_index\"] = self.spectral_index\n\n if hasattr(self, \"_rise_lst\"):\n arr[\"rise_lst\"] = self._rise_lst\n if hasattr(self, \"_set_lst\"):\n arr[\"set_lst\"] = self._set_lst\n\n return arr","def _body(self, x, ensembled_batch, non_ensembled_batch, idx):\n i, current_representations = x\n del x\n feats = self._slice_batch(i, ensembled_batch, non_ensembled_batch)\n representations_update = self.evoformer(*self.batch_expand(feats))\n new_representations = {}\n for k in current_representations:\n new_representations[k] = (\n current_representations[k] + representations_update[k])\n del representations_update\n return i+1, new_representations","def get_mapped_feature_name(self):\n\n # open a h5 file in case we need it\n f5 = h5py.File(self.train_database[0], 'r')\n mol_name = list(f5.keys())[0]\n mapped_data = f5.get(mol_name + '/mapped_features/')\n chain_tags = ['_chain1', '_chain2']\n\n # if we select all the features\n if self.select_feature == \"all\":\n\n # redefine dict\n self.select_feature = {}\n\n # loop over the feat types and add all the feat_names\n for feat_type, feat_names in mapped_data.items():\n self.select_feature[feat_type] = [\n name for name in feat_names]\n\n # if a selection was made\n else:\n\n # we loop over the input dict\n for feat_type, feat_names in self.select_feature.items():\n\n # if for a given type we need all the feature\n if feat_names == 'all':\n if feat_type in mapped_data:\n self.select_feature[feat_type] = list(\n mapped_data[feat_type].keys())\n else:\n self.print_possible_features()\n raise KeyError('Feature type %s not found')\n\n # if we have stored the individual\n # chainA chainB data we need to expand the feature list\n # however when we reload a pretrained model we already\n # come with _chainA, _chainB features.\n # So then we shouldn't add the tags\n else:\n # TODO to refactor this part\n if feat_type not in mapped_data:\n self.print_possible_features()\n raise KeyError('Feature type %s not found')\n\n self.select_feature[feat_type] = []\n\n # loop over all the specified feature names\n for name in feat_names:\n\n # check if there is not _chainA or _chainB in the name\n cond = [tag not in name for tag in chain_tags]\n\n # if there is no chain tag in the name\n if np.all(cond):\n\n # if we have a wild card e.g. PSSM_*\n # we check the matches and add them\n if '*' in name:\n match = name.split('*')[0]\n possible_names = list(\n mapped_data[feat_type].keys())\n match_names = [\n n for n in possible_names\n if n.startswith(match)]\n self.select_feature[feat_type] += match_names\n\n # if we don't have a wild card we append\n # <feature_name>_chainA and <feature_name>_chainB\n # to the list\n else:\n self.select_feature[feat_type] += [\n name + tag for tag in chain_tags]\n # if there is a chain tag in the name\n # (we probably relaod a pretrained model)\n # and we simply append the feaature name\n else:\n self.select_feature[feat_type].append(\n name)\n\n f5.close()","def DecodeStage():\n\n io = Io({\n 'if_id': Input(if_bundle),\n 'inst': Input(Bits(32)),\n 'stall': Input(Bits(1)),\n 'reg_write': Input(reg_write_bundle),\n 'ras_ctrl': Output(ras_ctrl_bundle),\n 'id_ex': Output(id_ex_bundle),\n 'rs1_data': Output(Bits(C['core-width'])),\n 'rs2_data': Output(Bits(C['core-width'])),\n })\n\n inst = Wire(Bits(32))\n\n with io.if_id.valid:\n inst <<= io.inst\n with otherwise:\n inst <<= 0\n\n regfile = Instance(RegisterFile())\n\n itype = Wire(Bits(ITypes.bitwidth))\n\n regfile.r0_addr <<= Rs1(inst)\n regfile.r0_en <<= ~io.stall\n regfile.r1_addr <<= Rs2(inst)\n regfile.r1_en <<= ~io.stall\n\n regfile.w0_addr <<= io.reg_write.w_addr\n regfile.w0_en <<= io.reg_write.w_en & ~io.stall\n regfile.w0_data <<= io.reg_write.w_data\n\n #\n # inst_data is metadata about the current instruction that is passed through\n # the pipeline unrelated to control signals. It's primary use is for hazard\n # detection and data forwarding.\n #\n\n io.id_ex.ctrl.valid <<= io.if_id.valid\n io.id_ex.ctrl.inst <<= inst\n io.id_ex.ctrl.pc <<= io.if_id.pc\n\n #\n # Hook up the register read outputs.\n #\n\n io.rs1_data <<= regfile.r0_data\n io.rs2_data <<= regfile.r1_data\n\n #\n # Control is a Python function that produces the primary decode logic. It\n # matches against a set of known instructions to produce control signals for\n # later stages in the pipeline. The known instructions are encoded in the\n # 'instructions' variable above.\n #\n\n Control(inst, itype, io.id_ex.ctrl)\n\n #\n # TODO: Documentation\n #\n\n HandleRasCtrl(io.ras_ctrl, inst, io.if_id.pc)\n\n #\n # GenerateImmediate produces logic that consume the itype (instruction\n # type, which is R, I, S, B, U, or J) and produces the immediate value for\n # this instruction.\n #\n\n io.id_ex.imm <<= GenerateImmediate(inst, itype)\n\n NameSignals(locals())","def _make_dijet_label(chain_parts):\n\n assert len(chain_parts) == 1\n scenario = chain_parts[0]['hypoScenario']\n \n assert scenario.startswith('dijet')\n\n arg_res = [\n re.compile(r'^(?P<lo>\\d*)(?P<key>djmass)(?P<hi>\\d*)$'),\n re.compile(r'^(?P<lo>\\d*)(?P<key>j1et)(?P<hi>\\d*)$'),\n re.compile(r'^(?P<lo>\\d*)(?P<key>j1eta)(?P<hi>\\d*)$'),\n re.compile(r'^(?P<lo>\\d*)(?P<key>j2et)(?P<hi>\\d*)$'),\n re.compile(r'^(?P<lo>\\d*)(?P<key>j2eta)(?P<hi>\\d*)$'),\n ]\n\n defaults = {\n 'j1et': ('100', 'inf'),\n 'j2et': ('100', 'inf'),\n 'j1eta': ('0', '320'),\n 'j2eta': ('0', '320'),\n 'djmass': ('1000', 'inf'),\n }\n\n\n args = _args_from_scenario(scenario)\n argvals = {}\n while args:\n assert len(args) == len(arg_res)\n arg = args.pop()\n for r in arg_res:\n m = r.match(arg)\n if m is not None:\n arg_res.remove(r)\n gd = m.groupdict()\n key = gd['key']\n\n try:\n lo = float(gd['lo'])\n except ValueError:\n lo = defaults[key][0]\n argvals[key+'lo'] = lo \n try:\n hi = float(gd['hi'])\n except ValueError:\n hi = defaults[key][1]\n argvals[key+'hi'] = hi\n\n assert len(args) == len(arg_res)\n assert len(args) == 0\n\n return \"\"\"\n combgen(\n [(2)(%(j1etlo).0fet, %(j1etalo).0feta%(j1etahi).0f)\n (%(j1etlo).0fet, %(j1etalo).0feta%(j1etahi).0f)\n ]\n \n dijet(\n [(%(djmasslo).0fdjmass)])\n simple([(%(j1etlo).0fet, %(j1etalo).0feta%(j1etahi).0f)\n (%(j2etlo).0fet, %(j2etalo).0feta%(j2etahi).0f)])\n )\"\"\" % argvals","def _indentity_block(self, X, filters, f, stage, block):\n\t\tconv_layer_name = 'res' + str(stage) + block + '_branch'\n\t\tbn_layer_name = 'bm' + str(stage) + block + '_branch'\n\n\t\tX_shortcut = X\n\n\t\tF1, F2, F3 = filters\n\n\t\t# First component of main path\n\t\tX = Conv2D(filters = F1, kernel_size = (1, 1), strides = (1, 1), padding = 'valid',\n\t\t\tname = conv_layer_name + '2a', kernel_initializer = glorot_uniform(seed=0))(X)\n\t\tX = BatchNormalization(axis = 3, name = bn_layer_name + '2a')(X)\n\t\tX = Activation('relu')(X)\n\n\t\t# Second component of main path\n\t\tX = Conv2D(filters = F2, kernel_size = (1, 1), strides = (1, 1), padding = 'same',\n\t\t\tname = conv_layer_name + '2b', kernel_initializer = glorot_uniform(seed=0))(X)\n\t\tX = BatchNormalization(axis = 3, name = bn_layer_name + '2b')(X)\n\t\tX = Activation('relu')(X)\n\n\t\t# Third component of main path\n\t\tX = Conv2D(filters = F3, kernel_size = (1, 1), strides = (1, 1), padding = 'valid',\n\t\t\tname = conv_layer_name + '2c', kernel_initializer = glorot_uniform(seed=0))(X)\n\t\tX = BatchNormalization(axis = 3, name = bn_layer_name + '2c')(X)\n\n\t\t# Final step : adding the shortcut componet to X and applying 'relu' activation on the combination \n\t\tX = Add()([X_shortcut,X])\n\t\tX = Activation('relu')(X)\n\n\t\treturn X","def output_fluent(fil,nodes,elems):\n print \"Nodal coordinates\"\n print nodes\n print \"Element connectivity\"\n print elems\n faces = array(Tet4.faces) # Turning faces into an array is important !\n print \"Tetraeder faces\"\n print faces\n elf = elems.take(faces,axis=1)\n # Remark: the shorter syntax elems[faces] takes its elements along the\n # axis 0. Then we would need to transpose() first (and probably\n # swap axes again later)\n print \"The faces of the elements:\"\n print elf\n # We need a copy to sort the nodes (sorting is done in-place)\n elfs = elf.copy()\n elfs.sort(axis=2) \n print \"The faces with sorted nodes:\"\n print elfs\n magic = elems.max()+1\n print \"Magic number = %d\" % magic\n code = encode(elfs[:,:,0],elfs[:,:,1],elfs[:,:,2],magic)\n # Remark how nice the encode function works on the whole array\n print \"Encoded faces:\"\n print code\n code = code.ravel()\n print code\n print \"Just A Check:\"\n print \"Element 5 face 2 is %s \" % elf[5,2]\n print \"Element 5 face 2 is %s \" % list(decode(code[4*5+2],magic))\n srt = code.argsort()\n print srt\n print code[srt]\n # Now shipout the faces in this order, removing the doubles\n j = -1 \n for i in srt:\n if j < 0: # no predecessor (or predecessor already shipped)\n j = i\n else:\n e1,f1 = j/4, j%4\n if code[i] == code[j]:\n e2,f2 = i/4, i%4\n j = -1\n else:\n e2 = -1\n j = i\n print \"Face %s belongs to el %s and el %s\" % ( elf[e1,f1], e2, e1 )","def pre_pipeline(self, results):\n results[\"img_prefix\"] = self.img_prefix\n results[\"seg_prefix\"] = self.seg_prefix\n results[\"proposal_file\"] = self.proposal_file\n results[\"bbox_fields\"] = []\n results[\"mask_fields\"] = []\n results[\"seg_fields\"] = []\n results[\"site_fields\"] = []\n results[\"label_fields\"] = []","def build_head(self):\n stages = [f'stage{i}' for i in range(1, 7)]\n for stage in stages:\n block = getattr(self.arch, stage)\n PAF, CFM = block.keys()\n PAF = build_blocks(block[PAF], 'head')\n CFM = build_blocks(block[CFM], 'head')\n setattr(self, f\"{stage}_PAF\", PAF)\n setattr(self, f\"{stage}_CFM\", CFM)","def _make_combinationsTest_label(chain_parts):\n\n assert len(chain_parts) == 1\n scenario = chain_parts[0]['hypoScenario']\n \n assert scenario == 'combinationsTest'\n\n \n\n return \"\"\"\n combgen(\n [(2)(20et, 0eta320)]\n \n simple([(40et, 0eta320) (50et, 0eta320)])\n simple([(35et, 0eta240) (55et, 0eta240)])\n )\"\"\"","def _make_simple_comb_label(chain_dict):\n\n cps = chain_dict['chainParts']\n if not (_select_simple_chainparts(cps)):\n raise NotImplementedError(\n 'chain fails substring selection: not \"simple\": %s' % (\n chain_dict['chainName']))\n \n simple_strs = []\n\n for cp in cps:\n print(cp)\n simple_strs.append(_make_simple_label([cp]))\n\n label = 'combgen([(%d)]' % len(cps)\n for s in simple_strs:\n label += ' %s ' % s\n label += ')'\n return label","def generate_code(self, parts: list):\n for i in range(len(parts)):\n\n if not self._involves_this_party(parts[i][0]):\n # not our data, skip job\n continue\n\n if parts[i][1] == \"python\":\n cg = PythonCodeGen(\n self.config,\n parts[i][0],\n f\"{self.config.system_configs['CODEGEN'].workflow_name}-python-job-{i}\"\n )\n cg.generate()\n elif parts[i][1] == \"jiff\":\n cg = JiffCodeGen(\n self.config,\n parts[i][0],\n f\"{self.config.system_configs['CODEGEN'].workflow_name}-jiff-job-{i}\"\n )\n cg.generate()\n else:\n raise Exception(f\"Unrecognized backend from partition: {parts[i][1]}.\")","def __call__(self, blocks, with_cab=False):\n\n # for k, v in blocks.items():\n # print(k, v.shape)\n\n #down fpn\n f_down = self.FPN_Down_Fusion(blocks)\n # print(\"f_down shape: {}\".format(f_down.shape))\n #up fpn\n f_up = self.FPN_Up_Fusion(blocks)\n # print(\"f_up shape: {}\".format(f_up.shape))\n #fusion\n f_common = fluid.layers.elementwise_add(x=f_down, y=f_up)\n f_common = fluid.layers.relu(f_common)\n # print(\"f_common: {}\".format(f_common.shape))\n\n if self.with_cab:\n # print('enhence f_common with CAB.')\n f_common = self.cross_attention(f_common)\n\n f_score, f_border = self.SAST_Header1(f_common)\n f_tvo, f_tco = self.SAST_Header2(f_common)\n\n predicts = OrderedDict()\n predicts['f_score'] = f_score\n predicts['f_border'] = f_border\n predicts['f_tvo'] = f_tvo\n predicts['f_tco'] = f_tco\n return predicts","def __call__(self, node):\n\n # should throw an error\n if node.cfgInterface == None:\n return\n\n # //\n # // Extract LFN base from included WorkflowSpec parameters\n #//\n if self.unmerged:\n base = node.getParameter(\"UnmergedLFNBase\")[0]\n else:\n base = node.getParameter(\"MergedLFNBase\")[0]\n mergedBase = node.getParameter(\"MergedLFNBase\")[0]\n\n acqEra=None\n if node.hasParameter(\"AcquisitionEra\"):\n acqEra = node.getParameter(\"AcquisitionEra\")[0]\n\n\n # //\n # // iterate over outputmodules/data tiers\n #// Generate LFN, PFN and Catalog for each module\n\n for modName, outModule in node.cfgInterface.outputModules.items():\n\n if ( not outModule.has_key('fileName') ):\n msg = \"OutputModule %s does not contain a fileName entry\" % modName\n raise RuntimeError, msg\n\n preserveLfnGroup = str(self.lfnGroup)\n lastBit = outModule['processedDataset']\n # //\n # // Skip if the file does not stage out. (i.e.\n #// --stageout-intermediates=False)\n if lastBit is None:\n msg = \"OutputModule does not stage out. Skipping.\"\n logging.debug(msg)\n continue\n # //but this guy has the AcquisitionEra at the beginning... delimited\n # // by a dash... we don't need it twice... we try to safely\n #// remove it from the beginning, basically punting if its not\n #\\\\ disadvantage of getting this from the ds name is having to\n # \\\\ then strip off -unmerged\n if acqEra is not None:\n thingtoStrip=\"%s-\" % acqEra\n mypieces = lastBit.split(thingtoStrip, 1)\n if len(mypieces) > 1: \n lastBit = mypieces[1]\n remainingBits = lastBit.split(\"-unmerged\", 1)[0]\n \n outModule['LFNBase'] = os.path.join(base,\n outModule['primaryDataset'],\n outModule['dataTier'],\n remainingBits,\n preserveLfnGroup)\n outModule['MergedLFNBase'] = os.path.join(mergedBase,\n outModule['primaryDataset'],\n outModule['dataTier'],\n remainingBits,\n preserveLfnGroup)\n\n return","def build_stage2_6(self):\n paf, cfm = self.stage2_6.values()\n for i in range(2, 7):\n paf_ = OrderedDict([(k.replace('i', str(i)),paf[k]) for k in paf])\n cfm_ = OrderedDict([(k.replace('i', str(i)),cfm[k]) for k in cfm])\n stage_ = OrderedDict(PAF=paf_, CFM=cfm_)\n setattr(self, f'stage{i}', stage_)","def slice_graph_bwd( endea, reg ): \r\n\tgraph = vcg_Graph.vcgGraph({\"title\":'\"Slice for %s\"' % reg, \\\r\n\t\t\"manhattan_edges\":\"no\", \"layoutalgorithm\":\"maxdepth\"})\r\n\t#\r\n\t# Retrieve the name of the current basic block\r\n\t# \r\n\tworklist = []\r\n\tdata_bib = {}\r\n\t\r\n\tstartnode = slice_node( 0, endea, reg )\t\t# start at the end of the slice node\r\n\trootnode = graph.Add_Node( startnode.to_name() )\r\n\tdata_bib[ startnode.to_name() ] = startnode\r\n\tworklist.insert( 0, rootnode )\r\n\twhile len( worklist ) > 0:\r\n\t\tcurrnode = worklist.pop()\r\n\t\tcurrslice = data_bib[ currnode.get_name() ]\r\n\t\t[tgt_reg, split] = currslice.get_target_reg_bwd()\r\n\t\tprint tgt_reg\r\n\t\tprint split\r\n\t\tif tgt_reg == \"END\":\r\n\t\t\t# Do not process this node any further\r\n\t\t\tpass\r\n\t\telif tgt_reg == \"\" or (( len( currslice.get_lines()) > 0) and \\\r\n\t\t\tcurrslice.startea != currslice.get_lines()[0][0]):\r\n\t\t\t# Do process this node further, nothing really going on \r\n\t\t\tprint \"ZEZ\"\r\n\t\t\txrefs = get_crefs_to( currslice.startea )\r\n\t\t\tfor ref in xrefs:\r\n\t\t\t\tnewslice = slice_node( 0,ref, currslice.reg )\r\n\t\t\t\tif graph.Get_Node( newslice.to_name() ) == 0:\r\n\t\t\t\t\tnewnode = graph.Add_Node( newslice.to_name() )\r\n\t\t\t\t\tworklist.insert( 0, newnode )\r\n\t\t\t\t\tdata_bib[ newslice.to_name() ] = newslice\r\n\t\t\t\tgraph.Add_Link( newslice.to_name(), currnode.get_name() )\r\n\t\telse:\r\n\t\t\txrefs = get_crefs_to( currslice.startea )\r\n\t\t\tfor ref in xrefs:\r\n\t\t\t\tnewslice = slice_node( 0,ref, tgt_reg )\r\n\t\t\t\tif graph.Get_Node( newslice.to_name() ) == 0:\r\n\t\t\t\t\tnewnode = graph.Add_Node( newslice.to_name() )\r\n\t\t\t\t\tworklist.insert( 0, newnode )\r\n\t\t\t\t\tdata_bib[ newslice.to_name() ] = newslice\r\n\t\t\t\tgraph.Add_Link( newslice.to_name(), currnode.get_name())\r\n\t\t\txrefs = get_crefs_to( currslice.startea )\r\n\t\t\tif split:\r\n\t\t\t\tfor ref in xrefs:\r\n\t\t\t\t\tnewslice = slice_node( 0,ref, currslice.reg )\r\n\t\t\t\t\tif graph.Get_Node( newslice.to_name() ) == 0:\r\n\t\t\t\t\t\tnewnode = graph.Add_Node( newslice.to_name() )\r\n\t\t\t\t\t\tworklist.insert( 0, newnode )\r\n\t\t\t\t\t\tdata_bib[ newslice.to_name() ] = newslice\r\n\t\t\t\t\tgraph.Add_Link( newslice.to_name(), currnode.get_name())\r\n\treturn [ graph, data_bib ]","def identity_block(self,X, f, filters, stage, block):\n # define name basis\n conv_name_base = 'res' + str(stage) + block + '_branch'\n bn_name_base = 'bn' + str(stage) + block + '_branch'\n\n # Retrieve filters\n f1,f2,f3 = filters\n\n # Save the input value. This needs to be added back to the main path later.\n X_shortcut = X\n\n # First component of the main path\n X = Conv2D(filters= f1, kernel_size=(1,1), strides=(1,1), padding='valid', name=conv_name_base + '2a', kernel_initializer=glorot_uniform(seed=0))(X)\n X = BatchNormalization(axis=3, name=bn_name_base + '2a')(X)\n X = Activation('relu')(X)\n\n # Second component of the main path\n X = Conv2D(filters= f2, kernel_size=(f,f), strides=(1,1), padding='same', name=conv_name_base + '2b', kernel_initializer=glorot_uniform(seed=0))(X)\n X = BatchNormalization(axis=3, name=bn_name_base + '2b')(X)\n X = Activation('relu')(X)\n\n # Third component of the main path\n X = Conv2D(filters= f3, kernel_size=(1,1), strides=(1,1), padding='valid', name=conv_name_base + '2c', kernel_initializer=glorot_uniform(seed=0))(X)\n X = BatchNormalization(axis=3, name=bn_name_base + '2c')(X)\n\n # Add the shortcut value to the main path\n X = Add()([X_shortcut, X])\n X = Activation('relu')(X) \n\n return X","def onBuildModels(self):\n if self.refSeriesNumber != '-1':\n ref = self.refSeriesNumber\n refLongName = self.seriesMap[ref]['LongName']\n labelNodes = slicer.util.getNodes('*'+refLongName+'*-label*')\n\n numNodes = slicer.mrmlScene.GetNumberOfNodesByClass( \"vtkMRMLModelHierarchyNode\" )\n outHierarchy = None\n\n for n in xrange(numNodes):\n node = slicer.mrmlScene.GetNthNodeByClass( n, \"vtkMRMLModelHierarchyNode\" )\n if node.GetName() == 'mpReview-'+refLongName:\n outHierarchy = node\n break\n\n # Remove the previous models\n if outHierarchy:\n collection = vtk.vtkCollection()\n outHierarchy.GetChildrenModelNodes(collection)\n n = collection.GetNumberOfItems()\n if n != 0:\n for i in xrange(n):\n modelNode = collection.GetItemAsObject(i)\n slicer.mrmlScene.RemoveNode(modelNode)\n\n # if models hierarchy does not exist, create it.\n else:\n outHierarchy = slicer.vtkMRMLModelHierarchyNode()\n outHierarchy.SetScene( slicer.mrmlScene )\n outHierarchy.SetName( 'mpReview-'+refLongName )\n slicer.mrmlScene.AddNode( outHierarchy )\n\n progress = self.makeProgressIndicator(len(labelNodes))\n step = 0\n for label in labelNodes.values():\n labelName = label.GetName().split(':')[1]\n structureName = labelName[labelName[:-6].rfind(\"-\")+1:-6]\n # Only save labels with known structure names\n if any(structureName in s for s in self.structureNames):\n parameters = {}\n parameters[\"InputVolume\"] = label.GetID()\n parameters['FilterType'] = \"Sinc\"\n parameters['GenerateAll'] = True\n\n parameters[\"JointSmoothing\"] = False\n parameters[\"SplitNormals\"] = True\n parameters[\"PointNormals\"] = True\n parameters[\"SkipUnNamed\"] = True\n\n # create models for all labels\n parameters[\"StartLabel\"] = -1\n parameters[\"EndLabel\"] = -1\n\n parameters[\"Decimate\"] = 0\n parameters[\"Smooth\"] = 0\n\n parameters[\"ModelSceneFile\"] = outHierarchy\n\n progress.labelText = '\\nMaking Model for %s' % structureName\n progress.setValue(step)\n if progress.wasCanceled:\n break\n\n try:\n modelMaker = slicer.modules.modelmaker\n self.CLINode = slicer.cli.run(modelMaker, self.CLINode,\n parameters, wait_for_completion=True)\n except AttributeError:\n qt.QMessageBox.critical(slicer.util.mainWindow(),'Editor', 'The ModelMaker module is not available<p>Perhaps it was disabled in the application settings or did not load correctly.')\n step += 1\n progress.close()\n #\n\n if outHierarchy:\n collection = vtk.vtkCollection()\n outHierarchy.GetChildrenModelNodes(collection)\n n = collection.GetNumberOfItems()\n if n != 0:\n for i in xrange(n):\n modelNode = collection.GetItemAsObject(i)\n displayNode = modelNode.GetDisplayNode()\n displayNode.SetSliceIntersectionVisibility(1)\n displayNode.SetSliceIntersectionThickness(2)\n self.modelsVisibilityButton.checked = False\n self.updateViewRenderer()","def make_label_data(self):\n from xml.etree.ElementTree import Element, SubElement, dump, ElementTree, parse\n\n if not self.graphicsView.hasImage():\n self.showImageSelectionMessageBox()\n return\n\n app_doc_data = AppDocData.instance()\n project = app_doc_data.getCurrentProject()\n\n smalls = []\n bigs = []\n\n symbol_list = app_doc_data.getTargetSymbolList(all=True)\n for symbol in symbol_list:\n if symbol.width and symbol.height:\n if symbol.width > 300 or symbol.height > 300:\n bigs.append(symbol.getName())\n else:\n smalls.append(symbol.getName())\n\n symbols = [item for item in self.graphicsView.scene().items() if issubclass(type(item), SymbolSvgItem)]\n names = [smalls, bigs]\n\n img = app_doc_data.activeDrawing.image_origin\n\n small_size = 500\n big_size = 850\n\n save_path = project.getTrainingSymbolFilePath()\n\n index = 0\n for size in [small_size, big_size]:\n offsets = [0, int(size / 2)]\n\n width, height = img.shape[1], img.shape[0]\n width_count, height_count = width // size + 2, height // size + 2\n b_width, b_height = width_count * size, height_count * size\n b_img = np.zeros((b_height, b_width), np.uint8) + 255\n b_img[:height, :width] = img[:, :]\n\n for offset in offsets:\n for row in range(height_count):\n for col in range(width_count):\n x, y = col * size + offset, row * size + offset\n tile_rect = QRectF(x, y, size, size)\n tile_symbols = []\n for symbol in [symbol for symbol in symbols if symbol.name in names[index]]:\n if tile_rect.contains(symbol.sceneBoundingRect()):\n tile_symbols.append(symbol)\n symbols.remove(symbol)\n\n if tile_symbols:\n training_uid = str(uuid.uuid4())\n training_image_path = os.path.join(save_path, training_uid + '.png')\n training_xml_path = os.path.join(save_path, training_uid + '.xml')\n\n # save image\n #_img = b_img[round(tile_rect.top()):round(tile_rect.bottom()),\n # round(tile_rect.left()):round(tile_rect.right())]\n #cv2.imwrite(training_image_path, _img)\n _img = self.graphicsView.image().copy(round(tile_rect.left()), round(tile_rect.top()), round(tile_rect.width()), round(tile_rect.height()))\n _img.save(training_image_path)\n\n # save label\n xml = Element('annotation')\n SubElement(xml, 'folder').text = 'None'\n SubElement(xml, 'filename').text = os.path.basename(save_path)\n\n pathNode = Element('path')\n pathNode.text = save_path.replace('/', '\\\\')\n xml.append(pathNode)\n\n sourceNode = Element('source')\n databaseNode = Element('database')\n databaseNode.text = 'Unknown'\n sourceNode.append(databaseNode)\n xml.append(sourceNode)\n\n sizeNode = Element('size')\n widthNode = Element('width')\n widthNode.text = str(int(tile_rect.width()))\n sizeNode.append(widthNode)\n heightNode = Element('height')\n heightNode.text = str(int(tile_rect.height()))\n sizeNode.append(heightNode)\n depthNode = Element('depth')\n depthNode.text = '3'\n sizeNode.append(depthNode)\n xml.append(sizeNode)\n\n segmentedNode = Element('segmented')\n segmentedNode.text = '0'\n xml.append(segmentedNode)\n\n labelContent = []\n counts = {}\n for item in tile_symbols:\n rect = item.sceneBoundingRect()\n label, xMin, yMin, xMax, yMax = item.name, int(rect.x() - 5 - x), int(rect.y() - 5 - y), int(rect.x() + rect.width() + 5 - x), int(rect.y() + rect.height() + 5 - y)\n xMin = xMin if xMin > 0 else 0\n yMin = yMin if yMin > 0 else 0\n xMax = xMax if xMax < size else size\n yMax = yMax if yMax < size else size\n\n if label == 'None' or label == '':\n continue\n if label not in labelContent:\n labelContent.append(label)\n counts[label] = 1\n else:\n counts[label] = counts[label] + 1\n\n objectNode = Element('object')\n nameNode = Element('name')\n nameNode.text = label\n objectNode.append(nameNode)\n poseNode = Element('pose')\n poseNode.text = 'Unspecified'\n objectNode.append(poseNode)\n truncatedNode = Element('truncated')\n truncatedNode.text = '0'\n objectNode.append(truncatedNode)\n difficultNode = Element('difficult')\n difficultNode.text = '0'\n objectNode.append(difficultNode)\n\n bndboxNode = Element('bndbox')\n xminNode = Element('xmin')\n xminNode.text = str(xMin)\n bndboxNode.append(xminNode)\n yminNode = Element('ymin')\n yminNode.text = str(yMin)\n bndboxNode.append(yminNode)\n xmaxNode = Element('xmax')\n xmaxNode.text = str(xMax)\n bndboxNode.append(xmaxNode)\n ymaxNode = Element('ymax')\n ymaxNode.text = str(yMax)\n bndboxNode.append(ymaxNode)\n objectNode.append(bndboxNode)\n\n xml.append(objectNode)\n\n ElementTree(xml).write(training_xml_path)\n\n index += 1\n\n QMessageBox.about(self, self.tr(\"Notice\"), self.tr('Successfully applied. '))","def gexf_graph():\n # you must replace these lines and supply your own graph\n \n \n \n my_gexf = Gexf(\"JiajiaXie\", \"My awesome graph\")\n graph=my_gexf.addGraph(\"undirected\", \"static\", \"My awesome networks\")\n \n atr1=graph.addNodeAttribute('Type',type='string')\n\n\n for set in data_specific:\n if graph.nodeExists(set['set_num']) ==0:\n tm1=graph.addNode(set['set_num'], set['name'], r='0', g='0', b='0')\n tm1.addAttribute(atr1,\"set\")\n\n\n\n counter_test=1\n for set, part in data_parts.items():\n for key, part_list in part.items():\n interme =part_list['color']\n red=interme[0]+interme[1]\n green=interme[2]+interme[3]\n blue=interme[4]+interme[5]\n\n red_de=str(int(red,16))\n green_de=str(int(green,16))\n blue_de=str(int(blue,16))\n if graph.nodeExists(part_list['id'])==0:\n tm2=graph.addNode(part_list['id'], part_list['part_name'],r=red_de, g=green_de, b = blue_de)\n tm2.addAttribute(atr1,\"part\")\n\n\n counter_test+=1\n graph.addEdge(\"_\"+str(counter_test), set, part_list['id'], part_list['quantity'])\n\n\n\n f=open('bricks_graph.gexf','wb')\n my_gexf.write(f)\n\n\n return my_gexf.graphs[0]","def DontuseThis():\n BCM_outputs = ['phi','rho','theta',\n 'r_probabilityMaps','l_probabilityMaps',\n 'models']\n BCM_Models = pe.Node(interface=nio.DataGrabber(input_names=['structures'],\n outfields=BCM_outputs),\n name='10_BCM_Models')\n BCM_Models.inputs.base_directory = atlas_fname_wpath\n BCM_Models.inputs.template_args['phi'] = [['spatialImages','phi','nii.gz']]\n BCM_Models.inputs.template_args['rho'] = [['spatialImages','rho','nii.gz']]\n BCM_Models.inputs.template_args['theta'] = [['spatialImages','theta','nii.gz']]\n BCM_Models.inputs.template_args['r_probabilityMaps'] = [['structures']]\n BCM_Models.inputs.template_args['l_probabilityMaps'] = [['structures']]\n BCM_Models.inputs.template_args['models'] = [['structures']]\n\n BRAINSCut_structures = ['caudate','thalamus','putamen','hippocampus']\n #BRAINSCut_structures = ['caudate','thalamus']\n BCM_Models.iterables = ( 'structures', BRAINSCut_structures )\n BCM_Models.inputs.template = '%s/%s.%s'\n BCM_Models.inputs.field_template = dict(\n r_probabilityMaps='probabilityMaps/r_%s_ProbabilityMap.nii.gz',\n l_probabilityMaps='probabilityMaps/l_%s_ProbabilityMap.nii.gz',\n models='modelFiles/%sModel*',\n )\n\n \"\"\"\n The xml creation and BRAINSCut need to be their own mini-pipeline that gets\n executed once for each of the structures in BRAINSCut_structures. This can be\n accomplished with a map node and a new pipeline.\n \"\"\"\n \"\"\"\n Create xml file for BRAINSCut\n \"\"\"\n\n\n BFitAtlasToSubject = pe.Node(interface=BRAINSFit(),name=\"BFitAtlasToSubject\")\n BFitAtlasToSubject.inputs.costMetric=\"MMI\"\n BFitAtlasToSubject.inputs.maskProcessingMode=\"ROI\"\n BFitAtlasToSubject.inputs.numberOfSamples=100000\n BFitAtlasToSubject.inputs.numberOfIterations=[1500,1500]\n BFitAtlasToSubject.inputs.numberOfHistogramBins=50\n BFitAtlasToSubject.inputs.maximumStepLength=0.2\n BFitAtlasToSubject.inputs.minimumStepLength=[0.005,0.005]\n BFitAtlasToSubject.inputs.transformType= [\"Affine\",\"BSpline\"]\n BFitAtlasToSubject.inputs.maxBSplineDisplacement= 7\n BFitAtlasToSubject.inputs.maskInferiorCutOffFromCenter=65\n BFitAtlasToSubject.inputs.splineGridSize=[28,20,24]\n BFitAtlasToSubject.inputs.outputVolume=\"Trial_Initializer_Output.nii.gz\"\n BFitAtlasToSubject.inputs.outputTransform=\"Trial_Initializer_Output.mat\"\n cutWF.connect(SplitAvgBABC,'avgBABCT1',BFitAtlasToSubject,'fixedVolume')\n cutWF.connect(BABC,'outputLabels',BFitAtlasToSubject,'fixedBinaryVolume')\n cutWF.connect(BAtlas,'template_t1',BFitAtlasToSubject,'movingVolume')\n cutWF.connect(BAtlas,'template_brain',BFitAtlasToSubject,'movingBinaryVolume')\n cutWF.connect(BLI,'outputTransformFilename',BFitAtlasToSubject,'initialTransform')\n\n CreateBRAINSCutXML = pe.Node(Function(input_names=['rho','phi','theta',\n 'model',\n 'r_probabilityMap',\n 'l_probabilityMap',\n 'atlasT1','atlasBrain',\n 'subjT1','subjT2',\n 'subjT1GAD','subjT2GAD',\n 'subjSGGAD','subjBrain',\n 'atlasToSubj','output_dir'],\n output_names=['xml_filename','rl_structure_filename_list'],\n function = create_BRAINSCut_XML),\n overwrite = True,\n name=\"CreateBRAINSCutXML\")\n\n ## HACK Makde better directory\n CreateBRAINSCutXML.inputs.output_dir = \".\" #os.path.join(cutWF.base_dir, \"BRAINSCut_output\")\n cutWF.connect(BCM_Models,'models',CreateBRAINSCutXML,'model')\n cutWF.connect(BCM_Models,'rho',CreateBRAINSCutXML,'rho')\n cutWF.connect(BCM_Models,'phi',CreateBRAINSCutXML,'phi')\n cutWF.connect(BCM_Models,'theta',CreateBRAINSCutXML,'theta')\n cutWF.connect(BCM_Models,'r_probabilityMaps',CreateBRAINSCutXML,'r_probabilityMap')\n cutWF.connect(BCM_Models,'l_probabilityMaps',CreateBRAINSCutXML,'l_probabilityMap')\n cutWF.connect(BAtlas,'template_t1',CreateBRAINSCutXML,'atlasT1')\n cutWF.connect(BAtlas,'template_brain',CreateBRAINSCutXML,'atlasBrain')\n cutWF.connect(SplitAvgBABC,'avgBABCT1',CreateBRAINSCutXML,'subjT1')\n cutWF.connect(SplitAvgBABC,'avgBABCT2',CreateBRAINSCutXML,'subjT2')\n cutWF.connect(GADT1,'outputVolume',CreateBRAINSCutXML,'subjT1GAD')\n cutWF.connect(GADT2,'outputVolume',CreateBRAINSCutXML,'subjT2GAD')\n cutWF.connect(SGI,'outputFileName',CreateBRAINSCutXML,'subjSGGAD')\n cutWF.connect(BABC,'outputLabels',CreateBRAINSCutXML,'subjBrain')\n cutWF.connect(BFitAtlasToSubject,'outputTransform',CreateBRAINSCutXML,'atlasToSubj')\n #CreateBRAINSCutXML.inputs.atlasToSubj = \"INTERNAL_REGISTER.mat\"\n #cutWF.connect(BABC,'atlasToSubjectTransform',CreateBRAINSCutXML,'atlasToSubj')\n\n \"\"\"\n ResampleNACLabels\n \"\"\"\n ResampleAtlasNACLabels=pe.Node(interface=BRAINSResample(),name=\"ResampleAtlasNACLabels\")\n ResampleAtlasNACLabels.inputs.interpolationMode = \"NearestNeighbor\"\n ResampleAtlasNACLabels.inputs.outputVolume = \"atlasToSubjectNACLabels.nii.gz\"\n\n cutWF.connect(cutWF,'OutputSpec.atlasToSubjectTransform',ResampleAtlasNACLabels,'warpTransform')\n cutWF.connect(cutWF,'OutputSpec.t1_corrected',ResampleAtlasNACLabels,'referenceVolume')\n cutWF.connect(BAtlas,'template_nac_lables',ResampleAtlasNACLabels,'inputVolume')\n\n \"\"\"\n BRAINSMush\n \"\"\"\n BMUSH=pe.Node(interface=BRAINSMush(),name=\"BMUSH\")\n BMUSH.inputs.outputVolume = \"MushImage.nii.gz\"\n BMUSH.inputs.outputMask = \"MushMask.nii.gz\"\n BMUSH.inputs.lowerThresholdFactor = 1.2\n BMUSH.inputs.upperThresholdFactor = 0.55\n\n cutWF.connect(myLocalTCWF,'OutputSpec.t1_corrected',BMUSH,'inputFirstVolume')\n cutWF.connect(myLocalTCWF,'OutputSpec.t2_corrected',BMUSH,'inputSecondVolume')\n cutWF.connect(myLocalTCWF,'OutputSpec.outputLabels',BMUSH,'inputMaskVolume')\n\n \"\"\"\n BRAINSROIAuto\n \"\"\"\n BROI = pe.Node(interface=BRAINSROIAuto(), name=\"BRAINSROIAuto\")\n BROI.inputs.closingSize=12\n BROI.inputs.otsuPercentileThreshold=0.01\n BROI.inputs.thresholdCorrectionFactor=1.0\n BROI.inputs.outputROIMaskVolume = \"temproiAuto_t1_ACPC_corrected_BRAINSABC.nii.gz\"\n cutWF.connect(myLocalTCWF,'OutputSpec.t1_corrected',BROI,'inputVolume')\n\n \"\"\"\n Split the implicit outputs of BABCext\n \"\"\"\n SplitAvgBABC = pe.Node(Function(input_names=['in_files','T1_count'], output_names=['avgBABCT1','avgBABCT2'],\n function = get_first_T1_and_T2), run_without_submitting=True, name=\"99_SplitAvgBABC\")\n SplitAvgBABC.inputs.T1_count = 1 ## There is only 1 average T1 image.\n\n cutWF.connect(myLocalTCWF,'OutputSpec.outputAverageImages',SplitAvgBABC,'in_files')\n\n\n\n def printFullPath(outFileFullPath):\n print(\"=\"*80)\n print(\"=\"*80)\n print(\"=\"*80)\n print(\"=\"*80)\n print(\"{0}\".format(outFileFullPath))\n return outFileFullPath\n printOutImage = pe.Node( Function(function=printFullPath, input_names = ['outFileFullPath'], output_names = ['genoutFileFullPath']), run_without_submitting=True, name=\"99_printOutImage\")\n cutWF.connect( GADT2, 'outputVolume', printOutImage, 'outFileFullPath' )","def identity_block(X, f, filters, stage, block):\n \n # Defines name basis.\n conv_name_base = 'res' + str(stage) + block + '_branch'\n bn_name_base = 'bn' + str(stage) + block + '_branch'\n \n # Retrieves Filters.\n F1, F2, F3 = filters\n \n # Saves the input value. This is needed later to add back to the main path. \n X_shortcut = X\n \n ##### MAIN PATH #####\n # First component of main path.\n X = Conv2D(filters = F1, kernel_size = (1, 1), strides = (1,1), padding = 'valid', name = conv_name_base + '2a', kernel_initializer = glorot_uniform())(X)\n X = BatchNormalization(axis = 3, name = bn_name_base + '2a')(X)\n X = Activation('relu')(X)\n \n \n # Second component of main path.\n X = Conv2D(filters = F2, kernel_size = (f, f), strides = (1,1), padding = 'same', name = conv_name_base + '2b', kernel_initializer = glorot_uniform())(X)\n X = BatchNormalization(axis = 3, name = bn_name_base + '2b')(X)\n X = Activation('relu')(X)\n \n # Third component of main path.\n X = Conv2D(filters = F3, kernel_size = (1, 1), strides = (1,1), padding = 'valid', name = conv_name_base + '2c', kernel_initializer = glorot_uniform())(X)\n X = BatchNormalization(axis = 3, name = bn_name_base + '2c')(X)\n\n\n # Final step: Adds shortcut value to main path, and pass it through a RELU activation.\n X = Add()([X, X_shortcut])\n X = Activation('relu')(X)\n\n return X","def identity_block(X, f, filters, stage, block):\n \n # defining name basis\n conv_name_base = 'res' + str(stage) + block + '_branch'\n bn_name_base = 'bn' + str(stage) + block + '_branch'\n \n # Retrieve Filters\n F1, F2, F3 = filters\n \n # Save the input value. You'll need this later to add back to the main path. \n X_shortcut = X\n \n # First component of main path\n X = Conv2D(filters = F1, kernel_size = (1, 1), strides = (1,1), padding = 'valid', name = conv_name_base + '2a', kernel_initializer = glorot_uniform(seed=0))(X)\n X = BatchNormalization(axis = 3, name = bn_name_base + '2a')(X)\n X = Activation('relu')(X)\n \n # Second component of main path\n X = Conv2D(filters = F2, kernel_size = (f, f), strides = (1,1), padding = 'same', name = conv_name_base + '2b', kernel_initializer = glorot_uniform(seed=0))(X)\n X = BatchNormalization(axis = 3, name = bn_name_base + '2b')(X)\n X = Activation('relu')(X)\n\n # Third component of main path\n X = Conv2D(filters = F3, kernel_size = (1, 1), strides = (1,1), padding = 'valid', name = conv_name_base + '2c', kernel_initializer = glorot_uniform(seed=0))(X)\n X = BatchNormalization(axis = 3, name = bn_name_base + '2c')(X)\n\n # Final step: Add shortcut value to main path, and pass it through a RELU activation\n X = Add()([X,X_shortcut])\n X = Activation('relu')(X)\n \n return X","def make_mixture_info(parts, operation='+'):\n # type: (List[ModelInfo], str) -> ModelInfo\n # Build new parameter list\n combined_pars = []\n\n # When creating a mixture model that is a sum of product models (ie (1*2)+(3*4))\n # the parameters for models 1 & 2 will be prefixed with A & B respectively,\n # but so will the parameters for models 3 & 4. We need to rename models 3 & 4\n # so that they are prefixed with C & D to avoid overlap of parameter names.\n used_prefixes = []\n for part in parts:\n if part.composition and part.composition[0] == 'mixture':\n i = 0\n for submodel in part.composition[1]:\n npars = len(submodel.parameters.kernel_parameters)\n # List of params of one of the constituent models of part\n submodel_pars = part.parameters.kernel_parameters[i:i+npars]\n # Prefix of the constituent model\n prefix = submodel_pars[0].name[0]\n if prefix not in used_prefixes: # Haven't seen this prefix so far\n used_prefixes.append(prefix)\n i += npars\n continue\n # TODO: don't modify submodel --- it may be used elsewhere\n # Existing code probably doesn't keep a handle on the model\n # parts so its probably okay, but it's possible that a mix\n # on user defined mixture models models will change the\n # parameters used for the parts in the GUI. Even worse if the\n # same plugin is used twice. For example, twosphere.py\n # contains sphere+sphere and you create twosphere+twosphere.\n while prefix in used_prefixes:\n # This prefix has been already used, so change it to the\n # next letter that hasn't been used\n prefix = chr(ord(prefix) + 1)\n used_prefixes.append(prefix)\n prefix += \"_\"\n # Update the parameters of this constituent model to use the\n # new prefix\n for par in submodel_pars:\n # Strip {prefix}_ using par.name[2:], etc.\n # TODO: fails for AB_scale\n par.id = prefix + par.id[2:]\n par.name = prefix + par.name[2:]\n if par.length_control is not None:\n par.length_control = prefix + par.length_control[2:]\n i += npars\n\n for part in parts:\n # Parameter prefix per model, A_, B_, ...\n # Note that prefix must also be applied to id and length_control\n # to support vector parameters\n prefix = ''\n if not part.composition or part.composition[0] == 'product':\n # Model isn't a composition model, so its parameters don't have a\n # a prefix. Add the next available prefix\n prefix = chr(ord('A')+len(used_prefixes))\n used_prefixes.append(prefix)\n prefix += '_'\n\n if operation == '+':\n # If model is a sum model, each constituent model gets its own scale parameter\n scale_prefix = prefix\n if prefix == '' and getattr(part, \"operation\", '') == '*':\n # `part` is a composition product model. Find the prefixes of\n # its parameters to form a new prefix for the scale.\n # For example, a model with A*B*C will have ABC_scale.\n sub_prefixes = []\n for param in part.parameters.kernel_parameters:\n # Prefix of constituent model\n sub_prefix = param.id.split('_')[0]\n if sub_prefix not in sub_prefixes:\n sub_prefixes.append(sub_prefix)\n # Concatenate sub_prefixes to form prefix for the scale\n scale_prefix = ''.join(sub_prefixes) + '_'\n scale = Parameter(scale_prefix + 'scale', default=1.0,\n description=\"model intensity for \" + part.name)\n combined_pars.append(scale)\n for p in part.parameters.kernel_parameters:\n p = copy(p)\n p.name = prefix + p.name\n p.id = prefix + p.id\n if p.length_control is not None:\n p.length_control = prefix + p.length_control\n combined_pars.append(p)\n parameters = ParameterTable(combined_pars)\n # Allow for the scenario in which each component has all its PD parameters\n # active simultaneously. details.make_details() will throw an error if\n # too many are used from any one component.\n parameters.max_pd = sum(part.parameters.max_pd for part in parts)\n\n def random():\n \"\"\"Random set of model parameters for mixture model\"\"\"\n combined_pars = {}\n for k, part in enumerate(parts):\n prefix = chr(ord('A')+k) + '_'\n pars = part.random()\n combined_pars.update((prefix+k, v) for k, v in pars.items())\n return combined_pars\n\n model_info = ModelInfo()\n model_info.id = operation.join(part.id for part in parts)\n model_info.operation = operation\n model_info.name = '(' + operation.join(part.name for part in parts) + ')'\n model_info.filename = None\n model_info.title = 'Mixture model with ' + model_info.name\n model_info.description = model_info.title\n model_info.docs = model_info.title\n model_info.category = \"custom\"\n model_info.parameters = parameters\n model_info.random = random\n #model_info.single = any(part['single'] for part in parts)\n model_info.structure_factor = False\n #model_info.tests = []\n #model_info.source = []\n # Remember the component info blocks so we can build the model\n model_info.composition = ('mixture', parts)\n return model_info","def tied_featurize(batch, device, chain_dict, fixed_position_dict=None, omit_AA_dict=None, tied_positions_dict=None, pssm_dict=None, bias_by_res_dict=None, ca_only=False):\n alphabet = 'ACDEFGHIKLMNPQRSTVWYX'\n B = len(batch)\n lengths = np.array([len(b['seq']) for b in batch], dtype=np.int32) #sum of chain seq lengths\n L_max = max([len(b['seq']) for b in batch])\n if ca_only:\n X = np.zeros([B, L_max, 1, 3])\n else:\n X = np.zeros([B, L_max, 4, 3])\n residue_idx = -100*np.ones([B, L_max], dtype=np.int32)\n chain_M = np.zeros([B, L_max], dtype=np.int32) #1.0 for the bits that need to be predicted\n pssm_coef_all = np.zeros([B, L_max], dtype=np.float32) #1.0 for the bits that need to be predicted\n pssm_bias_all = np.zeros([B, L_max, 21], dtype=np.float32) #1.0 for the bits that need to be predicted\n pssm_log_odds_all = 10000.0*np.ones([B, L_max, 21], dtype=np.float32) #1.0 for the bits that need to be predicted\n chain_M_pos = np.zeros([B, L_max], dtype=np.int32) #1.0 for the bits that need to be predicted\n bias_by_res_all = np.zeros([B, L_max, 21], dtype=np.float32)\n chain_encoding_all = np.zeros([B, L_max], dtype=np.int32) #1.0 for the bits that need to be predicted\n S = np.zeros([B, L_max], dtype=np.int32)\n omit_AA_mask = np.zeros([B, L_max, len(alphabet)], dtype=np.int32)\n # Build the batch\n letter_list_list = []\n visible_list_list = []\n masked_list_list = []\n masked_chain_length_list_list = []\n tied_pos_list_of_lists_list = []\n for i, b in enumerate(batch):\n if chain_dict != None:\n masked_chains, visible_chains = chain_dict[b['name']] #masked_chains a list of chain letters to predict [A, D, F]\n else:\n masked_chains = [item[-1:] for item in list(b) if item[:10]=='seq_chain_']\n visible_chains = []\n masked_chains.sort() #sort masked_chains \n visible_chains.sort() #sort visible_chains \n all_chains = masked_chains + visible_chains\n for i, b in enumerate(batch):\n mask_dict = {}\n a = 0\n x_chain_list = []\n chain_mask_list = []\n chain_seq_list = []\n chain_encoding_list = []\n c = 1\n letter_list = []\n global_idx_start_list = [0]\n visible_list = []\n masked_list = []\n masked_chain_length_list = []\n fixed_position_mask_list = []\n omit_AA_mask_list = []\n pssm_coef_list = []\n pssm_bias_list = []\n pssm_log_odds_list = []\n bias_by_res_list = []\n l0 = 0\n l1 = 0\n for step, letter in enumerate(all_chains):\n if letter in visible_chains:\n letter_list.append(letter)\n visible_list.append(letter)\n chain_seq = b[f'seq_chain_{letter}']\n chain_seq = ''.join([a if a!='-' else 'X' for a in chain_seq])\n chain_length = len(chain_seq)\n global_idx_start_list.append(global_idx_start_list[-1]+chain_length)\n chain_coords = b[f'coords_chain_{letter}'] #this is a dictionary\n chain_mask = np.zeros(chain_length) #0.0 for visible chains\n if ca_only:\n x_chain = np.array(chain_coords[f'CA_chain_{letter}']) #[chain_lenght,1,3] #CA_diff\n if len(x_chain.shape) == 2:\n x_chain = x_chain[:,None,:]\n else:\n x_chain = np.stack([chain_coords[c] for c in [f'N_chain_{letter}', f'CA_chain_{letter}', f'C_chain_{letter}', f'O_chain_{letter}']], 1) #[chain_lenght,4,3]\n x_chain_list.append(x_chain)\n chain_mask_list.append(chain_mask)\n chain_seq_list.append(chain_seq)\n chain_encoding_list.append(c*np.ones(np.array(chain_mask).shape[0]))\n l1 += chain_length\n residue_idx[i, l0:l1] = 100*(c-1)+np.arange(l0, l1)\n l0 += chain_length\n c+=1\n fixed_position_mask = np.ones(chain_length)\n fixed_position_mask_list.append(fixed_position_mask)\n omit_AA_mask_temp = np.zeros([chain_length, len(alphabet)], np.int32)\n omit_AA_mask_list.append(omit_AA_mask_temp)\n pssm_coef = np.zeros(chain_length)\n pssm_bias = np.zeros([chain_length, 21])\n pssm_log_odds = 10000.0*np.ones([chain_length, 21])\n pssm_coef_list.append(pssm_coef)\n pssm_bias_list.append(pssm_bias)\n pssm_log_odds_list.append(pssm_log_odds)\n bias_by_res_list.append(np.zeros([chain_length, 21]))\n if letter in masked_chains:\n masked_list.append(letter)\n letter_list.append(letter)\n chain_seq = b[f'seq_chain_{letter}']\n chain_seq = ''.join([a if a!='-' else 'X' for a in chain_seq])\n chain_length = len(chain_seq)\n global_idx_start_list.append(global_idx_start_list[-1]+chain_length)\n masked_chain_length_list.append(chain_length)\n chain_coords = b[f'coords_chain_{letter}'] #this is a dictionary\n chain_mask = np.ones(chain_length) #1.0 for masked\n if ca_only:\n x_chain = np.array(chain_coords[f'CA_chain_{letter}']) #[chain_lenght,1,3] #CA_diff\n if len(x_chain.shape) == 2:\n x_chain = x_chain[:,None,:]\n else:\n x_chain = np.stack([chain_coords[c] for c in [f'N_chain_{letter}', f'CA_chain_{letter}', f'C_chain_{letter}', f'O_chain_{letter}']], 1) #[chain_lenght,4,3] \n x_chain_list.append(x_chain)\n chain_mask_list.append(chain_mask)\n chain_seq_list.append(chain_seq)\n chain_encoding_list.append(c*np.ones(np.array(chain_mask).shape[0]))\n l1 += chain_length\n residue_idx[i, l0:l1] = 100*(c-1)+np.arange(l0, l1)\n l0 += chain_length\n c+=1\n fixed_position_mask = np.ones(chain_length)\n if fixed_position_dict!=None:\n fixed_pos_list = fixed_position_dict[b['name']][letter]\n if fixed_pos_list:\n fixed_position_mask[np.array(fixed_pos_list)-1] = 0.0\n fixed_position_mask_list.append(fixed_position_mask)\n omit_AA_mask_temp = np.zeros([chain_length, len(alphabet)], np.int32)\n if omit_AA_dict!=None:\n for item in omit_AA_dict[b['name']][letter]:\n idx_AA = np.array(item[0])-1\n AA_idx = np.array([np.argwhere(np.array(list(alphabet))== AA)[0][0] for AA in item[1]]).repeat(idx_AA.shape[0])\n idx_ = np.array([[a, b] for a in idx_AA for b in AA_idx])\n omit_AA_mask_temp[idx_[:,0], idx_[:,1]] = 1\n omit_AA_mask_list.append(omit_AA_mask_temp)\n pssm_coef = np.zeros(chain_length)\n pssm_bias = np.zeros([chain_length, 21])\n pssm_log_odds = 10000.0*np.ones([chain_length, 21])\n if pssm_dict:\n if pssm_dict[b['name']][letter]:\n pssm_coef = pssm_dict[b['name']][letter]['pssm_coef']\n pssm_bias = pssm_dict[b['name']][letter]['pssm_bias']\n pssm_log_odds = pssm_dict[b['name']][letter]['pssm_log_odds']\n pssm_coef_list.append(pssm_coef)\n pssm_bias_list.append(pssm_bias)\n pssm_log_odds_list.append(pssm_log_odds)\n if bias_by_res_dict:\n bias_by_res_list.append(bias_by_res_dict[b['name']][letter])\n else:\n bias_by_res_list.append(np.zeros([chain_length, 21]))\n\n \n letter_list_np = np.array(letter_list)\n tied_pos_list_of_lists = []\n tied_beta = np.ones(L_max)\n if tied_positions_dict!=None:\n tied_pos_list = tied_positions_dict[b['name']]\n if tied_pos_list:\n set_chains_tied = set(list(itertools.chain(*[list(item) for item in tied_pos_list])))\n for tied_item in tied_pos_list:\n one_list = []\n for k, v in tied_item.items():\n start_idx = global_idx_start_list[np.argwhere(letter_list_np == k)[0][0]]\n if isinstance(v[0], list):\n for v_count in range(len(v[0])):\n one_list.append(start_idx+v[0][v_count]-1)#make 0 to be the first\n tied_beta[start_idx+v[0][v_count]-1] = v[1][v_count]\n else:\n for v_ in v:\n one_list.append(start_idx+v_-1)#make 0 to be the first\n tied_pos_list_of_lists.append(one_list)\n tied_pos_list_of_lists_list.append(tied_pos_list_of_lists)\n\n\n \n x = np.concatenate(x_chain_list,0) #[L, 4, 3]\n all_sequence = \"\".join(chain_seq_list)\n m = np.concatenate(chain_mask_list,0) #[L,], 1.0 for places that need to be predicted\n chain_encoding = np.concatenate(chain_encoding_list,0)\n m_pos = np.concatenate(fixed_position_mask_list,0) #[L,], 1.0 for places that need to be predicted\n\n pssm_coef_ = np.concatenate(pssm_coef_list,0) #[L,], 1.0 for places that need to be predicted\n pssm_bias_ = np.concatenate(pssm_bias_list,0) #[L,], 1.0 for places that need to be predicted\n pssm_log_odds_ = np.concatenate(pssm_log_odds_list,0) #[L,], 1.0 for places that need to be predicted\n\n bias_by_res_ = np.concatenate(bias_by_res_list, 0) #[L,21], 0.0 for places where AA frequencies don't need to be tweaked\n\n l = len(all_sequence)\n x_pad = np.pad(x, [[0,L_max-l], [0,0], [0,0]], 'constant', constant_values=(np.nan, ))\n X[i,:,:,:] = x_pad\n\n m_pad = np.pad(m, [[0,L_max-l]], 'constant', constant_values=(0.0, ))\n m_pos_pad = np.pad(m_pos, [[0,L_max-l]], 'constant', constant_values=(0.0, ))\n omit_AA_mask_pad = np.pad(np.concatenate(omit_AA_mask_list,0), [[0,L_max-l]], 'constant', constant_values=(0.0, ))\n chain_M[i,:] = m_pad\n chain_M_pos[i,:] = m_pos_pad\n omit_AA_mask[i,] = omit_AA_mask_pad\n\n chain_encoding_pad = np.pad(chain_encoding, [[0,L_max-l]], 'constant', constant_values=(0.0, ))\n chain_encoding_all[i,:] = chain_encoding_pad\n\n pssm_coef_pad = np.pad(pssm_coef_, [[0,L_max-l]], 'constant', constant_values=(0.0, ))\n pssm_bias_pad = np.pad(pssm_bias_, [[0,L_max-l], [0,0]], 'constant', constant_values=(0.0, ))\n pssm_log_odds_pad = np.pad(pssm_log_odds_, [[0,L_max-l], [0,0]], 'constant', constant_values=(0.0, ))\n\n pssm_coef_all[i,:] = pssm_coef_pad\n pssm_bias_all[i,:] = pssm_bias_pad\n pssm_log_odds_all[i,:] = pssm_log_odds_pad\n\n bias_by_res_pad = np.pad(bias_by_res_, [[0,L_max-l], [0,0]], 'constant', constant_values=(0.0, ))\n bias_by_res_all[i,:] = bias_by_res_pad\n\n # Convert to labels\n indices = np.asarray([alphabet.index(a) for a in all_sequence], dtype=np.int32)\n S[i, :l] = indices\n letter_list_list.append(letter_list)\n visible_list_list.append(visible_list)\n masked_list_list.append(masked_list)\n masked_chain_length_list_list.append(masked_chain_length_list)\n\n\n isnan = np.isnan(X)\n mask = np.isfinite(np.sum(X,(2,3))).astype(np.float32)\n X[isnan] = 0.\n\n # Conversion\n pssm_coef_all = torch.from_numpy(pssm_coef_all).to(dtype=torch.float32, device=device)\n pssm_bias_all = torch.from_numpy(pssm_bias_all).to(dtype=torch.float32, device=device)\n pssm_log_odds_all = torch.from_numpy(pssm_log_odds_all).to(dtype=torch.float32, device=device)\n\n tied_beta = torch.from_numpy(tied_beta).to(dtype=torch.float32, device=device)\n\n jumps = ((residue_idx[:,1:]-residue_idx[:,:-1])==1).astype(np.float32)\n bias_by_res_all = torch.from_numpy(bias_by_res_all).to(dtype=torch.float32, device=device)\n phi_mask = np.pad(jumps, [[0,0],[1,0]])\n psi_mask = np.pad(jumps, [[0,0],[0,1]])\n omega_mask = np.pad(jumps, [[0,0],[0,1]])\n dihedral_mask = np.concatenate([phi_mask[:,:,None], psi_mask[:,:,None], omega_mask[:,:,None]], -1) #[B,L,3]\n dihedral_mask = torch.from_numpy(dihedral_mask).to(dtype=torch.float32, device=device)\n residue_idx = torch.from_numpy(residue_idx).to(dtype=torch.long,device=device)\n S = torch.from_numpy(S).to(dtype=torch.long,device=device)\n X = torch.from_numpy(X).to(dtype=torch.float32, device=device)\n mask = torch.from_numpy(mask).to(dtype=torch.float32, device=device)\n chain_M = torch.from_numpy(chain_M).to(dtype=torch.float32, device=device)\n chain_M_pos = torch.from_numpy(chain_M_pos).to(dtype=torch.float32, device=device)\n omit_AA_mask = torch.from_numpy(omit_AA_mask).to(dtype=torch.float32, device=device)\n chain_encoding_all = torch.from_numpy(chain_encoding_all).to(dtype=torch.long, device=device)\n if ca_only:\n X_out = X[:,:,0]\n else:\n X_out = X\n return X_out, S, mask, lengths, chain_M, chain_encoding_all, letter_list_list, visible_list_list, masked_list_list, masked_chain_length_list_list, chain_M_pos, omit_AA_mask, residue_idx, dihedral_mask, tied_pos_list_of_lists_list, pssm_coef_all, pssm_bias_all, pssm_log_odds_all, bias_by_res_all, tied_beta","def compiler_output(input_ckt, hier_graph_dict, design_name:str, result_dir:pathlib.Path, pdk_dir:pathlib.Path, uniform_height=False):\n layers_json = pdk_dir / 'layers.json'\n with open(layers_json,\"rt\") as fp:\n pdk_data=json.load(fp)\n design_config = pdk_data[\"design_info\"]\n\n if not result_dir.exists():\n result_dir.mkdir()\n logger.debug(f\"Writing results in dir: {result_dir} {hier_graph_dict}\")\n input_dir = input_ckt.parents[0]\n\n verilog_tbl = { 'modules': [], 'global_signals': []}\n\n design_setup = read_setup(input_dir / (design_name + '.setup'))\n try:\n POWER_PINS = [design_setup['GND'][0],design_setup['POWER'][0]]\n except (IndexError, ValueError):\n POWER_PINS = []\n logger.info(\"Power and ground nets not found. Power grid will not be constructed.\")\n\n #read lef to not write those modules as macros\n lef_path = pathlib.Path(__file__).resolve().parent.parent / 'config'\n all_lef = read_lef(lef_path)\n logger.debug(f\"Available library cells: {', '.join(all_lef)}\")\n\n primitives = {}\n for name,member in hier_graph_dict.items():\n logger.debug(f\"Found module: {name} {member['graph'].nodes()}\")\n graph = member[\"graph\"]\n constraints = member[\"constraints\"]\n\n for const in constraints:\n if isinstance(const, constraint.GuardRing):\n primitives['guard_ring'] = {'primitive':'guard_ring'}\n\n logger.debug(f\"Reading nodes from graph: {name}\")\n for node, attr in graph.nodes(data=True):\n if 'net' in attr['inst_type']: continue\n #Dropping floating ports\n lef_name = attr['inst_type']\n\n if \"values\" in attr and (lef_name in all_lef):\n block_name, block_args = generate_lef(lef_name, attr, primitives, design_config, uniform_height)\n #block_name_ext = block_name.replace(lef_name,'')\n logger.debug(f\"Created new lef for: {block_name} {lef_name}\")\n #Multiple instances of same module\n if 'inst_copy' in attr:\n for nm in list(hier_graph_dict.keys()):\n if nm == lef_name + attr['inst_copy']:\n if block_name not in hier_graph_dict.keys():\n logger.debug('Trying to modify a dictionary while iterating over it!')\n hier_graph_dict[block_name] = hier_graph_dict.pop(nm)\n else:\n #For cells with extra parameters than current primitive naming convention\n all_lef.append(nm)\n graph.nodes[node][\"inst_type\"] = block_name\n all_lef.append(block_name)\n\n # Only unit caps are generated\n if block_name.lower().startswith('cap'):\n graph.nodes[node]['inst_type'] = block_args['primitive']\n block_args['primitive'] = block_name\n else:\n graph.nodes[node]['inst_type'] = block_name\n\n if block_name in primitives:\n if block_args != primitives[block_name]:\n logging.warning(f\"two different primitve {block_name} of size {primitives[block_name]} {block_args}got approximated to same unit size\")\n else:\n primitives[block_name] = block_args\n elif \"values\" in attr and 'inst_copy' in attr:\n member[\"graph\"].nodes[node][\"inst_type\"]= lef_name + attr[\"inst_copy\"]\n all_lef.append(block_name)\n\n else:\n logger.debug(f\"No physical information found for: {name}\")\n logger.debug(f\"generated data for {name} : {pprint.pformat(primitives, indent=4)}\")\n logger.debug(f\"All available cell generator with updates: {all_lef}\")\n for name,member in hier_graph_dict.items():\n graph = member[\"graph\"]\n logger.debug(f\"Found module: {name} {graph.nodes()}\")\n inoutpin = []\n floating_ports=[]\n if \"ports_match\" in member and member[\"ports_match\"]:\n for key in member[\"ports_match\"].keys():\n if key not in POWER_PINS:\n inoutpin.append(key)\n if member[\"ports\"]:\n logger.debug(f'Found module ports: {member[\"ports\"]} {member[\"name\"]}')\n floating_ports = set(inoutpin) - set(member[\"ports\"]) - set(design_setup['POWER']) -set(design_setup['GND'])\n if len(list(floating_ports))> 0:\n logger.error(f\"floating ports found: {name} {floating_ports}\")\n raise SystemExit('Please remove floating ports')\n else:\n inoutpin = member[\"ports\"]\n if name not in all_lef:\n\n ## Removing constraints to fix cascoded cmc\n if name not in design_setup['DIGITAL']:\n logger.debug(f\"call constraint generator writer for block: {name}\")\n stop_points = design_setup['POWER'] + design_setup['GND'] + design_setup['CLOCK']\n constraints = member[\"constraints\"]\n if name not in design_setup['NO_CONST']:\n constraints = FindConst(graph, name, inoutpin, member[\"ports_weight\"], constraints, stop_points)\n constraints = CapConst(graph, name, design_config[\"unit_size_cap\"], constraints, design_setup['MERGE_SYMM_CAPS'])\n hier_graph_dict[name] = hier_graph_dict[name].copy(\n update={'constraints': constraints}\n )\n ## Write out modified netlist & constraints as JSON\n logger.debug(f\"call verilog writer for block: {name}\")\n wv = WriteVerilog(name, inoutpin, hier_graph_dict, POWER_PINS)\n verilog_tbl['modules'].append( wv.gen_dict())\n if len(POWER_PINS)>0:\n for i, nm in enumerate(POWER_PINS):\n verilog_tbl['global_signals'].append( { 'prefix' :'global_power', 'formal' : f'supply{i}', 'actual' : nm})\n\n with (result_dir / f'{design_name}.verilog.json').open( 'wt') as fp:\n json.dump( verilog_tbl, fp=fp, indent=2)\n\n with (result_dir / f'{design_name}.v').open( 'wt') as fp:\n write_verilog( verilog_tbl, fp)\n\n logger.info(\"Completed topology identification.\")\n logger.debug(f\"OUTPUT verilog json netlist at: {result_dir}/{design_name}.verilog.json\")\n logger.debug(f\"OUTPUT verilog netlist at: {result_dir}/{design_name}.v\")\n logger.debug(f\"OUTPUT const file at: {result_dir}/{design_name}.pnr.const.json\")\n return primitives","def convert2EbnerParam(joblib,list_prefix,directory):\n \n key=[p[0] for p in joblib]\n element=[p[1] for p in joblib]\n\n \n listSlice=element[key.index('listSlice')] #list of slice\n parameters=element[key.index('EvolutionParameters')][-1,:,:] #estimated paramters of the registration\n rejectedSlice=element[key.index('RejectedSlices')] #rejected slices\n\n \n images,mask = createVolumesFromAlist(listSlice.copy()) #list of images corresponding to differents original stacks\n \n for i_slice in range(len(listSlice)): \n slicei=listSlice[i_slice]\n slicei.set_parameters(parameters[i_slice,:]) #set parameters to the last estimated parameters\n \n mat = np.array([[-1,0,0,0],[0,-1,0,0],[0,0,1,0],[0,0,0,1]]) #matrix to convert affine matrix from nibabel to itk\n\n for n in range(len(images)): #for each stack\n \n imagen = images[n]\n \n for i_slice in range(len(images[n])): #for each slices (in each stacks)\n \n slicei=imagen[i_slice]\n s = (slicei.get_orientation(),slicei.get_index_slice())\n \n if s not in rejectedSlice:\n dimension=3\n X,Y,Z= slicei.get_slice().get_fdata().shape\n center= -slicei.get_center()\n centerMat = np.eye(4)\n centerMat[0:3,3] = center[0:3]\n invcenterMat = np.eye(4)\n invcenterMat[0:3,3] = -center[0:3] \n p = slicei.get_parameters()\n matrix = mat @ centerMat @ rigidMatrix([p[0],p[1],p[2],p[3],p[4],p[5]]) @ invcenterMat @ mat\n test = sitk.AffineTransform(dimension)\n test.SetMatrix(matrix[0:3,0:3].flatten())\n test.SetTranslation(matrix[0:3,3])\n images_index = slicei.get_index_image()\n sitk.WriteTransform(test,\"%s/%s_slice%d.tfm\" %(directory,list_prefix[images_index],slicei.get_index_slice())) #save rigid transformation, computed at the barycenter of the image, adatpted to itk\n #else:\n #print(s)","def build(width, height, depth, classes, stages, filters, include_top, pooling,\n reg=1e-3, bnEps=2e-5, bnMom=0.0):\n inputShape = (height, width, depth)\n chanDim = -1\n\n if K.image_data_format() == \"channels_first\":\n inputShape = (depth, height, width)\n chanDim = 1\n\n inputs = Input(shape=inputShape)\n\n\n # block 1 (initial conv block)\n x = ZeroPadding2D(padding=((3, 3), (3, 3)), name='conv1_pad')(inputs)\n x = Conv2D(64, (7,7), use_bias=False, strides=(2,2),\n kernel_initializer=\"he_normal\", kernel_regularizer=l2(reg))(x)\n x = BatchNormalization(axis=chanDim, name=\"bn_conv1\")(x)\n x = Activation(\"relu\")(x)\n x = ZeroPadding2D(padding=((1,1), (1,1)), name=\"pool1_pad\")(x)\n x = MaxPooling2D(3, strides=2)(x)\n\n for i in range(0, len(stages)):\n stride = (1,1) if i == 0 else (2,2) # block 2 (projection block) w stride(1,1)\n\n print(\"Stage {}, Stride={}\".format(i, stride))\n x = SEResNet.residual_module(x, filters[i+1], stride,\n chanDim=chanDim, red=True, bnEps=bnEps, bnMom=bnMom)\n for j in range(0, stages[i] + 1): #stacking res block to each depth layer\n x = SEResNet.residual_module(x, filters[i+1], stride=(1,1),\n chanDim=chanDim, bnEps=bnEps,\n bnMom=bnMom)\n x = BatchNormalization(axis=chanDim, epsilon=bnEps,\n momentum=bnMom)(x)\n x = Activation(\"relu\")(x)\n\n if include_top:\n x = GlobalAveragePooling2D()(x)\n x = Dense(classes, use_bias=False, kernel_regularizer=l2(reg),\n activation='softmax')(x)\n else:\n if pooling == 'avg':\n print(\"Adding average pool\")\n x = GlobalAveragePooling2D()(x)\n elif pooling == 'max':\n x = GlobalMaxPooling2D()(x)\n\n model = Model(inputs=inputs, outputs=x, name=\"SEResNet\")\n return model","def _processLabel(self, kitti_label):\n label = {\n 'category': kitti_label['type'].lower(),\n 'box2D': kitti_label['bbox'].copy(),\n 'box3D': {\n 'location': {\n 'x': kitti_label['location']['x'],\n 'y': kitti_label['location']['y'] - kitti_label['dimensions']['height'] / 2.0, # move to center\n 'z': kitti_label['location']['z'],\n },\n 'dimensions': kitti_label['dimensions'].copy(),\n 'rotation_y': kitti_label['rotation_y'],\n },\n 'info': {\n 'truncated': kitti_label['truncated'],\n 'occluded': kitti_label['occluded'],\n },\n }\n if 'trackId' in kitti_label:\n # set trackId if given\n label['info']['trackId'] = kitti_label['trackId']\n return label","def generate_semisupervized_label(self, idx_known, idx_unknown):\n tmp_df = self.data_info.set_index(['patientID','body_part'])\n # associate semi-supervized settings\n if len(idx_known) > 0:\n df_known = tmp_df.loc[idx_known,:]\n df_known['semi_label'] = df_known.abnormal_XR.apply(lambda x: -1 if x==1 else 1)\n df_unknown = tmp_df.loc[idx_unknown,:]\n df_unknown['semi_label'] = 0\n return pd.concat([df_known, df_unknown], axis=0).reset_index()\n else:\n df_unknown = tmp_df.loc[idx_unknown,:]\n df_unknown['semi_label'] = 0\n return df_unknown.reset_index()","def serialize(mode):\r\n serialize_version(mode)\r\n vcb.serialize(mode) \r\n for x in xfrms:\r\n x.serialize(mode)","def label(self, cfg):\n rep = \"\"\n nl = \"\"\n for node in cfg.nodes:\n rep += nl + \"{}\\tgen={}\\tkill={}\\tout={}\".format(\n node, \n set(self.gen.get(node)),\n set(self.kill.get(node)),\n set(self.out.get(node)))\n nl = \"\\n\"\n return rep","def m_dump_tf():\n\n # Info about ENS and Resolver Smart Contracts\n #print(f\"ENS address: {ens.address()}\")\n print(f\"ENS address (contract address): {ENS.address}\")\n print(f\"Resolver address (contract address): {resolver.address()}\")\n print(f\"Resolver address from ENS(root): {ens.resolver('root')}\")\n print(\"\\n\")\n\n print(f\"Owner of ROOT record: {ens.owner('root')}\")\n ROOT_address, ROOT_key = wallet.account_from_name(\"ROOT\", \"ThePassword\")\n print(f\"ROOT address from wallet: {ROOT_address}\")\n\n n_subnodes = ens.numberSubnodes(0)\n print(f\"Number of subnodes of root: {n_subnodes}\")\n for i in range(n_subnodes):\n hash = ens.subnode(index=i).hex()\n print(f\" Subnode hash {i}: {ens.subnode(i).hex()}\")\n name = resolver.name(node_hash=hash)\n print(f\" Name: {name}\")\n resolver_address = ENS.functions.resolver(hash).call()\n print(f\" Resolver: {resolver_address}\")\n ala_address = ens.resolver(name)\n print(f\" Resolver by name: {ala_address}\")\n owner = owner = ENS.functions.owner(hash).call()\n print(f\" Owner: {owner}\")\n ROOT_address, ROOT_key = wallet.account_from_name(\"Alastria\", \"ThePassword\")\n print(f\" Address from wallet: {ROOT_address}\")\n\n n_subnodes = ens.numberSubnodes(\"ala\")\n print(f\"Number of subnodes of {name}: {n_subnodes}\")\n for i in range(n_subnodes):\n hash = ens.subnode(node_name=\"ala\", index=i).hex()\n print(f\" Subnode hash {i}: {hash}\")\n name = resolver.name(node_hash=hash)\n print(f\" Name: {name}\")\n resolver_address = ENS.functions.resolver(hash).call()\n print(f\" Resolver: {resolver_address}\")\n ala_address = ens.resolver(name)\n print(f\" Resolver by name: {ala_address}\")\n owner = owner = ENS.functions.owner(hash).call()\n print(f\" Owner: {owner}\")","def serialize(self):\n return pickle.dumps([block.serialize() for block in self.chain])","def identity_block(X, f, filters, stage, block):\n\n # defining name basis\n conv_name_base = 'res' + str(stage) + block + '_branch'\n bn_name_base = 'bn' + str(stage) + block + '_branch'\n\n # Retrieve Filters\n F1, F2, F3 = filters\n\n # Save the input value.\n X_shortcut = X\n\n # First component of main path\n X = Conv2D(filters = F1, kernel_size = (1, 1), strides = (1,1), padding = 'valid', name = conv_name_base + '2a', kernel_initializer = glorot_uniform(seed=0))(X)\n X = BatchNormalization(axis = 3, name = bn_name_base + '2a')(X)\n X = Activation('relu')(X)\n\n # Second component of main path\n X = Conv2D(filters = F2, kernel_size= (f,f),strides= (1,1), padding= 'same' , name = conv_name_base + '2b', kernel_initializer = glorot_uniform(seed=0))(X)\n X = BatchNormalization(axis=3, name=bn_name_base + '2b')(X)\n X = Activation('relu')(X)\n\n # Third component of main path\n X = Conv2D(filters = F3, kernel_size= (1,1),strides= (1,1), padding= 'valid' , name = conv_name_base + '2c', kernel_initializer = glorot_uniform(seed=0))(X)\n X = BatchNormalization(axis=3, name=bn_name_base + '2c')(X)\n\n # Final step: Add shortcut value to main path, and pass it through a RELU activation\n X = layers.add([X,X_shortcut])\n X = Activation('relu')(X)\n\n return X","def build_label_transform():\n\n return NALabelEncoder()","def _make_ht_label(chain_parts):\n\n assert len(chain_parts) == 1, '_make_ht_label, no. of chain parts != 1'\n scenario = chain_parts[0]['hypoScenario']\n \n assert scenario.startswith('HT'), '_make_ht_label(): scenario does not start with HT'\n\n arg_res = [\n re.compile(r'^(?P<lo>\\d*)(?P<key>ht)(?P<hi>\\d*)$'),\n re.compile(r'^(?P<lo>\\d*)(?P<key>et)(?P<hi>\\d*)$'),\n re.compile(r'^(?P<lo>\\d*)(?P<key>eta)(?P<hi>\\d*)$'),\n ]\n\n defaults = {\n 'ht': ('0', 'inf'),\n 'et': ('0', 'inf'),\n 'eta': ('0', 'inf'),\n }\n\n\n args = _args_from_scenario(scenario)\n argvals = {}\n nargs = len(args)\n assert len(args) <= len(arg_res), 'bad num of args %d, expected < %d' % (len(args),\n len(arg_res))\n\n # obtain argument values frrom scenario\n while args:\n arg = args.pop()\n for r in arg_res:\n m = r.match(arg)\n if m is not None:\n arg_res.remove(r)\n gd = m.groupdict()\n key = gd['key']\n\n try:\n lo = float(gd['lo'])\n except ValueError:\n lo = float(defaults[key][0])\n argvals[key+'lo'] = lo \n try:\n hi = float(gd['hi'])\n except ValueError:\n hi = float(defaults[key][1])\n argvals[key+'hi'] = hi\n\n print (argvals)\n assert len(argvals) == 2*nargs, 'no of args: %d, expected %d' % (len(argvals), 2*nargs)\n\n print ('sent 100')\n result = \"\"\"\n ht([(%(htlo).0fht) \n (%(etlo).0fet)\n (%(etalo).0feta%(etahi).0f)\n ])\"\"\" % argvals\n print (result)\n return result","def makeBinaryChains():\n\t\n\t# retrieve the binding partner specifications\n\t(maxsize,types) = getTypes()\n\t\n\t# Do some basic argument checking for this model\n\tif (len(types) < 2):\n\t\tprint \"Number of defined types must equal two for binary chain calculations.\"\n\t\treturn\n\tif (maxsize == 0):\n\t\tprint \"Must specify a valid maximum number for one or more components.\"\n\t\treturn\n\n\tallChains = []\n\tnewChainsA = [[]]\n\tnewChainsB = []\n\t\n\ttypeA = types[0]\n\ttypeB = types[1]\n\t\n\t# start the chain with a single type A component\n\taddComponent(newChainsA[0],typeA,0,0)\n\n\tdepth = 0\n\tfor n in range(maxsize):\n\t\tdepth+=1\n\t\t\n\t\t# go through all the chains created last iteration and append B components\n\t\tnewChainsB = []\n\t\tfor thisChain in newChainsA:\n\n\t\t\t# get a list of new available sites in the provided chain\n\t\t\t# by setting depth -1, we will only add to components added last round\n\t\t\topenSites = makeSiteList(thisChain,typeB,depth-1)\n\t\t\t\n\t\t\t# make all the descendants from the current chain and append them to the pool\n\t\t\tif (n == 0) and (typeA['sym']): #if the starting binder is symmetric, no need to start chains at all its sites\n\t\t\t\tnewChainsB = newChainsB + fillSites(openSites,thisChain,typeB,-1)\n\t\t\telse:\n\t\t\t\tnewChainsB = newChainsB + fillSites(openSites,thisChain,typeB,depth)\n\t\t\n\t\tprint('n:'+str(n)+', '+str(len(newChainsB))+ ' chains created at depth '+str(depth))\n\t\t\n\t\tallChains = allChains + newChainsB\n\t\t\n\t\tdepth+=1\n\t\t\n\t\t# add an additional component to all the previously modified chains\n\t\tnewChainsA = []\n\t\tfor thisChain in newChainsB:\n\n\t\t\topenSites = makeSiteList(thisChain,typeA,depth-1)\n\t\t\tnewChainsA = newChainsA + fillSites(openSites,thisChain,typeA,depth)\n\t\t\t\n\t\tprint('n:'+str(n)+', '+str(len(newChainsA))+ ' chains created at depth '+str(depth))\n\t\t\n\t\tallChains = allChains + newChainsA\n\n\treturn allChains","def __init__(self):\n # Flag this instance as compiled now\n self.is_compiled = True\n \n super(HState2CProcDef, self).__init__(name='HState2CProcDef', num_nodes=0, edges=[])\n \n \n # Set the graph attributes\n self[\"mm__\"] = ['HimesisMM']\n \n self[\"name\"] = \"\"\"State2CProcDef\"\"\"\n self[\"GUID__\"] = uuid.uuid3(uuid.NAMESPACE_DNS,'State2CProcDef')\n \n # match model. We only support one match model\n self.add_node()\n self.vs[0][\"mm__\"] = \"\"\"MatchModel\"\"\"\n \n # apply model node\n self.add_node()\n self.vs[1][\"mm__\"] = \"\"\"ApplyModel\"\"\"\n \n # paired with relation between match and apply models\n self.add_node()\n self.vs[2][\"mm__\"] = \"\"\"paired_with\"\"\"\n \n \n # match class State() node\n self.add_node()\n\n self.vs[3][\"mm__\"] = \"\"\"State\"\"\" \n self.vs[3][\"attr1\"] = \"\"\"+\"\"\" \n # match_contains node for class State()\n self.add_node()\n self.vs[4][\"mm__\"] = \"\"\"match_contains\"\"\"\n # match class Transition() node\n self.add_node()\n\n self.vs[5][\"mm__\"] = \"\"\"Transition\"\"\" \n self.vs[5][\"attr1\"] = \"\"\"1\"\"\" \n # match_contains node for class Transition()\n self.add_node()\n self.vs[6][\"mm__\"] = \"\"\"match_contains\"\"\"\n # match class EntryPoint() node\n self.add_node()\n\n self.vs[7][\"mm__\"] = \"\"\"EntryPoint\"\"\" \n self.vs[7][\"attr1\"] = \"\"\"1\"\"\" \n # match_contains node for class EntryPoint()\n self.add_node()\n self.vs[8][\"mm__\"] = \"\"\"match_contains\"\"\"\n # match class StateMachine() node\n self.add_node()\n\n self.vs[9][\"mm__\"] = \"\"\"StateMachine\"\"\" \n self.vs[9][\"attr1\"] = \"\"\"1\"\"\" \n # match_contains node for class StateMachine()\n self.add_node()\n self.vs[10][\"mm__\"] = \"\"\"match_contains\"\"\"\n \n \n # apply class LocalDef() node\n self.add_node()\n\n self.vs[11][\"mm__\"] = \"\"\"LocalDef\"\"\" \n self.vs[11][\"attr1\"] = \"\"\"1\"\"\"\n # apply_contains node for class LocalDef()\n self.add_node()\n self.vs[12][\"mm__\"] = \"\"\"apply_contains\"\"\"\n # apply class ProcDef() node\n self.add_node()\n\n self.vs[13][\"mm__\"] = \"\"\"ProcDef\"\"\" \n self.vs[13][\"attr1\"] = \"\"\"1\"\"\"\n # apply_contains node for class ProcDef()\n self.add_node()\n self.vs[14][\"mm__\"] = \"\"\"apply_contains\"\"\"\n # apply class Name() node\n self.add_node()\n\n self.vs[15][\"mm__\"] = \"\"\"Name\"\"\" \n self.vs[15][\"attr1\"] = \"\"\"1\"\"\"\n # apply_contains node for class Name()\n self.add_node()\n self.vs[16][\"mm__\"] = \"\"\"apply_contains\"\"\"\n # apply class Name() node\n self.add_node()\n\n self.vs[17][\"mm__\"] = \"\"\"Name\"\"\" \n self.vs[17][\"attr1\"] = \"\"\"1\"\"\"\n # apply_contains node for class Name()\n self.add_node()\n self.vs[18][\"mm__\"] = \"\"\"apply_contains\"\"\"\n # apply class Name() node\n self.add_node()\n\n self.vs[19][\"mm__\"] = \"\"\"Name\"\"\" \n self.vs[19][\"attr1\"] = \"\"\"1\"\"\"\n # apply_contains node for class Name()\n self.add_node()\n self.vs[20][\"mm__\"] = \"\"\"apply_contains\"\"\"\n # apply class Name() node\n self.add_node()\n\n self.vs[21][\"mm__\"] = \"\"\"Name\"\"\" \n self.vs[21][\"attr1\"] = \"\"\"1\"\"\"\n # apply_contains node for class Name()\n self.add_node()\n self.vs[22][\"mm__\"] = \"\"\"apply_contains\"\"\"\n # apply class ConditionSet() node\n self.add_node()\n\n self.vs[23][\"mm__\"] = \"\"\"ConditionSet\"\"\" \n self.vs[23][\"attr1\"] = \"\"\"1\"\"\"\n # apply_contains node for class ConditionSet()\n self.add_node()\n self.vs[24][\"mm__\"] = \"\"\"apply_contains\"\"\"\n # apply class Inst() node\n self.add_node()\n\n self.vs[25][\"mm__\"] = \"\"\"Inst\"\"\" \n self.vs[25][\"attr1\"] = \"\"\"1\"\"\"\n # apply_contains node for class Inst()\n self.add_node()\n self.vs[26][\"mm__\"] = \"\"\"apply_contains\"\"\"\n # apply class Name() node\n self.add_node()\n\n self.vs[27][\"mm__\"] = \"\"\"Name\"\"\" \n self.vs[27][\"attr1\"] = \"\"\"1\"\"\"\n # apply_contains node for class Name()\n self.add_node()\n self.vs[28][\"mm__\"] = \"\"\"apply_contains\"\"\"\n # apply class Name() node\n self.add_node()\n\n self.vs[29][\"mm__\"] = \"\"\"Name\"\"\" \n self.vs[29][\"attr1\"] = \"\"\"1\"\"\"\n # apply_contains node for class Name()\n self.add_node()\n self.vs[30][\"mm__\"] = \"\"\"apply_contains\"\"\"\n # apply class Name() node\n self.add_node()\n\n self.vs[31][\"mm__\"] = \"\"\"Name\"\"\" \n self.vs[31][\"attr1\"] = \"\"\"1\"\"\"\n # apply_contains node for class Name()\n self.add_node()\n self.vs[32][\"mm__\"] = \"\"\"apply_contains\"\"\"\n # apply class Name() node\n self.add_node()\n\n self.vs[33][\"mm__\"] = \"\"\"Name\"\"\" \n self.vs[33][\"attr1\"] = \"\"\"1\"\"\"\n # apply_contains node for class Name()\n self.add_node()\n self.vs[34][\"mm__\"] = \"\"\"apply_contains\"\"\"\n \n \n # match association State--initialTransition-->Transition node\n self.add_node()\n self.vs[35][\"attr1\"] = \"\"\"initialTransition\"\"\"\n self.vs[35][\"mm__\"] = \"\"\"directLink_S\"\"\"\n # match association Transition--dest-->EntryPoint node\n self.add_node()\n self.vs[36][\"attr1\"] = \"\"\"dest\"\"\"\n self.vs[36][\"mm__\"] = \"\"\"directLink_S\"\"\"\n # match association EntryPoint--owningStateMachine-->StateMachine node\n self.add_node()\n self.vs[37][\"attr1\"] = \"\"\"owningStateMachine\"\"\"\n self.vs[37][\"mm__\"] = \"\"\"directLink_S\"\"\"\n \n # apply association LocalDef--def-->ProcDef node\n self.add_node()\n self.vs[38][\"attr1\"] = \"\"\"def\"\"\"\n self.vs[38][\"mm__\"] = \"\"\"directLink_T\"\"\"\n # apply association ProcDef--channelNames-->Name node\n self.add_node()\n self.vs[39][\"attr1\"] = \"\"\"channelNames\"\"\"\n self.vs[39][\"mm__\"] = \"\"\"directLink_T\"\"\"\n # apply association ProcDef--channelNames-->Name node\n self.add_node()\n self.vs[40][\"attr1\"] = \"\"\"channelNames\"\"\"\n self.vs[40][\"mm__\"] = \"\"\"directLink_T\"\"\"\n # apply association ProcDef--channelNames-->Name node\n self.add_node()\n self.vs[41][\"attr1\"] = \"\"\"channelNames\"\"\"\n self.vs[41][\"mm__\"] = \"\"\"directLink_T\"\"\"\n # apply association ProcDef--channelNames-->Name node\n self.add_node()\n self.vs[42][\"attr1\"] = \"\"\"channelNames\"\"\"\n self.vs[42][\"mm__\"] = \"\"\"directLink_T\"\"\"\n # apply association ProcDef--p-->ConditionSet node\n self.add_node()\n self.vs[43][\"attr1\"] = \"\"\"p\"\"\"\n self.vs[43][\"mm__\"] = \"\"\"directLink_T\"\"\"\n # apply association ConditionSet--alternative-->Inst node\n self.add_node()\n self.vs[44][\"attr1\"] = \"\"\"alternative\"\"\"\n self.vs[44][\"mm__\"] = \"\"\"directLink_T\"\"\"\n # apply association Inst--channelNames-->Name node\n self.add_node()\n self.vs[45][\"attr1\"] = \"\"\"channelNames\"\"\"\n self.vs[45][\"mm__\"] = \"\"\"directLink_T\"\"\"\n # apply association Inst--channelNames-->Name node\n self.add_node()\n self.vs[46][\"attr1\"] = \"\"\"channelNames\"\"\"\n self.vs[46][\"mm__\"] = \"\"\"directLink_T\"\"\"\n # apply association Inst--channelNames-->Name node\n self.add_node()\n self.vs[47][\"attr1\"] = \"\"\"channelNames\"\"\"\n self.vs[47][\"mm__\"] = \"\"\"directLink_T\"\"\"\n # apply association Inst--channelNames-->Name node\n self.add_node()\n self.vs[48][\"attr1\"] = \"\"\"channelNames\"\"\"\n self.vs[48][\"mm__\"] = \"\"\"directLink_T\"\"\"\n \n # backward association State---->LocalDef node\n self.add_node()\n\n self.vs[49][\"mm__\"] = \"\"\"backward_link\"\"\"\n \n \n \n \n \n \n # Add the edges\n self.add_edges([\n (0,4), # matchmodel -> match_contains\n (4,3), # match_contains -> match_class State()\n (0,6), # matchmodel -> match_contains\n (6,5), # match_contains -> match_class Transition()\n (0,8), # matchmodel -> match_contains\n (8,7), # match_contains -> match_class EntryPoint()\n (0,10), # matchmodel -> match_contains\n (10,9), # match_contains -> match_class StateMachine()\n (1,12), # applymodel -> apply_contains\n (12,11), # apply_contains -> apply_class LocalDef()\n (1,14), # applymodel -> apply_contains\n (14,13), # apply_contains -> apply_class ProcDef()\n (1,16), # applymodel -> apply_contains\n (16,15), # apply_contains -> apply_class Name()\n (1,18), # applymodel -> apply_contains\n (18,17), # apply_contains -> apply_class Name()\n (1,20), # applymodel -> apply_contains\n (20,19), # apply_contains -> apply_class Name()\n (1,22), # applymodel -> apply_contains\n (22,21), # apply_contains -> apply_class Name()\n (1,24), # applymodel -> apply_contains\n (24,23), # apply_contains -> apply_class ConditionSet()\n (1,26), # applymodel -> apply_contains\n (26,25), # apply_contains -> apply_class Inst()\n (1,28), # applymodel -> apply_contains\n (28,27), # apply_contains -> apply_class Name()\n (1,30), # applymodel -> apply_contains\n (30,29), # apply_contains -> apply_class Name()\n (1,32), # applymodel -> apply_contains\n (32,31), # apply_contains -> apply_class Name()\n (1,34), # applymodel -> apply_contains\n (34,33), # apply_contains -> apply_class Name()\n (3,35), # match_class State() -> association initialTransition\n (35,5), # association initialTransition -> match_class Transition()\n (5,36), # match_class Transition() -> association dest\n (36,7), # association dest -> match_class EntryPoint()\n (7,37), # match_class EntryPoint() -> association owningStateMachine\n (37,9), # association owningStateMachine -> match_class StateMachine()\n (11,38), # apply_class LocalDef() -> association def\n (38,13), # association def -> apply_class ProcDef()\n (13,39), # apply_class ProcDef() -> association channelNames\n (39,15), # association channelNames -> apply_class Name()\n (13,40), # apply_class ProcDef() -> association channelNames\n (40,17), # association channelNames -> apply_class Name()\n (13,41), # apply_class ProcDef() -> association channelNames\n (41,19), # association channelNames -> apply_class Name()\n (13,42), # apply_class ProcDef() -> association channelNames\n (42,21), # association channelNames -> apply_class Name()\n (13,43), # apply_class ProcDef() -> association p\n (43,23), # association p -> apply_class ConditionSet()\n (23,44), # apply_class ConditionSet() -> association alternative\n (44,25), # association alternative -> apply_class Inst()\n (25,45), # apply_class Inst() -> association channelNames\n (45,27), # association channelNames -> apply_class Name()\n (25,46), # apply_class Inst() -> association channelNames\n (46,29), # association channelNames -> apply_class Name()\n (25,47), # apply_class Inst() -> association channelNames\n (47,31), # association channelNames -> apply_class Name()\n (25,48), # apply_class Inst() -> association channelNames\n (48,33), # association channelNames -> apply_class Name()\n (11,49), # apply_class LocalDef() -> backward_association\n (49,3), # backward_association -> apply_class State()\n (0,2), # matchmodel -> pairedwith\n (2,1) # pairedwith -> applyModel\t\t\t\t\n\t\t])\n\n # Add the attribute equations\n self[\"equations\"] = [((3,'isComposite'),('constant','true')), ((11,'ApplyAttribute'),('constant','solveRef')), ((13,'name'),('constant','C')), ((15,'literal'),('constant','enp')), ((17,'literal'),('constant','exit')), ((19,'literal'),('constant','exack')), ((21,'literal'),('constant','sh')), ((23,'ApplyAttribute'),('constant','solveRef')), ((25,'name'),('concat',(('constant','S'),(9,'name')))), ((27,'literal'),('concat',(('constant','A'),('concat',((7,'name'),('constant','A')))))), ((29,'literal'),('constant','exit_in')), ((31,'literal'),('constant','exack_in')), ((33,'literal'),('constant','sh_in')), ]","def calculate_217f_part_count(**attributes):\n _msg = ''\n\n # Dictionary containing MIL-HDBK-217FN2 parts count base hazard rates.\n # First key is the subcategory_id, second key is the specification id. If\n # the resistor subcategory is NOT specification dependent, then the second\n # key will be zero. Current subcategory IDs are:\n #\n # 1. Fixed, Composition (RC, RCR)\n # 2. Fixed, Film (RL, RLR, RN, RNC, RNN, RNR)\n # 3. Fixed, Film, Power (RD)\n # 4. Fixed, Film, Network (RZ)\n # 5. Fixed, Wirewound, Power (RB, RBR)\n # 6. Fixed, Wirewound, Power, Chassis Mounted (RE, RER)\n # 7. Thermistor\n # 8. Variable, Wirewound (RT, RTR)\n # 9. Variable, Wirewound, Precision (RR)\n # 10. Variable, Wirewound, Semiprecision (RA, RK)\n # 11. Variable, Non-Wirewound (RJ, RJR)\n # 12. Variable, Composition (RV)\n # 13. Variable,Non-Wirewound, Film and Precision (RQ, RVC)\n #\n # These keys return a list of base hazard rates. The hazard rate to use is\n # selected from the list depending on the active environment.\n _dic_lambda_b = {\n 1: [\n 0.0005, 0.0022, 0.0071, 0.0037, 0.012, 0.0052, 0.0065, 0.016,\n 0.025, 0.025, 0.00025, 0.0098, 0.035, 0.36\n ],\n 2: {\n 1: [\n 0.0012, 0.0027, 0.011, 0.0054, 0.020, 0.0063, 0.013, 0.018,\n 0.033, 0.030, 0.00025, 0.014, 0.044, 0.69\n ],\n 2: [\n 0.0012, 0.0027, 0.011, 0.0054, 0.020, 0.0063, 0.013, 0.018,\n 0.033, 0.030, 0.00025, 0.014, 0.044, 0.69\n ],\n 3: [\n 0.0014, 0.0031, 0.013, 0.0061, 0.023, 0.0072, 0.014, 0.021,\n 0.038, 0.034, 0.00028, 0.016, 0.050, 0.78\n ],\n 4: [\n 0.0014, 0.0031, 0.013, 0.0061, 0.023, 0.0072, 0.014, 0.021,\n 0.038, 0.034, 0.00028, 0.016, 0.050, 0.78\n ]\n },\n 3: [\n 0.012, 0.025, 0.13, 0.062, 0.21, 0.078, 0.10, 0.19, 0.24, 0.32,\n 0.0060, 0.18, 0.47, 8.2\n ],\n 4: [\n 0.0023, 0.0066, 0.031, 0.013, 0.055, 0.022, 0.043, 0.077, 0.15,\n 0.10, 0.0011, 0.055, 0.15, 1.7\n ],\n 5: [\n 0.0085, 0.018, 0.10, 0.045, 0.16, 0.15, 0.17, 0.30, 0.38, 0.26,\n 0.0068, 0.13, 0.37, 5.4\n ],\n 6: {\n 1: [\n 0.014, 0.031, 0.16, 0.077, 0.26, 0.073, 0.15, 0.19, 0.39, 0.42,\n 0.0042, 0.21, 0.62, 9.4\n ],\n 2: [\n 0.013, 0.028, 0.15, 0.070, 0.24, 0.065, 0.13, 0.18, 0.35, 0.38,\n 0.0038, 0.19, 0.56, 8.6\n ]\n },\n 7: [\n 0.008, 0.18, 0.096, 0.045, 0.15, 0.044, 0.088, 0.12, 0.24, 0.25,\n 0.004, 0.13, 0.37, 5.5\n ],\n 8: [\n 0.065, 0.32, 1.4, 0.71, 1.6, 0.71, 1.9, 1.0, 2.7, 2.4, 0.032, 1.3,\n 3.4, 62.0\n ],\n 9: [\n 0.025, 0.055, 0.35, 0.15, 0.58, 0.16, 0.26, 0.35, 0.58, 1.1, 0.013,\n 0.52, 1.6, 24.0\n ],\n 10: [\n 0.33, 0.73, 7.0, 2.9, 12.0, 3.5, 5.3, 7.1, 9.8, 23.0, 0.16, 11.0,\n 33.0, 510.0\n ],\n 11: [\n 0.15, 0.35, 3.1, 1.2, 5.4, 1.9, 2.8, 0.0, 0.0, 9.0, 0.075, 0.0,\n 0.0, 0.0\n ],\n 12: [\n 0.15, 0.34, 2.9, 1.2, 5.0, 1.6, 2.4, 0.0, 0.0, 7.6, 0.076, 0.0,\n 0.0, 0.0\n ],\n 13: [\n 0.043, 0.15, 0.75, 0.35, 1.3, 0.39, 0.78, 1.8, 2.8, 2.5, 0.21, 1.2,\n 3.7, 49.0\n ],\n 14: [\n 0.05, 0.11, 1.1, 0.45, 1.7, 2.8, 4.6, 4.6, 7.5, 3.3, 0.025, 1.5,\n 4.7, 67.0\n ],\n 15: [\n 0.048, 0.16, 0.76, 0.36, 1.3, 0.36, 0.72, 1.4, 2.2, 2.3, 0.024,\n 1.2, 3.4, 52.0\n ]\n }\n\n # List containing piQ values for parts count method. The list positions\n # corrspond to the following quality levels:\n #\n # 0. Established reliability level S\n # 1. Established reliability level R\n # 2. Established reliability level P\n # 3. Established reliability level M\n # 4. Non-established reliability MIL-SPEC\n # 5. Non-established reliability lower\n #\n # The quality_id attribute is used to select the proper value of piQ.\n _lst_piQ = [0.030, 0.10, 0.30, 1.0, 3.0, 10.0]\n\n # Select the base hazard rate.\n try:\n if attributes['subcategory_id'] in [2, 6]:\n _lst_base_hr = _dic_lambda_b[attributes['subcategory_id']][\n attributes['specification_id']]\n else:\n _lst_base_hr = _dic_lambda_b[attributes['subcategory_id']]\n except KeyError:\n _lst_base_hr = [0.0]\n\n try:\n attributes['lambda_b'] = _lst_base_hr[\n attributes['environment_active_id'] - 1]\n except IndexError:\n attributes['lambda_b'] = 0.0\n\n # Select the piQ.\n try:\n attributes['piQ'] = _lst_piQ[attributes['quality_id'] - 1]\n except IndexError:\n attributes['piQ'] = 0.0\n\n # Confirm all inputs are within range. If not, set the message. The\n # hazard rate will be calculated anyway, but will be zero.\n if attributes['lambda_b'] <= 0.0:\n _msg = _msg + 'RAMSTK WARNING: Base hazard rate is 0.0 when ' \\\n 'calculating resistor, hardware ID: ' \\\n '{0:d}, subcategory ID: {1:d}, specification ID: {2:d}, ' \\\n 'active environment ID: {3:d}, and quality ID: ' \\\n '{4:d}.\\n'.format(attributes['hardware_id'],\n attributes['subcategory_id'],\n attributes['specification_id'],\n attributes['environment_active_id'],\n attributes['quality_id'])\n\n if attributes['piQ'] <= 0.0:\n _msg = _msg + 'RAMSTK WARNING: piQ is 0.0 when calculating ' \\\n 'resistor, hardware ID: {0:d}, quality ID: ' \\\n '{1:d}.'.format(attributes['hardware_id'],\n attributes['quality_id'])\n\n # Calculate the hazard rate.\n attributes['hazard_rate_active'] = (\n attributes['lambda_b'] * attributes['piQ'])\n\n return attributes, _msg","def identity_block(self,X,stage,block):\n conv_name_base='res'+str(stage)+block+'_branch'\n bn_name_base='bn'+str(stage)+block+'_branch'\n \n #retrieve the filters\n #F1,F2,F3=filters\n \n X_shortcut=X\n \n #first component of main path\n X=Conv3D(self.filter, (3,3,1),kernel_initializer=self.init,kernel_regularizer=self.regularizer,padding='same')(X)\n X=BatchNormalization(axis=3)(X)\n X=Activation('relu')(X)\n \n #second component of main path\n X=Conv3D(self.filter, (3,3,1),kernel_initializer=self.init,kernel_regularizer=self.regularizer,padding='same')(X)\n\n \n #final step, add the shortcut\n X=Add()([X,X_shortcut])\n X=Activation('relu')(X)\n \n \n return X","def run(self, voxels, entry='all', freq_raw=False):\n\n # Note. in this case we are processing all raw data into the data \n # attribute, so despite having multiple raw FIDs, we are really \n # only processing one voxel, so no for loop\n\n # local reference to input data\n self.raw = self._dataset.get_source_data('prep')\n\n # Choose voxel - for saving result for current single voxel plot\n self.voxel = voxels[0]\n\n # select the chain processing functor based on the entry point\n if entry == 'all':\n funct_fidsum_wbnaa.do_processing_all(self)\n else:\n print('oooops!')\n\n # save data and parameter results into the Block results arrays\n self._block.data[0,0,0,:] = self.time_summed_offset.copy()\n \n # Return values specific to calling Tab that contains this Block.Chain\n # Used to update its self.view (plot_panel_spectrum object).\n\n plot_results = { 'freq_current' : self.freq_current.copy(),\n 'freq_summed' : self.freq_summed.copy(),\n 'freq_summed_offset' : self.freq_summed_offset.copy() }\n \n return plot_results","def dumpData(self,out,index):\n #--SCVR\n out.pack('4siBB2sB',\n 'SCVR', 5+len(self.text), index+48, self.type, self.func, self.oper)\n if self.text: out.write(self.text)\n #--Value\n if isinstance(self.value,int):\n out.packSub('INTV','i', self.value)\n else:\n out.packSub('FLTV','f', self.value)","def __init__(self,config = None):\n \n self.join_path = join_path\n self.label_path = cfg['labels_path']\n self.pick_path = (cfg['result_path'] + cfg['pickle_path'])\n self.label_dir = os.path.join(CWD_PATH,self.join_path, self.label_path)\n\n #Variables inherent to the Fluent data: \n self.num_ins = 4\n\n self.scale_var = cfg['scale_var']\n # User set values are below. These can be adjusted in config.yml \n self.MSE_thresh1 = (cfg['thresh1']*self.scale_var)**2\n self.MSE_thresh2 = (cfg['thresh2']*self.scale_var)**2\n self.MSE_thresh3 = (cfg['thresh3']*self.scale_var)**2\n \n self.rew_goal = cfg['reward'] * self.scale_var\n\n self.noise = cfg['noise']\n self.minmaxbuffer = cfg['minmaxbuffer']\n\n # Get the function of input-output mapping, and max & min:\n [self.O_CH4_flow_uniformity, mins,maxes] = self.get_funcs('O_CH4_flow_uniformity')\n [self.O_CH4_mol_frac, mins,maxes] = self.get_funcs('O_CH4_mol_frac')\n [self.O_t, mins, maxes] = self.get_funcs('O_t')\n \n self.mins = mins# * self.scale_var\n self.maxes = maxes#* self.scale_var\n #Action range is a percentage of the total range\n self.action_range = cfg['action_range']*self.scale_var\n\n #Action space is the up & down range for the 4 actions \n self.action_space = Box(-self.action_range, self.action_range, shape=(self.num_ins,), dtype=np.float32)\n\n # For ref, this is a 10d state space:\n #in: 1 ch4 flow, 2 ch4 t, 3 o2 flow, 4 o2 t,\n #out: 5 flow unif, 6 mol frac, 7 temp\n #out - target: 8 flow unif, 9 mol frac, 10 temp\n \n self.observation_space = Tuple((Box(self.mins.values[0],self.maxes.values[0],shape=(1,), dtype=np.float32),\n Box(self.mins.values[1],self.maxes.values[1],shape=(1,), dtype=np.float32),\n Box(self.mins.values[2],self.maxes.values[2],shape=(1,), dtype=np.float32),\n Box(self.mins.values[3],self.maxes.values[3],shape=(1,), dtype=np.float32),\n Box(self.mins.values[4],self.maxes.values[4],shape=(1,), dtype=np.float32),\n Box(self.mins.values[5],self.maxes.values[5],shape=(1,), dtype=np.float32),\n Box(self.mins.values[6],self.maxes.values[6],shape=(1,), dtype=np.float32),\n Box(self.mins.values[4],self.maxes.values[4],shape=(1,), dtype=np.float32),\n Box(self.mins.values[5],self.maxes.values[5],shape=(1,), dtype=np.float32),\n Box(self.mins.values[6],self.maxes.values[6],shape=(1,), dtype=np.float32)))\n \n # TODO this isn't really a proper gym spec\n self._spec = lambda: None\n self._spec.id = \"AllVar-v0\"\n \n # For rendering:\n self.viewer = None\n self.labels = cfg['labels']\n \n #initialize variables for tracking:\n self.episode = 0\n self.reward = 0\n self.reset()","def compile_xilinx_graph(self):\n pass","def levelsets_to_vector_field(levelsets, stepsize):\r\n vector_field_shape = levelsets[0][0].shape\r\n y_comp_combined = np.ndarray(vector_field_shape)\r\n x_comp_combined = np.ndarray(vector_field_shape)\r\n y_comp_combined.fill(np.nan)\r\n x_comp_combined.fill(np.nan)\r\n\r\n for source, target in levelsets:\r\n labels_present = set(np.array([source.flatten(),target.flatten()]).flatten())\r\n labels_present.remove(0)#relates to background\r\n\r\n #print(labels_present)\r\n for l in labels_present:\r\n\r\n source_cluster = source == l\r\n target_cluster = target == l\r\n\r\n\r\n \"\"\"plt.imshow(source_cluster.astype(np.int32)+target_cluster.astype(np.int32))\r\n plt.show()\r\n print(\"-----------\")\"\"\"\r\n\r\n #plot_gradient_field(source_cluster.astype(np.int32), target_cluster.astype(np.int32))\r\n\r\n y_comp, x_comp = array_to_vector_field(source_cluster, target_cluster, stepsize=stepsize)\r\n y_comp_combined[~np.isnan(y_comp)] = y_comp[~np.isnan(y_comp)]\r\n x_comp_combined[~np.isnan(x_comp)] = x_comp[~np.isnan(x_comp)]\r\n return y_comp_combined, x_comp_combined","def convert_propbank(detail=True):\n\n out_dir = \"../data/wsj_propbank/\"\n os.system(\"rm -rf %s\" % (out_dir, ))\n os.system(\"mkdir -p %s\" % (out_dir, ))\n\n pb_instances = propbank.instances()\n # Count at first\n verb2idx = {}\n verb2frames = {}\n for i in range(0, len(pb_instances)):\n inst = pb_instances[i]\n verb_lemma, frame = inst.roleset.split(\".\")\n if verb_lemma not in verb2idx:\n verb2idx[verb_lemma] = []\n verb2idx[verb_lemma].append(i)\n if verb_lemma not in verb2frames:\n verb2frames[verb_lemma] = []\n if frame not in verb2frames[verb_lemma]:\n verb2frames[verb_lemma].append(frame)\n verb_nums = len(verb2idx.keys())\n verb_counter = 0\n\n pair_label = {'-LRB-':'(', '-RRB-':')', '-LCB-':'(', '-RCB-':')'}\n for verb_lemma, idxs in verb2idx.items():\n verb_counter += 1\n if len(verb2frames[verb_lemma]) < 2:\n continue\n fh = open(\"%s/%s\" % (out_dir, verb_lemma), \"w\")\n if detail:\n print(\"processing %s(%s/%s)\"\n % (verb_lemma, verb_counter, verb_nums))\n for i in idxs:\n inst = pb_instances[i]\n fileid = inst.fileid\n sent_num = inst.sentnum\n verb_pos = inst.wordnum\n verb_lemma, frame = inst.roleset.split(\".\")\n section = [x for x in fileid if x.isdigit()][0:2]\n section = \"\".join(section)\n fileid_for_ptb = \"WSJ/%s/%s\" % (section, fileid.upper())\n\n tagged_sent = ptb.tagged_sents(fileid_for_ptb)[sent_num]\n # Change tagged_sent from [tuples] to [list]\n tagged_sent = [[x[0], x[1]]for x in tagged_sent]\n verb_bak = tagged_sent[verb_pos][0]\n verb_identifier = \"verb_identifier_xxxxx\"\n tagged_sent[verb_pos][0] = verb_identifier\n sent = []\n for (token, tag)in tagged_sent:\n if tag != '-NONE-':\n if token in pair_label:\n token = pair_label[token]\n sent.append(token)\n sent = \" \".join(sent)\n sent_toks = nltk.sent_tokenize(sent)\n candidate_sent = None\n for sent_tok in sent_toks:\n if sent_tok.find(verb_identifier) >= 0:\n candidate_sent = sent_tok\n left_sent, right_sent = candidate_sent.split(verb_identifier)\n left_sent = left_sent.strip()\n right_sent = right_sent.strip()\n out_line = \"%s\\t%s\\t%s\\t%s\" % (frame, left_sent, verb_bak, right_sent)\n out_line = remove_punctuations(out_line)\n print(out_line, file=fh)\n fh.close()","def render(self): # pragma: no cover\n from graphviz import Digraph\n dot = Digraph(name=\"top\")\n for block in self.blocks:\n if isinstance(block, Branch):\n label = \"if \" + astor.to_source(block.cond)\n dot.node(str(id(block)), label.rstrip(), {\"shape\": \"invhouse\"})\n elif isinstance(block, Yield):\n label = astor.to_source(block.value)\n # label += \"\\nLive Ins : \" + str(block.live_ins)\n # label += \"\\nLive Outs : \" + str(block.live_outs)\n # label += \"\\nGen : \" + str(block.gen)\n # label += \"\\nKill : \" + str(block.kill)\n dot.node(str(id(block)), label.rstrip(), {\"shape\": \"oval\"})\n elif isinstance(block, BasicBlock):\n label = \"\\n\".join(astor.to_source(stmt).rstrip() for stmt in block.statements)\n # label += \"\\nLive Ins : \" + str(block.live_ins)\n # label += \"\\nLive Outs : \" + str(block.live_outs)\n # label += \"\\nGen : \" + str(block.gen)\n # label += \"\\nKill : \" + str(block.kill)\n dot.node(str(id(block)), label.rstrip(), {\"shape\": \"box\"})\n elif isinstance(block, HeadBlock):\n label = \"Initial\"\n dot.node(str(id(block)) + \"_start\", label.rstrip(), {\"shape\": \"doublecircle\"})\n label = \"\\n\".join(astor.to_source(stmt).rstrip() for stmt in block.initial_statements)\n # label += \"\\nLive Ins : \" + str(block.live_ins)\n # label += \"\\nLive Outs : \" + str(block.live_outs)\n # label += \"\\nGen : \" + str(block.gen)\n # label += \"\\nKill : \" + str(block.kill)\n dot.node(str(id(block)), label.rstrip(), {\"shape\": \"box\"})\n dot.edge(str(id(block)) + \"_start\", str(id(block)))\n else:\n raise NotImplementedError(type(block))\n # for source, sink, label in self.edges:\n for sink, label in block.outgoing_edges:\n dot.edge(str(id(block)), str(id(sink)), label)\n\n\n file_name = tempfile.mktemp(\"gv\")\n dot.render(file_name, view=True)\n # with open(\"cfg.dot\", \"w\") as file:\n # file.write(dot.source)\n # exit()","def process_tree(tree):\n c = circuit()\n l = line()\n names = {}\n procedures = []\n for lst in tree.children:\n print(lst)\n if type(lst[0]) is str:\n names[lst[0]] = lst[1]\n else:\n procedures.append(lst)\n print(names)\n #print(procedures)\n\n for proc in procedures:\n\n proc_elements_names = proc[0]\n proc_name = proc[1]\n\n #print(proc_elements_names)\n #print(proc_name)\n\n if proc_name == \"set_mode\":\n mode_name = proc_elements_names[0]\n if mode_name != \"draw-mode\": \n c.set_mode(mode_name)\n elif mode_name == \"draw-mode\":\n l1 = line()\n # draw mode is different from other modes\n for element in names:\n e = CompleteElement(element)\n e.set_other_attrs(names[element])\n e.process_other_attrs()\n l1.addElement(e)\n c.connectInSeries(l1)\n c.set_mode(\"draw-mode\")\n \n \n if proc_name == \"series\":\n l1 = line()\n for element in proc_elements_names:\n l1.addElement(names[element])\n l = l1\n c.connectInSeries(l)\n #raise SyntaxError(\"Alias {0} referrenced before assignment\".format(item[0]))\n\n elif proc_name == \"parallel\":\n l1 = line()\n for element in proc_elements_names:\n l1.addElement(names[element])\n c.connectInParallel(l1)\n l1 = line()\n\n\n elif proc_name == \"add_parallel\":\n new_element = proc_elements_names[1]\n old_element = proc_elements_names[0]\n l1 = line()\n l1.addElement(names[new_element])\n c.connection.append(l1)\n\n\n elif proc_name == \"add_series\":\n new_element = proc_elements_names[1]\n old_element = proc_elements_names[0]\n for ln in c.connection:\n for e in ln.elements:\n if names[old_element] == e:\n ln.addElement(names[new_element])\n\n\n c.evaluate(\"output.png\")\n #print(c)","def forward(self, Ca, mask, residue_idx, chain_labels):\n if self.augment_eps > 0:\n Ca = Ca + self.augment_eps * torch.randn_like(Ca)\n\n D_neighbors, E_idx, mask_neighbors = self._dist(Ca, mask)\n\n Ca_0 = torch.zeros(Ca.shape, device=Ca.device)\n Ca_2 = torch.zeros(Ca.shape, device=Ca.device)\n Ca_0[:,1:,:] = Ca[:,:-1,:]\n Ca_1 = Ca\n Ca_2[:,:-1,:] = Ca[:,1:,:]\n\n V, O_features = self._orientations_coarse(Ca, E_idx)\n \n RBF_all = []\n RBF_all.append(self._rbf(D_neighbors)) #Ca_1-Ca_1\n RBF_all.append(self._get_rbf(Ca_0, Ca_0, E_idx)) \n RBF_all.append(self._get_rbf(Ca_2, Ca_2, E_idx))\n\n RBF_all.append(self._get_rbf(Ca_0, Ca_1, E_idx))\n RBF_all.append(self._get_rbf(Ca_0, Ca_2, E_idx))\n\n RBF_all.append(self._get_rbf(Ca_1, Ca_0, E_idx))\n RBF_all.append(self._get_rbf(Ca_1, Ca_2, E_idx))\n\n RBF_all.append(self._get_rbf(Ca_2, Ca_0, E_idx))\n RBF_all.append(self._get_rbf(Ca_2, Ca_1, E_idx))\n\n\n RBF_all = torch.cat(tuple(RBF_all), dim=-1)\n\n\n offset = residue_idx[:,:,None]-residue_idx[:,None,:]\n offset = gather_edges(offset[:,:,:,None], E_idx)[:,:,:,0] #[B, L, K]\n\n d_chains = ((chain_labels[:, :, None] - chain_labels[:,None,:])==0).long()\n E_chains = gather_edges(d_chains[:,:,:,None], E_idx)[:,:,:,0]\n E_positional = self.embeddings(offset.long(), E_chains)\n E = torch.cat((E_positional, RBF_all, O_features), -1)\n \n\n E = self.edge_embedding(E)\n E = self.norm_edges(E)\n \n return E, E_idx","def trans_setup():\n # slot7 slot6 slot5 slot4 slot3 slot2 slot1 <------ beam direction (slot 8 is currently B-fiber only)\n # Be Be Be Be Be Be Be lens material\n # 1.5 1.5 0.5 0.5 0.5 0.5 0.5 lens radius [mm]\n # 1 1 5 8 4 2 1 number of lenses\n lens_R=[0.5,0.5,0.5,0.5,0.5,1.5,1.5]\n lens_mat=['Be','Be','Be','Be','Be','Be','Be']\n lens_N=[1,2,4,8,5,1,1]\n trans_pos=[35.2,35.8]\n return {'lens_material':lens_mat,'lens_number':lens_N,'lens_radius':lens_R,'trans_position':trans_pos}","def serialize(self):\n p = []\n p.append(self.particleCode)\n if self.particleCode == 'manual':\n p.append(str(self.particleMass))\n p.append(str(self.particleCharge))\n p.append(str(self.x0))\n p.append(str(self.y0))\n p.append(str(self.z0))\n if self.useKineticEnergy:\n p.append('Y')\n p.append(str(self.kineticEnergy))\n else:\n p.append('n')\n p.append(str(self.vx0))\n p.append(str(self.vy0))\n p.append(str(self.vz0))\n p.append(self.fieldCode)\n if self.fieldCode == 'Drift':\n p.append(str(self.fieldBaseStrength[0]))\n p.append(str(self.fieldBaseStrength[1]))\n p.append(str(self.fieldBaseStrength[2]))\n p.append(str(self.fieldGradient[0]))\n elif self.fieldCode == 'Smooth':\n p.append(str(self.fieldBaseStrength[0]))\n p.append(str(self.fieldGradient[0]))\n p.append(str(self.fieldGradient[1]))\n elif self.fieldCode == 'Sharp':\n p.append(str(self.fieldBaseStrength[0]))\n p.append(str(self.fieldGradient[0]))\n p.append(str(self.fieldGradient[1]))\n p.append(str(self.fieldLength))\n elif self.fieldCode == 'Sine':\n p.append(str(self.fieldBaseStrength[0]))\n p.append(str(self.fieldGradient[0]))\n p.append(str(self.fieldGradient[1]))\n p.append(str(self.fieldLength))\n p.append(str(self.fieldFreq))\n elif self.fieldCode == 'Helix':\n p.append(str(self.fieldBaseStrength[0]))\n p.append(str(self.fieldBaseStrength[1]))\n p.append(str(self.fieldGradient[0]))\n p.append(str(self.fieldGradient[1]))\n p.append(str(self.fieldGradient[2]))\n p.append(str(self.fieldLength))\n p.append(str(self.fieldFreq))\n elif self.fieldCode == 'Tokamak':\n p.append(str(self.fieldBaseStrength[0]))\n p.append(str(self.fieldBaseStrength[1]))\n p.append(str(self.fieldGradient[0]))\n p.append(str(self.fieldGradient[1]))\n p.append(str(self.fieldGradient[2]))\n p.append(str(self.fieldGradient[3]))\n p.append(str(self.fieldGradient[4]))\n p.append(str(self.fieldLength))\n p.append(str(self.fieldFreq))\n else:\n for val in self.fieldBaseStrength:\n p.append(str(val))\n p.append(str(self.initialTime))\n p.append(str(self.endTime))\n p.append(str(self.timeStep))\n p.append(str(self.tolerance))\n return p","def fst_tostring(self, fst_1, idx=False):\n\n fst_string = 'Transducer\\n'\n for state in fst_1.states:\n for arc in state.arcs:\n olabel = self.wmap[arc.olabel].encode('utf-8') if not idx and arc.olabel in self.wmap else arc.olabel\n\n fst_string += '{} -> {} / {} : {} / {}\\n'.format(state.stateid, arc.nextstate, arc.ilabel, olabel,\n float(arc.weight))\n\n if state.final:\n fst_string += '%s / %s\\n' % (state.stateid, state.final)\n\n fst_string += '-------\\n'\n\n return fst_string","def chainLabel(self,i):\n assert(i >= 0 and i < self.nAtoms())\n assert(self._c_structure is not NULL)\n cdef char label[2]\n label[0] = freesasa_structure_atom_chain(self._c_structure,i)\n label[1] = '\\0'\n return label","def createAddOrSelectLabelMapNode(self, script=False):\r\n # productive\r\n profprint()\r\n print \"creating label map for working intensity volume\"\r\n # create, select label map\r\n volLogic = slicer.modules.volumes.logic()\r\n sliceLogic = slicer.app.layoutManager().sliceWidget(\"Red\").sliceLogic()\r\n vn = sliceLogic.GetBackgroundLayer().GetVolumeNode()\r\n self.labelMapNode = slicer.util.getNode(vn.GetName() + \"-label\")\r\n if not self.labelMapNode:\r\n self.labelMapNode = volLogic.CreateAndAddLabelVolume(slicer.mrmlScene, vn, vn.GetName() + \"-label\")\r\n # select label volume\r\n if not script: #TODO guess there is a bug here (at least while testing with parSearch): also changes the main volume!!\r\n selectionNode = slicer.app.applicationLogic().GetSelectionNode()\r\n selectionNode.SetReferenceActiveLabelVolumeID(self.labelMapNode.GetID())\r\n #slicer.app.applicationLogic().PropagateVolumeSelection() #<<<this line causes unpredictable volume switching\r\n #set half transparency\r\n scRed=slicer.app.layoutManager().sliceWidget(\"Red\").sliceController()\r\n scRed.setLabelMapOpacity(.5)\r\n scYel=slicer.app.layoutManager().sliceWidget(\"Yellow\").sliceController()\r\n scYel.setLabelMapOpacity(.5)\r\n scGrn=slicer.app.layoutManager().sliceWidget(\"Green\").sliceController()\r\n scGrn.setLabelMapOpacity(.5)\r\n #enable label map outline display mode\r\n sRed = slicer.mrmlScene.GetNodeByID(\"vtkMRMLSliceNodeRed\")\r\n if sRed == None :\r\n sRed = slicer.mrmlScene.GetNodeByID(\"vtkMRMLSliceNode1\")\r\n sRed.SetUseLabelOutline(1)\r\n sYel = slicer.mrmlScene.GetNodeByID(\"vtkMRMLSliceNodeYellow\")\r\n if sYel == None :\r\n sYel = slicer.mrmlScene.GetNodeByID(\"vtkMRMLSliceNode2\")\r\n sYel.SetUseLabelOutline(1)\r\n sGrn = slicer.mrmlScene.GetNodeByID(\"vtkMRMLSliceNodeGreen\")\r\n if sGrn == None :\r\n sGrn = slicer.mrmlScene.GetNodeByID(\"vtkMRMLSliceNode3\")\r\n sGrn.SetUseLabelOutline(1)\r\n self.editorWidget.setMasterNode(vn)\r\n self.editorWidget.setMergeNode(self.labelMapNode)","def results(self):\n self.report('workchain succesfully completed')\n self.out('scf_parameters', self.ctx.workchain_scf.out.output_parameters)\n self.out('band_parameters', self.ctx.workchain_bands.out.output_parameters)\n self.out('band_structure', self.ctx.workchain_bands.out.output_band)\n\n if 'group' in self.inputs:\n output_band = self.ctx.workchain_bands.out.output_band\n group, _ = Group.get_or_create(name=self.inputs.group.value)\n group.add_nodes(output_band)\n self.report(\"storing the output_band<{}> in the group '{}'\"\n .format(output_band.pk, self.inputs.group.value))","def pack_firmware(self, work_dir, jobclient, ro, rw, version_string=\"\"):\n dts_file_path = ro / \"zephyr\" / \"zephyr.dts\"\n\n # Copy the inputs into the work directory so that Binman can\n # find them under a hard-coded name.\n shutil.copy2(ro / \"zephyr\" / self.ro_file, work_dir / \"zephyr_ro.bin\")\n shutil.copy2(rw / \"zephyr\" / self.rw_file, work_dir / \"zephyr_rw.bin\")\n\n # Version in FRID/FWID can be at most 31 bytes long (32, minus\n # one for null character).\n if len(version_string) > 31:\n version_string = version_string[:31]\n\n proc = jobclient.popen(\n [\n \"binman\",\n \"-v\",\n \"5\",\n \"build\",\n \"-a\",\n \"version={}\".format(version_string),\n \"-d\",\n dts_file_path,\n \"-m\",\n \"-O\",\n work_dir,\n ],\n cwd=work_dir,\n stdout=subprocess.PIPE,\n stderr=subprocess.PIPE,\n encoding=\"utf-8\",\n )\n\n zmake.multiproc.log_output(self.logger, logging.DEBUG, proc.stdout)\n zmake.multiproc.log_output(self.logger, logging.ERROR, proc.stderr)\n if proc.wait(timeout=60):\n raise OSError(\"Failed to run binman\")\n\n yield work_dir / \"zephyr.bin\", \"zephyr.bin\"\n yield ro / \"zephyr\" / \"zephyr.elf\", \"zephyr.ro.elf\"\n yield rw / \"zephyr\" / \"zephyr.elf\", \"zephyr.rw.elf\"","def _add_label_switching_node( self,\n node_tree,\n label_vec,\n last_element,\n label_ID_node=None,\n node_index=0,\n uv_map=None, \n node_offset=[0,0]):\n\n # define local variables #######################################################################################\n _step_node_width = 200 # x seperation of nodes\n _step_node_height = 200 # y seperation of nodes\n ################################################################################ end of define local variables #\n\n # create image ID handle #######################################################################################\n if label_ID_node is None:\n label_ID_node = node_tree.node_tree.nodes.new(\"ShaderNodeValue\")\n label_ID_node.location = ((node_offset[0]-400,node_offset[1]-100))\n label_ID_node.name = \"label_step_ID\"\n label_ID_node.label = \"label_step_ID\"\n label_ID_node.outputs[0].default_value = 1\n ############################################################################### end of create image ID handle #\n\n # create image nodes ###########################################################################################\n _x_offset = (node_index+1)*_step_node_width + node_offset[0]\n _y_offset = (node_index+1)*_step_node_height + node_offset[1]\n\n _semantic_node_offset = [(node_index+1)*_step_node_width*2 + node_offset[0]-1000,(node_index+1)*\\\n _step_node_height + node_offset[1]+200]\n\n _semantic_tree, self._semantic_pass_id = self.create_semantic_nodes(node_tree=self._world_node_tree,\n label_ID_vec=label_vec,\n num_label_per_channel=15, # TODO add in script\n env_mode=True,\n uv_map=uv_map,\n node_offset=_semantic_node_offset)\n\n _semantic_tree.inputs[0].default_value = 1\n\n # create new mix node ######################################################################################\n _current_mix_shader_node = node_tree.node_tree.nodes.new(\"ShaderNodeMixRGB\")\n _current_mix_shader_node.location = (((node_index+1)*_step_node_width*2 + node_offset[0],\n (node_index+1)*_step_node_height + node_offset[1]))\n ############################################################################### end of create new mix node #\n\n # create compare node ######################################################################################\n _current_compare_node = node_tree.node_tree.nodes.new(\"ShaderNodeMath\")\n _current_compare_node.location = (((node_index+1)*_step_node_width*2 + node_offset[0],\n node_offset[1]-_step_node_height))\n _current_compare_node.operation = 'COMPARE'\n _current_compare_node.inputs[0].default_value = node_index\n _current_compare_node.inputs[2].default_value = 0 # delta value should be zero for equal comparison\n ############################################################################### end of create compare node #\n\n\n # link nodes togther #######################################################################################\n node_tree.node_tree.links.new(_current_mix_shader_node.inputs[0], _current_compare_node.outputs[0])\n if last_element is not None:\n node_tree.node_tree.links.new(_current_mix_shader_node.inputs[1], last_element.outputs[0])\n node_tree.node_tree.links.new(_current_mix_shader_node.inputs[2], _semantic_tree.outputs[0])\n \n node_tree.node_tree.links.new(_current_compare_node.inputs[1], label_ID_node.outputs[0])\n ################################################################################ end of link nodes togther #\n #################################################################################### end of create image nodes #\n\n # return last mix shader node\n return _current_mix_shader_node, label_ID_node","def main(self, case, profile):\n case[\"branch\"][:, BR_STATUS] = ones(case[\"branch\"].shape[0])\n mpc = ext2int(case)\n baseMVA, bus, gen, branch, gencost = mpc[\"baseMVA\"], mpc[\"bus\"], mpc[\"gen\"], mpc[\"branch\"], mpc[\"gencost\"]\n\n nb = shape(mpc['bus'])[0] ## number of buses\n nl = shape(mpc['branch'])[0] ## number of branches\n ng = shape(mpc['gen'])[0] ## number of dispatchable injections\n\n f = branch[:, F_BUS] ## list of \"from\" buses\n t = branch[:, T_BUS] ## list of \"to\" buses\n i = range(nl) ## double set of row indices\n # Connection matrix\n Cf = sparse((ones(nl), (i, f)), (nl, nb))\n Ct = sparse((ones(nl), (i, t)), (nl, nb))\n Cg = sparse((ones(ng), (gen[:, GEN_BUS], range(ng))), (nb, ng))\n Branch_R = branch[:, BR_R]\n Branch_X = branch[:, BR_X]\n Cf = Cf.T\n Ct = Ct.T\n # Obtain the boundary information\n Slmax = branch[:, RATE_A] / baseMVA\n\n Pij_l = -Slmax\n Qij_l = -Slmax\n Iij_l = zeros(nl)\n Vm_l = bus[:, VMIN] ** 2\n Pg_l = gen[:, PMIN] / baseMVA\n Qg_l = gen[:, QMIN] / baseMVA\n Alpha_l = zeros(nl)\n Beta_f_l = zeros(nl)\n Beta_t_l = zeros(nl)\n\n Pij_u = Slmax\n Qij_u = Slmax\n Iij_u = Slmax\n Vm_u = bus[:, VMAX] ** 2\n Pg_u = 2 * gen[:, PMAX] / baseMVA\n Qg_u = 2 * gen[:, QMAX] / baseMVA\n Alpha_u = ones(nl)\n Beta_f_u = ones(nl)\n Beta_t_u = ones(nl)\n bigM = max(Vm_u)\n # For the spanning tree constraints\n Root_node = find(bus[:, BUS_TYPE] == REF)\n Root_line = find(branch[:, F_BUS] == Root_node)\n\n Span_f = zeros((nb, nl))\n Span_t = zeros((nb, nl))\n for i in range(nb):\n Span_f[i, find(branch[:, F_BUS] == i)] = 1\n Span_t[i, find(branch[:, T_BUS] == i)] = 1\n\n Alpha_l[Root_line] = 1\n Alpha_u[Root_line] = 1\n Beta_f_l[Root_line] = 0\n Beta_f_l[Root_line] = 0\n\n T = len(profile)\n nx = int(3 * nl + nb + 2 * ng)\n lx = concatenate([Alpha_l, Beta_f_l, Beta_t_l, tile(concatenate([Pij_l, Qij_l, Iij_l, Vm_l, Pg_l, Qg_l]), T)])\n ux = concatenate([Alpha_u, Beta_f_u, Beta_t_u, tile(concatenate([Pij_u, Qij_u, Iij_u, Vm_u, Pg_u, Qg_u]), T)])\n vtypes = [\"b\"] * 2 * nl + [\"c\"] * nl + [\"c\"] * nx * T\n\n # Define the decision variables\n NX = lx.shape[0]\n\n # Alpha = Beta_f + Beta_t\n Aeq_f = zeros((nl, NX))\n beq_f = zeros(nl)\n Aeq_f[:, 0: nl] = -eye(nl)\n Aeq_f[:, nl: 2 * nl] = eye(nl)\n Aeq_f[:, 2 * nl:3 * nl] = eye(nl)\n\n # sum(alpha)=nb-1\n Aeq_alpha = zeros((1, NX))\n beq_alpha = zeros(1)\n Aeq_alpha[0, 0: nl] = ones(nl)\n beq_alpha[0] = nb - 1\n\n # Span_f*Beta_f+Span_t*Beta_t = Spanning_tree\n Aeq_span = zeros((nb, NX))\n beq_span = ones(nb)\n beq_span[Root_node] = 0\n Aeq_span[:, nl:2 * nl] = Span_f\n Aeq_span[:, 2 * nl: 3 * nl] = Span_t\n\n # Add system level constraints\n # 1) Active power balance\n Aeq_p = zeros((nb * T, NX))\n beq_p = zeros(nb * T)\n for i in range(T):\n Aeq_p[i * nb:(i + 1) * nb, 3 * nl + i * nx:3 * nl + (i + 1) * nx] = hstack([Ct - Cf, zeros((nb, nl)),\n -diag(Ct * Branch_R) * Ct,\n zeros((nb, nb)), Cg,\n zeros((nb, ng))]).toarray()\n beq_p[i * nb:(i + 1) * nb] = profile[i] * bus[:, PD] / baseMVA\n\n # 2) Reactive power balance\n Aeq_q = zeros((nb * T, NX))\n beq_q = zeros(nb * T)\n for i in range(T):\n Aeq_q[i * nb:(i + 1) * nb, 3 * nl + i * nx:3 * nl + (i + 1) * nx] = hstack([zeros((nb, nl)), Ct - Cf,\n -diag(Ct * Branch_X) * Ct,\n zeros((nb, nb)),\n zeros((nb, ng)), Cg]).toarray()\n beq_q[i * nb:(i + 1) * nb] = profile[i] * bus[:, QD] / baseMVA\n\n Aeq = vstack([Aeq_f, Aeq_alpha, Aeq_span, Aeq_p, Aeq_q]).toarray()\n beq = concatenate([beq_f, beq_alpha, beq_span, beq_p, beq_q])\n\n # Inequality constraints\n A = zeros((nl * T, NX))\n b = zeros(nl * T)\n for i in range(T):\n A[i * nl:(i + 1) * nl, 3 * nl + i * nx + 2 * nl: 3 * nl + i * nx + 3 * nl] = eye(nl)\n A[i * nl:(i + 1) * nl, 0: nl] = -diag(Iij_u)\n\n A_temp = zeros((nl * T, NX))\n b_temp = zeros(nl * T)\n for i in range(T):\n A_temp[i * nl:(i + 1) * nl, 3 * nl + i * nx: 3 * nl + i * nx + nl] = eye(nl)\n A_temp[i * nl:(i + 1) * nl, 0: nl] = -diag(Pij_u)\n A = concatenate([A, A_temp])\n b = concatenate([b, b_temp])\n #\n A_temp = zeros((nl * T, NX))\n b_temp = zeros(nl * T)\n for i in range(T):\n A_temp[i * nl:(i + 1) * nl, 3 * nl + i * nx + nl: 3 * nl + i * nx + 2 * nl] = eye(nl)\n A_temp[i * nl:(i + 1) * nl, 0:nl] = -diag(Qij_u)\n A = concatenate([A, A_temp])\n b = concatenate([b, b_temp])\n\n A_temp = zeros((nl * T, NX))\n for i in range(T):\n A_temp[i * nl:(i + 1) * nl, 3 * nl + i * nx:3 * nl + i * nx + nl] = -2 * diag(Branch_R)\n A_temp[i * nl:(i + 1) * nl, 3 * nl + i * nx + nl:3 * nl + i * nx + 2 * nl] = -2 * diag(Branch_X)\n A_temp[i * nl:(i + 1) * nl, 3 * nl + i * nx + 2 * nl:3 * nl + i * nx + 3 * nl] = diag(Branch_R ** 2) + \\\n diag(Branch_X ** 2)\n A_temp[i * nl:(i + 1) * nl, 3 * nl + i * nx + 3 * nl:3 * nl + i * nx + 3 * nl + nb] = \\\n (Cf.T - Ct.T).toarray()\n A_temp[i * nl:(i + 1) * nl, 0:nl] = eye(nl) * bigM\n b_temp = ones(nl * T) * bigM\n A = concatenate([A, A_temp])\n b = concatenate([b, b_temp])\n\n A_temp = zeros((nl * T, NX))\n for i in range(T):\n A_temp[i * nl:(i + 1) * nl, 3 * nl + i * nx:3 * nl + i * nx + nl] = 2 * diag(Branch_R)\n A_temp[i * nl:(i + 1) * nl, 3 * nl + i * nx + nl:3 * nl + i * nx + 2 * nl] = 2 * diag(Branch_X)\n A_temp[i * nl:(i + 1) * nl, 3 * nl + i * nx + 2 * nl:3 * nl + i * nx + 3 * nl] = -diag(Branch_R ** 2) - \\\n diag(Branch_X ** 2)\n A_temp[i * nl:(i + 1) * nl, 3 * nl + i * nx + 3 * nl:3 * nl + i * nx + 3 * nl + nb] = \\\n (-Cf.T + Ct.T).toarray()\n A_temp[i * nl:(i + 1) * nl, 0: nl] = eye(nl) * bigM\n b_temp = ones(nl * T) * bigM\n A = concatenate([A, A_temp])\n b = concatenate([b, b_temp])\n\n Qc = dict()\n for t in range(T):\n for i in range(nl):\n Qc[t * nl + i] = [[int(3 * nl + t * nx + i), int(3 * nl + t * nx + i + nl),\n int(3 * nl + t * nx + i + 2 * nl), int(3 * nl + t * nx + f[i] + 3 * nl)],\n [int(3 * nl + t * nx + i), int(3 * nl + t * nx + i + nl),\n int(3 * nl + t * nx + f[i] + 3 * nl), int(3 * nl + t * nx + i + 2 * nl)],\n [1, 1, -1 / 2, -1 / 2]]\n c = zeros(NX)\n q = zeros(NX)\n c0 = 0\n for t in range(T):\n for i in range(ng):\n c[3 * nl + t * nx + i + 3 * nl + nb] = gencost[i, 5] * baseMVA\n q[3 * nl + t * nx + i + 3 * nl + nb] = gencost[i, 4] * baseMVA * baseMVA\n c0 += gencost[i, 6]\n\n sol = miqcp(c, q, Aeq=Aeq, beq=beq, A=A, b=b, xmin=lx, xmax=ux, vtypes=vtypes, Qc=Qc)\n xx = sol[0]\n Alpha = xx[0:nl]\n Beta_f = xx[nl:2 * nl]\n Beta_t = xx[2 * nl:3 * nl]\n Pij = zeros((nl, T))\n Qij = zeros((nl, T))\n Iij = zeros((nl, T))\n Vi = zeros((nb, T))\n Pg = zeros((ng, T))\n Qg = zeros((ng, T))\n for i in range(T):\n Pij[:, i] = xx[3 * nl + i * nx:3 * nl + i * nx + nl]\n Qij[:, i] = xx[3 * nl + i * nx + nl:3 * nl + i * nx + 2 * nl]\n Iij[:, i] = xx[3 * nl + i * nx + 2 * nl:3 * nl + i * nx + 3 * nl]\n Vi[:, i] = xx[3 * nl + i * nx + 3 * nl:3 * nl + i * nx + 3 * nl + nb]\n Pg[:, i] = xx[3 * nl + i * nx + 3 * nl + nb:3 * nl + i * nx + 3 * nl + nb + ng]\n Qg[:, i] = xx[3 * nl + i * nx + 3 * nl + nb + ng:3 * nl + i * nx + 3 * nl + nb + 2 * ng]\n\n primal_residual = zeros((nl, T))\n for t in range(T):\n for i in range(nl):\n primal_residual[i, t] = Pij[i, t] * Pij[i, t] + Qij[i, t] * Qij[i, t] - Iij[i, t] * Vi[int(f[i]), t]\n\n sol = {\"Pij\": Pij,\n \"Qij\": Qij,\n \"Iij\": Iij,\n \"Vi\": Vi,\n \"Pg\": Pg,\n \"Qg\": Qg,\n \"Alpha\": Alpha,\n \"Beta_f\": Beta_f,\n \"Beta_t\": Beta_t,\n \"residual\": primal_residual,\n \"obj\": sol[1] + c0}\n\n return sol","def write_bc_vtk(self):\n print \"Creating boundary condition arrays\"\n obst_array = np.zeros(self.nnodes)\n obst_array[list(self.obst_list)] = 100.\n\n #print type(self.inlet_list)\n inlet_array = np.zeros(self.nnodes)\n inlet_array[list(self.inlet_list)] = 200.\n\n outlet_array = np.zeros(self.nnodes)\n outlet_array[list(self.outlet_list)] = 300.\n\n solid_array = np.zeros(self.nnodes)\n solid_array[list(self.solid_list)] = 500.\n \n dims = [int(self.Nx), int(self.Ny), int(self.Nz)]\n origin = [0., 0., 0.]\n dx = self.x[1] - self.x[0]\n spacing = [dx, dx, dx] #uniform lattice\n \n print \"Writing boundary conditions to VTK files\"\n writeVTK(inlet_array,'inlet','inlet.vtk',dims,origin,spacing)\n writeVTK(outlet_array,'outlet','outlet.vtk',dims,origin,spacing)\n writeVTK(obst_array,'obst','obst.vtk',dims,origin,spacing)\n writeVTK(solid_array,'solid','solid.vtk',dims,origin,spacing)","def write_bc_vtk(self):\n print \"Creating boundary condition arrays\"\n obst_array = np.zeros(self.nnodes)\n obst_array[list(self.obst_list)] = 100.\n\n #print type(self.inlet_list)\n inlet_array = np.zeros(self.nnodes)\n inlet_array[list(self.inlet_list)] = 200.\n\n outlet_array = np.zeros(self.nnodes)\n outlet_array[list(self.outlet_list)] = 300.\n\n solid_array = np.zeros(self.nnodes)\n solid_array[list(self.solid_list)] = 500.\n \n dims = [int(self.Nx), int(self.Ny), int(self.Nz)]\n origin = [0., 0., 0.]\n dx = self.x[1] - self.x[0]\n spacing = [dx, dx, dx] #uniform lattice\n \n print \"Writing boundary conditions to VTK files\"\n writeVTK(inlet_array,'inlet','inlet.vtk',dims,origin,spacing)\n writeVTK(outlet_array,'outlet','outlet.vtk',dims,origin,spacing)\n writeVTK(obst_array,'obst','obst.vtk',dims,origin,spacing)\n writeVTK(solid_array,'solid','solid.vtk',dims,origin,spacing)","def feature_extract(self, CT_pairs):\n instances = []\n for pair in CT_pairs:\n config = pair[0]\n label = pair[1]\n data = []\n featureset = {}\n \n # for nltk NaiveBayes feature selection stuff when doing MaxEnt decoding parser commit this\n# featureset[\"topOfBuffer\"] = self.token_dict[config.beta.top()]\n# featureset[\"topOfStack\"] = self.token_dict[config.sigma.top()]\n# featureset[\"bufferStackPair\"] = (self.token_dict[config.sigma.top()], self.token_dict[config.beta.top()])\n# featureset[\"topOfBuffer\"] = self.POS_dict[config.beta.top()]\n# featureset[\"topOfStack\"] = self.POS_dict[config.sigma.top()]\n# featureset[\"bufferStackPair\"] = tuple((self.POS_dict[config.sigma.top()], self.POS_dict[config.beta.top()]))\n \n # add the (StackTopPOS,BufferTopPOS,bufferchildren_POS) feature\n #value_set = tuple([self.POS_dict[config.sigma.top()], self.POS_dict[config.beta.top()]] + [self.POS_dict[child] for child in self.getBufferChildren(config.beta.top())])\n #featureset[\"bufferStackbufferChildrenPair\"] = value_set\n \n # for MaxEnt decoding stuff\n # token variants\n data.append((\"topOfBuffer\",self.token_dict[config.beta.top()]))\n data.append((\"topOfStack\",self.token_dict[config.sigma.top()]))\n data.append((\"bufferStackPair\",self.token_dict[config.sigma.top()],self.token_dict[config.beta.top()]))\n #POS variants\n data.append((\"topOfBuffer\",self.POS_dict[config.beta.top()]))\n data.append((\"topOfStack\",self.POS_dict[config.sigma.top()]))\n data.append((\"bufferStackPair\",self.POS_dict[config.sigma.top()],self.POS_dict[config.beta.top()]))\n ins = Instance(label=label, data=data)\n #ins = Instance(label=label, data=featureset)\n instances.append(ins)\n \n return instances","def update_heads(info,\n heads):\n\n info[\"model_params\"][\"boltzmann_dict\"][\"num_heads\"] = heads\n # Concatenate the fingerprints produced by the different heads\n info[\"model_params\"][\"boltzmann_dict\"][\"head_pool\"] = \"concatenate\"\n\n readoutdict = info[\"model_params\"][\"readoutdict\"]\n feat_dim = info[\"model_params\"][\"mol_basis\"]\n\n for key, lst in readoutdict.items():\n for i, dic in enumerate(lst):\n if \"param\" in dic and \"in_features\" in dic.get(\"param\", {}):\n # make sure that the input dimension to the readout is equal to\n # `heads * feat_dim`, where `feat_dim` is the feature dimension\n # produced by each head\n readoutdict[key][i][\"param\"][\"in_features\"] = feat_dim * heads\n break\n info[\"model_params\"][\"readoutdict\"] = readoutdict","def detection_head_graph(self, feature_map, filters):\n x = KL.Conv2D(filters, (1, 1), strides=(1, 1),\n name=\"detection_head_\" + \"stage_1\", use_bias=True, padding=\"same\")(feature_map)\n x = KL.Activation('relu', name='detection_head_stage_1_activation')(x)\n x = KL.Conv2D(filters, (1, 1), strides=(1, 1),\n name=\"detection_head_\" + \"stage_2\", use_bias=True, padding=\"same\")(x)\n x = KL.Activation('relu', name='detection_head_stage_2_activation')(x)\n x = KL.Conv2D(3, (1, 1), strides=(1, 1),\n name=\"detection_head_\" + \"final_stage\", use_bias=True, padding=\"same\")(x)\n return x","def gexf_graph():\n # you must replace these lines and supply your own graph\n gexf = Gexf(\"author\", \"title\")\n mygraph = gexf.addGraph(\"undirected\", \"static\", \"A web network\")\n atr_type = mygraph.addNodeAttribute('Type', type='string')\n atr_id = mygraph.addNodeAttribute('id', type='string')\n atr_label = mygraph.addNodeAttribute('label', type='string')\n atr_color_r = mygraph.addNodeAttribute('color_r', type='string', defaultValue='0')\n atr_color_g = mygraph.addNodeAttribute('color_g', type='string', defaultValue='0')\n atr_color_b = mygraph.addNodeAttribute('color_b', type='string', defaultValue='0')\n k = 0\n for i in range(min_parts()):\n tmp = mygraph.addNode(set_num[i], name[i], r=\"0\", g=\"0\", b=\"0\")\n tmp.addAttribute(atr_type, \"set\")\n tmp.addAttribute(atr_id, set_num[i])\n tmp.addAttribute(atr_label, name[i])\n for j in range(len(Parts[i][\"Parts\"])):\n if mygraph.nodeExists(Parts[i][\"Parts\"][j][\"number\"]+\"_\"+Parts[i][\"Parts\"][j][\"color\"][\"rgb\"])==0:\n temp = mygraph.addNode((Parts[i][\"Parts\"][j][\"number\"]+\"_\"+Parts[i][\"Parts\"][j][\"color\"][\"rgb\"]), Parts[i][\"Parts\"][j][\"name\"], r=str(int(Parts[i][\"Parts\"][j][\"color\"][\"rgb\"][0:2], 16)), g=str(int(Parts[i][\"Parts\"][j][\"color\"][\"rgb\"][2:4], 16)), b=str(int(Parts[i][\"Parts\"][j][\"color\"][\"rgb\"][4:6], 16)))\n temp.addAttribute(atr_type, \"part\")\n temp.addAttribute(atr_id, (Parts[i][\"Parts\"][j][\"number\"]+\"_\"+Parts[i][\"Parts\"][j][\"color\"][\"rgb\"]))\n temp.addAttribute(atr_label, Parts[i][\"Parts\"][j][\"name\"])\n temp.addAttribute(atr_color_r, Parts[i][\"Parts\"][j][\"color\"][\"rgb\"][0:2])\n temp.addAttribute(atr_color_g, Parts[i][\"Parts\"][j][\"color\"][\"rgb\"][2:4])\n temp.addAttribute(atr_color_b, Parts[i][\"Parts\"][j][\"color\"][\"rgb\"][4:6])\n mygraph.addEdge(str(k), set_num[i], (Parts[i][\"Parts\"][j][\"number\"]+\"_\"+Parts[i][\"Parts\"][j][\"color\"][\"rgb\"]), weight=Parts[i][\"Parts\"][j][\"quantity\"])\n k = k+1\n output_file = open(\"bricks_graph.gexf\", \"wb\")\n gexf.write(output_file)\n return -1","def _viterbi_decode(self, feats):\n backpointers = []\n\n init_vvars = torch.full((self.batch_size, 1, self.tagset_size), -10000.).to(self.device)\n init_vvars[:, 0, self.tag2idx[START_TAG]] = 0.\n\n forward_var = init_vvars\n for i in range(feats.shape[1]):\n feat = feats[:,i,:]\n\n next_tag_var = forward_var + self.transitions + feat.view(self.batch_size, self.tagset_size, 1)\n best_tag_var, best_tag_id = torch.max(next_tag_var, dim=-1)\n backpointers.append(best_tag_id)\n forward_var = best_tag_var.view(self.batch_size, 1, self.tagset_size)\n\n # Transition to STOP_TAG\n terminal_var = forward_var + self.transitions[self.tag2idx[STOP_TAG]]\n path_score, best_tag_id = torch.max(terminal_var, dim=-1)\n\n # Follow the back pointers to decode the best path.\n best_path = [best_tag_id]\n for bptrs_t in reversed(backpointers):\n # gather the value in bptrs_t according to best_tag_id\n best_tag_id = bptrs_t.gather(dim=-1,index=best_tag_id)\n best_path.append(best_tag_id)\n \n # Pop off the start tag (we dont want to return that to the caller)\n best_path.pop()\n best_path.reverse()\n best_path = torch.cat(best_path, dim=1)\n # best_path = [[self.idx2tag[j] for j in i] for i in best_path.tolist()]\n \n return path_score, best_path","def encodeToCartBoxesLabels(self, gt_instances):\n raw_boxes_xywh = np.zeros((self.config_data[\"max_boxes_per_frame\"], 5))\n ### initialize gronud truth labels as np.zeros ###\n gt_labels = np.zeros(list(self.cart_shape[1:3]) + \\\n [len(self.anchor_boxes_cart)] + \\\n [len(self.config_data[\"all_classes\"]) + 5]) \n\n ### start transferring box to ground turth label format ###\n for i in range(len(gt_instances[\"classes\"])):\n if i > self.config_data[\"max_boxes_per_frame\"]:\n continue\n class_name = gt_instances[\"classes\"][i]\n box_xywh = gt_instances[\"cart_boxes\"][i]\n class_id = self.config_data[\"all_classes\"].index(class_name)\n if i <= self.config_data[\"max_boxes_per_frame\"]:\n raw_boxes_xywh[i, :4] = box_xywh\n raw_boxes_xywh[i, 4] = class_id\n class_onehot = helper.smoothOnehot(class_id, \\\n len(self.config_data[\"all_classes\"]))\n exist_positive = False\n grid_strid = self.cart_grid_strides\n anchors = self.anchor_boxes_cart\n box_xywh_scaled = box_xywh[np.newaxis, :].astype(np.float32)\n box_xywh_scaled[:, :2] /= grid_strid\n anchors_xywh = np.zeros([len(anchors), 4])\n anchors_xywh[:, :2] = np.floor(box_xywh_scaled[:, :2]) + 0.5\n anchors_xywh[:, 2:] = anchors.astype(np.float32)\n\n iou_scaled = helper.iou2d(box_xywh_scaled, anchors_xywh)\n ### NOTE: 0.3 is from YOLOv4, maybe this should be different here ###\n ### it means, as long as iou is over 0.3 with an anchor, the anchor\n ### should be taken into consideration as a ground truth label\n iou_mask = iou_scaled > 0.3\n\n if np.any(iou_mask):\n xind, yind = np.floor(np.squeeze(box_xywh_scaled)[:2]).astype(np.int32)\n ### TODO: consider changing the box to raw yolohead output format ###\n gt_labels[xind, yind, iou_mask, 0:4] = box_xywh\n gt_labels[xind, yind, iou_mask, 4:5] = 1.\n gt_labels[xind, yind, iou_mask, 5:] = class_onehot\n exist_positive = True\n\n if not exist_positive:\n ### NOTE: this is the normal one ###\n ### it means take the anchor box with maximum iou to the raw\n ### box as the ground truth label\n iou_mask = iou_scaled == iou_scaled.max()\n\n if np.any(iou_mask):\n xind, yind = np.floor(np.squeeze(box_xywh_scaled)[:2]).astype(np.int32)\n ### TODO: consider changing the box to raw yolohead output format ###\n gt_labels[xind, yind, iou_mask, 0:4] = box_xywh\n gt_labels[xind, yind, iou_mask, 4:5] = 1.\n gt_labels[xind, yind, iou_mask, 5:] = class_onehot\n\n has_label = False\n if gt_labels.max() != 0:\n has_label = True\n gt_labels = np.where(gt_labels == 0, 1e-16, gt_labels)\n return gt_labels, has_label, raw_boxes_xywh","def _fusion(self, expert_outputs):\n raise NotImplementedError","def reagent_label_data(bcl_step):\n\n define_step = None\n indexes = {}\n flowcell_total_reads = 0\n\n for inp, outp in bcl_step.input_output_maps:\n pre_bcl_steps = MASTER_STEPS_UDFS['reagent_labels']['steps']['pre_bcl']\n if inp['parent-process'].type.name not in pre_bcl_steps:\n continue\n\n if outp['output-generation-type'] != 'PerReagentLabel':\n continue\n\n lane = inp['uri']\n art = outp['uri']\n\n index_reads = art.udf.get(\n MASTER_STEPS_UDFS['reagent_labels']['udfs']['reads'])\n\n if index_reads is None or art.qc_flag == 'FAILED':\n continue\n\n flowcell_total_reads += index_reads\n\n sample = art.samples[0] # Will always be only one sample in the list\n application_tag = sample.udf.get('Sequencing Analysis')\n\n if application_tag[0:2] in MASTER_STEPS_UDFS['reagent_labels'][\n 'exclue_tags']:\n continue\n\n if not define_step:\n define_step_outputs, flowcell_target_reads, define_step = get_define_step_data(\n lane)\n\n if not sample.id in define_step_outputs:\n LOG.info('This sample whas put as a pool into the define step: ' +\n sample.id + ' ' + application_tag)\n continue\n\n index = art.reagent_labels[0]\n\n container, lane_nr = lane.location\n if index not in indexes:\n indexes[index] = {\n '_id': '_'.join([index, container.name]),\n 'url': index.replace(' ', ''),\n 'index_total_reads': index_reads,\n 'index_target_reads': define_step_outputs[sample.id],\n 'flowcell_target_reads': flowcell_target_reads,\n 'index': index,\n 'sample': sample.id,\n 'lanes': {\n lane_nr: dict(art.udf.items())\n },\n 'flowcell_id': container.name,\n 'flowcell_type': container.type.name,\n 'define_step_udfs': dict(define_step.udf.items()),\n 'define_step_id': define_step.id,\n 'bcl_step_id': bcl_step.id\n }\n else:\n indexes[index]['lanes'][lane_nr] = dict(art.udf.items())\n indexes[index]['index_total_reads'] += index_reads\n\n for index, data in indexes.items():\n data['flowcell_total_reads'] = flowcell_total_reads\n indexes[index] = filter_none(data)\n\n return indexes","def create_pipeline_flow(\n self, cmp_deriv_subject_directory, nipype_deriv_subject_directory\n ):\n acquisition_model = self.stages[\"Diffusion\"].config.diffusion_imaging_model\n recon_tool = self.stages[\"Diffusion\"].config.recon_processing_tool\n\n recon_model = \"DTI\"\n\n if acquisition_model == \"DSI\":\n recon_model = \"SHORE\"\n else:\n if recon_tool == \"Dipy\" and self.stages[\"Diffusion\"].config.dipy_recon_config.local_model:\n recon_model = \"CSD\"\n elif recon_tool == \"MRtrix\" and self.stages[\"Diffusion\"].config.mrtrix_recon_config.local_model:\n recon_model = \"CSD\"\n\n tracking_model = self.stages[\"Diffusion\"].config.diffusion_model\n\n if tracking_model == \"Deterministic\":\n tracking_model = \"DET\"\n elif tracking_model == \"Probabilistic\":\n tracking_model = \"PROB\"\n\n if self.parcellation_scheme == \"Lausanne2018\":\n bids_atlas_label = \"L2018\"\n elif self.parcellation_scheme == \"NativeFreesurfer\":\n bids_atlas_label = \"Desikan\"\n elif self.parcellation_scheme == \"Custom\":\n bids_atlas_label = self.custom_atlas_name\n if self.custom_atlas_res is not None and self.custom_atlas_res != \"\":\n bids_atlas_label += f'_res-{self.custom_atlas_res}'\n\n # Clear previous outputs\n self.clear_stages_outputs()\n\n # Create diffusion workflow with input and output Identityinterface nodes\n diffusion_flow = pe.Workflow(\n name=\"diffusion_pipeline\",\n base_dir=os.path.abspath(nipype_deriv_subject_directory),\n )\n\n diffusion_inputnode = pe.Node(\n interface=util.IdentityInterface(\n fields=[\n \"diffusion\",\n \"bvecs\",\n \"bvals\",\n \"T1\",\n \"aseg\",\n \"aparc_aseg\",\n \"brain\",\n \"T2\",\n \"brain_mask\",\n \"wm_mask_file\",\n \"roi_volumes\",\n \"roi_graphMLs\",\n \"subjects_dir\",\n \"subject_id\",\n \"parcellation_scheme\",\n ]\n ),\n name=\"inputnode\",\n )\n diffusion_inputnode.inputs.parcellation_scheme = self.parcellation_scheme\n diffusion_inputnode.inputs.atlas_info = self.atlas_info\n\n diffusion_outputnode = pe.Node(\n interface=util.IdentityInterface(fields=[\"connectivity_matrices\"]),\n name=\"outputnode\",\n )\n\n diffusion_flow.add_nodes([diffusion_inputnode, diffusion_outputnode])\n\n # Data import\n datasource = self.create_datagrabber_node(\n base_directory=cmp_deriv_subject_directory,\n bids_atlas_label=bids_atlas_label\n )\n\n # Data sinker for output\n sinker = self.create_datasinker_node(\n base_directory=cmp_deriv_subject_directory,\n bids_atlas_label=bids_atlas_label,\n recon_model=recon_model,\n tracking_model=tracking_model\n )\n\n # fmt:off\n diffusion_flow.connect(\n [\n (datasource, diffusion_inputnode, [(\"diffusion\", \"diffusion\"),\n (\"bvecs\", \"bvecs\"),\n (\"bvals\", \"bvals\"),\n (\"T1\", \"T1\"),\n (\"aseg\", \"aseg\"),\n (\"aparc_aseg\", \"aparc_aseg\"),\n (\"brain\", \"brain\"),\n (\"brain_mask\", \"brain_mask\"),\n (\"wm_mask_file\", \"wm_mask_file\")]),\n ]\n )\n # fmt:on\n\n merge_roi_volumes = pe.Node(interface=Merge(5), name=\"merge_roi_volumes\")\n merge_roi_graphmls = pe.Node(interface=Merge(5), name=\"merge_roi_graphmls\")\n\n def remove_non_existing_scales(roi_volumes):\n \"\"\"Returns a list which do not contained any empty element.\n\n Parameters\n ----------\n roi_volumes : list\n A list of output parcellations that might contain empty element\n in the case of the monoscale Desikan scheme for instance\n\n Returns\n -------\n out_roi_volumes : list\n The list with no empty element\n \"\"\"\n out_roi_volumes = []\n for vol in roi_volumes:\n if vol is not None:\n out_roi_volumes.append(vol)\n return out_roi_volumes\n\n # fmt:off\n diffusion_flow.connect(\n [\n (datasource, merge_roi_volumes, [(\"roi_volume_s1\", \"in1\"),\n (\"roi_volume_s2\", \"in2\"),\n (\"roi_volume_s3\", \"in3\"),\n (\"roi_volume_s4\", \"in4\"),\n (\"roi_volume_s5\", \"in5\")]),\n (datasource, merge_roi_graphmls, [(\"roi_graphml_s1\", \"in1\"),\n (\"roi_graphml_s2\", \"in2\"),\n (\"roi_graphml_s3\", \"in3\"),\n (\"roi_graphml_s4\", \"in4\"),\n (\"roi_graphml_s5\", \"in5\")]),\n (merge_roi_volumes, diffusion_inputnode, [((\"out\", remove_non_existing_scales), \"roi_volumes\")],),\n (merge_roi_graphmls, diffusion_inputnode, [((\"out\", remove_non_existing_scales), \"roi_graphMLs\")],),\n ]\n )\n # fmt:on\n\n if self.stages[\"Preprocessing\"].enabled:\n preproc_flow = self.create_stage_flow(\"Preprocessing\")\n # fmt:off\n diffusion_flow.connect(\n [\n (diffusion_inputnode, preproc_flow, [(\"diffusion\", \"inputnode.diffusion\"),\n (\"brain\", \"inputnode.brain\"),\n (\"aseg\", \"inputnode.aseg\"),\n (\"aparc_aseg\", \"inputnode.aparc_aseg\"),\n (\"brain_mask\", \"inputnode.brain_mask\"),\n (\"wm_mask_file\", \"inputnode.wm_mask_file\"),\n (\"roi_volumes\", \"inputnode.roi_volumes\"),\n (\"bvecs\", \"inputnode.bvecs\"),\n (\"bvals\", \"inputnode.bvals\"),\n (\"T1\", \"inputnode.T1\")]),\n ]\n )\n # fmt:on\n\n if self.stages[\"Registration\"].enabled:\n reg_flow = self.create_stage_flow(\"Registration\")\n # fmt:off\n diffusion_flow.connect(\n [\n # (diffusion_inputnode,reg_flow,[('T2','inputnode.T2')]),\n (preproc_flow, reg_flow, [(\"outputnode.T1\", \"inputnode.T1\"),\n (\"outputnode.act_5TT\", \"inputnode.act_5TT\"),\n (\"outputnode.gmwmi\", \"inputnode.gmwmi\"),\n (\"outputnode.bvecs_rot\", \"inputnode.bvecs\"),\n (\"outputnode.bvals\", \"inputnode.bvals\"),\n (\"outputnode.wm_mask_file\", \"inputnode.wm_mask\"),\n (\"outputnode.partial_volume_files\", \"inputnode.partial_volume_files\",),\n (\"outputnode.roi_volumes\", \"inputnode.roi_volumes\"),\n (\"outputnode.brain\", \"inputnode.brain\"),\n (\"outputnode.brain_mask\", \"inputnode.brain_mask\"),\n (\"outputnode.brain_mask_full\", \"inputnode.brain_mask_full\"),\n (\"outputnode.diffusion_preproc\", \"inputnode.target\"),\n (\"outputnode.dwi_brain_mask\", \"inputnode.target_mask\")]),\n (preproc_flow, sinker, [(\"outputnode.bvecs_rot\", \"dwi.@bvecs_rot\"),\n (\"outputnode.diffusion_preproc\", \"dwi.@diffusion_preproc\"),\n (\"outputnode.dwi_brain_mask\", \"dwi.@diffusion_brainmask\")]),\n ]\n )\n # fmt:on\n if self.stages[\"Registration\"].config.registration_mode == \"BBregister (FS)\":\n # fmt:off\n diffusion_flow.connect(\n [\n (diffusion_inputnode, reg_flow, [(\"subjects_dir\", \"inputnode.subjects_dir\"), (\"subject_id\", \"inputnode.subject_id\")]),\n ]\n )\n # fmt:on\n\n if self.stages[\"Diffusion\"].enabled:\n diff_flow = self.create_stage_flow(\"Diffusion\")\n # fmt:off\n diffusion_flow.connect(\n [\n (preproc_flow, diff_flow, [(\"outputnode.diffusion_preproc\", \"inputnode.diffusion\")]),\n (reg_flow, diff_flow, [(\"outputnode.wm_mask_registered_crop\", \"inputnode.wm_mask_registered\",),\n (\"outputnode.brain_mask_registered_crop\", \"inputnode.brain_mask_registered\",),\n (\"outputnode.partial_volumes_registered_crop\", \"inputnode.partial_volumes\",),\n (\"outputnode.roi_volumes_registered_crop\", \"inputnode.roi_volumes\",),\n (\"outputnode.act_5tt_registered_crop\", \"inputnode.act_5tt_registered\",),\n (\"outputnode.gmwmi_registered_crop\", \"inputnode.gmwmi_registered\",),\n (\"outputnode.grad\", \"inputnode.grad\"),\n (\"outputnode.bvals\", \"inputnode.bvals\"),\n (\"outputnode.bvecs\", \"inputnode.bvecs\")]),\n (reg_flow, sinker, [(\"outputnode.target_epicorrected\", \"dwi.@bdiffusion_reg_crop\",),\n (\"outputnode.grad\", \"dwi.@diffusion_grad\"),\n (\"outputnode.affine_transform\", \"xfm.@affine_transform\"),\n (\"outputnode.warp_field\", \"xfm.@warp_field\"),\n (\"outputnode.T1_registered_crop\", \"anat.@T1_reg_crop\"),\n (\"outputnode.act_5tt_registered_crop\", \"anat.@act_5tt_reg_crop\",),\n (\"outputnode.gmwmi_registered_crop\", \"anat.@gmwmi_reg_crop\"),\n (\"outputnode.brain_registered_crop\", \"anat.@brain_reg_crop\"),\n (\"outputnode.brain_mask_registered_crop\", \"anat.@brain_mask_reg_crop\",),\n (\"outputnode.wm_mask_registered_crop\", \"anat.@wm_mask_reg_crop\",),\n (\"outputnode.roi_volumes_registered_crop\", \"anat.@roivs_reg_crop\",),\n (\"outputnode.partial_volumes_registered_crop\", \"anat.@pves_reg_crop\",)],),\n ]\n )\n # fmt:on\n\n if self.stages[\"Connectome\"].enabled:\n self.stages[\"Connectome\"].config.probtrackx = False\n self.stages[\"Connectome\"].config.subject = self.global_conf.subject\n con_flow = self.create_stage_flow(\"Connectome\")\n # fmt:off\n diffusion_flow.connect(\n [\n (diffusion_inputnode, con_flow, [(\"parcellation_scheme\", \"inputnode.parcellation_scheme\"),\n (\"atlas_info\", \"inputnode.atlas_info\"),\n (\"roi_graphMLs\", \"inputnode.roi_graphMLs\")]),\n (diff_flow, con_flow, [(\"outputnode.track_file\", \"inputnode.track_file\"),\n (\"outputnode.FA\", \"inputnode.FA\"),\n (\"outputnode.ADC\", \"inputnode.ADC\"),\n (\"outputnode.AD\", \"inputnode.AD\"),\n (\"outputnode.RD\", \"inputnode.RD\"),\n (\"outputnode.roi_volumes\", \"inputnode.roi_volumes_registered\",),\n (\"outputnode.skewness\", \"inputnode.skewness\"),\n (\"outputnode.kurtosis\", \"inputnode.kurtosis\"),\n (\"outputnode.P0\", \"inputnode.P0\"),\n (\"outputnode.mapmri_maps\", \"inputnode.mapmri_maps\"),\n (\"outputnode.shore_maps\", \"inputnode.shore_maps\")]),\n (con_flow, diffusion_outputnode, [(\"outputnode.connectivity_matrices\", \"connectivity_matrices\")]),\n (diff_flow, sinker, [(\"outputnode.fod_file\", \"dwi.@fod_file\"),\n (\"outputnode.FA\", \"dwi.@FA\"),\n (\"outputnode.ADC\", \"dwi.@ADC\"),\n (\"outputnode.AD\", \"dwi.@AD\"),\n (\"outputnode.RD\", \"dwi.@RD\"),\n (\"outputnode.skewness\", \"dwi.@skewness\"),\n (\"outputnode.kurtosis\", \"dwi.@kurtosis\"),\n (\"outputnode.P0\", \"dwi.@P0\"),\n (\"outputnode.mapmri_maps\", \"dwi.@mapmri_maps\"),\n (\"outputnode.shore_maps\", \"dwi.@shore_maps\")]),\n (con_flow, sinker, [(\"outputnode.streamline_final_file\", \"dwi.@streamline_final_file\"),\n (\"outputnode.connectivity_matrices\", \"dwi.@connectivity_matrices\")]),\n ]\n )\n # fmt:on\n\n return diffusion_flow","def pack_firmware(self, work_dir, jobclient, version_string=\"\"):\n raise NotImplementedError(\"Abstract method not implemented\")","def __call__(self, node):\n\n # should throw an error\n if node.cfgInterface == None:\n return\n\n # //\n # // Extract LFN base from included WorkflowSpec parameters\n #//\n base = node.getParameter(\"UnmergedLFNBase\")[0]\n\n # //\n # // iterate over outputmodules/data tiers\n #// Generate LFN, PFN and Catalog for each module\n for modName, outModule in node.cfgInterface.outputModules.items():\n if ( not outModule.has_key('fileName') ):\n msg = \"OutputModule %s does not contain a fileName entry\" % modName\n raise RuntimeError, msg\n outModule['logicalFileName'] = os.path.join(base, outModule['dataTier'], str(self.lfnGroup))\n outModule['logicalFileName'] += '/'\n outModule['logicalFileName'] += outModule['fileName']\n\n return","def encodeToLabels(self, gt_instances):\n raw_boxes_xyzwhd = np.zeros((self.config_data[\"max_boxes_per_frame\"], 7))\n ### initialize gronud truth labels as np.zeors ###\n gt_labels = np.zeros(list(self.headoutput_shape[1:4]) + \\\n [len(self.anchor_boxes)] + \\\n [len(self.config_data[\"all_classes\"]) + 7])\n\n ### start transferring box to ground turth label format ###\n for i in range(len(gt_instances[\"classes\"])):\n if i > self.config_data[\"max_boxes_per_frame\"]:\n continue\n class_name = gt_instances[\"classes\"][i]\n box_xyzwhd = gt_instances[\"boxes\"][i]\n class_id = self.config_data[\"all_classes\"].index(class_name)\n if i < self.config_data[\"max_boxes_per_frame\"]:\n raw_boxes_xyzwhd[i, :6] = box_xyzwhd\n raw_boxes_xyzwhd[i, 6] = class_id\n class_onehot = helper.smoothOnehot(class_id, len(self.config_data[\"all_classes\"]))\n \n exist_positive = False\n\n grid_strid = self.grid_strides\n anchor_stage = self.anchor_boxes\n box_xyzwhd_scaled = box_xyzwhd[np.newaxis, :].astype(np.float32)\n box_xyzwhd_scaled[:, :3] /= grid_strid\n anchorstage_xyzwhd = np.zeros([len(anchor_stage), 6])\n anchorstage_xyzwhd[:, :3] = np.floor(box_xyzwhd_scaled[:, :3]) + 0.5\n anchorstage_xyzwhd[:, 3:] = anchor_stage.astype(np.float32)\n\n iou_scaled = helper.iou3d(box_xyzwhd_scaled, anchorstage_xyzwhd, \\\n self.input_size)\n ### NOTE: 0.3 is from YOLOv4, maybe this should be different here ###\n ### it means, as long as iou is over 0.3 with an anchor, the anchor\n ### should be taken into consideration as a ground truth label\n iou_mask = iou_scaled > 0.3\n\n if np.any(iou_mask):\n xind, yind, zind = np.floor(np.squeeze(box_xyzwhd_scaled)[:3]).\\\n astype(np.int32)\n ### TODO: consider changing the box to raw yolohead output format ###\n gt_labels[xind, yind, zind, iou_mask, 0:6] = box_xyzwhd\n gt_labels[xind, yind, zind, iou_mask, 6:7] = 1.\n gt_labels[xind, yind, zind, iou_mask, 7:] = class_onehot\n exist_positive = True\n\n if not exist_positive:\n ### NOTE: this is the normal one ###\n ### it means take the anchor box with maximum iou to the raw\n ### box as the ground truth label\n anchor_ind = np.argmax(iou_scaled)\n xind, yind, zind = np.floor(np.squeeze(box_xyzwhd_scaled)[:3]).\\\n astype(np.int32)\n gt_labels[xind, yind, zind, anchor_ind, 0:6] = box_xyzwhd\n gt_labels[xind, yind, zind, anchor_ind, 6:7] = 1.\n gt_labels[xind, yind, zind, anchor_ind, 7:] = class_onehot\n\n has_label = False\n for label_stage in gt_labels:\n if label_stage.max() != 0:\n has_label = True\n gt_labels = [np.where(gt_i == 0, 1e-16, gt_i) for gt_i in gt_labels]\n return gt_labels, has_label, raw_boxes_xyzwhd","def worker(selection_idx, results_table):\n randgen = np.random.RandomState()\n \n # Data-specific positive set partition (the real-world dataset consists of multiple motif classes, always exactly 3 instances of each class stored consequently).\n # The partition assures that the training and test sets do not share instances of the same motif class\n positive_n_train = round(0.8 * len(positive_set_) / 3) * 3\n block_start_idx = randgen.randint(positive_n_train / 3 + 1) * 3 \n block_end_idx = block_start_idx + len(positive_set_) - positive_n_train\n positive_set_part_train, positive_set_part_test = (np.concatenate((positive_set_[: block_start_idx], positive_set_[block_end_idx: ])), positive_set_[block_start_idx: block_end_idx])\n \n # Negative set partition with random selection of elements to match the size of the positive set\n negative_set = negative_set_[randgen.choice(len(negative_set_), size = positive_set_.shape[0], replace = False)]\n negative_n = len(negative_set)\n negative_n_train = round(negative_n * 0.8)\n negative_set_part_train, negative_set_part_test = (negative_set[: negative_n_train], negative_set[negative_n_train: ])\n \n data_part_train = np.float64(np.concatenate((positive_set_part_train, negative_set_part_train)))\n labels_part_train = np.concatenate((np.ones(len(positive_set_part_train), dtype = 'i1'), np.zeros(len(negative_set_part_train), dtype = 'i1')))\n data_part_test = np.float64(np.concatenate((positive_set_part_test, negative_set_part_test)))\n labels_part_test = np.concatenate((np.ones(len(positive_set_part_test), dtype = 'i1'), np.zeros(len(negative_set_part_test), dtype = 'i1')))\n \n # Specifying the pipeline and the CV structure\n pruner = feature_selection.VarianceThreshold()\n scaler = preprocessing.StandardScaler()\n feature_selector = feature_selection.SelectKBest(feature_selection.f_classif)\n classifier = svm.SVC(kernel = 'rbf', gamma = 0.01, class_weight = 'balanced')\n pipeline0 = pipeline.Pipeline([\n ('pruning', pruner),\n ('scaling', scaler),\n ('selection', feature_selector),\n ('classification', classifier)\n ])\n cv_structure = model_selection.StratifiedShuffleSplit(n_splits = 10, test_size = 0.2)\n scoring = 'recall_macro' #same as balanced accuracy\n grid = model_selection.GridSearchCV(pipeline0, scoring = scoring, param_grid = param_grid, cv = cv_structure, n_jobs = 1)\n \n # Training the pipeline, saving the data\n grid.fit(data_part_train, labels_part_train)\n results_table[selection_idx][0] = np.log10(grid.best_params_['classification__C'])\n results_table[selection_idx][1] = grid.best_params_['selection__k']\n results_table[selection_idx][2] = grid.best_score_\n \n # Testing the pipeline, saving the data\n results_table[selection_idx][3] = grid.score(data_part_test, labels_part_test)","def _vVBEL_XXXX(self,vKNOT=None,OBJTYPE=None):\r\n\r\n logStr = \"{0:s}.{1:s}: \".format(self.__class__.__name__, sys._getframe().f_code.co_name)\r\n logger.debug(\"{0:s}{1:s}\".format(logStr,'Start.')) \r\n \r\n try: \r\n \r\n #'KVR','PZON_NAME', 'FSTF_NAME', 'STOF_NAME', 'GMIX_NAME','UTMP_NAME'\r\n\r\n\r\n\r\n vXXXX=None\r\n\r\n vXXXX=pd.merge(self.dataFrames[OBJTYPE],vKNOT,left_on='fkKI',right_on='pk',suffixes=('','_i')) \r\n vXXXX=vXXXX[['fkKK','BESCHREIBUNG','IDREFERENZ','pk','tk','NAME','CONT','CONT_VKNO','pk_i','ZKOR']]\r\n vXXXX.rename(columns={'NAME':'NAME_i','CONT':'CONT_i','CONT_VKNO':'CONT_VKNO_i','ZKOR':'Z_i'},inplace=True)\r\n\r\n vXXXX=pd.merge(vXXXX,vKNOT,left_on='fkKK',right_on='pk',suffixes=('','_k'))\r\n vXXXX=vXXXX[['BESCHREIBUNG','IDREFERENZ','pk','tk','NAME_i','CONT_i','CONT_VKNO_i','Z_i','pk_i','NAME','CONT','CONT_VKNO','pk_k','ZKOR']]\r\n vXXXX.rename(columns={'NAME':'NAME_k','CONT':'CONT_k','CONT_VKNO':'CONT_VKNO_k','ZKOR':'Z_k'},inplace=True)\r\n \r\n vXXXX=vXXXX.assign(OBJTYPE=lambda x: OBJTYPE)\r\n vXXXX=vXXXX[['OBJTYPE','BESCHREIBUNG','IDREFERENZ','pk','tk','NAME_i','CONT_i','CONT_VKNO_i','Z_i','pk_i','NAME_k','CONT_k','CONT_VKNO_k','Z_k','pk_k']]\r\n\r\n except Exception as e:\r\n logStrFinal=\"{:s}Exception: Line: {:d}: {!s:s}: {:s}\".format(logStr,sys.exc_info()[-1].tb_lineno,type(e),str(e))\r\n logger.debug(logStrFinal) \r\n vXXXX=None\r\n \r\n finally:\r\n logger.debug(\"{0:s}{1:s}\".format(logStr,'_Done.'))\r\n return vXXXX","def process_circuits(self, processor_fn, updated_aliases=None):\n P = processor_fn # shorthand\n cpy = LsGermsSerialStructure(self.Ls, list(map(P, self.germs)),\n self.nMinorRows, self.nMinorCols,\n updated_aliases, self.sequenceRules)\n cpy.allstrs = list(map(P, self.allstrs))\n cpy.allstrs_set = set(cpy.allstrs)\n cpy.unindexed = list(map(P, self.unindexed))\n cpy._plaquettes = {k: v.process_circuits(P, updated_aliases) for k, v in self._plaquettes.items()}\n cpy._firsts = [(L, P(germ)) for (L, germ) in self._firsts]\n cpy._baseStrToLGerm = {P(base): (L, P(germ)) for base, (L, germ) in self._baseStrToLGerm.items()}\n return cpy","def build(self):\n super(VaporStateBlockData, self).build()\n\n # Object reference for molecular weight if needed by CV1D\n # Molecular weights\n self.mw_comp = Reference(self.params.mw_comp)\n\n self.flow_mol = Var(initialize=1.0,\n domain=NonNegativeReals,\n units=pyunits.mol / pyunits.s,\n doc='Total molar flowrate')\n\n self.mole_frac_comp = Var(self.component_list,\n domain=NonNegativeReals,\n bounds=(0, 1),\n units=None,\n initialize=1 / len(self.component_list),\n doc='Component mole fractions [-]')\n\n self.pressure = Var(initialize=101325,\n domain=NonNegativeReals,\n units=pyunits.Pa,\n doc='Pressure [Pa]')\n\n self.temperature = Var(initialize=298.15,\n domain=NonNegativeReals,\n units=pyunits.K,\n doc='Temperature [K]')\n\n # Sum mole fractions if not inlet block\n if self.config.defined_state is False:\n def sum_component_eqn(b):\n return b.flow_mol == sum(b.flow_mol_comp[j]\n for j in b._params.component_list)\n self.sum_component_eqn = Constraint(rule=sum_component_eqn)","def exec_attention(self,curr_step): \n\n assert(self.curr_step_idx > 0 and self.dlist is not None), \"Step Error: Must call init before combine\" \n \n detectType = curr_step[\"detectionNetwork\"]\n paramsFile = curr_step[\"paramsFile\"]\n funclist = curr_step[\"funclist\"]\n\n #verify raw data & dlist\n # self.B_VER(self.sess_path, self.dlist)\n raw_datadir = self.sess_path\n dest_datadir = self.sess_path \n\n model_dict = {\"detectType\": detectType, \"paramsFile\" : paramsFile} \n\n for i, folder in enumerate(self.dlist):\n flist = funclist[i]\n self.data_utils.DETECT(raw_datadir, folder, dest_datadir, model_dict, flist=[], preview=False)\n self.default_vis(curr_step)","def encode(self):\n payload = []\n\n # Generate Payload\n if self.IsEnsembleData:\n payload += self.EnsembleData.encode()\n if self.IsAncillaryData:\n payload += self.AncillaryData.encode()\n if self.IsAmplitude:\n payload += self.Amplitude.encode()\n if self.IsCorrelation:\n payload += self.Correlation.encode()\n if self.IsBeamVelocity:\n payload += self.BeamVelocity.encode()\n if self.IsInstrumentVelocity:\n payload += self.InstrumentVelocity.encode()\n if self.IsEarthVelocity:\n payload += self.EarthVelocity.encode()\n if self.IsGoodBeam:\n payload += self.GoodBeam.encode()\n if self.IsGoodEarth:\n payload += self.GoodEarth.encode()\n if self.IsBottomTrack:\n payload += self.BottomTrack.encode()\n if self.IsRangeTracking:\n payload += self.RangeTracking.encode()\n if self.IsSystemSetup:\n payload += self.SystemSetup.encode()\n if self.IsNmeaData:\n payload += self.NmeaData.encode()\n\n # Generate the header\n # Get the ensemble number\n ens_num = 0\n if self.IsEnsembleData:\n ens_num = self.EnsembleData.EnsembleNumber\n\n # Get the payload size\n payload_size = len(payload)\n\n header = Ensemble.generate_ens_header(ens_num, payload_size)\n\n # Generate the Checksum CITT\n # Parameters found at https: // pycrc.org / models.html\n #crc = pycrc.algorithms.Crc(width=16, poly=0x1021,\n # reflect_in=False, xor_in=0x1d0f,\n # reflect_out=False, xor_out=0x0000)\n #checksum = crc.bit_by_bit_fast(binascii.a2b_hex(bytes(payload)))\n #checksum = Ensemble.int32_to_bytes(CRCCCITT().calculate(input_data=bytes(payload)))\n checksum = crc16.crc16xmodem(payload)\n\n\n result = []\n result += header\n result += payload\n result += checksum\n\n return bytearray(result)","def transform(self, inputs: list, stage: str) -> datapack.DataPack:","def predict_structure(prefix, model_runner_1: alphafold.model.model.RunModel,\n model_runner_3: alphafold.model.model.RunModel,\n feature_dict, Ls: list[int], model_params: haiku.Params, use_model, do_relax=False,\n random_seed=0):\n\n # Minkyung's code\n # add big enough number to residue index to indicate chain breaks\n idx_res = feature_dict['residue_index']\n L_prev = 0\n # Ls: number of residues in each chain\n for L_i in Ls[:-1]:\n idx_res[L_prev + L_i:] += 200\n L_prev += L_i\n chains = list(\"\".join([ascii_uppercase[n] * L for n, L in enumerate(Ls)]))\n feature_dict['residue_index'] = idx_res\n\n # Run the models.\n plddts, paes = [], []\n unrelaxed_pdb_lines = []\n relaxed_pdb_lines = []\n\n print(f\"Use_model {use_model}\")\n\n for model_name, params in model_params.items():\n if model_name in use_model:\n print(f\"running {model_name}\")\n # swap params to avoid recompiling\n # note: models 1,2 have diff number of params compared to models 3,4,5\n if any(str(m) in model_name for m in [1, 2]): model_runner = model_runner_1\n if any(str(m) in model_name for m in [3, 4, 5]): model_runner = model_runner_3\n model_runner.params = params\n\n processed_feature_dict: affeatures.FeatureDict = model_runner.process_features(feature_dict,\n random_seed=random_seed)\n # prediction_result is a dictionary of NumPy feature arrays\n prediction_result: dict = model_runner.predict(processed_feature_dict)\n unrelaxed_protein: protein.Protein = protein.from_prediction(processed_feature_dict, prediction_result)\n unrelaxed_pdb_lines.append(protein.to_pdb(unrelaxed_protein))\n plddts.append(prediction_result['plddt'])\n paes.append(prediction_result['predicted_aligned_error'])\n\n if do_relax:\n # Relax the prediction.\n amber_relaxer: relax.AmberRelaxation = relax.AmberRelaxation(max_iterations=0, tolerance=2.39,\n stiffness=10.0, exclude_residues=[],\n max_outer_iterations=20)\n relaxed_pdb_str, _, _ = amber_relaxer.process(prot=unrelaxed_protein)\n relaxed_pdb_lines.append(relaxed_pdb_str)\n\n # rerank models based on predicted lddt\n lddt_rank = np.mean(plddts, -1).argsort()[::-1]\n out = {}\n print(\"reranking models based on avg. predicted lDDT\")\n for n, r in enumerate(lddt_rank):\n print(f\"model_{n + 1} {np.mean(plddts[r])}\")\n\n unrelaxed_pdb_path = f'{prefix}_unrelaxed_model_{n + 1}.pdb'\n with open(unrelaxed_pdb_path, 'w') as f:\n f.write(unrelaxed_pdb_lines[r])\n set_bfactor(unrelaxed_pdb_path, plddts[r], idx_res, chains)\n\n if do_relax:\n relaxed_pdb_path = f'{prefix}_relaxed_model_{n + 1}.pdb'\n with open(relaxed_pdb_path, 'w') as f: f.write(relaxed_pdb_lines[r])\n set_bfactor(relaxed_pdb_path, plddts[r], idx_res, chains)\n\n out[f\"model_{n + 1}\"] = {\"plddt\": plddts[r], \"pae\": paes[r]}\n return out","def __init__(self, objects=()):\n\n vtk.vtkPropAssembly.__init__(self)\n\n self.name = \"\"\n self.created = \"\"\n self.trail = None\n self.trail_points = []\n self.trail_segment_size = 0\n self.trail_offset = None\n self.shadows = []\n self.info = {}\n self.rendered_at = set()\n self.transform = None\n self.scalarbar = None\n\n for a in vedo.utils.flatten(objects):\n if a:\n self.AddPart(a)\n\n self.PickableOff()","def dovisitcomb(allv) :\n allvisits = allv[0]\n load = allv[1]\n field = allv[2][0]\n apogee_id = allv[2][1]\n clobber = allv[2][2]\n pixelmask=bitmask.PixelBitMask()\n\n # already done?\n outdir=os.path.dirname(load.filename('Field',field=field))\n outdir=outdir.replace('/stars/','/rv/')\n if os.path.exists(outdir+'/'+apogee_id+'.pkl') and not clobber:\n print(apogee_id,' already done visitcomb')\n fp=open(outdir+'/'+apogee_id+'.pkl','rb')\n try: \n out=pickle.load(fp)\n fp.close()\n return out\n except: \n print('error loading: ', apogee_id+'.pkl')\n pass\n\n # do the combination\n apstar=visitcomb(allvisits,load=load,plot=False)\n\n # dump\n pickle.dump(apstar,open(outdir+'/'+apogee_id+'.pkl','wb'))\n\n return apstar","def _form_computation_graph(self, idx):\n _list, _set = list, set\n if type(idx) is int:\n node_layers = [np.array([idx], dtype=np.int64)]\n elif type(idx) is list:\n node_layers = [np.array(idx, dtype=np.int64)]\n\n for _ in range(self.n_layers):\n prev = node_layers[-1]\n arr = [node for node in prev]\n arr.extend([e[0] for node in arr for e in self.nbrs_t[node]])\n arr = np.array(_list(_set(arr)), dtype=np.int64)\n node_layers.append(arr)\n node_layers.reverse()\n\n mappings = [{j: i for (i, j) in enumerate(arr)} for arr in node_layers]\n\n return node_layers, mappings","def genereate_echo_picklist(self):\n sample_names = []\n sample_wells = []\n indices = {'i5 name': {}, 'i5 plate': {}, 'i5 sequence': {},\n 'i5 well': {}, 'i7 name': {}, 'i7 plate': {},\n 'i7 sequence': {}, 'i7 well': {}, 'index combo': {},\n 'index combo seq': {}}\n\n for idx, well in enumerate(chain.from_iterable(self.plates[0].layout)):\n # Add the sample well\n sample_wells.append(well.well_id)\n # Get the sample name - we need to go back to the SampleComposition\n lib_comp = well.composition\n sample_comp = lib_comp.normalized_gdna_composition\\\n .gdna_composition.sample_composition\n sample_names.append(sample_comp.content)\n # Retrieve all the information about the indices\n i5_comp = lib_comp.i5_composition.primer_set_composition\n i5_well = i5_comp.container\n indices['i5 name'][idx] = i5_comp.external_id\n indices['i5 plate'][idx] = i5_well.plate.external_id\n indices['i5 sequence'][idx] = i5_comp.barcode\n indices['i5 well'][idx] = i5_well.well_id\n\n i7_comp = lib_comp.i7_composition.primer_set_composition\n i7_well = i7_comp.container\n indices['i7 name'][idx] = i7_comp.external_id\n indices['i7 plate'][idx] = i7_well.plate.external_id\n indices['i7 sequence'][idx] = i7_comp.barcode\n indices['i7 well'][idx] = i7_well.well_id\n\n indices['index combo seq'][idx] = '%s%s' % (\n indices['i5 sequence'][idx], indices['i7 sequence'][idx])\n\n sample_names = np.asarray(sample_names)\n sample_wells = np.asarray(sample_wells)\n indices = pd.DataFrame(indices)\n\n return LibraryPrepShotgunProcess._format_picklist(\n sample_names, sample_wells, indices)","def __rechaindict__(c):\n from TriggerMenu.menu.DictFromChainName import DictFromChainName\n dfcn = DictFromChainName()\n\n pl1 = []\n for pch in c['chainParts']:\n pl1.append(pch['L1item'])\n\n newname = c['chainName'].replace('dv_','').replace('TestChain','j')\n nchlist = [ newname ,c['chainCounter'],c['L1item'],pl1,c['stream'],\n c['groups'],c['EBstep'] ]\n \n return dfcn.getChainDict(nchlist)","def hierarchical( x, output_prefix, labels_to_register=[2,3,4,5], is_test=False, verbose=True ):\n if verbose:\n print(\"Read\")\n tfn = get_data('T_template0', target_extension='.nii.gz' )\n tfnw = get_data('T_template0_WMP', target_extension='.nii.gz' )\n tlrfn = get_data('T_template0_LR', target_extension='.nii.gz' )\n bfn = antspynet.get_antsxnet_data( \"croppedMni152\" )\n\n ##### read images and do simple bxt ops\n templatea = ants.image_read( tfn )\n if verbose:\n print(\"bxt\")\n templatea = ( templatea * antspynet.brain_extraction( templatea, 't1' ) ).iMath( \"Normalize\" )\n templateawmprior = ants.image_read( tfnw )\n templatealr = ants.image_read( tlrfn )\n templateb = ants.image_read( bfn )\n templateb = ( templateb * antspynet.brain_extraction( templateb, 't1' ) ).iMath( \"Normalize\" )\n imgbxt = brain_extraction( x )\n img = x * imgbxt\n\n if verbose:\n print(\"rbp\")\n\n # this is an unbiased method for identifying predictors that can be used to\n # rank / sort data into clusters, some of which may be associated\n # with outlierness or low-quality data\n templatesmall = ants.resample_image( templateb, (91,109,91), use_voxels=True )\n rbp = random_basis_projection( img, templatesmall )\n\n if verbose:\n print(\"intensity\")\n\n ##### intensity modifications\n img = ants.iMath( img, \"Normalize\" ) * 255.0\n img = ants.denoise_image( img, imgbxt, noise_model='Gaussian')\n img = ants.n4_bias_field_correction( img ).iMath(\"Normalize\")\n\n # optional - quick look at result\n bxt_png = output_prefix + \"_brain_extraction_dnz_n4_view.png\"\n ants.plot(img,axis=2,ncol=8,nslices=24, crop=True, black_bg=False,\n filename = bxt_png )\n\n if verbose:\n print(\"hemi\")\n\n # assuming data is reasonable quality, we should proceed with the rest ...\n mylr = label_hemispheres( img, templatea, templatealr )\n\n if verbose:\n print(\"parcellation\")\n\n ##### hierarchical labeling\n myparc = deep_brain_parcellation( img, templateb,\n do_cortical_propagation = not is_test, verbose=False )\n\n ##### accumulate data into data frames\n hemi = map_segmentation_to_dataframe( \"hemisphere\", myparc['hemisphere_labels'] )\n tissue = map_segmentation_to_dataframe( \"tissues\", myparc['tissue_segmentation'] )\n dktl = map_segmentation_to_dataframe( \"lobes\", myparc['dkt_lobes'] )\n dktp = map_segmentation_to_dataframe( \"dkt\", myparc['dkt_parcellation'] )\n dktc = None\n if not is_test:\n dktc = map_segmentation_to_dataframe( \"dkt\", myparc['dkt_cortex'] )\n\n tissue_seg_png = output_prefix + \"_seg.png\"\n ants.plot( img, myparc['tissue_segmentation'], axis=2, nslices=21, ncol=7,\n alpha=0.6, filename=tissue_seg_png,\n crop=True, black_bg=False )\n\n if verbose:\n print(\"WMH\")\n\n ##### below here are more exploratory nice to have outputs\n myhypo = t1_hypointensity(\n img,\n myparc['tissue_segmentation'], # segmentation\n myparc['tissue_probabilities'][3], # wm posteriors\n templatea,\n templateawmprior )\n\n if verbose:\n print(\"registration\")\n\n ##### traditional deformable registration as a high-resolution complement to above\n wm_tractsL = None\n wm_tractsR = None\n wmtdfL = None\n wmtdfR = None\n reg = None\n if labels_to_register is not None:\n reg = hemi_reg(\n input_image = img,\n input_image_tissue_segmentation = myparc['tissue_segmentation'],\n input_image_hemisphere_segmentation = mylr,\n input_template=templatea,\n input_template_hemisphere_labels=templatealr,\n output_prefix = output_prefix + \"_SYN\",\n labels_to_register = labels_to_register,\n is_test=is_test )\n if verbose:\n print(\"wm tracts\")\n ##### how to use the hemi-reg output to generate any roi value from a template roi\n wm_tracts = ants.image_read( get_data( \"wm_major_tracts\", target_extension='.nii.gz' ) )\n wm_tractsL = ants.apply_transforms( img, wm_tracts, reg['synL']['invtransforms'],\n interpolator='genericLabel' ) * ants.threshold_image( mylr, 1, 1 )\n wm_tractsR = ants.apply_transforms( img, wm_tracts, reg['synR']['invtransforms'],\n interpolator='genericLabel' ) * ants.threshold_image( mylr, 2, 2 )\n wmtdfL = map_segmentation_to_dataframe( \"wm_major_tracts\", wm_tractsL )\n wmtdfR = map_segmentation_to_dataframe( \"wm_major_tracts\", wm_tractsR )\n\n if verbose:\n print(\"hippocampus\")\n\n ##### specialized labeling for hippocampus\n ntries = 10\n if is_test:\n ntries = 1\n hippLR = deep_hippo( img, templateb, ntries )\n\n mydataframes = {\n \"hemispheres\":hemi,\n \"tissues\":tissue,\n \"dktlobes\":dktl,\n \"dktregions\":dktp,\n \"dktcortex\":dktc,\n \"wmtracts_left\":wmtdfL,\n \"wmtracts_right\":wmtdfR,\n \"wmh\":myhypo['wmh_summary']\n }\n\n outputs = {\n \"brain_n4_dnz\": img,\n \"brain_n4_dnz_png\": bxt_png,\n \"brain_extraction\": imgbxt,\n \"tissue_seg_png\": tissue_seg_png,\n \"rbp\": rbp,\n \"left_right\": mylr,\n \"dkt_parc\": myparc,\n \"registration\":reg,\n \"hippLR\":hippLR,\n \"white_matter_hypointensity\":myhypo,\n \"wm_tractsL\":wm_tractsL,\n \"wm_tractsR\":wm_tractsR,\n \"dataframes\": mydataframes\n }\n\n return outputs","def label(gt_dataset, volume_dim, voxel_dim, labeling_params):\n labeled_volumes = dict()\n labeled_cells = dict()\n #Use global density and reduce the size of gt_dataset here\n global_density = labeling_params[\"global_density\"]\n gt_dataset = {k: v for k,v in gt_dataset.items() if random_sample() < global_density}\n #Label in the order specified in the configuration\n layers = sorted(labeling_params.keys())\n #Remove global_density\n layers.remove(\"global_density\")\n for layer in layers:\n print \"Labeling {}\".format(layer)\n fluorophore = labeling_params[layer]['fluorophore']\n volume, cells = brainbow(gt_dataset, volume_dim, voxel_dim, **labeling_params[layer])\n if fluorophore in labeled_volumes:\n labeled_volumes[fluorophore] += volume\n labeled_cells[fluorophore] |= cells\n else:\n labeled_volumes[fluorophore] = volume\n labeled_cells[fluorophore] = cells\n return labeled_volumes, labeled_cells","def mapping_image_to_label (self, labels_df, polygons, fpath_tiff): \n \n unread_tiff = rasterio.open(fpath_tiff)\n\n #Projecting the coordinates to that CRS \n proj = Proj(init='epsg:32618')\n data = []\n labels = []\n failed = []\n \n src = rasterio.open(fpath_tiff, 'r')\n outfolder = '/train/batch'\n \n print (\"Hold on tight! Mapping each image to its respective label...\")\n \n \n for num, row in labels_df.iterrows():\n try:\n \n \n roof_material_num = 0\n polygon0 = polygons [num]\n polygon0['coordinates'] = self.transforming_coordinates(polygon0['coordinates'], proj)\n masked_image, out_transform = rasterio.mask.mask(src,[polygon0], filled = True, crop=True, nodata = 0)\n img_image = reshape_as_image (masked_image)\n \n #Defining the name of the image file as \"buildingID+roofMaterial+png\" and its path \n img_path = os.path.join (outfolder, str (row['id'])+'-'+ str (row['roof_material'])+'.png')\n \n #swapping the color channels from RGB2BGR\n img_image = cv2.cvtColor (img_image, cv2.COLOR_RGB2BGR) #img_image is a numpy array\n \n #resizing the image dimensions to 128x128 to match ImageNet dimensions\n img_image = cv2.resize(img_image, (128, 128))\n \n #writing the image in the file\n #cv2.imwrite (img_path, img_image)\n # update the data and labels lists, respectively\n data.append(img_image) #data is a list\n labels.append(row['roof_material'])\n \n except Exception as e:\n print (e)\n failed.append (num)\n \n \n #print number of images we failed to crop and write \n print (\"Bad News First: Failed to write\", len(failed), \"Images.\")\n print (\"Good News: Successfully mapped\", len (data), \"Images.\")\n data = np.array(data)\n labels = np.array(labels)\n #batch = data.sample(frac=0.5, replace=False, random_state=1)\n #print(\"Size and shape of validY: {}\\n\".format(batch.shape))\n return data, labels","def case():\r\n #ppc = {\"version\": '2'}\r\n ppc = {}\r\n ##----- Power Flow Data -----##\r\n ## system MVA base\r\n ppc[\"baseMVA\"] = 100.0\r\n\r\n ## bus data\r\n # bus_i type Pd Qd Gs Bs area Vm Va baseKV zone Vmax Vmin\r\n ppc[\"bus\"] = array([\r\n [1, 3, 0, 0, 0, 0, 1, 1, 0, 0.4, 1, 1.1, 0.9, 0,0, 0, 0],\r\n [2, 1, 0, 0, 0, 0, 1, 1, 0, 0.4, 1, 1.1, 0.9, 0,0, 0, 0],\r\n [3, 1, 0, 0, 0, 0, 1, 1, 0, 0.4, 1, 1.1, 0.9, 0,0, 0, 0],\r\n [4, 1, 0, 0, 0, 0, 1, 1, 0, 0.4, 1, 1.1, 0.9, 0,0, 0, 0],\r\n [5, 1, 0, 0, 0, 0, 1, 1, 0, 0.4, 1, 1.1, 0.9, 0,0, 0, 0],\r\n [6, 1, 0, 0, 0, 0, 1, 1, 0, 0.4, 1, 1.1, 0.9, 0,0, 0, 0],\r\n [7, 1, 0, 0, 0, 0, 1, 1, 0, 0.4, 1, 1.1, 0.9, 0,0, 0, 0],\r\n [8, 1, 0, 0, 0, 0, 1, 1, 0, 0.4, 1, 1.1, 0.9, 0,0, 0, 0],\r\n [9, 1, 0, 0, 0, 0, 1, 1, 0, 0.4, 1, 1.1, 0.9, 0,0, 0, 0],\r\n [10, 1, 0, 0, 0, 0, 1, 1, 0, 0.4, 1, 1.1, 0.9, 0,0, 0, 0],\r\n [11, 1, 0, 0, 0, 0, 1, 1, 0, 0.4, 1, 1.1, 0.9, 0,0, 0, 0],\r\n [12, 1, 0, 0, 0, 0, 1, 1, 0, 0.4, 1, 1.1, 0.9, 0,0, 0, 0],\r\n [13, 1, 0, 0, 0, 0, 1, 1, 0, 0.4, 1, 1.1, 0.9, 0,0, 0, 0],\r\n [14, 1, 0, 0, 0, 0, 1, 1, 0, 0.4, 1, 1.1, 0.9, 0,0, 0, 0],\r\n [15, 1, 0, 0, 0, 0, 1, 1, 0, 0.4, 1, 1.1, 0.9, 0,0, 0, 0],\r\n [16, 1, 0, 0, 0, 0, 1, 1, 0, 0.4, 1, 1.1, 0.9, 0,0, 0, 0]\r\n ])\r\n\r\n ## generator data\r\n # bus, Pg, Qg, Qmax, Qmin, Vg, mBase, status, Pmax, Pmin, Pc1, Pc2,\r\n # Qc1min, Qc1max, Qc2min, Qc2max, ramp_agc, ramp_10, ramp_30, ramp_q, apf\r\n ppc[\"gen\"] = array([\r\n [1,\t0,\t0,\t10,\t-10,\t1.0224,\t100,\t1,\t10,\t-10,\t0,\t0,\t0,\t0,\t0,\t0,\t0,\t0,\t0,\t0, 0, 0,0, 0, 0],\r\n [3 ,0, 0, 50e-3, -50e-3, 1, 100, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0],\r\n [5 , 0, 0, 10e-3, -10e-3, 1, 100, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0],\r\n [10 , 0, 0, 10e-3, -10e-3, 1, 100, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0],\r\n [13 ,0, 0, 10e-3, -10e-3, 1, 100, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0],\r\n [15 , 0, 0, 50e-3, -50e-3, 1, 100, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0]\r\n ])\r\n load_b = array([2, 4, 9, 12, 14])\r\n ppc[\"bus\"][load_b, 2] = multiply(array([-2.1125, -0.2231, -0.1664, -0.0719, -1.4633]).T, 0.03)\r\n ppc[\"bus\"][load_b, 3] = multiply(array([1.6492, 0.4054, 0.8599, 0.8845, 0.6778]).T, 0.03)\r\n ## branch data\r\n # fbus, tbus, r, x, b, rateA, rateB, rateC, ratio, angle, status, angmin, angmax\r\n ppc[\"branch\"] = array([\r\n [1, 2, 0.0, 0.0, 0.0, 250, 250, 250, 0, 0, 1, -360, 360, 0,0, 0, 0, 0,0, 0, 0],\r\n [1, 8, 0.0, 0.0, 0.0, 250, 250, 250, 0, 0, 1, -360, 360, 0,0, 0, 0, 0,0, 0, 0],\r\n [1, 15, 0.0, 0.0, 0.0, 250, 250, 250, 0, 0, 1, -360, 360, 0,0, 0, 0, 0,0, 0, 0],\r\n [2, 3, 0.0, 0.0, 0.0, 250, 250, 250, 0, 0, 1, -360, 360, 0,0, 0, 0, 0,0, 0, 0],\r\n [2, 6, 0.0, 0.0, 0.0, 250, 250, 250, 0, 0, 1, -360, 360, 0,0, 0, 0, 0,0, 0, 0],\r\n [2, 7, 0.0, 0.0, 0.0, 250, 250, 250, 0, 0, 1, -360, 360, 0,0, 0, 0, 0,0, 0, 0],\r\n [3, 4, 0.0, 0.0, 0.0, 250, 250, 250, 0, 0, 1, -360, 360, 0,0, 0, 0, 0,0, 0, 0],\r\n [4, 5, 0.0, 0.0, 0.0, 250, 250, 250, 0, 0, 1, -360, 360, 0,0, 0, 0, 0,0, 0, 0],\r\n [8, 9, 0.0, 0.0, 0.0, 250, 250, 250, 0, 0, 1, -360, 360, 0,0, 0, 0, 0,0, 0, 0],\r\n [8, 12, 0.0, 0.0, 0.0, 250, 250, 250, 0, 0, 1, -360, 360, 0,0, 0, 0, 0,0, 0, 0],\r\n [8, 13, 0.0, 0.0, 0.0, 250, 250, 250, 0, 0, 1, -360, 360, 0,0, 0, 0, 0,0, 0, 0],\r\n [9, 10, 0.0, 0.0, 0.0, 250, 250, 250, 0, 0, 1, -360, 360, 0,0, 0, 0, 0,0, 0, 0],\r\n [9, 14, 0.0, 0.0, 0.0, 250, 250, 250, 0, 0, 1, -360, 360, 0,0, 0, 0, 0,0, 0, 0],\r\n [10, 11, 0.0, 0.0, 0.0, 250, 250, 250, 0, 0, 1, -360, 360, 0,0, 0, 0, 0,0, 0, 0],\r\n [15, 16, 0.0, 0.0, 0.0, 250, 250, 250, 0, 0, 1, -360, 360, 0,0, 0, 0, 0,0, 0, 0]\r\n ])\r\n R1 = 0.43\r\n L1 = 0.4e-3\r\n RS1 = 0.32\r\n LS1 = 0.39e-3\r\n Zbase = (0.4*0.4/100)\r\n branch_phase =array([\r\n [1, 1, 2, 188, R1, L1],\r\n [2, 1 ,8, 346, R1, L1],\r\n [3 ,1 ,15,501, R1 ,L1],\r\n [4, 2, 3, 130, RS1,LS1],\r\n [5, 2, 6, 145, RS1,LS1],\r\n [6, 2 ,7, 157, RS1,LS1],\r\n [7, 3, 4, 185, RS1,LS1],\r\n [8, 4, 5, 1000,RS1,LS1],\r\n [9, 8 ,9, 416, RS1,LS1],\r\n [10,8 ,12,130, RS1,LS1],\r\n [11,8 ,13,121, RS1,LS1],\r\n [12,9 ,10,130, RS1,LS1],\r\n [13,9 ,14,127, RS1,LS1],\r\n [14,10,11,251, RS1,LS1],\r\n [15,15,16,345, RS1,LS1]\r\n ])\r\n ppc[\"branch\"][:, [2,3]] = multiply(array([branch_phase[:, 4]*branch_phase[:, 3], branch_phase[:, 4]*branch_phase[:, 4]*100*pi]).T,0.001/Zbase)\r\n\r\n ##----- OPF Data -----##\r\n ## area data\r\n # area refbus\r\n\r\n\r\n ## generator cost data\r\n # 1 startup shutdown n x1 y1 ... xn yn\r\n # 2 startup shutdown n c(n-1) ... c0\r\n\r\n\r\n return ppc","def _label_encoding(self):\n for feat in self.cat_feats:\n if self.train:\n lbl = preprocessing.LabelEncoder()\n lbl.fit(self.dataframe[feat].values)\n self.dataframe_d_copy.loc[:,feat] = lbl.transform(self.dataframe[feat].values)\n self.label_encoders[feat] = lbl\n else:\n lbl = self.encoders[feat]\n self.dataframe_d_copy.loc[:,feat] = lbl.transform(self.dataframe[feat].values)\n \n if self.train:\n encoder_path = f\"{self.output_path}/_label_encoder.pkl\"\n self.cat_feats_cfg['encoder_path'] = encoder_path\n joblib.dump(self.label_encoders, encoder_path)\n \n return self.dataframe_d_copy","def convert2EbnerParamOriginalParam(listSlice,list_prefix,directory,paramAx,paramCor,paramSag):\n paramAx=np.load(paramAx)\n paramCor=np.load(paramCor)\n paramSag=np.load(paramSag)\n param=[]\n param.append(paramAx)\n param.append(paramCor)\n param.append(paramSag)\n \n images,mask = createVolumesFromAlist(listSlice.copy()) #list of images corresponding to differents original stacks\n \n \n mat = np.array([[-1,0,0,0],[0,-1,0,0],[0,0,1,0],[0,0,0,1]]) #matrix to convert affine matrix from nibabel to itk\n\n for n in range(len(images)): #for each stack\n \n imagen = images[n]\n \n for i_slice in range(len(images[n])): #for each slices (in each stacks)\n \n slicei=imagen[i_slice]\n dimension=3\n X,Y,Z= slicei.get_slice().get_fdata().shape\n transfo = param[n][slicei.get_index_slice(),:,:]\n #print()\n matrix = mat @ transfo @ mat\n #print(matrix)\n test = sitk.AffineTransform(dimension)\n test.SetMatrix(matrix[0:3,0:3].flatten())\n test.SetTranslation(matrix[0:3,3])\n images_index = slicei.get_index_image()\n\n sitk.WriteTransform(test,\"%s/%s_slice%d.tfm\" %(directory,list_prefix[images_index],slicei.get_index_slice())) #save rigid transformation, computed at the barycenter of the image, adatpted to itk","def nodeSeparate(self,compInfo, ifSub, subname, subcktName,numNodesSub):\n node = []\n nodeTemp = []\n nodeDic = {}\n pinInit = 'Modelica.Electrical.Analog.Interfaces.Pin '\n pinProtectedInit = 'Modelica.Electrical.Analog.Interfaces.Pin '\n protectedNode = []\n print \"CompInfo coming to nodeSeparate function: compInfo\",compInfo\n \n #Removing '[' and ']' from compInfo for Digital node\n for i in range(0,len(compInfo),1):\n compInfo[i] = compInfo[i].replace(\"[\",\"\").replace(\"]\",\"\")\n \n \n for eachline in compInfo:\n words = eachline.split()\n if eachline[0] in ['m', 'e', 'g', 't','M','E','G','T']:\n nodeTemp.append(words[1])\n nodeTemp.append(words[2])\n nodeTemp.append(words[3])\n nodeTemp.append(words[4])\n elif eachline[0] in ['q', 'j','J','Q']:\n nodeTemp.append(words[1])\n nodeTemp.append(words[2])\n nodeTemp.append(words[3])\n elif eachline[0]=='x' or eachline[0]=='X':\n templine = eachline.split()\n for i in range(0,len(templine),1):\n if templine[i] in subcktName:\n point = i \n nodeTemp.extend(words[1:point])\n else:\n nodeTemp.append(words[1])\n nodeTemp.append(words[2])\n for i in nodeTemp:\n if i not in node:\n node.append(i)\n \n for i in range(0, len(node),1):\n nodeDic[node[i]] = 'n' + node[i]\n if ifSub == '0':\n if i != len(node)-1:\n pinInit = pinInit + nodeDic[node[i]] + ', '\n else:\n pinInit = pinInit + nodeDic[node[i]]\n else:\n nonprotectedNode = self.getSubInterface(subname, numNodesSub) \n if node[i] in nonprotectedNode:\n continue\n else:\n protectedNode.append(node[i])\n if ifSub == '1':\n if len(nonprotectedNode) > 0:\n for i in range(0, len(nonprotectedNode),1):\n if i != len(nonprotectedNode)-1:\n pinProtectedInit = pinProtectedInit + nodeDic[nonprotectedNode[i]] + ','\n else:\n pinProtectedInit = pinProtectedInit + nodeDic[nonprotectedNode[i]]\n if len(protectedNode) > 0:\n for i in range(0, len(protectedNode),1):\n if i != len(protectedNode)-1: \n pinInit = pinInit + nodeDic[protectedNode[i]] + ','\n else:\n pinInit = pinInit + nodeDic[protectedNode[i]]\n pinInit = pinInit + ';'\n pinProtectedInit = pinProtectedInit + ';'\n print \"Node---->\",node\n print \"nodeDic----->\",nodeDic\n print \"PinInit----->\",pinInit\n print \"pinProtectedinit--->\",pinProtectedInit\n return node, nodeDic, pinInit, pinProtectedInit","def __repr__(self):\n data = sorted(\n (state, pos, tape_cache, outputs)\n for pos, states in self.iteritems()\n for state, (tape_cache, outputs) in states.iteritems())\n branch = \"branch\" if len(data) == 1 else \"branches\"\n result = \"process (%s %s)\" % (len(data), branch)\n for s, sdata in itertools.groupby(data, lambda x: x[0]):\n result += \"\\n+ at state %s\" % (s,)\n for state, pos, tape_cache, outputs in sdata:\n result += \"\\n+-- %s, %s\" % (tape_cache, outputs)\n return result","def _vVBEL(self,vKNOT=None,edges=vVBEL_edges,edgesD=vVBEL_edgesD,mColNames=['OBJTYPE','pk'],mIdxNames=['OBJTYPE','OBJID']):\r\n\r\n logStr = \"{0:s}.{1:s}: \".format(self.__class__.__name__, sys._getframe().f_code.co_name)\r\n logger.debug(\"{0:s}{1:s}\".format(logStr,'Start.')) \r\n \r\n try: \r\n # construct \r\n vVBEL=None\r\n vVBEL_UnionList=[]\r\n\r\n for VBEL in edges:\r\n if VBEL in self.dataFrames:\r\n vXXXX=self._vVBEL_XXXX(vKNOT=vKNOT,OBJTYPE=VBEL)\r\n if vXXXX is None:\r\n pass\r\n else:\r\n vVBEL_UnionList.append(vXXXX)\r\n vVBEL=pd.concat(vVBEL_UnionList)\r\n\r\n # MIndices\r\n vVBEL=Xm.constructNewMultiindexFromCols(df=vVBEL,mColNames=mColNames,mIdxNames=mIdxNames)\r\n\r\n # Gruppenzugeh. ergaenzen\r\n vVBEL['LAYR']=[list() for dummy in vVBEL['tk']]\r\n dfLayr=self.dataFrames['vLAYR']\r\n if not dfLayr.empty:\r\n dfLayr=dfLayr.rename(columns={'OBJTYPE':'TYPE'}) \r\n dfLayr=pd.merge(\r\n vVBEL\r\n ,dfLayr\r\n ,how='inner' # nur die VBEL die eine Gruppenzugehoerigkeit haben\r\n ,left_index=True \r\n ,right_on=['TYPE','OBJID'] \r\n ,suffixes=('', '_y'))[['NAME','TYPE','OBJID','nrObjInGroup','nrObjtypeInGroup']]\r\n dfLayr=dfLayr[dfLayr.nrObjInGroup <= 1] # pro VBEL und Gruppe nur 1 Zeile\r\n\r\n for index, row in vVBEL.merge(dfLayr.sort_values(by=['NAME','OBJID']),how='left',left_index=True ,right_on=['TYPE','OBJID'],suffixes=('', '_y')).iterrows(): \r\n if pd.isnull(row.NAME):\r\n continue\r\n row.LAYR.append(row.NAME)\r\n\r\n # L ergaenzen\r\n Rohr=self.dataFrames['ROHR']\r\n VbelL=vVBEL.join(Rohr.set_index('pk').rename_axis('OBJID', axis='index'),rsuffix='_y')[['L']] \r\n vVBEL['L']=VbelL['L'].fillna(0) \r\n\r\n # D ergaenzen\r\n # Spalte erzeugen ... \r\n vRohr=self.dataFrames['vROHR']\r\n VbelD=vVBEL.join(vRohr.set_index('pk').rename_axis('OBJID', axis='index'),rsuffix='_y')[['DI']]\r\n vVBEL['D']=VbelD['DI'] # ... mit ROHR\r\n\r\n # ueber alle ausser ROHR\r\n for eIdx,edge in enumerate(edges):\r\n if edge == 'ROHR':\r\n continue\r\n edgeDCol=edgesD[eIdx]\r\n if edgeDCol=='':\r\n continue \r\n if edge not in self.dataFrames:\r\n continue\r\n Edge=self.dataFrames[edge] \r\n if edgeDCol not in Edge.columns.tolist():\r\n continue\r\n edgeD=vVBEL.join(Edge.set_index('pk').rename_axis('OBJID', axis='index'),rsuffix='_y',how='inner')[[edgeDCol]]\r\n vVBEL.loc[[edge],'D']=edgeD.loc[[edge],:].values\r\n\r\n\r\n # fehlende Spaltenwerte zuweisen\r\n #Vent=self.dataFrames['VENT']\r\n #VentD=vVBEL.join(Vent.set_index('pk'),rsuffix='_y',how='inner')[['DN']]\r\n #vVBEL.loc[['VENT'],'D']=VentD.loc[['VENT'],:].values\r\n\r\n # Finish\r\n vVBEL.sort_index(level=0,inplace=True)\r\n\r\n except Exception as e:\r\n logStrFinal=\"{:s}Exception: Line: {:d}: {!s:s}: {:s}\".format(logStr,sys.exc_info()[-1].tb_lineno,type(e),str(e))\r\n logger.debug(logStrFinal) \r\n finally:\r\n logger.debug(\"{0:s}{1:s}\".format(logStr,'_Done.'))\r\n return vVBEL","def apply_grub_cmdline(self):\n\n for i in self._nodes.items():\n node = i[1]\n\n # Get the isolated CPUs\n other_workers = node[\"cpu\"][\"other_workers\"]\n vpp_workers = node[\"cpu\"][\"vpp_workers\"]\n if \"vpp_main_core\" in node[\"cpu\"]:\n vpp_main_core = node[\"cpu\"][\"vpp_main_core\"]\n else:\n vpp_main_core = 0\n all_workers = []\n if other_workers is not None:\n all_workers = [other_workers]\n if vpp_main_core != 0:\n all_workers += [(vpp_main_core, vpp_main_core)]\n all_workers += vpp_workers\n isolated_cpus = \"\"\n for idx, worker in enumerate(all_workers):\n if worker is None:\n continue\n if idx > 0:\n isolated_cpus += \",\"\n if worker[0] == worker[1]:\n isolated_cpus += \"{}\".format(worker[0])\n else:\n isolated_cpus += \"{}-{}\".format(worker[0], worker[1])\n\n vppgrb = VppGrubUtil(node)\n current_cmdline = vppgrb.get_current_cmdline()\n if \"grub\" not in node:\n node[\"grub\"] = {}\n node[\"grub\"][\"current_cmdline\"] = current_cmdline\n node[\"grub\"][\"default_cmdline\"] = vppgrb.apply_cmdline(node, isolated_cpus)\n\n self.updateconfig()"],"string":"[\n \"def chainDict2jetLabel(chain_dict):\\n\\n # suported scenarios \\n router = {\\n 'simple': _make_simple_label,\\n 'HT': _make_ht_label,\\n 'vbenf': _make_vbenf_label,\\n 'dijet': _make_dijet_label,\\n 'combinationsTest': _make_combinationsTest_label,\\n 'partitionsTest': _make_partitionsTest_label,\\n }\\n\\n # chain_part - scenario association\\n cp_sorter = {}\\n for k in router: cp_sorter[k] = []\\n\\n for cp in chain_dict['chainParts']:\\n if cp['signature'] != 'Jet' and cp['signature'] != 'Bjet': \\n continue\\n for k in cp_sorter:\\n if cp['hypoScenario'].startswith(k):\\n cp_sorter[k].append(cp)\\n break\\n\\n # obtain labels by scenario.\\n labels = []\\n for k, chain_parts in cp_sorter.items():\\n if chain_parts: labels.append(router[k](chain_parts))\\n\\n assert labels\\n nlabels = len(labels)\\n if nlabels == 1: return labels[0]\\n if nlabels == 2:\\n alabel = \\\"\\\"\\\"\\\\\\nand([]\\n %s\\n %s)\\\"\\\"\\\" % (tuple(labels))\\n return alabel\\n\\n # more than 2 labels is not expected\\n assert False\",\n \"def _make_partitionsTest_label(chain_parts):\\n\\n assert len(chain_parts) == 1\\n scenario = chain_parts[0]['hypoScenario']\\n \\n assert scenario == 'partitionsTest'\\n\\n \\n\\n return \\\"\\\"\\\"\\n partgen(\\n [(20et, 0eta320)]\\n \\n simple([(40et, 0eta320) (50et, 0eta320)])\\n simple([(35et, 0eta240) (55et, 0eta240)])\\n )\\\"\\\"\\\"\",\n \"def _make_simple_label(chain_parts):\\n \\n if not _select_simple_chainparts(chain_parts):\\n msg = 'Jet Configuration error: '\\\\\\n 'chain fails substring selection: not \\\"simple\\\" '\\n\\n raise NotImplementedError(msg)\\n \\n label = 'simple(['\\n for cp in chain_parts:\\n smcstr = str(cp['smc'])\\n jvtstr = str(cp['jvt'])\\n if smcstr == 'nosmc':\\n smcstr = ''\\n for i in range(int(cp['multiplicity'])):\\n # condition_str = '(%set,%s,%s)' % (str(cp['threshold']),\\n # str(cp['etaRange']),\\n # smcstr,)\\n condition_str = '(%set,%s' % (str(cp['threshold']),\\n str(cp['etaRange']),)\\n if smcstr: # Run 2 chains have \\\"INF\\\" in the SMC substring\\n condition_str += ',%s)' % smcstr.replace('INF','')\\n elif jvtstr:\\n condition_str += ',%s)' % jvtstr\\n else:\\n condition_str += ')'\\n label += condition_str\\n label += '])'\\n return label\",\n \"def _make_simple_partition_label(chain_dict):\\n\\n cps = chain_dict['chainParts']\\n if not (_select_simple_chainparts(cps)):\\n raise NotImplementedError(\\n 'chain fails substring selection: not \\\"simple\\\": %s' % (\\n chain_dict['chainName']))\\n \\n label = 'simplepartition(['\\n for cp in cps:\\n smcstr = str(cp['smc'])\\n if smcstr == 'nosmc':\\n smcstr = ''\\n for i in range(int(cp['multiplicity'])):\\n # condition_str = '(%set,%s,%s)' % (str(cp['threshold']),\\n # str(cp['etaRange']),\\n # smcstr,)\\n condition_str = '(%set,%s' % (str(cp['threshold']),\\n str(cp['etaRange']),)\\n if smcstr:\\n condition_str += ',%s)'\\n else:\\n condition_str += ')'\\n label += condition_str\\n label += '])'\\n return label\",\n \"def _text_write_preprocess(self):\\n self.check()\\n\\n max_name_len = np.max([len(name) for name in self.name])\\n fieldtypes = [\\\"U\\\" + str(max_name_len), \\\"f8\\\", \\\"f8\\\"]\\n comp_names = self._get_lon_lat_component_names()\\n frame_obj = self._get_frame_obj()\\n frame_desc_str = _get_frame_desc_str(frame_obj)\\n\\n component_fieldnames = []\\n for comp_name in comp_names:\\n # This will add e.g. ra_J2000 and dec_J2000 for FK5\\n component_fieldnames.append(comp_name + \\\"_\\\" + frame_desc_str)\\n fieldnames = [\\\"source_id\\\"] + component_fieldnames\\n stokes_names = [\\\"I\\\", \\\"Q\\\", \\\"U\\\", \\\"V\\\"]\\n fieldshapes = [()] * 3\\n\\n if self.stokes_error is not None:\\n stokes_error_names = [(f\\\"{k}_error\\\") for k in [\\\"I\\\", \\\"Q\\\", \\\"U\\\", \\\"V\\\"]]\\n\\n n_stokes = 0\\n stokes_keep = []\\n for si, total in enumerate(np.nansum(self.stokes.to(\\\"Jy\\\"), axis=(1, 2))):\\n if total > 0:\\n fieldnames.append(stokes_names[si])\\n fieldshapes.append((self.Nfreqs,))\\n fieldtypes.append(\\\"f8\\\")\\n if self.stokes_error is not None:\\n fieldnames.append(stokes_error_names[si])\\n fieldshapes.append((self.Nfreqs,))\\n fieldtypes.append(\\\"f8\\\")\\n n_stokes += 1\\n stokes_keep.append(total > 0)\\n\\n assert n_stokes >= 1, \\\"No components with nonzero flux.\\\"\\n\\n if self.freq_array is not None:\\n if self.spectral_type == \\\"subband\\\":\\n fieldnames.append(\\\"subband_frequency\\\")\\n else:\\n fieldnames.append(\\\"frequency\\\")\\n fieldtypes.append(\\\"f8\\\")\\n fieldshapes.extend([(self.Nfreqs,)])\\n elif self.reference_frequency is not None:\\n fieldnames.extend([(\\\"reference_frequency\\\")])\\n fieldtypes.extend([\\\"f8\\\"])\\n fieldshapes.extend([()] * n_stokes + [()])\\n if self.spectral_index is not None:\\n fieldnames.append(\\\"spectral_index\\\")\\n fieldtypes.append(\\\"f8\\\")\\n fieldshapes.append(())\\n\\n if hasattr(self, \\\"_rise_lst\\\"):\\n fieldnames.append(\\\"rise_lst\\\")\\n fieldtypes.append(\\\"f8\\\")\\n fieldshapes.append(())\\n\\n if hasattr(self, \\\"_set_lst\\\"):\\n fieldnames.append(\\\"set_lst\\\")\\n fieldtypes.append(\\\"f8\\\")\\n fieldshapes.append(())\\n\\n dt = np.dtype(list(zip(fieldnames, fieldtypes, fieldshapes)))\\n\\n arr = np.empty(self.Ncomponents, dtype=dt)\\n arr[\\\"source_id\\\"] = self.name\\n\\n for comp_ind, comp in enumerate(comp_names):\\n arr[component_fieldnames[comp_ind]] = getattr(self.skycoord, comp).deg\\n\\n for ii in range(4):\\n if stokes_keep[ii]:\\n arr[stokes_names[ii]] = self.stokes[ii].T.to(\\\"Jy\\\").value\\n if self.stokes_error is not None:\\n arr[stokes_error_names[ii]] = self.stokes_error[ii].T.to(\\\"Jy\\\").value\\n\\n if self.freq_array is not None:\\n if self.spectral_type == \\\"subband\\\":\\n arr[\\\"subband_frequency\\\"] = self.freq_array.to(\\\"Hz\\\").value\\n else:\\n arr[\\\"frequency\\\"] = self.freq_array.to(\\\"Hz\\\").value\\n elif self.reference_frequency is not None:\\n arr[\\\"reference_frequency\\\"] = self.reference_frequency.to(\\\"Hz\\\").value\\n if self.spectral_index is not None:\\n arr[\\\"spectral_index\\\"] = self.spectral_index\\n\\n if hasattr(self, \\\"_rise_lst\\\"):\\n arr[\\\"rise_lst\\\"] = self._rise_lst\\n if hasattr(self, \\\"_set_lst\\\"):\\n arr[\\\"set_lst\\\"] = self._set_lst\\n\\n return arr\",\n \"def _body(self, x, ensembled_batch, non_ensembled_batch, idx):\\n i, current_representations = x\\n del x\\n feats = self._slice_batch(i, ensembled_batch, non_ensembled_batch)\\n representations_update = self.evoformer(*self.batch_expand(feats))\\n new_representations = {}\\n for k in current_representations:\\n new_representations[k] = (\\n current_representations[k] + representations_update[k])\\n del representations_update\\n return i+1, new_representations\",\n \"def get_mapped_feature_name(self):\\n\\n # open a h5 file in case we need it\\n f5 = h5py.File(self.train_database[0], 'r')\\n mol_name = list(f5.keys())[0]\\n mapped_data = f5.get(mol_name + '/mapped_features/')\\n chain_tags = ['_chain1', '_chain2']\\n\\n # if we select all the features\\n if self.select_feature == \\\"all\\\":\\n\\n # redefine dict\\n self.select_feature = {}\\n\\n # loop over the feat types and add all the feat_names\\n for feat_type, feat_names in mapped_data.items():\\n self.select_feature[feat_type] = [\\n name for name in feat_names]\\n\\n # if a selection was made\\n else:\\n\\n # we loop over the input dict\\n for feat_type, feat_names in self.select_feature.items():\\n\\n # if for a given type we need all the feature\\n if feat_names == 'all':\\n if feat_type in mapped_data:\\n self.select_feature[feat_type] = list(\\n mapped_data[feat_type].keys())\\n else:\\n self.print_possible_features()\\n raise KeyError('Feature type %s not found')\\n\\n # if we have stored the individual\\n # chainA chainB data we need to expand the feature list\\n # however when we reload a pretrained model we already\\n # come with _chainA, _chainB features.\\n # So then we shouldn't add the tags\\n else:\\n # TODO to refactor this part\\n if feat_type not in mapped_data:\\n self.print_possible_features()\\n raise KeyError('Feature type %s not found')\\n\\n self.select_feature[feat_type] = []\\n\\n # loop over all the specified feature names\\n for name in feat_names:\\n\\n # check if there is not _chainA or _chainB in the name\\n cond = [tag not in name for tag in chain_tags]\\n\\n # if there is no chain tag in the name\\n if np.all(cond):\\n\\n # if we have a wild card e.g. PSSM_*\\n # we check the matches and add them\\n if '*' in name:\\n match = name.split('*')[0]\\n possible_names = list(\\n mapped_data[feat_type].keys())\\n match_names = [\\n n for n in possible_names\\n if n.startswith(match)]\\n self.select_feature[feat_type] += match_names\\n\\n # if we don't have a wild card we append\\n # <feature_name>_chainA and <feature_name>_chainB\\n # to the list\\n else:\\n self.select_feature[feat_type] += [\\n name + tag for tag in chain_tags]\\n # if there is a chain tag in the name\\n # (we probably relaod a pretrained model)\\n # and we simply append the feaature name\\n else:\\n self.select_feature[feat_type].append(\\n name)\\n\\n f5.close()\",\n \"def DecodeStage():\\n\\n io = Io({\\n 'if_id': Input(if_bundle),\\n 'inst': Input(Bits(32)),\\n 'stall': Input(Bits(1)),\\n 'reg_write': Input(reg_write_bundle),\\n 'ras_ctrl': Output(ras_ctrl_bundle),\\n 'id_ex': Output(id_ex_bundle),\\n 'rs1_data': Output(Bits(C['core-width'])),\\n 'rs2_data': Output(Bits(C['core-width'])),\\n })\\n\\n inst = Wire(Bits(32))\\n\\n with io.if_id.valid:\\n inst <<= io.inst\\n with otherwise:\\n inst <<= 0\\n\\n regfile = Instance(RegisterFile())\\n\\n itype = Wire(Bits(ITypes.bitwidth))\\n\\n regfile.r0_addr <<= Rs1(inst)\\n regfile.r0_en <<= ~io.stall\\n regfile.r1_addr <<= Rs2(inst)\\n regfile.r1_en <<= ~io.stall\\n\\n regfile.w0_addr <<= io.reg_write.w_addr\\n regfile.w0_en <<= io.reg_write.w_en & ~io.stall\\n regfile.w0_data <<= io.reg_write.w_data\\n\\n #\\n # inst_data is metadata about the current instruction that is passed through\\n # the pipeline unrelated to control signals. It's primary use is for hazard\\n # detection and data forwarding.\\n #\\n\\n io.id_ex.ctrl.valid <<= io.if_id.valid\\n io.id_ex.ctrl.inst <<= inst\\n io.id_ex.ctrl.pc <<= io.if_id.pc\\n\\n #\\n # Hook up the register read outputs.\\n #\\n\\n io.rs1_data <<= regfile.r0_data\\n io.rs2_data <<= regfile.r1_data\\n\\n #\\n # Control is a Python function that produces the primary decode logic. It\\n # matches against a set of known instructions to produce control signals for\\n # later stages in the pipeline. The known instructions are encoded in the\\n # 'instructions' variable above.\\n #\\n\\n Control(inst, itype, io.id_ex.ctrl)\\n\\n #\\n # TODO: Documentation\\n #\\n\\n HandleRasCtrl(io.ras_ctrl, inst, io.if_id.pc)\\n\\n #\\n # GenerateImmediate produces logic that consume the itype (instruction\\n # type, which is R, I, S, B, U, or J) and produces the immediate value for\\n # this instruction.\\n #\\n\\n io.id_ex.imm <<= GenerateImmediate(inst, itype)\\n\\n NameSignals(locals())\",\n \"def _make_dijet_label(chain_parts):\\n\\n assert len(chain_parts) == 1\\n scenario = chain_parts[0]['hypoScenario']\\n \\n assert scenario.startswith('dijet')\\n\\n arg_res = [\\n re.compile(r'^(?P<lo>\\\\d*)(?P<key>djmass)(?P<hi>\\\\d*)$'),\\n re.compile(r'^(?P<lo>\\\\d*)(?P<key>j1et)(?P<hi>\\\\d*)$'),\\n re.compile(r'^(?P<lo>\\\\d*)(?P<key>j1eta)(?P<hi>\\\\d*)$'),\\n re.compile(r'^(?P<lo>\\\\d*)(?P<key>j2et)(?P<hi>\\\\d*)$'),\\n re.compile(r'^(?P<lo>\\\\d*)(?P<key>j2eta)(?P<hi>\\\\d*)$'),\\n ]\\n\\n defaults = {\\n 'j1et': ('100', 'inf'),\\n 'j2et': ('100', 'inf'),\\n 'j1eta': ('0', '320'),\\n 'j2eta': ('0', '320'),\\n 'djmass': ('1000', 'inf'),\\n }\\n\\n\\n args = _args_from_scenario(scenario)\\n argvals = {}\\n while args:\\n assert len(args) == len(arg_res)\\n arg = args.pop()\\n for r in arg_res:\\n m = r.match(arg)\\n if m is not None:\\n arg_res.remove(r)\\n gd = m.groupdict()\\n key = gd['key']\\n\\n try:\\n lo = float(gd['lo'])\\n except ValueError:\\n lo = defaults[key][0]\\n argvals[key+'lo'] = lo \\n try:\\n hi = float(gd['hi'])\\n except ValueError:\\n hi = defaults[key][1]\\n argvals[key+'hi'] = hi\\n\\n assert len(args) == len(arg_res)\\n assert len(args) == 0\\n\\n return \\\"\\\"\\\"\\n combgen(\\n [(2)(%(j1etlo).0fet, %(j1etalo).0feta%(j1etahi).0f)\\n (%(j1etlo).0fet, %(j1etalo).0feta%(j1etahi).0f)\\n ]\\n \\n dijet(\\n [(%(djmasslo).0fdjmass)])\\n simple([(%(j1etlo).0fet, %(j1etalo).0feta%(j1etahi).0f)\\n (%(j2etlo).0fet, %(j2etalo).0feta%(j2etahi).0f)])\\n )\\\"\\\"\\\" % argvals\",\n \"def _indentity_block(self, X, filters, f, stage, block):\\n\\t\\tconv_layer_name = 'res' + str(stage) + block + '_branch'\\n\\t\\tbn_layer_name = 'bm' + str(stage) + block + '_branch'\\n\\n\\t\\tX_shortcut = X\\n\\n\\t\\tF1, F2, F3 = filters\\n\\n\\t\\t# First component of main path\\n\\t\\tX = Conv2D(filters = F1, kernel_size = (1, 1), strides = (1, 1), padding = 'valid',\\n\\t\\t\\tname = conv_layer_name + '2a', kernel_initializer = glorot_uniform(seed=0))(X)\\n\\t\\tX = BatchNormalization(axis = 3, name = bn_layer_name + '2a')(X)\\n\\t\\tX = Activation('relu')(X)\\n\\n\\t\\t# Second component of main path\\n\\t\\tX = Conv2D(filters = F2, kernel_size = (1, 1), strides = (1, 1), padding = 'same',\\n\\t\\t\\tname = conv_layer_name + '2b', kernel_initializer = glorot_uniform(seed=0))(X)\\n\\t\\tX = BatchNormalization(axis = 3, name = bn_layer_name + '2b')(X)\\n\\t\\tX = Activation('relu')(X)\\n\\n\\t\\t# Third component of main path\\n\\t\\tX = Conv2D(filters = F3, kernel_size = (1, 1), strides = (1, 1), padding = 'valid',\\n\\t\\t\\tname = conv_layer_name + '2c', kernel_initializer = glorot_uniform(seed=0))(X)\\n\\t\\tX = BatchNormalization(axis = 3, name = bn_layer_name + '2c')(X)\\n\\n\\t\\t# Final step : adding the shortcut componet to X and applying 'relu' activation on the combination \\n\\t\\tX = Add()([X_shortcut,X])\\n\\t\\tX = Activation('relu')(X)\\n\\n\\t\\treturn X\",\n \"def output_fluent(fil,nodes,elems):\\n print \\\"Nodal coordinates\\\"\\n print nodes\\n print \\\"Element connectivity\\\"\\n print elems\\n faces = array(Tet4.faces) # Turning faces into an array is important !\\n print \\\"Tetraeder faces\\\"\\n print faces\\n elf = elems.take(faces,axis=1)\\n # Remark: the shorter syntax elems[faces] takes its elements along the\\n # axis 0. Then we would need to transpose() first (and probably\\n # swap axes again later)\\n print \\\"The faces of the elements:\\\"\\n print elf\\n # We need a copy to sort the nodes (sorting is done in-place)\\n elfs = elf.copy()\\n elfs.sort(axis=2) \\n print \\\"The faces with sorted nodes:\\\"\\n print elfs\\n magic = elems.max()+1\\n print \\\"Magic number = %d\\\" % magic\\n code = encode(elfs[:,:,0],elfs[:,:,1],elfs[:,:,2],magic)\\n # Remark how nice the encode function works on the whole array\\n print \\\"Encoded faces:\\\"\\n print code\\n code = code.ravel()\\n print code\\n print \\\"Just A Check:\\\"\\n print \\\"Element 5 face 2 is %s \\\" % elf[5,2]\\n print \\\"Element 5 face 2 is %s \\\" % list(decode(code[4*5+2],magic))\\n srt = code.argsort()\\n print srt\\n print code[srt]\\n # Now shipout the faces in this order, removing the doubles\\n j = -1 \\n for i in srt:\\n if j < 0: # no predecessor (or predecessor already shipped)\\n j = i\\n else:\\n e1,f1 = j/4, j%4\\n if code[i] == code[j]:\\n e2,f2 = i/4, i%4\\n j = -1\\n else:\\n e2 = -1\\n j = i\\n print \\\"Face %s belongs to el %s and el %s\\\" % ( elf[e1,f1], e2, e1 )\",\n \"def pre_pipeline(self, results):\\n results[\\\"img_prefix\\\"] = self.img_prefix\\n results[\\\"seg_prefix\\\"] = self.seg_prefix\\n results[\\\"proposal_file\\\"] = self.proposal_file\\n results[\\\"bbox_fields\\\"] = []\\n results[\\\"mask_fields\\\"] = []\\n results[\\\"seg_fields\\\"] = []\\n results[\\\"site_fields\\\"] = []\\n results[\\\"label_fields\\\"] = []\",\n \"def build_head(self):\\n stages = [f'stage{i}' for i in range(1, 7)]\\n for stage in stages:\\n block = getattr(self.arch, stage)\\n PAF, CFM = block.keys()\\n PAF = build_blocks(block[PAF], 'head')\\n CFM = build_blocks(block[CFM], 'head')\\n setattr(self, f\\\"{stage}_PAF\\\", PAF)\\n setattr(self, f\\\"{stage}_CFM\\\", CFM)\",\n \"def _make_combinationsTest_label(chain_parts):\\n\\n assert len(chain_parts) == 1\\n scenario = chain_parts[0]['hypoScenario']\\n \\n assert scenario == 'combinationsTest'\\n\\n \\n\\n return \\\"\\\"\\\"\\n combgen(\\n [(2)(20et, 0eta320)]\\n \\n simple([(40et, 0eta320) (50et, 0eta320)])\\n simple([(35et, 0eta240) (55et, 0eta240)])\\n )\\\"\\\"\\\"\",\n \"def _make_simple_comb_label(chain_dict):\\n\\n cps = chain_dict['chainParts']\\n if not (_select_simple_chainparts(cps)):\\n raise NotImplementedError(\\n 'chain fails substring selection: not \\\"simple\\\": %s' % (\\n chain_dict['chainName']))\\n \\n simple_strs = []\\n\\n for cp in cps:\\n print(cp)\\n simple_strs.append(_make_simple_label([cp]))\\n\\n label = 'combgen([(%d)]' % len(cps)\\n for s in simple_strs:\\n label += ' %s ' % s\\n label += ')'\\n return label\",\n \"def generate_code(self, parts: list):\\n for i in range(len(parts)):\\n\\n if not self._involves_this_party(parts[i][0]):\\n # not our data, skip job\\n continue\\n\\n if parts[i][1] == \\\"python\\\":\\n cg = PythonCodeGen(\\n self.config,\\n parts[i][0],\\n f\\\"{self.config.system_configs['CODEGEN'].workflow_name}-python-job-{i}\\\"\\n )\\n cg.generate()\\n elif parts[i][1] == \\\"jiff\\\":\\n cg = JiffCodeGen(\\n self.config,\\n parts[i][0],\\n f\\\"{self.config.system_configs['CODEGEN'].workflow_name}-jiff-job-{i}\\\"\\n )\\n cg.generate()\\n else:\\n raise Exception(f\\\"Unrecognized backend from partition: {parts[i][1]}.\\\")\",\n \"def __call__(self, blocks, with_cab=False):\\n\\n # for k, v in blocks.items():\\n # print(k, v.shape)\\n\\n #down fpn\\n f_down = self.FPN_Down_Fusion(blocks)\\n # print(\\\"f_down shape: {}\\\".format(f_down.shape))\\n #up fpn\\n f_up = self.FPN_Up_Fusion(blocks)\\n # print(\\\"f_up shape: {}\\\".format(f_up.shape))\\n #fusion\\n f_common = fluid.layers.elementwise_add(x=f_down, y=f_up)\\n f_common = fluid.layers.relu(f_common)\\n # print(\\\"f_common: {}\\\".format(f_common.shape))\\n\\n if self.with_cab:\\n # print('enhence f_common with CAB.')\\n f_common = self.cross_attention(f_common)\\n\\n f_score, f_border = self.SAST_Header1(f_common)\\n f_tvo, f_tco = self.SAST_Header2(f_common)\\n\\n predicts = OrderedDict()\\n predicts['f_score'] = f_score\\n predicts['f_border'] = f_border\\n predicts['f_tvo'] = f_tvo\\n predicts['f_tco'] = f_tco\\n return predicts\",\n \"def __call__(self, node):\\n\\n # should throw an error\\n if node.cfgInterface == None:\\n return\\n\\n # //\\n # // Extract LFN base from included WorkflowSpec parameters\\n #//\\n if self.unmerged:\\n base = node.getParameter(\\\"UnmergedLFNBase\\\")[0]\\n else:\\n base = node.getParameter(\\\"MergedLFNBase\\\")[0]\\n mergedBase = node.getParameter(\\\"MergedLFNBase\\\")[0]\\n\\n acqEra=None\\n if node.hasParameter(\\\"AcquisitionEra\\\"):\\n acqEra = node.getParameter(\\\"AcquisitionEra\\\")[0]\\n\\n\\n # //\\n # // iterate over outputmodules/data tiers\\n #// Generate LFN, PFN and Catalog for each module\\n\\n for modName, outModule in node.cfgInterface.outputModules.items():\\n\\n if ( not outModule.has_key('fileName') ):\\n msg = \\\"OutputModule %s does not contain a fileName entry\\\" % modName\\n raise RuntimeError, msg\\n\\n preserveLfnGroup = str(self.lfnGroup)\\n lastBit = outModule['processedDataset']\\n # //\\n # // Skip if the file does not stage out. (i.e.\\n #// --stageout-intermediates=False)\\n if lastBit is None:\\n msg = \\\"OutputModule does not stage out. Skipping.\\\"\\n logging.debug(msg)\\n continue\\n # //but this guy has the AcquisitionEra at the beginning... delimited\\n # // by a dash... we don't need it twice... we try to safely\\n #// remove it from the beginning, basically punting if its not\\n #\\\\\\\\ disadvantage of getting this from the ds name is having to\\n # \\\\\\\\ then strip off -unmerged\\n if acqEra is not None:\\n thingtoStrip=\\\"%s-\\\" % acqEra\\n mypieces = lastBit.split(thingtoStrip, 1)\\n if len(mypieces) > 1: \\n lastBit = mypieces[1]\\n remainingBits = lastBit.split(\\\"-unmerged\\\", 1)[0]\\n \\n outModule['LFNBase'] = os.path.join(base,\\n outModule['primaryDataset'],\\n outModule['dataTier'],\\n remainingBits,\\n preserveLfnGroup)\\n outModule['MergedLFNBase'] = os.path.join(mergedBase,\\n outModule['primaryDataset'],\\n outModule['dataTier'],\\n remainingBits,\\n preserveLfnGroup)\\n\\n return\",\n \"def build_stage2_6(self):\\n paf, cfm = self.stage2_6.values()\\n for i in range(2, 7):\\n paf_ = OrderedDict([(k.replace('i', str(i)),paf[k]) for k in paf])\\n cfm_ = OrderedDict([(k.replace('i', str(i)),cfm[k]) for k in cfm])\\n stage_ = OrderedDict(PAF=paf_, CFM=cfm_)\\n setattr(self, f'stage{i}', stage_)\",\n \"def slice_graph_bwd( endea, reg ): \\r\\n\\tgraph = vcg_Graph.vcgGraph({\\\"title\\\":'\\\"Slice for %s\\\"' % reg, \\\\\\r\\n\\t\\t\\\"manhattan_edges\\\":\\\"no\\\", \\\"layoutalgorithm\\\":\\\"maxdepth\\\"})\\r\\n\\t#\\r\\n\\t# Retrieve the name of the current basic block\\r\\n\\t# \\r\\n\\tworklist = []\\r\\n\\tdata_bib = {}\\r\\n\\t\\r\\n\\tstartnode = slice_node( 0, endea, reg )\\t\\t# start at the end of the slice node\\r\\n\\trootnode = graph.Add_Node( startnode.to_name() )\\r\\n\\tdata_bib[ startnode.to_name() ] = startnode\\r\\n\\tworklist.insert( 0, rootnode )\\r\\n\\twhile len( worklist ) > 0:\\r\\n\\t\\tcurrnode = worklist.pop()\\r\\n\\t\\tcurrslice = data_bib[ currnode.get_name() ]\\r\\n\\t\\t[tgt_reg, split] = currslice.get_target_reg_bwd()\\r\\n\\t\\tprint tgt_reg\\r\\n\\t\\tprint split\\r\\n\\t\\tif tgt_reg == \\\"END\\\":\\r\\n\\t\\t\\t# Do not process this node any further\\r\\n\\t\\t\\tpass\\r\\n\\t\\telif tgt_reg == \\\"\\\" or (( len( currslice.get_lines()) > 0) and \\\\\\r\\n\\t\\t\\tcurrslice.startea != currslice.get_lines()[0][0]):\\r\\n\\t\\t\\t# Do process this node further, nothing really going on \\r\\n\\t\\t\\tprint \\\"ZEZ\\\"\\r\\n\\t\\t\\txrefs = get_crefs_to( currslice.startea )\\r\\n\\t\\t\\tfor ref in xrefs:\\r\\n\\t\\t\\t\\tnewslice = slice_node( 0,ref, currslice.reg )\\r\\n\\t\\t\\t\\tif graph.Get_Node( newslice.to_name() ) == 0:\\r\\n\\t\\t\\t\\t\\tnewnode = graph.Add_Node( newslice.to_name() )\\r\\n\\t\\t\\t\\t\\tworklist.insert( 0, newnode )\\r\\n\\t\\t\\t\\t\\tdata_bib[ newslice.to_name() ] = newslice\\r\\n\\t\\t\\t\\tgraph.Add_Link( newslice.to_name(), currnode.get_name() )\\r\\n\\t\\telse:\\r\\n\\t\\t\\txrefs = get_crefs_to( currslice.startea )\\r\\n\\t\\t\\tfor ref in xrefs:\\r\\n\\t\\t\\t\\tnewslice = slice_node( 0,ref, tgt_reg )\\r\\n\\t\\t\\t\\tif graph.Get_Node( newslice.to_name() ) == 0:\\r\\n\\t\\t\\t\\t\\tnewnode = graph.Add_Node( newslice.to_name() )\\r\\n\\t\\t\\t\\t\\tworklist.insert( 0, newnode )\\r\\n\\t\\t\\t\\t\\tdata_bib[ newslice.to_name() ] = newslice\\r\\n\\t\\t\\t\\tgraph.Add_Link( newslice.to_name(), currnode.get_name())\\r\\n\\t\\t\\txrefs = get_crefs_to( currslice.startea )\\r\\n\\t\\t\\tif split:\\r\\n\\t\\t\\t\\tfor ref in xrefs:\\r\\n\\t\\t\\t\\t\\tnewslice = slice_node( 0,ref, currslice.reg )\\r\\n\\t\\t\\t\\t\\tif graph.Get_Node( newslice.to_name() ) == 0:\\r\\n\\t\\t\\t\\t\\t\\tnewnode = graph.Add_Node( newslice.to_name() )\\r\\n\\t\\t\\t\\t\\t\\tworklist.insert( 0, newnode )\\r\\n\\t\\t\\t\\t\\t\\tdata_bib[ newslice.to_name() ] = newslice\\r\\n\\t\\t\\t\\t\\tgraph.Add_Link( newslice.to_name(), currnode.get_name())\\r\\n\\treturn [ graph, data_bib ]\",\n \"def identity_block(self,X, f, filters, stage, block):\\n # define name basis\\n conv_name_base = 'res' + str(stage) + block + '_branch'\\n bn_name_base = 'bn' + str(stage) + block + '_branch'\\n\\n # Retrieve filters\\n f1,f2,f3 = filters\\n\\n # Save the input value. This needs to be added back to the main path later.\\n X_shortcut = X\\n\\n # First component of the main path\\n X = Conv2D(filters= f1, kernel_size=(1,1), strides=(1,1), padding='valid', name=conv_name_base + '2a', kernel_initializer=glorot_uniform(seed=0))(X)\\n X = BatchNormalization(axis=3, name=bn_name_base + '2a')(X)\\n X = Activation('relu')(X)\\n\\n # Second component of the main path\\n X = Conv2D(filters= f2, kernel_size=(f,f), strides=(1,1), padding='same', name=conv_name_base + '2b', kernel_initializer=glorot_uniform(seed=0))(X)\\n X = BatchNormalization(axis=3, name=bn_name_base + '2b')(X)\\n X = Activation('relu')(X)\\n\\n # Third component of the main path\\n X = Conv2D(filters= f3, kernel_size=(1,1), strides=(1,1), padding='valid', name=conv_name_base + '2c', kernel_initializer=glorot_uniform(seed=0))(X)\\n X = BatchNormalization(axis=3, name=bn_name_base + '2c')(X)\\n\\n # Add the shortcut value to the main path\\n X = Add()([X_shortcut, X])\\n X = Activation('relu')(X) \\n\\n return X\",\n \"def onBuildModels(self):\\n if self.refSeriesNumber != '-1':\\n ref = self.refSeriesNumber\\n refLongName = self.seriesMap[ref]['LongName']\\n labelNodes = slicer.util.getNodes('*'+refLongName+'*-label*')\\n\\n numNodes = slicer.mrmlScene.GetNumberOfNodesByClass( \\\"vtkMRMLModelHierarchyNode\\\" )\\n outHierarchy = None\\n\\n for n in xrange(numNodes):\\n node = slicer.mrmlScene.GetNthNodeByClass( n, \\\"vtkMRMLModelHierarchyNode\\\" )\\n if node.GetName() == 'mpReview-'+refLongName:\\n outHierarchy = node\\n break\\n\\n # Remove the previous models\\n if outHierarchy:\\n collection = vtk.vtkCollection()\\n outHierarchy.GetChildrenModelNodes(collection)\\n n = collection.GetNumberOfItems()\\n if n != 0:\\n for i in xrange(n):\\n modelNode = collection.GetItemAsObject(i)\\n slicer.mrmlScene.RemoveNode(modelNode)\\n\\n # if models hierarchy does not exist, create it.\\n else:\\n outHierarchy = slicer.vtkMRMLModelHierarchyNode()\\n outHierarchy.SetScene( slicer.mrmlScene )\\n outHierarchy.SetName( 'mpReview-'+refLongName )\\n slicer.mrmlScene.AddNode( outHierarchy )\\n\\n progress = self.makeProgressIndicator(len(labelNodes))\\n step = 0\\n for label in labelNodes.values():\\n labelName = label.GetName().split(':')[1]\\n structureName = labelName[labelName[:-6].rfind(\\\"-\\\")+1:-6]\\n # Only save labels with known structure names\\n if any(structureName in s for s in self.structureNames):\\n parameters = {}\\n parameters[\\\"InputVolume\\\"] = label.GetID()\\n parameters['FilterType'] = \\\"Sinc\\\"\\n parameters['GenerateAll'] = True\\n\\n parameters[\\\"JointSmoothing\\\"] = False\\n parameters[\\\"SplitNormals\\\"] = True\\n parameters[\\\"PointNormals\\\"] = True\\n parameters[\\\"SkipUnNamed\\\"] = True\\n\\n # create models for all labels\\n parameters[\\\"StartLabel\\\"] = -1\\n parameters[\\\"EndLabel\\\"] = -1\\n\\n parameters[\\\"Decimate\\\"] = 0\\n parameters[\\\"Smooth\\\"] = 0\\n\\n parameters[\\\"ModelSceneFile\\\"] = outHierarchy\\n\\n progress.labelText = '\\\\nMaking Model for %s' % structureName\\n progress.setValue(step)\\n if progress.wasCanceled:\\n break\\n\\n try:\\n modelMaker = slicer.modules.modelmaker\\n self.CLINode = slicer.cli.run(modelMaker, self.CLINode,\\n parameters, wait_for_completion=True)\\n except AttributeError:\\n qt.QMessageBox.critical(slicer.util.mainWindow(),'Editor', 'The ModelMaker module is not available<p>Perhaps it was disabled in the application settings or did not load correctly.')\\n step += 1\\n progress.close()\\n #\\n\\n if outHierarchy:\\n collection = vtk.vtkCollection()\\n outHierarchy.GetChildrenModelNodes(collection)\\n n = collection.GetNumberOfItems()\\n if n != 0:\\n for i in xrange(n):\\n modelNode = collection.GetItemAsObject(i)\\n displayNode = modelNode.GetDisplayNode()\\n displayNode.SetSliceIntersectionVisibility(1)\\n displayNode.SetSliceIntersectionThickness(2)\\n self.modelsVisibilityButton.checked = False\\n self.updateViewRenderer()\",\n \"def make_label_data(self):\\n from xml.etree.ElementTree import Element, SubElement, dump, ElementTree, parse\\n\\n if not self.graphicsView.hasImage():\\n self.showImageSelectionMessageBox()\\n return\\n\\n app_doc_data = AppDocData.instance()\\n project = app_doc_data.getCurrentProject()\\n\\n smalls = []\\n bigs = []\\n\\n symbol_list = app_doc_data.getTargetSymbolList(all=True)\\n for symbol in symbol_list:\\n if symbol.width and symbol.height:\\n if symbol.width > 300 or symbol.height > 300:\\n bigs.append(symbol.getName())\\n else:\\n smalls.append(symbol.getName())\\n\\n symbols = [item for item in self.graphicsView.scene().items() if issubclass(type(item), SymbolSvgItem)]\\n names = [smalls, bigs]\\n\\n img = app_doc_data.activeDrawing.image_origin\\n\\n small_size = 500\\n big_size = 850\\n\\n save_path = project.getTrainingSymbolFilePath()\\n\\n index = 0\\n for size in [small_size, big_size]:\\n offsets = [0, int(size / 2)]\\n\\n width, height = img.shape[1], img.shape[0]\\n width_count, height_count = width // size + 2, height // size + 2\\n b_width, b_height = width_count * size, height_count * size\\n b_img = np.zeros((b_height, b_width), np.uint8) + 255\\n b_img[:height, :width] = img[:, :]\\n\\n for offset in offsets:\\n for row in range(height_count):\\n for col in range(width_count):\\n x, y = col * size + offset, row * size + offset\\n tile_rect = QRectF(x, y, size, size)\\n tile_symbols = []\\n for symbol in [symbol for symbol in symbols if symbol.name in names[index]]:\\n if tile_rect.contains(symbol.sceneBoundingRect()):\\n tile_symbols.append(symbol)\\n symbols.remove(symbol)\\n\\n if tile_symbols:\\n training_uid = str(uuid.uuid4())\\n training_image_path = os.path.join(save_path, training_uid + '.png')\\n training_xml_path = os.path.join(save_path, training_uid + '.xml')\\n\\n # save image\\n #_img = b_img[round(tile_rect.top()):round(tile_rect.bottom()),\\n # round(tile_rect.left()):round(tile_rect.right())]\\n #cv2.imwrite(training_image_path, _img)\\n _img = self.graphicsView.image().copy(round(tile_rect.left()), round(tile_rect.top()), round(tile_rect.width()), round(tile_rect.height()))\\n _img.save(training_image_path)\\n\\n # save label\\n xml = Element('annotation')\\n SubElement(xml, 'folder').text = 'None'\\n SubElement(xml, 'filename').text = os.path.basename(save_path)\\n\\n pathNode = Element('path')\\n pathNode.text = save_path.replace('/', '\\\\\\\\')\\n xml.append(pathNode)\\n\\n sourceNode = Element('source')\\n databaseNode = Element('database')\\n databaseNode.text = 'Unknown'\\n sourceNode.append(databaseNode)\\n xml.append(sourceNode)\\n\\n sizeNode = Element('size')\\n widthNode = Element('width')\\n widthNode.text = str(int(tile_rect.width()))\\n sizeNode.append(widthNode)\\n heightNode = Element('height')\\n heightNode.text = str(int(tile_rect.height()))\\n sizeNode.append(heightNode)\\n depthNode = Element('depth')\\n depthNode.text = '3'\\n sizeNode.append(depthNode)\\n xml.append(sizeNode)\\n\\n segmentedNode = Element('segmented')\\n segmentedNode.text = '0'\\n xml.append(segmentedNode)\\n\\n labelContent = []\\n counts = {}\\n for item in tile_symbols:\\n rect = item.sceneBoundingRect()\\n label, xMin, yMin, xMax, yMax = item.name, int(rect.x() - 5 - x), int(rect.y() - 5 - y), int(rect.x() + rect.width() + 5 - x), int(rect.y() + rect.height() + 5 - y)\\n xMin = xMin if xMin > 0 else 0\\n yMin = yMin if yMin > 0 else 0\\n xMax = xMax if xMax < size else size\\n yMax = yMax if yMax < size else size\\n\\n if label == 'None' or label == '':\\n continue\\n if label not in labelContent:\\n labelContent.append(label)\\n counts[label] = 1\\n else:\\n counts[label] = counts[label] + 1\\n\\n objectNode = Element('object')\\n nameNode = Element('name')\\n nameNode.text = label\\n objectNode.append(nameNode)\\n poseNode = Element('pose')\\n poseNode.text = 'Unspecified'\\n objectNode.append(poseNode)\\n truncatedNode = Element('truncated')\\n truncatedNode.text = '0'\\n objectNode.append(truncatedNode)\\n difficultNode = Element('difficult')\\n difficultNode.text = '0'\\n objectNode.append(difficultNode)\\n\\n bndboxNode = Element('bndbox')\\n xminNode = Element('xmin')\\n xminNode.text = str(xMin)\\n bndboxNode.append(xminNode)\\n yminNode = Element('ymin')\\n yminNode.text = str(yMin)\\n bndboxNode.append(yminNode)\\n xmaxNode = Element('xmax')\\n xmaxNode.text = str(xMax)\\n bndboxNode.append(xmaxNode)\\n ymaxNode = Element('ymax')\\n ymaxNode.text = str(yMax)\\n bndboxNode.append(ymaxNode)\\n objectNode.append(bndboxNode)\\n\\n xml.append(objectNode)\\n\\n ElementTree(xml).write(training_xml_path)\\n\\n index += 1\\n\\n QMessageBox.about(self, self.tr(\\\"Notice\\\"), self.tr('Successfully applied. '))\",\n \"def gexf_graph():\\n # you must replace these lines and supply your own graph\\n \\n \\n \\n my_gexf = Gexf(\\\"JiajiaXie\\\", \\\"My awesome graph\\\")\\n graph=my_gexf.addGraph(\\\"undirected\\\", \\\"static\\\", \\\"My awesome networks\\\")\\n \\n atr1=graph.addNodeAttribute('Type',type='string')\\n\\n\\n for set in data_specific:\\n if graph.nodeExists(set['set_num']) ==0:\\n tm1=graph.addNode(set['set_num'], set['name'], r='0', g='0', b='0')\\n tm1.addAttribute(atr1,\\\"set\\\")\\n\\n\\n\\n counter_test=1\\n for set, part in data_parts.items():\\n for key, part_list in part.items():\\n interme =part_list['color']\\n red=interme[0]+interme[1]\\n green=interme[2]+interme[3]\\n blue=interme[4]+interme[5]\\n\\n red_de=str(int(red,16))\\n green_de=str(int(green,16))\\n blue_de=str(int(blue,16))\\n if graph.nodeExists(part_list['id'])==0:\\n tm2=graph.addNode(part_list['id'], part_list['part_name'],r=red_de, g=green_de, b = blue_de)\\n tm2.addAttribute(atr1,\\\"part\\\")\\n\\n\\n counter_test+=1\\n graph.addEdge(\\\"_\\\"+str(counter_test), set, part_list['id'], part_list['quantity'])\\n\\n\\n\\n f=open('bricks_graph.gexf','wb')\\n my_gexf.write(f)\\n\\n\\n return my_gexf.graphs[0]\",\n \"def DontuseThis():\\n BCM_outputs = ['phi','rho','theta',\\n 'r_probabilityMaps','l_probabilityMaps',\\n 'models']\\n BCM_Models = pe.Node(interface=nio.DataGrabber(input_names=['structures'],\\n outfields=BCM_outputs),\\n name='10_BCM_Models')\\n BCM_Models.inputs.base_directory = atlas_fname_wpath\\n BCM_Models.inputs.template_args['phi'] = [['spatialImages','phi','nii.gz']]\\n BCM_Models.inputs.template_args['rho'] = [['spatialImages','rho','nii.gz']]\\n BCM_Models.inputs.template_args['theta'] = [['spatialImages','theta','nii.gz']]\\n BCM_Models.inputs.template_args['r_probabilityMaps'] = [['structures']]\\n BCM_Models.inputs.template_args['l_probabilityMaps'] = [['structures']]\\n BCM_Models.inputs.template_args['models'] = [['structures']]\\n\\n BRAINSCut_structures = ['caudate','thalamus','putamen','hippocampus']\\n #BRAINSCut_structures = ['caudate','thalamus']\\n BCM_Models.iterables = ( 'structures', BRAINSCut_structures )\\n BCM_Models.inputs.template = '%s/%s.%s'\\n BCM_Models.inputs.field_template = dict(\\n r_probabilityMaps='probabilityMaps/r_%s_ProbabilityMap.nii.gz',\\n l_probabilityMaps='probabilityMaps/l_%s_ProbabilityMap.nii.gz',\\n models='modelFiles/%sModel*',\\n )\\n\\n \\\"\\\"\\\"\\n The xml creation and BRAINSCut need to be their own mini-pipeline that gets\\n executed once for each of the structures in BRAINSCut_structures. This can be\\n accomplished with a map node and a new pipeline.\\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n Create xml file for BRAINSCut\\n \\\"\\\"\\\"\\n\\n\\n BFitAtlasToSubject = pe.Node(interface=BRAINSFit(),name=\\\"BFitAtlasToSubject\\\")\\n BFitAtlasToSubject.inputs.costMetric=\\\"MMI\\\"\\n BFitAtlasToSubject.inputs.maskProcessingMode=\\\"ROI\\\"\\n BFitAtlasToSubject.inputs.numberOfSamples=100000\\n BFitAtlasToSubject.inputs.numberOfIterations=[1500,1500]\\n BFitAtlasToSubject.inputs.numberOfHistogramBins=50\\n BFitAtlasToSubject.inputs.maximumStepLength=0.2\\n BFitAtlasToSubject.inputs.minimumStepLength=[0.005,0.005]\\n BFitAtlasToSubject.inputs.transformType= [\\\"Affine\\\",\\\"BSpline\\\"]\\n BFitAtlasToSubject.inputs.maxBSplineDisplacement= 7\\n BFitAtlasToSubject.inputs.maskInferiorCutOffFromCenter=65\\n BFitAtlasToSubject.inputs.splineGridSize=[28,20,24]\\n BFitAtlasToSubject.inputs.outputVolume=\\\"Trial_Initializer_Output.nii.gz\\\"\\n BFitAtlasToSubject.inputs.outputTransform=\\\"Trial_Initializer_Output.mat\\\"\\n cutWF.connect(SplitAvgBABC,'avgBABCT1',BFitAtlasToSubject,'fixedVolume')\\n cutWF.connect(BABC,'outputLabels',BFitAtlasToSubject,'fixedBinaryVolume')\\n cutWF.connect(BAtlas,'template_t1',BFitAtlasToSubject,'movingVolume')\\n cutWF.connect(BAtlas,'template_brain',BFitAtlasToSubject,'movingBinaryVolume')\\n cutWF.connect(BLI,'outputTransformFilename',BFitAtlasToSubject,'initialTransform')\\n\\n CreateBRAINSCutXML = pe.Node(Function(input_names=['rho','phi','theta',\\n 'model',\\n 'r_probabilityMap',\\n 'l_probabilityMap',\\n 'atlasT1','atlasBrain',\\n 'subjT1','subjT2',\\n 'subjT1GAD','subjT2GAD',\\n 'subjSGGAD','subjBrain',\\n 'atlasToSubj','output_dir'],\\n output_names=['xml_filename','rl_structure_filename_list'],\\n function = create_BRAINSCut_XML),\\n overwrite = True,\\n name=\\\"CreateBRAINSCutXML\\\")\\n\\n ## HACK Makde better directory\\n CreateBRAINSCutXML.inputs.output_dir = \\\".\\\" #os.path.join(cutWF.base_dir, \\\"BRAINSCut_output\\\")\\n cutWF.connect(BCM_Models,'models',CreateBRAINSCutXML,'model')\\n cutWF.connect(BCM_Models,'rho',CreateBRAINSCutXML,'rho')\\n cutWF.connect(BCM_Models,'phi',CreateBRAINSCutXML,'phi')\\n cutWF.connect(BCM_Models,'theta',CreateBRAINSCutXML,'theta')\\n cutWF.connect(BCM_Models,'r_probabilityMaps',CreateBRAINSCutXML,'r_probabilityMap')\\n cutWF.connect(BCM_Models,'l_probabilityMaps',CreateBRAINSCutXML,'l_probabilityMap')\\n cutWF.connect(BAtlas,'template_t1',CreateBRAINSCutXML,'atlasT1')\\n cutWF.connect(BAtlas,'template_brain',CreateBRAINSCutXML,'atlasBrain')\\n cutWF.connect(SplitAvgBABC,'avgBABCT1',CreateBRAINSCutXML,'subjT1')\\n cutWF.connect(SplitAvgBABC,'avgBABCT2',CreateBRAINSCutXML,'subjT2')\\n cutWF.connect(GADT1,'outputVolume',CreateBRAINSCutXML,'subjT1GAD')\\n cutWF.connect(GADT2,'outputVolume',CreateBRAINSCutXML,'subjT2GAD')\\n cutWF.connect(SGI,'outputFileName',CreateBRAINSCutXML,'subjSGGAD')\\n cutWF.connect(BABC,'outputLabels',CreateBRAINSCutXML,'subjBrain')\\n cutWF.connect(BFitAtlasToSubject,'outputTransform',CreateBRAINSCutXML,'atlasToSubj')\\n #CreateBRAINSCutXML.inputs.atlasToSubj = \\\"INTERNAL_REGISTER.mat\\\"\\n #cutWF.connect(BABC,'atlasToSubjectTransform',CreateBRAINSCutXML,'atlasToSubj')\\n\\n \\\"\\\"\\\"\\n ResampleNACLabels\\n \\\"\\\"\\\"\\n ResampleAtlasNACLabels=pe.Node(interface=BRAINSResample(),name=\\\"ResampleAtlasNACLabels\\\")\\n ResampleAtlasNACLabels.inputs.interpolationMode = \\\"NearestNeighbor\\\"\\n ResampleAtlasNACLabels.inputs.outputVolume = \\\"atlasToSubjectNACLabels.nii.gz\\\"\\n\\n cutWF.connect(cutWF,'OutputSpec.atlasToSubjectTransform',ResampleAtlasNACLabels,'warpTransform')\\n cutWF.connect(cutWF,'OutputSpec.t1_corrected',ResampleAtlasNACLabels,'referenceVolume')\\n cutWF.connect(BAtlas,'template_nac_lables',ResampleAtlasNACLabels,'inputVolume')\\n\\n \\\"\\\"\\\"\\n BRAINSMush\\n \\\"\\\"\\\"\\n BMUSH=pe.Node(interface=BRAINSMush(),name=\\\"BMUSH\\\")\\n BMUSH.inputs.outputVolume = \\\"MushImage.nii.gz\\\"\\n BMUSH.inputs.outputMask = \\\"MushMask.nii.gz\\\"\\n BMUSH.inputs.lowerThresholdFactor = 1.2\\n BMUSH.inputs.upperThresholdFactor = 0.55\\n\\n cutWF.connect(myLocalTCWF,'OutputSpec.t1_corrected',BMUSH,'inputFirstVolume')\\n cutWF.connect(myLocalTCWF,'OutputSpec.t2_corrected',BMUSH,'inputSecondVolume')\\n cutWF.connect(myLocalTCWF,'OutputSpec.outputLabels',BMUSH,'inputMaskVolume')\\n\\n \\\"\\\"\\\"\\n BRAINSROIAuto\\n \\\"\\\"\\\"\\n BROI = pe.Node(interface=BRAINSROIAuto(), name=\\\"BRAINSROIAuto\\\")\\n BROI.inputs.closingSize=12\\n BROI.inputs.otsuPercentileThreshold=0.01\\n BROI.inputs.thresholdCorrectionFactor=1.0\\n BROI.inputs.outputROIMaskVolume = \\\"temproiAuto_t1_ACPC_corrected_BRAINSABC.nii.gz\\\"\\n cutWF.connect(myLocalTCWF,'OutputSpec.t1_corrected',BROI,'inputVolume')\\n\\n \\\"\\\"\\\"\\n Split the implicit outputs of BABCext\\n \\\"\\\"\\\"\\n SplitAvgBABC = pe.Node(Function(input_names=['in_files','T1_count'], output_names=['avgBABCT1','avgBABCT2'],\\n function = get_first_T1_and_T2), run_without_submitting=True, name=\\\"99_SplitAvgBABC\\\")\\n SplitAvgBABC.inputs.T1_count = 1 ## There is only 1 average T1 image.\\n\\n cutWF.connect(myLocalTCWF,'OutputSpec.outputAverageImages',SplitAvgBABC,'in_files')\\n\\n\\n\\n def printFullPath(outFileFullPath):\\n print(\\\"=\\\"*80)\\n print(\\\"=\\\"*80)\\n print(\\\"=\\\"*80)\\n print(\\\"=\\\"*80)\\n print(\\\"{0}\\\".format(outFileFullPath))\\n return outFileFullPath\\n printOutImage = pe.Node( Function(function=printFullPath, input_names = ['outFileFullPath'], output_names = ['genoutFileFullPath']), run_without_submitting=True, name=\\\"99_printOutImage\\\")\\n cutWF.connect( GADT2, 'outputVolume', printOutImage, 'outFileFullPath' )\",\n \"def identity_block(X, f, filters, stage, block):\\n \\n # Defines name basis.\\n conv_name_base = 'res' + str(stage) + block + '_branch'\\n bn_name_base = 'bn' + str(stage) + block + '_branch'\\n \\n # Retrieves Filters.\\n F1, F2, F3 = filters\\n \\n # Saves the input value. This is needed later to add back to the main path. \\n X_shortcut = X\\n \\n ##### MAIN PATH #####\\n # First component of main path.\\n X = Conv2D(filters = F1, kernel_size = (1, 1), strides = (1,1), padding = 'valid', name = conv_name_base + '2a', kernel_initializer = glorot_uniform())(X)\\n X = BatchNormalization(axis = 3, name = bn_name_base + '2a')(X)\\n X = Activation('relu')(X)\\n \\n \\n # Second component of main path.\\n X = Conv2D(filters = F2, kernel_size = (f, f), strides = (1,1), padding = 'same', name = conv_name_base + '2b', kernel_initializer = glorot_uniform())(X)\\n X = BatchNormalization(axis = 3, name = bn_name_base + '2b')(X)\\n X = Activation('relu')(X)\\n \\n # Third component of main path.\\n X = Conv2D(filters = F3, kernel_size = (1, 1), strides = (1,1), padding = 'valid', name = conv_name_base + '2c', kernel_initializer = glorot_uniform())(X)\\n X = BatchNormalization(axis = 3, name = bn_name_base + '2c')(X)\\n\\n\\n # Final step: Adds shortcut value to main path, and pass it through a RELU activation.\\n X = Add()([X, X_shortcut])\\n X = Activation('relu')(X)\\n\\n return X\",\n \"def identity_block(X, f, filters, stage, block):\\n \\n # defining name basis\\n conv_name_base = 'res' + str(stage) + block + '_branch'\\n bn_name_base = 'bn' + str(stage) + block + '_branch'\\n \\n # Retrieve Filters\\n F1, F2, F3 = filters\\n \\n # Save the input value. You'll need this later to add back to the main path. \\n X_shortcut = X\\n \\n # First component of main path\\n X = Conv2D(filters = F1, kernel_size = (1, 1), strides = (1,1), padding = 'valid', name = conv_name_base + '2a', kernel_initializer = glorot_uniform(seed=0))(X)\\n X = BatchNormalization(axis = 3, name = bn_name_base + '2a')(X)\\n X = Activation('relu')(X)\\n \\n # Second component of main path\\n X = Conv2D(filters = F2, kernel_size = (f, f), strides = (1,1), padding = 'same', name = conv_name_base + '2b', kernel_initializer = glorot_uniform(seed=0))(X)\\n X = BatchNormalization(axis = 3, name = bn_name_base + '2b')(X)\\n X = Activation('relu')(X)\\n\\n # Third component of main path\\n X = Conv2D(filters = F3, kernel_size = (1, 1), strides = (1,1), padding = 'valid', name = conv_name_base + '2c', kernel_initializer = glorot_uniform(seed=0))(X)\\n X = BatchNormalization(axis = 3, name = bn_name_base + '2c')(X)\\n\\n # Final step: Add shortcut value to main path, and pass it through a RELU activation\\n X = Add()([X,X_shortcut])\\n X = Activation('relu')(X)\\n \\n return X\",\n \"def make_mixture_info(parts, operation='+'):\\n # type: (List[ModelInfo], str) -> ModelInfo\\n # Build new parameter list\\n combined_pars = []\\n\\n # When creating a mixture model that is a sum of product models (ie (1*2)+(3*4))\\n # the parameters for models 1 & 2 will be prefixed with A & B respectively,\\n # but so will the parameters for models 3 & 4. We need to rename models 3 & 4\\n # so that they are prefixed with C & D to avoid overlap of parameter names.\\n used_prefixes = []\\n for part in parts:\\n if part.composition and part.composition[0] == 'mixture':\\n i = 0\\n for submodel in part.composition[1]:\\n npars = len(submodel.parameters.kernel_parameters)\\n # List of params of one of the constituent models of part\\n submodel_pars = part.parameters.kernel_parameters[i:i+npars]\\n # Prefix of the constituent model\\n prefix = submodel_pars[0].name[0]\\n if prefix not in used_prefixes: # Haven't seen this prefix so far\\n used_prefixes.append(prefix)\\n i += npars\\n continue\\n # TODO: don't modify submodel --- it may be used elsewhere\\n # Existing code probably doesn't keep a handle on the model\\n # parts so its probably okay, but it's possible that a mix\\n # on user defined mixture models models will change the\\n # parameters used for the parts in the GUI. Even worse if the\\n # same plugin is used twice. For example, twosphere.py\\n # contains sphere+sphere and you create twosphere+twosphere.\\n while prefix in used_prefixes:\\n # This prefix has been already used, so change it to the\\n # next letter that hasn't been used\\n prefix = chr(ord(prefix) + 1)\\n used_prefixes.append(prefix)\\n prefix += \\\"_\\\"\\n # Update the parameters of this constituent model to use the\\n # new prefix\\n for par in submodel_pars:\\n # Strip {prefix}_ using par.name[2:], etc.\\n # TODO: fails for AB_scale\\n par.id = prefix + par.id[2:]\\n par.name = prefix + par.name[2:]\\n if par.length_control is not None:\\n par.length_control = prefix + par.length_control[2:]\\n i += npars\\n\\n for part in parts:\\n # Parameter prefix per model, A_, B_, ...\\n # Note that prefix must also be applied to id and length_control\\n # to support vector parameters\\n prefix = ''\\n if not part.composition or part.composition[0] == 'product':\\n # Model isn't a composition model, so its parameters don't have a\\n # a prefix. Add the next available prefix\\n prefix = chr(ord('A')+len(used_prefixes))\\n used_prefixes.append(prefix)\\n prefix += '_'\\n\\n if operation == '+':\\n # If model is a sum model, each constituent model gets its own scale parameter\\n scale_prefix = prefix\\n if prefix == '' and getattr(part, \\\"operation\\\", '') == '*':\\n # `part` is a composition product model. Find the prefixes of\\n # its parameters to form a new prefix for the scale.\\n # For example, a model with A*B*C will have ABC_scale.\\n sub_prefixes = []\\n for param in part.parameters.kernel_parameters:\\n # Prefix of constituent model\\n sub_prefix = param.id.split('_')[0]\\n if sub_prefix not in sub_prefixes:\\n sub_prefixes.append(sub_prefix)\\n # Concatenate sub_prefixes to form prefix for the scale\\n scale_prefix = ''.join(sub_prefixes) + '_'\\n scale = Parameter(scale_prefix + 'scale', default=1.0,\\n description=\\\"model intensity for \\\" + part.name)\\n combined_pars.append(scale)\\n for p in part.parameters.kernel_parameters:\\n p = copy(p)\\n p.name = prefix + p.name\\n p.id = prefix + p.id\\n if p.length_control is not None:\\n p.length_control = prefix + p.length_control\\n combined_pars.append(p)\\n parameters = ParameterTable(combined_pars)\\n # Allow for the scenario in which each component has all its PD parameters\\n # active simultaneously. details.make_details() will throw an error if\\n # too many are used from any one component.\\n parameters.max_pd = sum(part.parameters.max_pd for part in parts)\\n\\n def random():\\n \\\"\\\"\\\"Random set of model parameters for mixture model\\\"\\\"\\\"\\n combined_pars = {}\\n for k, part in enumerate(parts):\\n prefix = chr(ord('A')+k) + '_'\\n pars = part.random()\\n combined_pars.update((prefix+k, v) for k, v in pars.items())\\n return combined_pars\\n\\n model_info = ModelInfo()\\n model_info.id = operation.join(part.id for part in parts)\\n model_info.operation = operation\\n model_info.name = '(' + operation.join(part.name for part in parts) + ')'\\n model_info.filename = None\\n model_info.title = 'Mixture model with ' + model_info.name\\n model_info.description = model_info.title\\n model_info.docs = model_info.title\\n model_info.category = \\\"custom\\\"\\n model_info.parameters = parameters\\n model_info.random = random\\n #model_info.single = any(part['single'] for part in parts)\\n model_info.structure_factor = False\\n #model_info.tests = []\\n #model_info.source = []\\n # Remember the component info blocks so we can build the model\\n model_info.composition = ('mixture', parts)\\n return model_info\",\n \"def tied_featurize(batch, device, chain_dict, fixed_position_dict=None, omit_AA_dict=None, tied_positions_dict=None, pssm_dict=None, bias_by_res_dict=None, ca_only=False):\\n alphabet = 'ACDEFGHIKLMNPQRSTVWYX'\\n B = len(batch)\\n lengths = np.array([len(b['seq']) for b in batch], dtype=np.int32) #sum of chain seq lengths\\n L_max = max([len(b['seq']) for b in batch])\\n if ca_only:\\n X = np.zeros([B, L_max, 1, 3])\\n else:\\n X = np.zeros([B, L_max, 4, 3])\\n residue_idx = -100*np.ones([B, L_max], dtype=np.int32)\\n chain_M = np.zeros([B, L_max], dtype=np.int32) #1.0 for the bits that need to be predicted\\n pssm_coef_all = np.zeros([B, L_max], dtype=np.float32) #1.0 for the bits that need to be predicted\\n pssm_bias_all = np.zeros([B, L_max, 21], dtype=np.float32) #1.0 for the bits that need to be predicted\\n pssm_log_odds_all = 10000.0*np.ones([B, L_max, 21], dtype=np.float32) #1.0 for the bits that need to be predicted\\n chain_M_pos = np.zeros([B, L_max], dtype=np.int32) #1.0 for the bits that need to be predicted\\n bias_by_res_all = np.zeros([B, L_max, 21], dtype=np.float32)\\n chain_encoding_all = np.zeros([B, L_max], dtype=np.int32) #1.0 for the bits that need to be predicted\\n S = np.zeros([B, L_max], dtype=np.int32)\\n omit_AA_mask = np.zeros([B, L_max, len(alphabet)], dtype=np.int32)\\n # Build the batch\\n letter_list_list = []\\n visible_list_list = []\\n masked_list_list = []\\n masked_chain_length_list_list = []\\n tied_pos_list_of_lists_list = []\\n for i, b in enumerate(batch):\\n if chain_dict != None:\\n masked_chains, visible_chains = chain_dict[b['name']] #masked_chains a list of chain letters to predict [A, D, F]\\n else:\\n masked_chains = [item[-1:] for item in list(b) if item[:10]=='seq_chain_']\\n visible_chains = []\\n masked_chains.sort() #sort masked_chains \\n visible_chains.sort() #sort visible_chains \\n all_chains = masked_chains + visible_chains\\n for i, b in enumerate(batch):\\n mask_dict = {}\\n a = 0\\n x_chain_list = []\\n chain_mask_list = []\\n chain_seq_list = []\\n chain_encoding_list = []\\n c = 1\\n letter_list = []\\n global_idx_start_list = [0]\\n visible_list = []\\n masked_list = []\\n masked_chain_length_list = []\\n fixed_position_mask_list = []\\n omit_AA_mask_list = []\\n pssm_coef_list = []\\n pssm_bias_list = []\\n pssm_log_odds_list = []\\n bias_by_res_list = []\\n l0 = 0\\n l1 = 0\\n for step, letter in enumerate(all_chains):\\n if letter in visible_chains:\\n letter_list.append(letter)\\n visible_list.append(letter)\\n chain_seq = b[f'seq_chain_{letter}']\\n chain_seq = ''.join([a if a!='-' else 'X' for a in chain_seq])\\n chain_length = len(chain_seq)\\n global_idx_start_list.append(global_idx_start_list[-1]+chain_length)\\n chain_coords = b[f'coords_chain_{letter}'] #this is a dictionary\\n chain_mask = np.zeros(chain_length) #0.0 for visible chains\\n if ca_only:\\n x_chain = np.array(chain_coords[f'CA_chain_{letter}']) #[chain_lenght,1,3] #CA_diff\\n if len(x_chain.shape) == 2:\\n x_chain = x_chain[:,None,:]\\n else:\\n x_chain = np.stack([chain_coords[c] for c in [f'N_chain_{letter}', f'CA_chain_{letter}', f'C_chain_{letter}', f'O_chain_{letter}']], 1) #[chain_lenght,4,3]\\n x_chain_list.append(x_chain)\\n chain_mask_list.append(chain_mask)\\n chain_seq_list.append(chain_seq)\\n chain_encoding_list.append(c*np.ones(np.array(chain_mask).shape[0]))\\n l1 += chain_length\\n residue_idx[i, l0:l1] = 100*(c-1)+np.arange(l0, l1)\\n l0 += chain_length\\n c+=1\\n fixed_position_mask = np.ones(chain_length)\\n fixed_position_mask_list.append(fixed_position_mask)\\n omit_AA_mask_temp = np.zeros([chain_length, len(alphabet)], np.int32)\\n omit_AA_mask_list.append(omit_AA_mask_temp)\\n pssm_coef = np.zeros(chain_length)\\n pssm_bias = np.zeros([chain_length, 21])\\n pssm_log_odds = 10000.0*np.ones([chain_length, 21])\\n pssm_coef_list.append(pssm_coef)\\n pssm_bias_list.append(pssm_bias)\\n pssm_log_odds_list.append(pssm_log_odds)\\n bias_by_res_list.append(np.zeros([chain_length, 21]))\\n if letter in masked_chains:\\n masked_list.append(letter)\\n letter_list.append(letter)\\n chain_seq = b[f'seq_chain_{letter}']\\n chain_seq = ''.join([a if a!='-' else 'X' for a in chain_seq])\\n chain_length = len(chain_seq)\\n global_idx_start_list.append(global_idx_start_list[-1]+chain_length)\\n masked_chain_length_list.append(chain_length)\\n chain_coords = b[f'coords_chain_{letter}'] #this is a dictionary\\n chain_mask = np.ones(chain_length) #1.0 for masked\\n if ca_only:\\n x_chain = np.array(chain_coords[f'CA_chain_{letter}']) #[chain_lenght,1,3] #CA_diff\\n if len(x_chain.shape) == 2:\\n x_chain = x_chain[:,None,:]\\n else:\\n x_chain = np.stack([chain_coords[c] for c in [f'N_chain_{letter}', f'CA_chain_{letter}', f'C_chain_{letter}', f'O_chain_{letter}']], 1) #[chain_lenght,4,3] \\n x_chain_list.append(x_chain)\\n chain_mask_list.append(chain_mask)\\n chain_seq_list.append(chain_seq)\\n chain_encoding_list.append(c*np.ones(np.array(chain_mask).shape[0]))\\n l1 += chain_length\\n residue_idx[i, l0:l1] = 100*(c-1)+np.arange(l0, l1)\\n l0 += chain_length\\n c+=1\\n fixed_position_mask = np.ones(chain_length)\\n if fixed_position_dict!=None:\\n fixed_pos_list = fixed_position_dict[b['name']][letter]\\n if fixed_pos_list:\\n fixed_position_mask[np.array(fixed_pos_list)-1] = 0.0\\n fixed_position_mask_list.append(fixed_position_mask)\\n omit_AA_mask_temp = np.zeros([chain_length, len(alphabet)], np.int32)\\n if omit_AA_dict!=None:\\n for item in omit_AA_dict[b['name']][letter]:\\n idx_AA = np.array(item[0])-1\\n AA_idx = np.array([np.argwhere(np.array(list(alphabet))== AA)[0][0] for AA in item[1]]).repeat(idx_AA.shape[0])\\n idx_ = np.array([[a, b] for a in idx_AA for b in AA_idx])\\n omit_AA_mask_temp[idx_[:,0], idx_[:,1]] = 1\\n omit_AA_mask_list.append(omit_AA_mask_temp)\\n pssm_coef = np.zeros(chain_length)\\n pssm_bias = np.zeros([chain_length, 21])\\n pssm_log_odds = 10000.0*np.ones([chain_length, 21])\\n if pssm_dict:\\n if pssm_dict[b['name']][letter]:\\n pssm_coef = pssm_dict[b['name']][letter]['pssm_coef']\\n pssm_bias = pssm_dict[b['name']][letter]['pssm_bias']\\n pssm_log_odds = pssm_dict[b['name']][letter]['pssm_log_odds']\\n pssm_coef_list.append(pssm_coef)\\n pssm_bias_list.append(pssm_bias)\\n pssm_log_odds_list.append(pssm_log_odds)\\n if bias_by_res_dict:\\n bias_by_res_list.append(bias_by_res_dict[b['name']][letter])\\n else:\\n bias_by_res_list.append(np.zeros([chain_length, 21]))\\n\\n \\n letter_list_np = np.array(letter_list)\\n tied_pos_list_of_lists = []\\n tied_beta = np.ones(L_max)\\n if tied_positions_dict!=None:\\n tied_pos_list = tied_positions_dict[b['name']]\\n if tied_pos_list:\\n set_chains_tied = set(list(itertools.chain(*[list(item) for item in tied_pos_list])))\\n for tied_item in tied_pos_list:\\n one_list = []\\n for k, v in tied_item.items():\\n start_idx = global_idx_start_list[np.argwhere(letter_list_np == k)[0][0]]\\n if isinstance(v[0], list):\\n for v_count in range(len(v[0])):\\n one_list.append(start_idx+v[0][v_count]-1)#make 0 to be the first\\n tied_beta[start_idx+v[0][v_count]-1] = v[1][v_count]\\n else:\\n for v_ in v:\\n one_list.append(start_idx+v_-1)#make 0 to be the first\\n tied_pos_list_of_lists.append(one_list)\\n tied_pos_list_of_lists_list.append(tied_pos_list_of_lists)\\n\\n\\n \\n x = np.concatenate(x_chain_list,0) #[L, 4, 3]\\n all_sequence = \\\"\\\".join(chain_seq_list)\\n m = np.concatenate(chain_mask_list,0) #[L,], 1.0 for places that need to be predicted\\n chain_encoding = np.concatenate(chain_encoding_list,0)\\n m_pos = np.concatenate(fixed_position_mask_list,0) #[L,], 1.0 for places that need to be predicted\\n\\n pssm_coef_ = np.concatenate(pssm_coef_list,0) #[L,], 1.0 for places that need to be predicted\\n pssm_bias_ = np.concatenate(pssm_bias_list,0) #[L,], 1.0 for places that need to be predicted\\n pssm_log_odds_ = np.concatenate(pssm_log_odds_list,0) #[L,], 1.0 for places that need to be predicted\\n\\n bias_by_res_ = np.concatenate(bias_by_res_list, 0) #[L,21], 0.0 for places where AA frequencies don't need to be tweaked\\n\\n l = len(all_sequence)\\n x_pad = np.pad(x, [[0,L_max-l], [0,0], [0,0]], 'constant', constant_values=(np.nan, ))\\n X[i,:,:,:] = x_pad\\n\\n m_pad = np.pad(m, [[0,L_max-l]], 'constant', constant_values=(0.0, ))\\n m_pos_pad = np.pad(m_pos, [[0,L_max-l]], 'constant', constant_values=(0.0, ))\\n omit_AA_mask_pad = np.pad(np.concatenate(omit_AA_mask_list,0), [[0,L_max-l]], 'constant', constant_values=(0.0, ))\\n chain_M[i,:] = m_pad\\n chain_M_pos[i,:] = m_pos_pad\\n omit_AA_mask[i,] = omit_AA_mask_pad\\n\\n chain_encoding_pad = np.pad(chain_encoding, [[0,L_max-l]], 'constant', constant_values=(0.0, ))\\n chain_encoding_all[i,:] = chain_encoding_pad\\n\\n pssm_coef_pad = np.pad(pssm_coef_, [[0,L_max-l]], 'constant', constant_values=(0.0, ))\\n pssm_bias_pad = np.pad(pssm_bias_, [[0,L_max-l], [0,0]], 'constant', constant_values=(0.0, ))\\n pssm_log_odds_pad = np.pad(pssm_log_odds_, [[0,L_max-l], [0,0]], 'constant', constant_values=(0.0, ))\\n\\n pssm_coef_all[i,:] = pssm_coef_pad\\n pssm_bias_all[i,:] = pssm_bias_pad\\n pssm_log_odds_all[i,:] = pssm_log_odds_pad\\n\\n bias_by_res_pad = np.pad(bias_by_res_, [[0,L_max-l], [0,0]], 'constant', constant_values=(0.0, ))\\n bias_by_res_all[i,:] = bias_by_res_pad\\n\\n # Convert to labels\\n indices = np.asarray([alphabet.index(a) for a in all_sequence], dtype=np.int32)\\n S[i, :l] = indices\\n letter_list_list.append(letter_list)\\n visible_list_list.append(visible_list)\\n masked_list_list.append(masked_list)\\n masked_chain_length_list_list.append(masked_chain_length_list)\\n\\n\\n isnan = np.isnan(X)\\n mask = np.isfinite(np.sum(X,(2,3))).astype(np.float32)\\n X[isnan] = 0.\\n\\n # Conversion\\n pssm_coef_all = torch.from_numpy(pssm_coef_all).to(dtype=torch.float32, device=device)\\n pssm_bias_all = torch.from_numpy(pssm_bias_all).to(dtype=torch.float32, device=device)\\n pssm_log_odds_all = torch.from_numpy(pssm_log_odds_all).to(dtype=torch.float32, device=device)\\n\\n tied_beta = torch.from_numpy(tied_beta).to(dtype=torch.float32, device=device)\\n\\n jumps = ((residue_idx[:,1:]-residue_idx[:,:-1])==1).astype(np.float32)\\n bias_by_res_all = torch.from_numpy(bias_by_res_all).to(dtype=torch.float32, device=device)\\n phi_mask = np.pad(jumps, [[0,0],[1,0]])\\n psi_mask = np.pad(jumps, [[0,0],[0,1]])\\n omega_mask = np.pad(jumps, [[0,0],[0,1]])\\n dihedral_mask = np.concatenate([phi_mask[:,:,None], psi_mask[:,:,None], omega_mask[:,:,None]], -1) #[B,L,3]\\n dihedral_mask = torch.from_numpy(dihedral_mask).to(dtype=torch.float32, device=device)\\n residue_idx = torch.from_numpy(residue_idx).to(dtype=torch.long,device=device)\\n S = torch.from_numpy(S).to(dtype=torch.long,device=device)\\n X = torch.from_numpy(X).to(dtype=torch.float32, device=device)\\n mask = torch.from_numpy(mask).to(dtype=torch.float32, device=device)\\n chain_M = torch.from_numpy(chain_M).to(dtype=torch.float32, device=device)\\n chain_M_pos = torch.from_numpy(chain_M_pos).to(dtype=torch.float32, device=device)\\n omit_AA_mask = torch.from_numpy(omit_AA_mask).to(dtype=torch.float32, device=device)\\n chain_encoding_all = torch.from_numpy(chain_encoding_all).to(dtype=torch.long, device=device)\\n if ca_only:\\n X_out = X[:,:,0]\\n else:\\n X_out = X\\n return X_out, S, mask, lengths, chain_M, chain_encoding_all, letter_list_list, visible_list_list, masked_list_list, masked_chain_length_list_list, chain_M_pos, omit_AA_mask, residue_idx, dihedral_mask, tied_pos_list_of_lists_list, pssm_coef_all, pssm_bias_all, pssm_log_odds_all, bias_by_res_all, tied_beta\",\n \"def compiler_output(input_ckt, hier_graph_dict, design_name:str, result_dir:pathlib.Path, pdk_dir:pathlib.Path, uniform_height=False):\\n layers_json = pdk_dir / 'layers.json'\\n with open(layers_json,\\\"rt\\\") as fp:\\n pdk_data=json.load(fp)\\n design_config = pdk_data[\\\"design_info\\\"]\\n\\n if not result_dir.exists():\\n result_dir.mkdir()\\n logger.debug(f\\\"Writing results in dir: {result_dir} {hier_graph_dict}\\\")\\n input_dir = input_ckt.parents[0]\\n\\n verilog_tbl = { 'modules': [], 'global_signals': []}\\n\\n design_setup = read_setup(input_dir / (design_name + '.setup'))\\n try:\\n POWER_PINS = [design_setup['GND'][0],design_setup['POWER'][0]]\\n except (IndexError, ValueError):\\n POWER_PINS = []\\n logger.info(\\\"Power and ground nets not found. Power grid will not be constructed.\\\")\\n\\n #read lef to not write those modules as macros\\n lef_path = pathlib.Path(__file__).resolve().parent.parent / 'config'\\n all_lef = read_lef(lef_path)\\n logger.debug(f\\\"Available library cells: {', '.join(all_lef)}\\\")\\n\\n primitives = {}\\n for name,member in hier_graph_dict.items():\\n logger.debug(f\\\"Found module: {name} {member['graph'].nodes()}\\\")\\n graph = member[\\\"graph\\\"]\\n constraints = member[\\\"constraints\\\"]\\n\\n for const in constraints:\\n if isinstance(const, constraint.GuardRing):\\n primitives['guard_ring'] = {'primitive':'guard_ring'}\\n\\n logger.debug(f\\\"Reading nodes from graph: {name}\\\")\\n for node, attr in graph.nodes(data=True):\\n if 'net' in attr['inst_type']: continue\\n #Dropping floating ports\\n lef_name = attr['inst_type']\\n\\n if \\\"values\\\" in attr and (lef_name in all_lef):\\n block_name, block_args = generate_lef(lef_name, attr, primitives, design_config, uniform_height)\\n #block_name_ext = block_name.replace(lef_name,'')\\n logger.debug(f\\\"Created new lef for: {block_name} {lef_name}\\\")\\n #Multiple instances of same module\\n if 'inst_copy' in attr:\\n for nm in list(hier_graph_dict.keys()):\\n if nm == lef_name + attr['inst_copy']:\\n if block_name not in hier_graph_dict.keys():\\n logger.debug('Trying to modify a dictionary while iterating over it!')\\n hier_graph_dict[block_name] = hier_graph_dict.pop(nm)\\n else:\\n #For cells with extra parameters than current primitive naming convention\\n all_lef.append(nm)\\n graph.nodes[node][\\\"inst_type\\\"] = block_name\\n all_lef.append(block_name)\\n\\n # Only unit caps are generated\\n if block_name.lower().startswith('cap'):\\n graph.nodes[node]['inst_type'] = block_args['primitive']\\n block_args['primitive'] = block_name\\n else:\\n graph.nodes[node]['inst_type'] = block_name\\n\\n if block_name in primitives:\\n if block_args != primitives[block_name]:\\n logging.warning(f\\\"two different primitve {block_name} of size {primitives[block_name]} {block_args}got approximated to same unit size\\\")\\n else:\\n primitives[block_name] = block_args\\n elif \\\"values\\\" in attr and 'inst_copy' in attr:\\n member[\\\"graph\\\"].nodes[node][\\\"inst_type\\\"]= lef_name + attr[\\\"inst_copy\\\"]\\n all_lef.append(block_name)\\n\\n else:\\n logger.debug(f\\\"No physical information found for: {name}\\\")\\n logger.debug(f\\\"generated data for {name} : {pprint.pformat(primitives, indent=4)}\\\")\\n logger.debug(f\\\"All available cell generator with updates: {all_lef}\\\")\\n for name,member in hier_graph_dict.items():\\n graph = member[\\\"graph\\\"]\\n logger.debug(f\\\"Found module: {name} {graph.nodes()}\\\")\\n inoutpin = []\\n floating_ports=[]\\n if \\\"ports_match\\\" in member and member[\\\"ports_match\\\"]:\\n for key in member[\\\"ports_match\\\"].keys():\\n if key not in POWER_PINS:\\n inoutpin.append(key)\\n if member[\\\"ports\\\"]:\\n logger.debug(f'Found module ports: {member[\\\"ports\\\"]} {member[\\\"name\\\"]}')\\n floating_ports = set(inoutpin) - set(member[\\\"ports\\\"]) - set(design_setup['POWER']) -set(design_setup['GND'])\\n if len(list(floating_ports))> 0:\\n logger.error(f\\\"floating ports found: {name} {floating_ports}\\\")\\n raise SystemExit('Please remove floating ports')\\n else:\\n inoutpin = member[\\\"ports\\\"]\\n if name not in all_lef:\\n\\n ## Removing constraints to fix cascoded cmc\\n if name not in design_setup['DIGITAL']:\\n logger.debug(f\\\"call constraint generator writer for block: {name}\\\")\\n stop_points = design_setup['POWER'] + design_setup['GND'] + design_setup['CLOCK']\\n constraints = member[\\\"constraints\\\"]\\n if name not in design_setup['NO_CONST']:\\n constraints = FindConst(graph, name, inoutpin, member[\\\"ports_weight\\\"], constraints, stop_points)\\n constraints = CapConst(graph, name, design_config[\\\"unit_size_cap\\\"], constraints, design_setup['MERGE_SYMM_CAPS'])\\n hier_graph_dict[name] = hier_graph_dict[name].copy(\\n update={'constraints': constraints}\\n )\\n ## Write out modified netlist & constraints as JSON\\n logger.debug(f\\\"call verilog writer for block: {name}\\\")\\n wv = WriteVerilog(name, inoutpin, hier_graph_dict, POWER_PINS)\\n verilog_tbl['modules'].append( wv.gen_dict())\\n if len(POWER_PINS)>0:\\n for i, nm in enumerate(POWER_PINS):\\n verilog_tbl['global_signals'].append( { 'prefix' :'global_power', 'formal' : f'supply{i}', 'actual' : nm})\\n\\n with (result_dir / f'{design_name}.verilog.json').open( 'wt') as fp:\\n json.dump( verilog_tbl, fp=fp, indent=2)\\n\\n with (result_dir / f'{design_name}.v').open( 'wt') as fp:\\n write_verilog( verilog_tbl, fp)\\n\\n logger.info(\\\"Completed topology identification.\\\")\\n logger.debug(f\\\"OUTPUT verilog json netlist at: {result_dir}/{design_name}.verilog.json\\\")\\n logger.debug(f\\\"OUTPUT verilog netlist at: {result_dir}/{design_name}.v\\\")\\n logger.debug(f\\\"OUTPUT const file at: {result_dir}/{design_name}.pnr.const.json\\\")\\n return primitives\",\n \"def convert2EbnerParam(joblib,list_prefix,directory):\\n \\n key=[p[0] for p in joblib]\\n element=[p[1] for p in joblib]\\n\\n \\n listSlice=element[key.index('listSlice')] #list of slice\\n parameters=element[key.index('EvolutionParameters')][-1,:,:] #estimated paramters of the registration\\n rejectedSlice=element[key.index('RejectedSlices')] #rejected slices\\n\\n \\n images,mask = createVolumesFromAlist(listSlice.copy()) #list of images corresponding to differents original stacks\\n \\n for i_slice in range(len(listSlice)): \\n slicei=listSlice[i_slice]\\n slicei.set_parameters(parameters[i_slice,:]) #set parameters to the last estimated parameters\\n \\n mat = np.array([[-1,0,0,0],[0,-1,0,0],[0,0,1,0],[0,0,0,1]]) #matrix to convert affine matrix from nibabel to itk\\n\\n for n in range(len(images)): #for each stack\\n \\n imagen = images[n]\\n \\n for i_slice in range(len(images[n])): #for each slices (in each stacks)\\n \\n slicei=imagen[i_slice]\\n s = (slicei.get_orientation(),slicei.get_index_slice())\\n \\n if s not in rejectedSlice:\\n dimension=3\\n X,Y,Z= slicei.get_slice().get_fdata().shape\\n center= -slicei.get_center()\\n centerMat = np.eye(4)\\n centerMat[0:3,3] = center[0:3]\\n invcenterMat = np.eye(4)\\n invcenterMat[0:3,3] = -center[0:3] \\n p = slicei.get_parameters()\\n matrix = mat @ centerMat @ rigidMatrix([p[0],p[1],p[2],p[3],p[4],p[5]]) @ invcenterMat @ mat\\n test = sitk.AffineTransform(dimension)\\n test.SetMatrix(matrix[0:3,0:3].flatten())\\n test.SetTranslation(matrix[0:3,3])\\n images_index = slicei.get_index_image()\\n sitk.WriteTransform(test,\\\"%s/%s_slice%d.tfm\\\" %(directory,list_prefix[images_index],slicei.get_index_slice())) #save rigid transformation, computed at the barycenter of the image, adatpted to itk\\n #else:\\n #print(s)\",\n \"def build(width, height, depth, classes, stages, filters, include_top, pooling,\\n reg=1e-3, bnEps=2e-5, bnMom=0.0):\\n inputShape = (height, width, depth)\\n chanDim = -1\\n\\n if K.image_data_format() == \\\"channels_first\\\":\\n inputShape = (depth, height, width)\\n chanDim = 1\\n\\n inputs = Input(shape=inputShape)\\n\\n\\n # block 1 (initial conv block)\\n x = ZeroPadding2D(padding=((3, 3), (3, 3)), name='conv1_pad')(inputs)\\n x = Conv2D(64, (7,7), use_bias=False, strides=(2,2),\\n kernel_initializer=\\\"he_normal\\\", kernel_regularizer=l2(reg))(x)\\n x = BatchNormalization(axis=chanDim, name=\\\"bn_conv1\\\")(x)\\n x = Activation(\\\"relu\\\")(x)\\n x = ZeroPadding2D(padding=((1,1), (1,1)), name=\\\"pool1_pad\\\")(x)\\n x = MaxPooling2D(3, strides=2)(x)\\n\\n for i in range(0, len(stages)):\\n stride = (1,1) if i == 0 else (2,2) # block 2 (projection block) w stride(1,1)\\n\\n print(\\\"Stage {}, Stride={}\\\".format(i, stride))\\n x = SEResNet.residual_module(x, filters[i+1], stride,\\n chanDim=chanDim, red=True, bnEps=bnEps, bnMom=bnMom)\\n for j in range(0, stages[i] + 1): #stacking res block to each depth layer\\n x = SEResNet.residual_module(x, filters[i+1], stride=(1,1),\\n chanDim=chanDim, bnEps=bnEps,\\n bnMom=bnMom)\\n x = BatchNormalization(axis=chanDim, epsilon=bnEps,\\n momentum=bnMom)(x)\\n x = Activation(\\\"relu\\\")(x)\\n\\n if include_top:\\n x = GlobalAveragePooling2D()(x)\\n x = Dense(classes, use_bias=False, kernel_regularizer=l2(reg),\\n activation='softmax')(x)\\n else:\\n if pooling == 'avg':\\n print(\\\"Adding average pool\\\")\\n x = GlobalAveragePooling2D()(x)\\n elif pooling == 'max':\\n x = GlobalMaxPooling2D()(x)\\n\\n model = Model(inputs=inputs, outputs=x, name=\\\"SEResNet\\\")\\n return model\",\n \"def _processLabel(self, kitti_label):\\n label = {\\n 'category': kitti_label['type'].lower(),\\n 'box2D': kitti_label['bbox'].copy(),\\n 'box3D': {\\n 'location': {\\n 'x': kitti_label['location']['x'],\\n 'y': kitti_label['location']['y'] - kitti_label['dimensions']['height'] / 2.0, # move to center\\n 'z': kitti_label['location']['z'],\\n },\\n 'dimensions': kitti_label['dimensions'].copy(),\\n 'rotation_y': kitti_label['rotation_y'],\\n },\\n 'info': {\\n 'truncated': kitti_label['truncated'],\\n 'occluded': kitti_label['occluded'],\\n },\\n }\\n if 'trackId' in kitti_label:\\n # set trackId if given\\n label['info']['trackId'] = kitti_label['trackId']\\n return label\",\n \"def generate_semisupervized_label(self, idx_known, idx_unknown):\\n tmp_df = self.data_info.set_index(['patientID','body_part'])\\n # associate semi-supervized settings\\n if len(idx_known) > 0:\\n df_known = tmp_df.loc[idx_known,:]\\n df_known['semi_label'] = df_known.abnormal_XR.apply(lambda x: -1 if x==1 else 1)\\n df_unknown = tmp_df.loc[idx_unknown,:]\\n df_unknown['semi_label'] = 0\\n return pd.concat([df_known, df_unknown], axis=0).reset_index()\\n else:\\n df_unknown = tmp_df.loc[idx_unknown,:]\\n df_unknown['semi_label'] = 0\\n return df_unknown.reset_index()\",\n \"def serialize(mode):\\r\\n serialize_version(mode)\\r\\n vcb.serialize(mode) \\r\\n for x in xfrms:\\r\\n x.serialize(mode)\",\n \"def label(self, cfg):\\n rep = \\\"\\\"\\n nl = \\\"\\\"\\n for node in cfg.nodes:\\n rep += nl + \\\"{}\\\\tgen={}\\\\tkill={}\\\\tout={}\\\".format(\\n node, \\n set(self.gen.get(node)),\\n set(self.kill.get(node)),\\n set(self.out.get(node)))\\n nl = \\\"\\\\n\\\"\\n return rep\",\n \"def m_dump_tf():\\n\\n # Info about ENS and Resolver Smart Contracts\\n #print(f\\\"ENS address: {ens.address()}\\\")\\n print(f\\\"ENS address (contract address): {ENS.address}\\\")\\n print(f\\\"Resolver address (contract address): {resolver.address()}\\\")\\n print(f\\\"Resolver address from ENS(root): {ens.resolver('root')}\\\")\\n print(\\\"\\\\n\\\")\\n\\n print(f\\\"Owner of ROOT record: {ens.owner('root')}\\\")\\n ROOT_address, ROOT_key = wallet.account_from_name(\\\"ROOT\\\", \\\"ThePassword\\\")\\n print(f\\\"ROOT address from wallet: {ROOT_address}\\\")\\n\\n n_subnodes = ens.numberSubnodes(0)\\n print(f\\\"Number of subnodes of root: {n_subnodes}\\\")\\n for i in range(n_subnodes):\\n hash = ens.subnode(index=i).hex()\\n print(f\\\" Subnode hash {i}: {ens.subnode(i).hex()}\\\")\\n name = resolver.name(node_hash=hash)\\n print(f\\\" Name: {name}\\\")\\n resolver_address = ENS.functions.resolver(hash).call()\\n print(f\\\" Resolver: {resolver_address}\\\")\\n ala_address = ens.resolver(name)\\n print(f\\\" Resolver by name: {ala_address}\\\")\\n owner = owner = ENS.functions.owner(hash).call()\\n print(f\\\" Owner: {owner}\\\")\\n ROOT_address, ROOT_key = wallet.account_from_name(\\\"Alastria\\\", \\\"ThePassword\\\")\\n print(f\\\" Address from wallet: {ROOT_address}\\\")\\n\\n n_subnodes = ens.numberSubnodes(\\\"ala\\\")\\n print(f\\\"Number of subnodes of {name}: {n_subnodes}\\\")\\n for i in range(n_subnodes):\\n hash = ens.subnode(node_name=\\\"ala\\\", index=i).hex()\\n print(f\\\" Subnode hash {i}: {hash}\\\")\\n name = resolver.name(node_hash=hash)\\n print(f\\\" Name: {name}\\\")\\n resolver_address = ENS.functions.resolver(hash).call()\\n print(f\\\" Resolver: {resolver_address}\\\")\\n ala_address = ens.resolver(name)\\n print(f\\\" Resolver by name: {ala_address}\\\")\\n owner = owner = ENS.functions.owner(hash).call()\\n print(f\\\" Owner: {owner}\\\")\",\n \"def serialize(self):\\n return pickle.dumps([block.serialize() for block in self.chain])\",\n \"def identity_block(X, f, filters, stage, block):\\n\\n # defining name basis\\n conv_name_base = 'res' + str(stage) + block + '_branch'\\n bn_name_base = 'bn' + str(stage) + block + '_branch'\\n\\n # Retrieve Filters\\n F1, F2, F3 = filters\\n\\n # Save the input value.\\n X_shortcut = X\\n\\n # First component of main path\\n X = Conv2D(filters = F1, kernel_size = (1, 1), strides = (1,1), padding = 'valid', name = conv_name_base + '2a', kernel_initializer = glorot_uniform(seed=0))(X)\\n X = BatchNormalization(axis = 3, name = bn_name_base + '2a')(X)\\n X = Activation('relu')(X)\\n\\n # Second component of main path\\n X = Conv2D(filters = F2, kernel_size= (f,f),strides= (1,1), padding= 'same' , name = conv_name_base + '2b', kernel_initializer = glorot_uniform(seed=0))(X)\\n X = BatchNormalization(axis=3, name=bn_name_base + '2b')(X)\\n X = Activation('relu')(X)\\n\\n # Third component of main path\\n X = Conv2D(filters = F3, kernel_size= (1,1),strides= (1,1), padding= 'valid' , name = conv_name_base + '2c', kernel_initializer = glorot_uniform(seed=0))(X)\\n X = BatchNormalization(axis=3, name=bn_name_base + '2c')(X)\\n\\n # Final step: Add shortcut value to main path, and pass it through a RELU activation\\n X = layers.add([X,X_shortcut])\\n X = Activation('relu')(X)\\n\\n return X\",\n \"def build_label_transform():\\n\\n return NALabelEncoder()\",\n \"def _make_ht_label(chain_parts):\\n\\n assert len(chain_parts) == 1, '_make_ht_label, no. of chain parts != 1'\\n scenario = chain_parts[0]['hypoScenario']\\n \\n assert scenario.startswith('HT'), '_make_ht_label(): scenario does not start with HT'\\n\\n arg_res = [\\n re.compile(r'^(?P<lo>\\\\d*)(?P<key>ht)(?P<hi>\\\\d*)$'),\\n re.compile(r'^(?P<lo>\\\\d*)(?P<key>et)(?P<hi>\\\\d*)$'),\\n re.compile(r'^(?P<lo>\\\\d*)(?P<key>eta)(?P<hi>\\\\d*)$'),\\n ]\\n\\n defaults = {\\n 'ht': ('0', 'inf'),\\n 'et': ('0', 'inf'),\\n 'eta': ('0', 'inf'),\\n }\\n\\n\\n args = _args_from_scenario(scenario)\\n argvals = {}\\n nargs = len(args)\\n assert len(args) <= len(arg_res), 'bad num of args %d, expected < %d' % (len(args),\\n len(arg_res))\\n\\n # obtain argument values frrom scenario\\n while args:\\n arg = args.pop()\\n for r in arg_res:\\n m = r.match(arg)\\n if m is not None:\\n arg_res.remove(r)\\n gd = m.groupdict()\\n key = gd['key']\\n\\n try:\\n lo = float(gd['lo'])\\n except ValueError:\\n lo = float(defaults[key][0])\\n argvals[key+'lo'] = lo \\n try:\\n hi = float(gd['hi'])\\n except ValueError:\\n hi = float(defaults[key][1])\\n argvals[key+'hi'] = hi\\n\\n print (argvals)\\n assert len(argvals) == 2*nargs, 'no of args: %d, expected %d' % (len(argvals), 2*nargs)\\n\\n print ('sent 100')\\n result = \\\"\\\"\\\"\\n ht([(%(htlo).0fht) \\n (%(etlo).0fet)\\n (%(etalo).0feta%(etahi).0f)\\n ])\\\"\\\"\\\" % argvals\\n print (result)\\n return result\",\n \"def makeBinaryChains():\\n\\t\\n\\t# retrieve the binding partner specifications\\n\\t(maxsize,types) = getTypes()\\n\\t\\n\\t# Do some basic argument checking for this model\\n\\tif (len(types) < 2):\\n\\t\\tprint \\\"Number of defined types must equal two for binary chain calculations.\\\"\\n\\t\\treturn\\n\\tif (maxsize == 0):\\n\\t\\tprint \\\"Must specify a valid maximum number for one or more components.\\\"\\n\\t\\treturn\\n\\n\\tallChains = []\\n\\tnewChainsA = [[]]\\n\\tnewChainsB = []\\n\\t\\n\\ttypeA = types[0]\\n\\ttypeB = types[1]\\n\\t\\n\\t# start the chain with a single type A component\\n\\taddComponent(newChainsA[0],typeA,0,0)\\n\\n\\tdepth = 0\\n\\tfor n in range(maxsize):\\n\\t\\tdepth+=1\\n\\t\\t\\n\\t\\t# go through all the chains created last iteration and append B components\\n\\t\\tnewChainsB = []\\n\\t\\tfor thisChain in newChainsA:\\n\\n\\t\\t\\t# get a list of new available sites in the provided chain\\n\\t\\t\\t# by setting depth -1, we will only add to components added last round\\n\\t\\t\\topenSites = makeSiteList(thisChain,typeB,depth-1)\\n\\t\\t\\t\\n\\t\\t\\t# make all the descendants from the current chain and append them to the pool\\n\\t\\t\\tif (n == 0) and (typeA['sym']): #if the starting binder is symmetric, no need to start chains at all its sites\\n\\t\\t\\t\\tnewChainsB = newChainsB + fillSites(openSites,thisChain,typeB,-1)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tnewChainsB = newChainsB + fillSites(openSites,thisChain,typeB,depth)\\n\\t\\t\\n\\t\\tprint('n:'+str(n)+', '+str(len(newChainsB))+ ' chains created at depth '+str(depth))\\n\\t\\t\\n\\t\\tallChains = allChains + newChainsB\\n\\t\\t\\n\\t\\tdepth+=1\\n\\t\\t\\n\\t\\t# add an additional component to all the previously modified chains\\n\\t\\tnewChainsA = []\\n\\t\\tfor thisChain in newChainsB:\\n\\n\\t\\t\\topenSites = makeSiteList(thisChain,typeA,depth-1)\\n\\t\\t\\tnewChainsA = newChainsA + fillSites(openSites,thisChain,typeA,depth)\\n\\t\\t\\t\\n\\t\\tprint('n:'+str(n)+', '+str(len(newChainsA))+ ' chains created at depth '+str(depth))\\n\\t\\t\\n\\t\\tallChains = allChains + newChainsA\\n\\n\\treturn allChains\",\n \"def __init__(self):\\n # Flag this instance as compiled now\\n self.is_compiled = True\\n \\n super(HState2CProcDef, self).__init__(name='HState2CProcDef', num_nodes=0, edges=[])\\n \\n \\n # Set the graph attributes\\n self[\\\"mm__\\\"] = ['HimesisMM']\\n \\n self[\\\"name\\\"] = \\\"\\\"\\\"State2CProcDef\\\"\\\"\\\"\\n self[\\\"GUID__\\\"] = uuid.uuid3(uuid.NAMESPACE_DNS,'State2CProcDef')\\n \\n # match model. We only support one match model\\n self.add_node()\\n self.vs[0][\\\"mm__\\\"] = \\\"\\\"\\\"MatchModel\\\"\\\"\\\"\\n \\n # apply model node\\n self.add_node()\\n self.vs[1][\\\"mm__\\\"] = \\\"\\\"\\\"ApplyModel\\\"\\\"\\\"\\n \\n # paired with relation between match and apply models\\n self.add_node()\\n self.vs[2][\\\"mm__\\\"] = \\\"\\\"\\\"paired_with\\\"\\\"\\\"\\n \\n \\n # match class State() node\\n self.add_node()\\n\\n self.vs[3][\\\"mm__\\\"] = \\\"\\\"\\\"State\\\"\\\"\\\" \\n self.vs[3][\\\"attr1\\\"] = \\\"\\\"\\\"+\\\"\\\"\\\" \\n # match_contains node for class State()\\n self.add_node()\\n self.vs[4][\\\"mm__\\\"] = \\\"\\\"\\\"match_contains\\\"\\\"\\\"\\n # match class Transition() node\\n self.add_node()\\n\\n self.vs[5][\\\"mm__\\\"] = \\\"\\\"\\\"Transition\\\"\\\"\\\" \\n self.vs[5][\\\"attr1\\\"] = \\\"\\\"\\\"1\\\"\\\"\\\" \\n # match_contains node for class Transition()\\n self.add_node()\\n self.vs[6][\\\"mm__\\\"] = \\\"\\\"\\\"match_contains\\\"\\\"\\\"\\n # match class EntryPoint() node\\n self.add_node()\\n\\n self.vs[7][\\\"mm__\\\"] = \\\"\\\"\\\"EntryPoint\\\"\\\"\\\" \\n self.vs[7][\\\"attr1\\\"] = \\\"\\\"\\\"1\\\"\\\"\\\" \\n # match_contains node for class EntryPoint()\\n self.add_node()\\n self.vs[8][\\\"mm__\\\"] = \\\"\\\"\\\"match_contains\\\"\\\"\\\"\\n # match class StateMachine() node\\n self.add_node()\\n\\n self.vs[9][\\\"mm__\\\"] = \\\"\\\"\\\"StateMachine\\\"\\\"\\\" \\n self.vs[9][\\\"attr1\\\"] = \\\"\\\"\\\"1\\\"\\\"\\\" \\n # match_contains node for class StateMachine()\\n self.add_node()\\n self.vs[10][\\\"mm__\\\"] = \\\"\\\"\\\"match_contains\\\"\\\"\\\"\\n \\n \\n # apply class LocalDef() node\\n self.add_node()\\n\\n self.vs[11][\\\"mm__\\\"] = \\\"\\\"\\\"LocalDef\\\"\\\"\\\" \\n self.vs[11][\\\"attr1\\\"] = \\\"\\\"\\\"1\\\"\\\"\\\"\\n # apply_contains node for class LocalDef()\\n self.add_node()\\n self.vs[12][\\\"mm__\\\"] = \\\"\\\"\\\"apply_contains\\\"\\\"\\\"\\n # apply class ProcDef() node\\n self.add_node()\\n\\n self.vs[13][\\\"mm__\\\"] = \\\"\\\"\\\"ProcDef\\\"\\\"\\\" \\n self.vs[13][\\\"attr1\\\"] = \\\"\\\"\\\"1\\\"\\\"\\\"\\n # apply_contains node for class ProcDef()\\n self.add_node()\\n self.vs[14][\\\"mm__\\\"] = \\\"\\\"\\\"apply_contains\\\"\\\"\\\"\\n # apply class Name() node\\n self.add_node()\\n\\n self.vs[15][\\\"mm__\\\"] = \\\"\\\"\\\"Name\\\"\\\"\\\" \\n self.vs[15][\\\"attr1\\\"] = \\\"\\\"\\\"1\\\"\\\"\\\"\\n # apply_contains node for class Name()\\n self.add_node()\\n self.vs[16][\\\"mm__\\\"] = \\\"\\\"\\\"apply_contains\\\"\\\"\\\"\\n # apply class Name() node\\n self.add_node()\\n\\n self.vs[17][\\\"mm__\\\"] = \\\"\\\"\\\"Name\\\"\\\"\\\" \\n self.vs[17][\\\"attr1\\\"] = \\\"\\\"\\\"1\\\"\\\"\\\"\\n # apply_contains node for class Name()\\n self.add_node()\\n self.vs[18][\\\"mm__\\\"] = \\\"\\\"\\\"apply_contains\\\"\\\"\\\"\\n # apply class Name() node\\n self.add_node()\\n\\n self.vs[19][\\\"mm__\\\"] = \\\"\\\"\\\"Name\\\"\\\"\\\" \\n self.vs[19][\\\"attr1\\\"] = \\\"\\\"\\\"1\\\"\\\"\\\"\\n # apply_contains node for class Name()\\n self.add_node()\\n self.vs[20][\\\"mm__\\\"] = \\\"\\\"\\\"apply_contains\\\"\\\"\\\"\\n # apply class Name() node\\n self.add_node()\\n\\n self.vs[21][\\\"mm__\\\"] = \\\"\\\"\\\"Name\\\"\\\"\\\" \\n self.vs[21][\\\"attr1\\\"] = \\\"\\\"\\\"1\\\"\\\"\\\"\\n # apply_contains node for class Name()\\n self.add_node()\\n self.vs[22][\\\"mm__\\\"] = \\\"\\\"\\\"apply_contains\\\"\\\"\\\"\\n # apply class ConditionSet() node\\n self.add_node()\\n\\n self.vs[23][\\\"mm__\\\"] = \\\"\\\"\\\"ConditionSet\\\"\\\"\\\" \\n self.vs[23][\\\"attr1\\\"] = \\\"\\\"\\\"1\\\"\\\"\\\"\\n # apply_contains node for class ConditionSet()\\n self.add_node()\\n self.vs[24][\\\"mm__\\\"] = \\\"\\\"\\\"apply_contains\\\"\\\"\\\"\\n # apply class Inst() node\\n self.add_node()\\n\\n self.vs[25][\\\"mm__\\\"] = \\\"\\\"\\\"Inst\\\"\\\"\\\" \\n self.vs[25][\\\"attr1\\\"] = \\\"\\\"\\\"1\\\"\\\"\\\"\\n # apply_contains node for class Inst()\\n self.add_node()\\n self.vs[26][\\\"mm__\\\"] = \\\"\\\"\\\"apply_contains\\\"\\\"\\\"\\n # apply class Name() node\\n self.add_node()\\n\\n self.vs[27][\\\"mm__\\\"] = \\\"\\\"\\\"Name\\\"\\\"\\\" \\n self.vs[27][\\\"attr1\\\"] = \\\"\\\"\\\"1\\\"\\\"\\\"\\n # apply_contains node for class Name()\\n self.add_node()\\n self.vs[28][\\\"mm__\\\"] = \\\"\\\"\\\"apply_contains\\\"\\\"\\\"\\n # apply class Name() node\\n self.add_node()\\n\\n self.vs[29][\\\"mm__\\\"] = \\\"\\\"\\\"Name\\\"\\\"\\\" \\n self.vs[29][\\\"attr1\\\"] = \\\"\\\"\\\"1\\\"\\\"\\\"\\n # apply_contains node for class Name()\\n self.add_node()\\n self.vs[30][\\\"mm__\\\"] = \\\"\\\"\\\"apply_contains\\\"\\\"\\\"\\n # apply class Name() node\\n self.add_node()\\n\\n self.vs[31][\\\"mm__\\\"] = \\\"\\\"\\\"Name\\\"\\\"\\\" \\n self.vs[31][\\\"attr1\\\"] = \\\"\\\"\\\"1\\\"\\\"\\\"\\n # apply_contains node for class Name()\\n self.add_node()\\n self.vs[32][\\\"mm__\\\"] = \\\"\\\"\\\"apply_contains\\\"\\\"\\\"\\n # apply class Name() node\\n self.add_node()\\n\\n self.vs[33][\\\"mm__\\\"] = \\\"\\\"\\\"Name\\\"\\\"\\\" \\n self.vs[33][\\\"attr1\\\"] = \\\"\\\"\\\"1\\\"\\\"\\\"\\n # apply_contains node for class Name()\\n self.add_node()\\n self.vs[34][\\\"mm__\\\"] = \\\"\\\"\\\"apply_contains\\\"\\\"\\\"\\n \\n \\n # match association State--initialTransition-->Transition node\\n self.add_node()\\n self.vs[35][\\\"attr1\\\"] = \\\"\\\"\\\"initialTransition\\\"\\\"\\\"\\n self.vs[35][\\\"mm__\\\"] = \\\"\\\"\\\"directLink_S\\\"\\\"\\\"\\n # match association Transition--dest-->EntryPoint node\\n self.add_node()\\n self.vs[36][\\\"attr1\\\"] = \\\"\\\"\\\"dest\\\"\\\"\\\"\\n self.vs[36][\\\"mm__\\\"] = \\\"\\\"\\\"directLink_S\\\"\\\"\\\"\\n # match association EntryPoint--owningStateMachine-->StateMachine node\\n self.add_node()\\n self.vs[37][\\\"attr1\\\"] = \\\"\\\"\\\"owningStateMachine\\\"\\\"\\\"\\n self.vs[37][\\\"mm__\\\"] = \\\"\\\"\\\"directLink_S\\\"\\\"\\\"\\n \\n # apply association LocalDef--def-->ProcDef node\\n self.add_node()\\n self.vs[38][\\\"attr1\\\"] = \\\"\\\"\\\"def\\\"\\\"\\\"\\n self.vs[38][\\\"mm__\\\"] = \\\"\\\"\\\"directLink_T\\\"\\\"\\\"\\n # apply association ProcDef--channelNames-->Name node\\n self.add_node()\\n self.vs[39][\\\"attr1\\\"] = \\\"\\\"\\\"channelNames\\\"\\\"\\\"\\n self.vs[39][\\\"mm__\\\"] = \\\"\\\"\\\"directLink_T\\\"\\\"\\\"\\n # apply association ProcDef--channelNames-->Name node\\n self.add_node()\\n self.vs[40][\\\"attr1\\\"] = \\\"\\\"\\\"channelNames\\\"\\\"\\\"\\n self.vs[40][\\\"mm__\\\"] = \\\"\\\"\\\"directLink_T\\\"\\\"\\\"\\n # apply association ProcDef--channelNames-->Name node\\n self.add_node()\\n self.vs[41][\\\"attr1\\\"] = \\\"\\\"\\\"channelNames\\\"\\\"\\\"\\n self.vs[41][\\\"mm__\\\"] = \\\"\\\"\\\"directLink_T\\\"\\\"\\\"\\n # apply association ProcDef--channelNames-->Name node\\n self.add_node()\\n self.vs[42][\\\"attr1\\\"] = \\\"\\\"\\\"channelNames\\\"\\\"\\\"\\n self.vs[42][\\\"mm__\\\"] = \\\"\\\"\\\"directLink_T\\\"\\\"\\\"\\n # apply association ProcDef--p-->ConditionSet node\\n self.add_node()\\n self.vs[43][\\\"attr1\\\"] = \\\"\\\"\\\"p\\\"\\\"\\\"\\n self.vs[43][\\\"mm__\\\"] = \\\"\\\"\\\"directLink_T\\\"\\\"\\\"\\n # apply association ConditionSet--alternative-->Inst node\\n self.add_node()\\n self.vs[44][\\\"attr1\\\"] = \\\"\\\"\\\"alternative\\\"\\\"\\\"\\n self.vs[44][\\\"mm__\\\"] = \\\"\\\"\\\"directLink_T\\\"\\\"\\\"\\n # apply association Inst--channelNames-->Name node\\n self.add_node()\\n self.vs[45][\\\"attr1\\\"] = \\\"\\\"\\\"channelNames\\\"\\\"\\\"\\n self.vs[45][\\\"mm__\\\"] = \\\"\\\"\\\"directLink_T\\\"\\\"\\\"\\n # apply association Inst--channelNames-->Name node\\n self.add_node()\\n self.vs[46][\\\"attr1\\\"] = \\\"\\\"\\\"channelNames\\\"\\\"\\\"\\n self.vs[46][\\\"mm__\\\"] = \\\"\\\"\\\"directLink_T\\\"\\\"\\\"\\n # apply association Inst--channelNames-->Name node\\n self.add_node()\\n self.vs[47][\\\"attr1\\\"] = \\\"\\\"\\\"channelNames\\\"\\\"\\\"\\n self.vs[47][\\\"mm__\\\"] = \\\"\\\"\\\"directLink_T\\\"\\\"\\\"\\n # apply association Inst--channelNames-->Name node\\n self.add_node()\\n self.vs[48][\\\"attr1\\\"] = \\\"\\\"\\\"channelNames\\\"\\\"\\\"\\n self.vs[48][\\\"mm__\\\"] = \\\"\\\"\\\"directLink_T\\\"\\\"\\\"\\n \\n # backward association State---->LocalDef node\\n self.add_node()\\n\\n self.vs[49][\\\"mm__\\\"] = \\\"\\\"\\\"backward_link\\\"\\\"\\\"\\n \\n \\n \\n \\n \\n \\n # Add the edges\\n self.add_edges([\\n (0,4), # matchmodel -> match_contains\\n (4,3), # match_contains -> match_class State()\\n (0,6), # matchmodel -> match_contains\\n (6,5), # match_contains -> match_class Transition()\\n (0,8), # matchmodel -> match_contains\\n (8,7), # match_contains -> match_class EntryPoint()\\n (0,10), # matchmodel -> match_contains\\n (10,9), # match_contains -> match_class StateMachine()\\n (1,12), # applymodel -> apply_contains\\n (12,11), # apply_contains -> apply_class LocalDef()\\n (1,14), # applymodel -> apply_contains\\n (14,13), # apply_contains -> apply_class ProcDef()\\n (1,16), # applymodel -> apply_contains\\n (16,15), # apply_contains -> apply_class Name()\\n (1,18), # applymodel -> apply_contains\\n (18,17), # apply_contains -> apply_class Name()\\n (1,20), # applymodel -> apply_contains\\n (20,19), # apply_contains -> apply_class Name()\\n (1,22), # applymodel -> apply_contains\\n (22,21), # apply_contains -> apply_class Name()\\n (1,24), # applymodel -> apply_contains\\n (24,23), # apply_contains -> apply_class ConditionSet()\\n (1,26), # applymodel -> apply_contains\\n (26,25), # apply_contains -> apply_class Inst()\\n (1,28), # applymodel -> apply_contains\\n (28,27), # apply_contains -> apply_class Name()\\n (1,30), # applymodel -> apply_contains\\n (30,29), # apply_contains -> apply_class Name()\\n (1,32), # applymodel -> apply_contains\\n (32,31), # apply_contains -> apply_class Name()\\n (1,34), # applymodel -> apply_contains\\n (34,33), # apply_contains -> apply_class Name()\\n (3,35), # match_class State() -> association initialTransition\\n (35,5), # association initialTransition -> match_class Transition()\\n (5,36), # match_class Transition() -> association dest\\n (36,7), # association dest -> match_class EntryPoint()\\n (7,37), # match_class EntryPoint() -> association owningStateMachine\\n (37,9), # association owningStateMachine -> match_class StateMachine()\\n (11,38), # apply_class LocalDef() -> association def\\n (38,13), # association def -> apply_class ProcDef()\\n (13,39), # apply_class ProcDef() -> association channelNames\\n (39,15), # association channelNames -> apply_class Name()\\n (13,40), # apply_class ProcDef() -> association channelNames\\n (40,17), # association channelNames -> apply_class Name()\\n (13,41), # apply_class ProcDef() -> association channelNames\\n (41,19), # association channelNames -> apply_class Name()\\n (13,42), # apply_class ProcDef() -> association channelNames\\n (42,21), # association channelNames -> apply_class Name()\\n (13,43), # apply_class ProcDef() -> association p\\n (43,23), # association p -> apply_class ConditionSet()\\n (23,44), # apply_class ConditionSet() -> association alternative\\n (44,25), # association alternative -> apply_class Inst()\\n (25,45), # apply_class Inst() -> association channelNames\\n (45,27), # association channelNames -> apply_class Name()\\n (25,46), # apply_class Inst() -> association channelNames\\n (46,29), # association channelNames -> apply_class Name()\\n (25,47), # apply_class Inst() -> association channelNames\\n (47,31), # association channelNames -> apply_class Name()\\n (25,48), # apply_class Inst() -> association channelNames\\n (48,33), # association channelNames -> apply_class Name()\\n (11,49), # apply_class LocalDef() -> backward_association\\n (49,3), # backward_association -> apply_class State()\\n (0,2), # matchmodel -> pairedwith\\n (2,1) # pairedwith -> applyModel\\t\\t\\t\\t\\n\\t\\t])\\n\\n # Add the attribute equations\\n self[\\\"equations\\\"] = [((3,'isComposite'),('constant','true')), ((11,'ApplyAttribute'),('constant','solveRef')), ((13,'name'),('constant','C')), ((15,'literal'),('constant','enp')), ((17,'literal'),('constant','exit')), ((19,'literal'),('constant','exack')), ((21,'literal'),('constant','sh')), ((23,'ApplyAttribute'),('constant','solveRef')), ((25,'name'),('concat',(('constant','S'),(9,'name')))), ((27,'literal'),('concat',(('constant','A'),('concat',((7,'name'),('constant','A')))))), ((29,'literal'),('constant','exit_in')), ((31,'literal'),('constant','exack_in')), ((33,'literal'),('constant','sh_in')), ]\",\n \"def calculate_217f_part_count(**attributes):\\n _msg = ''\\n\\n # Dictionary containing MIL-HDBK-217FN2 parts count base hazard rates.\\n # First key is the subcategory_id, second key is the specification id. If\\n # the resistor subcategory is NOT specification dependent, then the second\\n # key will be zero. Current subcategory IDs are:\\n #\\n # 1. Fixed, Composition (RC, RCR)\\n # 2. Fixed, Film (RL, RLR, RN, RNC, RNN, RNR)\\n # 3. Fixed, Film, Power (RD)\\n # 4. Fixed, Film, Network (RZ)\\n # 5. Fixed, Wirewound, Power (RB, RBR)\\n # 6. Fixed, Wirewound, Power, Chassis Mounted (RE, RER)\\n # 7. Thermistor\\n # 8. Variable, Wirewound (RT, RTR)\\n # 9. Variable, Wirewound, Precision (RR)\\n # 10. Variable, Wirewound, Semiprecision (RA, RK)\\n # 11. Variable, Non-Wirewound (RJ, RJR)\\n # 12. Variable, Composition (RV)\\n # 13. Variable,Non-Wirewound, Film and Precision (RQ, RVC)\\n #\\n # These keys return a list of base hazard rates. The hazard rate to use is\\n # selected from the list depending on the active environment.\\n _dic_lambda_b = {\\n 1: [\\n 0.0005, 0.0022, 0.0071, 0.0037, 0.012, 0.0052, 0.0065, 0.016,\\n 0.025, 0.025, 0.00025, 0.0098, 0.035, 0.36\\n ],\\n 2: {\\n 1: [\\n 0.0012, 0.0027, 0.011, 0.0054, 0.020, 0.0063, 0.013, 0.018,\\n 0.033, 0.030, 0.00025, 0.014, 0.044, 0.69\\n ],\\n 2: [\\n 0.0012, 0.0027, 0.011, 0.0054, 0.020, 0.0063, 0.013, 0.018,\\n 0.033, 0.030, 0.00025, 0.014, 0.044, 0.69\\n ],\\n 3: [\\n 0.0014, 0.0031, 0.013, 0.0061, 0.023, 0.0072, 0.014, 0.021,\\n 0.038, 0.034, 0.00028, 0.016, 0.050, 0.78\\n ],\\n 4: [\\n 0.0014, 0.0031, 0.013, 0.0061, 0.023, 0.0072, 0.014, 0.021,\\n 0.038, 0.034, 0.00028, 0.016, 0.050, 0.78\\n ]\\n },\\n 3: [\\n 0.012, 0.025, 0.13, 0.062, 0.21, 0.078, 0.10, 0.19, 0.24, 0.32,\\n 0.0060, 0.18, 0.47, 8.2\\n ],\\n 4: [\\n 0.0023, 0.0066, 0.031, 0.013, 0.055, 0.022, 0.043, 0.077, 0.15,\\n 0.10, 0.0011, 0.055, 0.15, 1.7\\n ],\\n 5: [\\n 0.0085, 0.018, 0.10, 0.045, 0.16, 0.15, 0.17, 0.30, 0.38, 0.26,\\n 0.0068, 0.13, 0.37, 5.4\\n ],\\n 6: {\\n 1: [\\n 0.014, 0.031, 0.16, 0.077, 0.26, 0.073, 0.15, 0.19, 0.39, 0.42,\\n 0.0042, 0.21, 0.62, 9.4\\n ],\\n 2: [\\n 0.013, 0.028, 0.15, 0.070, 0.24, 0.065, 0.13, 0.18, 0.35, 0.38,\\n 0.0038, 0.19, 0.56, 8.6\\n ]\\n },\\n 7: [\\n 0.008, 0.18, 0.096, 0.045, 0.15, 0.044, 0.088, 0.12, 0.24, 0.25,\\n 0.004, 0.13, 0.37, 5.5\\n ],\\n 8: [\\n 0.065, 0.32, 1.4, 0.71, 1.6, 0.71, 1.9, 1.0, 2.7, 2.4, 0.032, 1.3,\\n 3.4, 62.0\\n ],\\n 9: [\\n 0.025, 0.055, 0.35, 0.15, 0.58, 0.16, 0.26, 0.35, 0.58, 1.1, 0.013,\\n 0.52, 1.6, 24.0\\n ],\\n 10: [\\n 0.33, 0.73, 7.0, 2.9, 12.0, 3.5, 5.3, 7.1, 9.8, 23.0, 0.16, 11.0,\\n 33.0, 510.0\\n ],\\n 11: [\\n 0.15, 0.35, 3.1, 1.2, 5.4, 1.9, 2.8, 0.0, 0.0, 9.0, 0.075, 0.0,\\n 0.0, 0.0\\n ],\\n 12: [\\n 0.15, 0.34, 2.9, 1.2, 5.0, 1.6, 2.4, 0.0, 0.0, 7.6, 0.076, 0.0,\\n 0.0, 0.0\\n ],\\n 13: [\\n 0.043, 0.15, 0.75, 0.35, 1.3, 0.39, 0.78, 1.8, 2.8, 2.5, 0.21, 1.2,\\n 3.7, 49.0\\n ],\\n 14: [\\n 0.05, 0.11, 1.1, 0.45, 1.7, 2.8, 4.6, 4.6, 7.5, 3.3, 0.025, 1.5,\\n 4.7, 67.0\\n ],\\n 15: [\\n 0.048, 0.16, 0.76, 0.36, 1.3, 0.36, 0.72, 1.4, 2.2, 2.3, 0.024,\\n 1.2, 3.4, 52.0\\n ]\\n }\\n\\n # List containing piQ values for parts count method. The list positions\\n # corrspond to the following quality levels:\\n #\\n # 0. Established reliability level S\\n # 1. Established reliability level R\\n # 2. Established reliability level P\\n # 3. Established reliability level M\\n # 4. Non-established reliability MIL-SPEC\\n # 5. Non-established reliability lower\\n #\\n # The quality_id attribute is used to select the proper value of piQ.\\n _lst_piQ = [0.030, 0.10, 0.30, 1.0, 3.0, 10.0]\\n\\n # Select the base hazard rate.\\n try:\\n if attributes['subcategory_id'] in [2, 6]:\\n _lst_base_hr = _dic_lambda_b[attributes['subcategory_id']][\\n attributes['specification_id']]\\n else:\\n _lst_base_hr = _dic_lambda_b[attributes['subcategory_id']]\\n except KeyError:\\n _lst_base_hr = [0.0]\\n\\n try:\\n attributes['lambda_b'] = _lst_base_hr[\\n attributes['environment_active_id'] - 1]\\n except IndexError:\\n attributes['lambda_b'] = 0.0\\n\\n # Select the piQ.\\n try:\\n attributes['piQ'] = _lst_piQ[attributes['quality_id'] - 1]\\n except IndexError:\\n attributes['piQ'] = 0.0\\n\\n # Confirm all inputs are within range. If not, set the message. The\\n # hazard rate will be calculated anyway, but will be zero.\\n if attributes['lambda_b'] <= 0.0:\\n _msg = _msg + 'RAMSTK WARNING: Base hazard rate is 0.0 when ' \\\\\\n 'calculating resistor, hardware ID: ' \\\\\\n '{0:d}, subcategory ID: {1:d}, specification ID: {2:d}, ' \\\\\\n 'active environment ID: {3:d}, and quality ID: ' \\\\\\n '{4:d}.\\\\n'.format(attributes['hardware_id'],\\n attributes['subcategory_id'],\\n attributes['specification_id'],\\n attributes['environment_active_id'],\\n attributes['quality_id'])\\n\\n if attributes['piQ'] <= 0.0:\\n _msg = _msg + 'RAMSTK WARNING: piQ is 0.0 when calculating ' \\\\\\n 'resistor, hardware ID: {0:d}, quality ID: ' \\\\\\n '{1:d}.'.format(attributes['hardware_id'],\\n attributes['quality_id'])\\n\\n # Calculate the hazard rate.\\n attributes['hazard_rate_active'] = (\\n attributes['lambda_b'] * attributes['piQ'])\\n\\n return attributes, _msg\",\n \"def identity_block(self,X,stage,block):\\n conv_name_base='res'+str(stage)+block+'_branch'\\n bn_name_base='bn'+str(stage)+block+'_branch'\\n \\n #retrieve the filters\\n #F1,F2,F3=filters\\n \\n X_shortcut=X\\n \\n #first component of main path\\n X=Conv3D(self.filter, (3,3,1),kernel_initializer=self.init,kernel_regularizer=self.regularizer,padding='same')(X)\\n X=BatchNormalization(axis=3)(X)\\n X=Activation('relu')(X)\\n \\n #second component of main path\\n X=Conv3D(self.filter, (3,3,1),kernel_initializer=self.init,kernel_regularizer=self.regularizer,padding='same')(X)\\n\\n \\n #final step, add the shortcut\\n X=Add()([X,X_shortcut])\\n X=Activation('relu')(X)\\n \\n \\n return X\",\n \"def run(self, voxels, entry='all', freq_raw=False):\\n\\n # Note. in this case we are processing all raw data into the data \\n # attribute, so despite having multiple raw FIDs, we are really \\n # only processing one voxel, so no for loop\\n\\n # local reference to input data\\n self.raw = self._dataset.get_source_data('prep')\\n\\n # Choose voxel - for saving result for current single voxel plot\\n self.voxel = voxels[0]\\n\\n # select the chain processing functor based on the entry point\\n if entry == 'all':\\n funct_fidsum_wbnaa.do_processing_all(self)\\n else:\\n print('oooops!')\\n\\n # save data and parameter results into the Block results arrays\\n self._block.data[0,0,0,:] = self.time_summed_offset.copy()\\n \\n # Return values specific to calling Tab that contains this Block.Chain\\n # Used to update its self.view (plot_panel_spectrum object).\\n\\n plot_results = { 'freq_current' : self.freq_current.copy(),\\n 'freq_summed' : self.freq_summed.copy(),\\n 'freq_summed_offset' : self.freq_summed_offset.copy() }\\n \\n return plot_results\",\n \"def dumpData(self,out,index):\\n #--SCVR\\n out.pack('4siBB2sB',\\n 'SCVR', 5+len(self.text), index+48, self.type, self.func, self.oper)\\n if self.text: out.write(self.text)\\n #--Value\\n if isinstance(self.value,int):\\n out.packSub('INTV','i', self.value)\\n else:\\n out.packSub('FLTV','f', self.value)\",\n \"def __init__(self,config = None):\\n \\n self.join_path = join_path\\n self.label_path = cfg['labels_path']\\n self.pick_path = (cfg['result_path'] + cfg['pickle_path'])\\n self.label_dir = os.path.join(CWD_PATH,self.join_path, self.label_path)\\n\\n #Variables inherent to the Fluent data: \\n self.num_ins = 4\\n\\n self.scale_var = cfg['scale_var']\\n # User set values are below. These can be adjusted in config.yml \\n self.MSE_thresh1 = (cfg['thresh1']*self.scale_var)**2\\n self.MSE_thresh2 = (cfg['thresh2']*self.scale_var)**2\\n self.MSE_thresh3 = (cfg['thresh3']*self.scale_var)**2\\n \\n self.rew_goal = cfg['reward'] * self.scale_var\\n\\n self.noise = cfg['noise']\\n self.minmaxbuffer = cfg['minmaxbuffer']\\n\\n # Get the function of input-output mapping, and max & min:\\n [self.O_CH4_flow_uniformity, mins,maxes] = self.get_funcs('O_CH4_flow_uniformity')\\n [self.O_CH4_mol_frac, mins,maxes] = self.get_funcs('O_CH4_mol_frac')\\n [self.O_t, mins, maxes] = self.get_funcs('O_t')\\n \\n self.mins = mins# * self.scale_var\\n self.maxes = maxes#* self.scale_var\\n #Action range is a percentage of the total range\\n self.action_range = cfg['action_range']*self.scale_var\\n\\n #Action space is the up & down range for the 4 actions \\n self.action_space = Box(-self.action_range, self.action_range, shape=(self.num_ins,), dtype=np.float32)\\n\\n # For ref, this is a 10d state space:\\n #in: 1 ch4 flow, 2 ch4 t, 3 o2 flow, 4 o2 t,\\n #out: 5 flow unif, 6 mol frac, 7 temp\\n #out - target: 8 flow unif, 9 mol frac, 10 temp\\n \\n self.observation_space = Tuple((Box(self.mins.values[0],self.maxes.values[0],shape=(1,), dtype=np.float32),\\n Box(self.mins.values[1],self.maxes.values[1],shape=(1,), dtype=np.float32),\\n Box(self.mins.values[2],self.maxes.values[2],shape=(1,), dtype=np.float32),\\n Box(self.mins.values[3],self.maxes.values[3],shape=(1,), dtype=np.float32),\\n Box(self.mins.values[4],self.maxes.values[4],shape=(1,), dtype=np.float32),\\n Box(self.mins.values[5],self.maxes.values[5],shape=(1,), dtype=np.float32),\\n Box(self.mins.values[6],self.maxes.values[6],shape=(1,), dtype=np.float32),\\n Box(self.mins.values[4],self.maxes.values[4],shape=(1,), dtype=np.float32),\\n Box(self.mins.values[5],self.maxes.values[5],shape=(1,), dtype=np.float32),\\n Box(self.mins.values[6],self.maxes.values[6],shape=(1,), dtype=np.float32)))\\n \\n # TODO this isn't really a proper gym spec\\n self._spec = lambda: None\\n self._spec.id = \\\"AllVar-v0\\\"\\n \\n # For rendering:\\n self.viewer = None\\n self.labels = cfg['labels']\\n \\n #initialize variables for tracking:\\n self.episode = 0\\n self.reward = 0\\n self.reset()\",\n \"def compile_xilinx_graph(self):\\n pass\",\n \"def levelsets_to_vector_field(levelsets, stepsize):\\r\\n vector_field_shape = levelsets[0][0].shape\\r\\n y_comp_combined = np.ndarray(vector_field_shape)\\r\\n x_comp_combined = np.ndarray(vector_field_shape)\\r\\n y_comp_combined.fill(np.nan)\\r\\n x_comp_combined.fill(np.nan)\\r\\n\\r\\n for source, target in levelsets:\\r\\n labels_present = set(np.array([source.flatten(),target.flatten()]).flatten())\\r\\n labels_present.remove(0)#relates to background\\r\\n\\r\\n #print(labels_present)\\r\\n for l in labels_present:\\r\\n\\r\\n source_cluster = source == l\\r\\n target_cluster = target == l\\r\\n\\r\\n\\r\\n \\\"\\\"\\\"plt.imshow(source_cluster.astype(np.int32)+target_cluster.astype(np.int32))\\r\\n plt.show()\\r\\n print(\\\"-----------\\\")\\\"\\\"\\\"\\r\\n\\r\\n #plot_gradient_field(source_cluster.astype(np.int32), target_cluster.astype(np.int32))\\r\\n\\r\\n y_comp, x_comp = array_to_vector_field(source_cluster, target_cluster, stepsize=stepsize)\\r\\n y_comp_combined[~np.isnan(y_comp)] = y_comp[~np.isnan(y_comp)]\\r\\n x_comp_combined[~np.isnan(x_comp)] = x_comp[~np.isnan(x_comp)]\\r\\n return y_comp_combined, x_comp_combined\",\n \"def convert_propbank(detail=True):\\n\\n out_dir = \\\"../data/wsj_propbank/\\\"\\n os.system(\\\"rm -rf %s\\\" % (out_dir, ))\\n os.system(\\\"mkdir -p %s\\\" % (out_dir, ))\\n\\n pb_instances = propbank.instances()\\n # Count at first\\n verb2idx = {}\\n verb2frames = {}\\n for i in range(0, len(pb_instances)):\\n inst = pb_instances[i]\\n verb_lemma, frame = inst.roleset.split(\\\".\\\")\\n if verb_lemma not in verb2idx:\\n verb2idx[verb_lemma] = []\\n verb2idx[verb_lemma].append(i)\\n if verb_lemma not in verb2frames:\\n verb2frames[verb_lemma] = []\\n if frame not in verb2frames[verb_lemma]:\\n verb2frames[verb_lemma].append(frame)\\n verb_nums = len(verb2idx.keys())\\n verb_counter = 0\\n\\n pair_label = {'-LRB-':'(', '-RRB-':')', '-LCB-':'(', '-RCB-':')'}\\n for verb_lemma, idxs in verb2idx.items():\\n verb_counter += 1\\n if len(verb2frames[verb_lemma]) < 2:\\n continue\\n fh = open(\\\"%s/%s\\\" % (out_dir, verb_lemma), \\\"w\\\")\\n if detail:\\n print(\\\"processing %s(%s/%s)\\\"\\n % (verb_lemma, verb_counter, verb_nums))\\n for i in idxs:\\n inst = pb_instances[i]\\n fileid = inst.fileid\\n sent_num = inst.sentnum\\n verb_pos = inst.wordnum\\n verb_lemma, frame = inst.roleset.split(\\\".\\\")\\n section = [x for x in fileid if x.isdigit()][0:2]\\n section = \\\"\\\".join(section)\\n fileid_for_ptb = \\\"WSJ/%s/%s\\\" % (section, fileid.upper())\\n\\n tagged_sent = ptb.tagged_sents(fileid_for_ptb)[sent_num]\\n # Change tagged_sent from [tuples] to [list]\\n tagged_sent = [[x[0], x[1]]for x in tagged_sent]\\n verb_bak = tagged_sent[verb_pos][0]\\n verb_identifier = \\\"verb_identifier_xxxxx\\\"\\n tagged_sent[verb_pos][0] = verb_identifier\\n sent = []\\n for (token, tag)in tagged_sent:\\n if tag != '-NONE-':\\n if token in pair_label:\\n token = pair_label[token]\\n sent.append(token)\\n sent = \\\" \\\".join(sent)\\n sent_toks = nltk.sent_tokenize(sent)\\n candidate_sent = None\\n for sent_tok in sent_toks:\\n if sent_tok.find(verb_identifier) >= 0:\\n candidate_sent = sent_tok\\n left_sent, right_sent = candidate_sent.split(verb_identifier)\\n left_sent = left_sent.strip()\\n right_sent = right_sent.strip()\\n out_line = \\\"%s\\\\t%s\\\\t%s\\\\t%s\\\" % (frame, left_sent, verb_bak, right_sent)\\n out_line = remove_punctuations(out_line)\\n print(out_line, file=fh)\\n fh.close()\",\n \"def render(self): # pragma: no cover\\n from graphviz import Digraph\\n dot = Digraph(name=\\\"top\\\")\\n for block in self.blocks:\\n if isinstance(block, Branch):\\n label = \\\"if \\\" + astor.to_source(block.cond)\\n dot.node(str(id(block)), label.rstrip(), {\\\"shape\\\": \\\"invhouse\\\"})\\n elif isinstance(block, Yield):\\n label = astor.to_source(block.value)\\n # label += \\\"\\\\nLive Ins : \\\" + str(block.live_ins)\\n # label += \\\"\\\\nLive Outs : \\\" + str(block.live_outs)\\n # label += \\\"\\\\nGen : \\\" + str(block.gen)\\n # label += \\\"\\\\nKill : \\\" + str(block.kill)\\n dot.node(str(id(block)), label.rstrip(), {\\\"shape\\\": \\\"oval\\\"})\\n elif isinstance(block, BasicBlock):\\n label = \\\"\\\\n\\\".join(astor.to_source(stmt).rstrip() for stmt in block.statements)\\n # label += \\\"\\\\nLive Ins : \\\" + str(block.live_ins)\\n # label += \\\"\\\\nLive Outs : \\\" + str(block.live_outs)\\n # label += \\\"\\\\nGen : \\\" + str(block.gen)\\n # label += \\\"\\\\nKill : \\\" + str(block.kill)\\n dot.node(str(id(block)), label.rstrip(), {\\\"shape\\\": \\\"box\\\"})\\n elif isinstance(block, HeadBlock):\\n label = \\\"Initial\\\"\\n dot.node(str(id(block)) + \\\"_start\\\", label.rstrip(), {\\\"shape\\\": \\\"doublecircle\\\"})\\n label = \\\"\\\\n\\\".join(astor.to_source(stmt).rstrip() for stmt in block.initial_statements)\\n # label += \\\"\\\\nLive Ins : \\\" + str(block.live_ins)\\n # label += \\\"\\\\nLive Outs : \\\" + str(block.live_outs)\\n # label += \\\"\\\\nGen : \\\" + str(block.gen)\\n # label += \\\"\\\\nKill : \\\" + str(block.kill)\\n dot.node(str(id(block)), label.rstrip(), {\\\"shape\\\": \\\"box\\\"})\\n dot.edge(str(id(block)) + \\\"_start\\\", str(id(block)))\\n else:\\n raise NotImplementedError(type(block))\\n # for source, sink, label in self.edges:\\n for sink, label in block.outgoing_edges:\\n dot.edge(str(id(block)), str(id(sink)), label)\\n\\n\\n file_name = tempfile.mktemp(\\\"gv\\\")\\n dot.render(file_name, view=True)\\n # with open(\\\"cfg.dot\\\", \\\"w\\\") as file:\\n # file.write(dot.source)\\n # exit()\",\n \"def process_tree(tree):\\n c = circuit()\\n l = line()\\n names = {}\\n procedures = []\\n for lst in tree.children:\\n print(lst)\\n if type(lst[0]) is str:\\n names[lst[0]] = lst[1]\\n else:\\n procedures.append(lst)\\n print(names)\\n #print(procedures)\\n\\n for proc in procedures:\\n\\n proc_elements_names = proc[0]\\n proc_name = proc[1]\\n\\n #print(proc_elements_names)\\n #print(proc_name)\\n\\n if proc_name == \\\"set_mode\\\":\\n mode_name = proc_elements_names[0]\\n if mode_name != \\\"draw-mode\\\": \\n c.set_mode(mode_name)\\n elif mode_name == \\\"draw-mode\\\":\\n l1 = line()\\n # draw mode is different from other modes\\n for element in names:\\n e = CompleteElement(element)\\n e.set_other_attrs(names[element])\\n e.process_other_attrs()\\n l1.addElement(e)\\n c.connectInSeries(l1)\\n c.set_mode(\\\"draw-mode\\\")\\n \\n \\n if proc_name == \\\"series\\\":\\n l1 = line()\\n for element in proc_elements_names:\\n l1.addElement(names[element])\\n l = l1\\n c.connectInSeries(l)\\n #raise SyntaxError(\\\"Alias {0} referrenced before assignment\\\".format(item[0]))\\n\\n elif proc_name == \\\"parallel\\\":\\n l1 = line()\\n for element in proc_elements_names:\\n l1.addElement(names[element])\\n c.connectInParallel(l1)\\n l1 = line()\\n\\n\\n elif proc_name == \\\"add_parallel\\\":\\n new_element = proc_elements_names[1]\\n old_element = proc_elements_names[0]\\n l1 = line()\\n l1.addElement(names[new_element])\\n c.connection.append(l1)\\n\\n\\n elif proc_name == \\\"add_series\\\":\\n new_element = proc_elements_names[1]\\n old_element = proc_elements_names[0]\\n for ln in c.connection:\\n for e in ln.elements:\\n if names[old_element] == e:\\n ln.addElement(names[new_element])\\n\\n\\n c.evaluate(\\\"output.png\\\")\\n #print(c)\",\n \"def forward(self, Ca, mask, residue_idx, chain_labels):\\n if self.augment_eps > 0:\\n Ca = Ca + self.augment_eps * torch.randn_like(Ca)\\n\\n D_neighbors, E_idx, mask_neighbors = self._dist(Ca, mask)\\n\\n Ca_0 = torch.zeros(Ca.shape, device=Ca.device)\\n Ca_2 = torch.zeros(Ca.shape, device=Ca.device)\\n Ca_0[:,1:,:] = Ca[:,:-1,:]\\n Ca_1 = Ca\\n Ca_2[:,:-1,:] = Ca[:,1:,:]\\n\\n V, O_features = self._orientations_coarse(Ca, E_idx)\\n \\n RBF_all = []\\n RBF_all.append(self._rbf(D_neighbors)) #Ca_1-Ca_1\\n RBF_all.append(self._get_rbf(Ca_0, Ca_0, E_idx)) \\n RBF_all.append(self._get_rbf(Ca_2, Ca_2, E_idx))\\n\\n RBF_all.append(self._get_rbf(Ca_0, Ca_1, E_idx))\\n RBF_all.append(self._get_rbf(Ca_0, Ca_2, E_idx))\\n\\n RBF_all.append(self._get_rbf(Ca_1, Ca_0, E_idx))\\n RBF_all.append(self._get_rbf(Ca_1, Ca_2, E_idx))\\n\\n RBF_all.append(self._get_rbf(Ca_2, Ca_0, E_idx))\\n RBF_all.append(self._get_rbf(Ca_2, Ca_1, E_idx))\\n\\n\\n RBF_all = torch.cat(tuple(RBF_all), dim=-1)\\n\\n\\n offset = residue_idx[:,:,None]-residue_idx[:,None,:]\\n offset = gather_edges(offset[:,:,:,None], E_idx)[:,:,:,0] #[B, L, K]\\n\\n d_chains = ((chain_labels[:, :, None] - chain_labels[:,None,:])==0).long()\\n E_chains = gather_edges(d_chains[:,:,:,None], E_idx)[:,:,:,0]\\n E_positional = self.embeddings(offset.long(), E_chains)\\n E = torch.cat((E_positional, RBF_all, O_features), -1)\\n \\n\\n E = self.edge_embedding(E)\\n E = self.norm_edges(E)\\n \\n return E, E_idx\",\n \"def trans_setup():\\n # slot7 slot6 slot5 slot4 slot3 slot2 slot1 <------ beam direction (slot 8 is currently B-fiber only)\\n # Be Be Be Be Be Be Be lens material\\n # 1.5 1.5 0.5 0.5 0.5 0.5 0.5 lens radius [mm]\\n # 1 1 5 8 4 2 1 number of lenses\\n lens_R=[0.5,0.5,0.5,0.5,0.5,1.5,1.5]\\n lens_mat=['Be','Be','Be','Be','Be','Be','Be']\\n lens_N=[1,2,4,8,5,1,1]\\n trans_pos=[35.2,35.8]\\n return {'lens_material':lens_mat,'lens_number':lens_N,'lens_radius':lens_R,'trans_position':trans_pos}\",\n \"def serialize(self):\\n p = []\\n p.append(self.particleCode)\\n if self.particleCode == 'manual':\\n p.append(str(self.particleMass))\\n p.append(str(self.particleCharge))\\n p.append(str(self.x0))\\n p.append(str(self.y0))\\n p.append(str(self.z0))\\n if self.useKineticEnergy:\\n p.append('Y')\\n p.append(str(self.kineticEnergy))\\n else:\\n p.append('n')\\n p.append(str(self.vx0))\\n p.append(str(self.vy0))\\n p.append(str(self.vz0))\\n p.append(self.fieldCode)\\n if self.fieldCode == 'Drift':\\n p.append(str(self.fieldBaseStrength[0]))\\n p.append(str(self.fieldBaseStrength[1]))\\n p.append(str(self.fieldBaseStrength[2]))\\n p.append(str(self.fieldGradient[0]))\\n elif self.fieldCode == 'Smooth':\\n p.append(str(self.fieldBaseStrength[0]))\\n p.append(str(self.fieldGradient[0]))\\n p.append(str(self.fieldGradient[1]))\\n elif self.fieldCode == 'Sharp':\\n p.append(str(self.fieldBaseStrength[0]))\\n p.append(str(self.fieldGradient[0]))\\n p.append(str(self.fieldGradient[1]))\\n p.append(str(self.fieldLength))\\n elif self.fieldCode == 'Sine':\\n p.append(str(self.fieldBaseStrength[0]))\\n p.append(str(self.fieldGradient[0]))\\n p.append(str(self.fieldGradient[1]))\\n p.append(str(self.fieldLength))\\n p.append(str(self.fieldFreq))\\n elif self.fieldCode == 'Helix':\\n p.append(str(self.fieldBaseStrength[0]))\\n p.append(str(self.fieldBaseStrength[1]))\\n p.append(str(self.fieldGradient[0]))\\n p.append(str(self.fieldGradient[1]))\\n p.append(str(self.fieldGradient[2]))\\n p.append(str(self.fieldLength))\\n p.append(str(self.fieldFreq))\\n elif self.fieldCode == 'Tokamak':\\n p.append(str(self.fieldBaseStrength[0]))\\n p.append(str(self.fieldBaseStrength[1]))\\n p.append(str(self.fieldGradient[0]))\\n p.append(str(self.fieldGradient[1]))\\n p.append(str(self.fieldGradient[2]))\\n p.append(str(self.fieldGradient[3]))\\n p.append(str(self.fieldGradient[4]))\\n p.append(str(self.fieldLength))\\n p.append(str(self.fieldFreq))\\n else:\\n for val in self.fieldBaseStrength:\\n p.append(str(val))\\n p.append(str(self.initialTime))\\n p.append(str(self.endTime))\\n p.append(str(self.timeStep))\\n p.append(str(self.tolerance))\\n return p\",\n \"def fst_tostring(self, fst_1, idx=False):\\n\\n fst_string = 'Transducer\\\\n'\\n for state in fst_1.states:\\n for arc in state.arcs:\\n olabel = self.wmap[arc.olabel].encode('utf-8') if not idx and arc.olabel in self.wmap else arc.olabel\\n\\n fst_string += '{} -> {} / {} : {} / {}\\\\n'.format(state.stateid, arc.nextstate, arc.ilabel, olabel,\\n float(arc.weight))\\n\\n if state.final:\\n fst_string += '%s / %s\\\\n' % (state.stateid, state.final)\\n\\n fst_string += '-------\\\\n'\\n\\n return fst_string\",\n \"def chainLabel(self,i):\\n assert(i >= 0 and i < self.nAtoms())\\n assert(self._c_structure is not NULL)\\n cdef char label[2]\\n label[0] = freesasa_structure_atom_chain(self._c_structure,i)\\n label[1] = '\\\\0'\\n return label\",\n \"def createAddOrSelectLabelMapNode(self, script=False):\\r\\n # productive\\r\\n profprint()\\r\\n print \\\"creating label map for working intensity volume\\\"\\r\\n # create, select label map\\r\\n volLogic = slicer.modules.volumes.logic()\\r\\n sliceLogic = slicer.app.layoutManager().sliceWidget(\\\"Red\\\").sliceLogic()\\r\\n vn = sliceLogic.GetBackgroundLayer().GetVolumeNode()\\r\\n self.labelMapNode = slicer.util.getNode(vn.GetName() + \\\"-label\\\")\\r\\n if not self.labelMapNode:\\r\\n self.labelMapNode = volLogic.CreateAndAddLabelVolume(slicer.mrmlScene, vn, vn.GetName() + \\\"-label\\\")\\r\\n # select label volume\\r\\n if not script: #TODO guess there is a bug here (at least while testing with parSearch): also changes the main volume!!\\r\\n selectionNode = slicer.app.applicationLogic().GetSelectionNode()\\r\\n selectionNode.SetReferenceActiveLabelVolumeID(self.labelMapNode.GetID())\\r\\n #slicer.app.applicationLogic().PropagateVolumeSelection() #<<<this line causes unpredictable volume switching\\r\\n #set half transparency\\r\\n scRed=slicer.app.layoutManager().sliceWidget(\\\"Red\\\").sliceController()\\r\\n scRed.setLabelMapOpacity(.5)\\r\\n scYel=slicer.app.layoutManager().sliceWidget(\\\"Yellow\\\").sliceController()\\r\\n scYel.setLabelMapOpacity(.5)\\r\\n scGrn=slicer.app.layoutManager().sliceWidget(\\\"Green\\\").sliceController()\\r\\n scGrn.setLabelMapOpacity(.5)\\r\\n #enable label map outline display mode\\r\\n sRed = slicer.mrmlScene.GetNodeByID(\\\"vtkMRMLSliceNodeRed\\\")\\r\\n if sRed == None :\\r\\n sRed = slicer.mrmlScene.GetNodeByID(\\\"vtkMRMLSliceNode1\\\")\\r\\n sRed.SetUseLabelOutline(1)\\r\\n sYel = slicer.mrmlScene.GetNodeByID(\\\"vtkMRMLSliceNodeYellow\\\")\\r\\n if sYel == None :\\r\\n sYel = slicer.mrmlScene.GetNodeByID(\\\"vtkMRMLSliceNode2\\\")\\r\\n sYel.SetUseLabelOutline(1)\\r\\n sGrn = slicer.mrmlScene.GetNodeByID(\\\"vtkMRMLSliceNodeGreen\\\")\\r\\n if sGrn == None :\\r\\n sGrn = slicer.mrmlScene.GetNodeByID(\\\"vtkMRMLSliceNode3\\\")\\r\\n sGrn.SetUseLabelOutline(1)\\r\\n self.editorWidget.setMasterNode(vn)\\r\\n self.editorWidget.setMergeNode(self.labelMapNode)\",\n \"def results(self):\\n self.report('workchain succesfully completed')\\n self.out('scf_parameters', self.ctx.workchain_scf.out.output_parameters)\\n self.out('band_parameters', self.ctx.workchain_bands.out.output_parameters)\\n self.out('band_structure', self.ctx.workchain_bands.out.output_band)\\n\\n if 'group' in self.inputs:\\n output_band = self.ctx.workchain_bands.out.output_band\\n group, _ = Group.get_or_create(name=self.inputs.group.value)\\n group.add_nodes(output_band)\\n self.report(\\\"storing the output_band<{}> in the group '{}'\\\"\\n .format(output_band.pk, self.inputs.group.value))\",\n \"def pack_firmware(self, work_dir, jobclient, ro, rw, version_string=\\\"\\\"):\\n dts_file_path = ro / \\\"zephyr\\\" / \\\"zephyr.dts\\\"\\n\\n # Copy the inputs into the work directory so that Binman can\\n # find them under a hard-coded name.\\n shutil.copy2(ro / \\\"zephyr\\\" / self.ro_file, work_dir / \\\"zephyr_ro.bin\\\")\\n shutil.copy2(rw / \\\"zephyr\\\" / self.rw_file, work_dir / \\\"zephyr_rw.bin\\\")\\n\\n # Version in FRID/FWID can be at most 31 bytes long (32, minus\\n # one for null character).\\n if len(version_string) > 31:\\n version_string = version_string[:31]\\n\\n proc = jobclient.popen(\\n [\\n \\\"binman\\\",\\n \\\"-v\\\",\\n \\\"5\\\",\\n \\\"build\\\",\\n \\\"-a\\\",\\n \\\"version={}\\\".format(version_string),\\n \\\"-d\\\",\\n dts_file_path,\\n \\\"-m\\\",\\n \\\"-O\\\",\\n work_dir,\\n ],\\n cwd=work_dir,\\n stdout=subprocess.PIPE,\\n stderr=subprocess.PIPE,\\n encoding=\\\"utf-8\\\",\\n )\\n\\n zmake.multiproc.log_output(self.logger, logging.DEBUG, proc.stdout)\\n zmake.multiproc.log_output(self.logger, logging.ERROR, proc.stderr)\\n if proc.wait(timeout=60):\\n raise OSError(\\\"Failed to run binman\\\")\\n\\n yield work_dir / \\\"zephyr.bin\\\", \\\"zephyr.bin\\\"\\n yield ro / \\\"zephyr\\\" / \\\"zephyr.elf\\\", \\\"zephyr.ro.elf\\\"\\n yield rw / \\\"zephyr\\\" / \\\"zephyr.elf\\\", \\\"zephyr.rw.elf\\\"\",\n \"def _add_label_switching_node( self,\\n node_tree,\\n label_vec,\\n last_element,\\n label_ID_node=None,\\n node_index=0,\\n uv_map=None, \\n node_offset=[0,0]):\\n\\n # define local variables #######################################################################################\\n _step_node_width = 200 # x seperation of nodes\\n _step_node_height = 200 # y seperation of nodes\\n ################################################################################ end of define local variables #\\n\\n # create image ID handle #######################################################################################\\n if label_ID_node is None:\\n label_ID_node = node_tree.node_tree.nodes.new(\\\"ShaderNodeValue\\\")\\n label_ID_node.location = ((node_offset[0]-400,node_offset[1]-100))\\n label_ID_node.name = \\\"label_step_ID\\\"\\n label_ID_node.label = \\\"label_step_ID\\\"\\n label_ID_node.outputs[0].default_value = 1\\n ############################################################################### end of create image ID handle #\\n\\n # create image nodes ###########################################################################################\\n _x_offset = (node_index+1)*_step_node_width + node_offset[0]\\n _y_offset = (node_index+1)*_step_node_height + node_offset[1]\\n\\n _semantic_node_offset = [(node_index+1)*_step_node_width*2 + node_offset[0]-1000,(node_index+1)*\\\\\\n _step_node_height + node_offset[1]+200]\\n\\n _semantic_tree, self._semantic_pass_id = self.create_semantic_nodes(node_tree=self._world_node_tree,\\n label_ID_vec=label_vec,\\n num_label_per_channel=15, # TODO add in script\\n env_mode=True,\\n uv_map=uv_map,\\n node_offset=_semantic_node_offset)\\n\\n _semantic_tree.inputs[0].default_value = 1\\n\\n # create new mix node ######################################################################################\\n _current_mix_shader_node = node_tree.node_tree.nodes.new(\\\"ShaderNodeMixRGB\\\")\\n _current_mix_shader_node.location = (((node_index+1)*_step_node_width*2 + node_offset[0],\\n (node_index+1)*_step_node_height + node_offset[1]))\\n ############################################################################### end of create new mix node #\\n\\n # create compare node ######################################################################################\\n _current_compare_node = node_tree.node_tree.nodes.new(\\\"ShaderNodeMath\\\")\\n _current_compare_node.location = (((node_index+1)*_step_node_width*2 + node_offset[0],\\n node_offset[1]-_step_node_height))\\n _current_compare_node.operation = 'COMPARE'\\n _current_compare_node.inputs[0].default_value = node_index\\n _current_compare_node.inputs[2].default_value = 0 # delta value should be zero for equal comparison\\n ############################################################################### end of create compare node #\\n\\n\\n # link nodes togther #######################################################################################\\n node_tree.node_tree.links.new(_current_mix_shader_node.inputs[0], _current_compare_node.outputs[0])\\n if last_element is not None:\\n node_tree.node_tree.links.new(_current_mix_shader_node.inputs[1], last_element.outputs[0])\\n node_tree.node_tree.links.new(_current_mix_shader_node.inputs[2], _semantic_tree.outputs[0])\\n \\n node_tree.node_tree.links.new(_current_compare_node.inputs[1], label_ID_node.outputs[0])\\n ################################################################################ end of link nodes togther #\\n #################################################################################### end of create image nodes #\\n\\n # return last mix shader node\\n return _current_mix_shader_node, label_ID_node\",\n \"def main(self, case, profile):\\n case[\\\"branch\\\"][:, BR_STATUS] = ones(case[\\\"branch\\\"].shape[0])\\n mpc = ext2int(case)\\n baseMVA, bus, gen, branch, gencost = mpc[\\\"baseMVA\\\"], mpc[\\\"bus\\\"], mpc[\\\"gen\\\"], mpc[\\\"branch\\\"], mpc[\\\"gencost\\\"]\\n\\n nb = shape(mpc['bus'])[0] ## number of buses\\n nl = shape(mpc['branch'])[0] ## number of branches\\n ng = shape(mpc['gen'])[0] ## number of dispatchable injections\\n\\n f = branch[:, F_BUS] ## list of \\\"from\\\" buses\\n t = branch[:, T_BUS] ## list of \\\"to\\\" buses\\n i = range(nl) ## double set of row indices\\n # Connection matrix\\n Cf = sparse((ones(nl), (i, f)), (nl, nb))\\n Ct = sparse((ones(nl), (i, t)), (nl, nb))\\n Cg = sparse((ones(ng), (gen[:, GEN_BUS], range(ng))), (nb, ng))\\n Branch_R = branch[:, BR_R]\\n Branch_X = branch[:, BR_X]\\n Cf = Cf.T\\n Ct = Ct.T\\n # Obtain the boundary information\\n Slmax = branch[:, RATE_A] / baseMVA\\n\\n Pij_l = -Slmax\\n Qij_l = -Slmax\\n Iij_l = zeros(nl)\\n Vm_l = bus[:, VMIN] ** 2\\n Pg_l = gen[:, PMIN] / baseMVA\\n Qg_l = gen[:, QMIN] / baseMVA\\n Alpha_l = zeros(nl)\\n Beta_f_l = zeros(nl)\\n Beta_t_l = zeros(nl)\\n\\n Pij_u = Slmax\\n Qij_u = Slmax\\n Iij_u = Slmax\\n Vm_u = bus[:, VMAX] ** 2\\n Pg_u = 2 * gen[:, PMAX] / baseMVA\\n Qg_u = 2 * gen[:, QMAX] / baseMVA\\n Alpha_u = ones(nl)\\n Beta_f_u = ones(nl)\\n Beta_t_u = ones(nl)\\n bigM = max(Vm_u)\\n # For the spanning tree constraints\\n Root_node = find(bus[:, BUS_TYPE] == REF)\\n Root_line = find(branch[:, F_BUS] == Root_node)\\n\\n Span_f = zeros((nb, nl))\\n Span_t = zeros((nb, nl))\\n for i in range(nb):\\n Span_f[i, find(branch[:, F_BUS] == i)] = 1\\n Span_t[i, find(branch[:, T_BUS] == i)] = 1\\n\\n Alpha_l[Root_line] = 1\\n Alpha_u[Root_line] = 1\\n Beta_f_l[Root_line] = 0\\n Beta_f_l[Root_line] = 0\\n\\n T = len(profile)\\n nx = int(3 * nl + nb + 2 * ng)\\n lx = concatenate([Alpha_l, Beta_f_l, Beta_t_l, tile(concatenate([Pij_l, Qij_l, Iij_l, Vm_l, Pg_l, Qg_l]), T)])\\n ux = concatenate([Alpha_u, Beta_f_u, Beta_t_u, tile(concatenate([Pij_u, Qij_u, Iij_u, Vm_u, Pg_u, Qg_u]), T)])\\n vtypes = [\\\"b\\\"] * 2 * nl + [\\\"c\\\"] * nl + [\\\"c\\\"] * nx * T\\n\\n # Define the decision variables\\n NX = lx.shape[0]\\n\\n # Alpha = Beta_f + Beta_t\\n Aeq_f = zeros((nl, NX))\\n beq_f = zeros(nl)\\n Aeq_f[:, 0: nl] = -eye(nl)\\n Aeq_f[:, nl: 2 * nl] = eye(nl)\\n Aeq_f[:, 2 * nl:3 * nl] = eye(nl)\\n\\n # sum(alpha)=nb-1\\n Aeq_alpha = zeros((1, NX))\\n beq_alpha = zeros(1)\\n Aeq_alpha[0, 0: nl] = ones(nl)\\n beq_alpha[0] = nb - 1\\n\\n # Span_f*Beta_f+Span_t*Beta_t = Spanning_tree\\n Aeq_span = zeros((nb, NX))\\n beq_span = ones(nb)\\n beq_span[Root_node] = 0\\n Aeq_span[:, nl:2 * nl] = Span_f\\n Aeq_span[:, 2 * nl: 3 * nl] = Span_t\\n\\n # Add system level constraints\\n # 1) Active power balance\\n Aeq_p = zeros((nb * T, NX))\\n beq_p = zeros(nb * T)\\n for i in range(T):\\n Aeq_p[i * nb:(i + 1) * nb, 3 * nl + i * nx:3 * nl + (i + 1) * nx] = hstack([Ct - Cf, zeros((nb, nl)),\\n -diag(Ct * Branch_R) * Ct,\\n zeros((nb, nb)), Cg,\\n zeros((nb, ng))]).toarray()\\n beq_p[i * nb:(i + 1) * nb] = profile[i] * bus[:, PD] / baseMVA\\n\\n # 2) Reactive power balance\\n Aeq_q = zeros((nb * T, NX))\\n beq_q = zeros(nb * T)\\n for i in range(T):\\n Aeq_q[i * nb:(i + 1) * nb, 3 * nl + i * nx:3 * nl + (i + 1) * nx] = hstack([zeros((nb, nl)), Ct - Cf,\\n -diag(Ct * Branch_X) * Ct,\\n zeros((nb, nb)),\\n zeros((nb, ng)), Cg]).toarray()\\n beq_q[i * nb:(i + 1) * nb] = profile[i] * bus[:, QD] / baseMVA\\n\\n Aeq = vstack([Aeq_f, Aeq_alpha, Aeq_span, Aeq_p, Aeq_q]).toarray()\\n beq = concatenate([beq_f, beq_alpha, beq_span, beq_p, beq_q])\\n\\n # Inequality constraints\\n A = zeros((nl * T, NX))\\n b = zeros(nl * T)\\n for i in range(T):\\n A[i * nl:(i + 1) * nl, 3 * nl + i * nx + 2 * nl: 3 * nl + i * nx + 3 * nl] = eye(nl)\\n A[i * nl:(i + 1) * nl, 0: nl] = -diag(Iij_u)\\n\\n A_temp = zeros((nl * T, NX))\\n b_temp = zeros(nl * T)\\n for i in range(T):\\n A_temp[i * nl:(i + 1) * nl, 3 * nl + i * nx: 3 * nl + i * nx + nl] = eye(nl)\\n A_temp[i * nl:(i + 1) * nl, 0: nl] = -diag(Pij_u)\\n A = concatenate([A, A_temp])\\n b = concatenate([b, b_temp])\\n #\\n A_temp = zeros((nl * T, NX))\\n b_temp = zeros(nl * T)\\n for i in range(T):\\n A_temp[i * nl:(i + 1) * nl, 3 * nl + i * nx + nl: 3 * nl + i * nx + 2 * nl] = eye(nl)\\n A_temp[i * nl:(i + 1) * nl, 0:nl] = -diag(Qij_u)\\n A = concatenate([A, A_temp])\\n b = concatenate([b, b_temp])\\n\\n A_temp = zeros((nl * T, NX))\\n for i in range(T):\\n A_temp[i * nl:(i + 1) * nl, 3 * nl + i * nx:3 * nl + i * nx + nl] = -2 * diag(Branch_R)\\n A_temp[i * nl:(i + 1) * nl, 3 * nl + i * nx + nl:3 * nl + i * nx + 2 * nl] = -2 * diag(Branch_X)\\n A_temp[i * nl:(i + 1) * nl, 3 * nl + i * nx + 2 * nl:3 * nl + i * nx + 3 * nl] = diag(Branch_R ** 2) + \\\\\\n diag(Branch_X ** 2)\\n A_temp[i * nl:(i + 1) * nl, 3 * nl + i * nx + 3 * nl:3 * nl + i * nx + 3 * nl + nb] = \\\\\\n (Cf.T - Ct.T).toarray()\\n A_temp[i * nl:(i + 1) * nl, 0:nl] = eye(nl) * bigM\\n b_temp = ones(nl * T) * bigM\\n A = concatenate([A, A_temp])\\n b = concatenate([b, b_temp])\\n\\n A_temp = zeros((nl * T, NX))\\n for i in range(T):\\n A_temp[i * nl:(i + 1) * nl, 3 * nl + i * nx:3 * nl + i * nx + nl] = 2 * diag(Branch_R)\\n A_temp[i * nl:(i + 1) * nl, 3 * nl + i * nx + nl:3 * nl + i * nx + 2 * nl] = 2 * diag(Branch_X)\\n A_temp[i * nl:(i + 1) * nl, 3 * nl + i * nx + 2 * nl:3 * nl + i * nx + 3 * nl] = -diag(Branch_R ** 2) - \\\\\\n diag(Branch_X ** 2)\\n A_temp[i * nl:(i + 1) * nl, 3 * nl + i * nx + 3 * nl:3 * nl + i * nx + 3 * nl + nb] = \\\\\\n (-Cf.T + Ct.T).toarray()\\n A_temp[i * nl:(i + 1) * nl, 0: nl] = eye(nl) * bigM\\n b_temp = ones(nl * T) * bigM\\n A = concatenate([A, A_temp])\\n b = concatenate([b, b_temp])\\n\\n Qc = dict()\\n for t in range(T):\\n for i in range(nl):\\n Qc[t * nl + i] = [[int(3 * nl + t * nx + i), int(3 * nl + t * nx + i + nl),\\n int(3 * nl + t * nx + i + 2 * nl), int(3 * nl + t * nx + f[i] + 3 * nl)],\\n [int(3 * nl + t * nx + i), int(3 * nl + t * nx + i + nl),\\n int(3 * nl + t * nx + f[i] + 3 * nl), int(3 * nl + t * nx + i + 2 * nl)],\\n [1, 1, -1 / 2, -1 / 2]]\\n c = zeros(NX)\\n q = zeros(NX)\\n c0 = 0\\n for t in range(T):\\n for i in range(ng):\\n c[3 * nl + t * nx + i + 3 * nl + nb] = gencost[i, 5] * baseMVA\\n q[3 * nl + t * nx + i + 3 * nl + nb] = gencost[i, 4] * baseMVA * baseMVA\\n c0 += gencost[i, 6]\\n\\n sol = miqcp(c, q, Aeq=Aeq, beq=beq, A=A, b=b, xmin=lx, xmax=ux, vtypes=vtypes, Qc=Qc)\\n xx = sol[0]\\n Alpha = xx[0:nl]\\n Beta_f = xx[nl:2 * nl]\\n Beta_t = xx[2 * nl:3 * nl]\\n Pij = zeros((nl, T))\\n Qij = zeros((nl, T))\\n Iij = zeros((nl, T))\\n Vi = zeros((nb, T))\\n Pg = zeros((ng, T))\\n Qg = zeros((ng, T))\\n for i in range(T):\\n Pij[:, i] = xx[3 * nl + i * nx:3 * nl + i * nx + nl]\\n Qij[:, i] = xx[3 * nl + i * nx + nl:3 * nl + i * nx + 2 * nl]\\n Iij[:, i] = xx[3 * nl + i * nx + 2 * nl:3 * nl + i * nx + 3 * nl]\\n Vi[:, i] = xx[3 * nl + i * nx + 3 * nl:3 * nl + i * nx + 3 * nl + nb]\\n Pg[:, i] = xx[3 * nl + i * nx + 3 * nl + nb:3 * nl + i * nx + 3 * nl + nb + ng]\\n Qg[:, i] = xx[3 * nl + i * nx + 3 * nl + nb + ng:3 * nl + i * nx + 3 * nl + nb + 2 * ng]\\n\\n primal_residual = zeros((nl, T))\\n for t in range(T):\\n for i in range(nl):\\n primal_residual[i, t] = Pij[i, t] * Pij[i, t] + Qij[i, t] * Qij[i, t] - Iij[i, t] * Vi[int(f[i]), t]\\n\\n sol = {\\\"Pij\\\": Pij,\\n \\\"Qij\\\": Qij,\\n \\\"Iij\\\": Iij,\\n \\\"Vi\\\": Vi,\\n \\\"Pg\\\": Pg,\\n \\\"Qg\\\": Qg,\\n \\\"Alpha\\\": Alpha,\\n \\\"Beta_f\\\": Beta_f,\\n \\\"Beta_t\\\": Beta_t,\\n \\\"residual\\\": primal_residual,\\n \\\"obj\\\": sol[1] + c0}\\n\\n return sol\",\n \"def write_bc_vtk(self):\\n print \\\"Creating boundary condition arrays\\\"\\n obst_array = np.zeros(self.nnodes)\\n obst_array[list(self.obst_list)] = 100.\\n\\n #print type(self.inlet_list)\\n inlet_array = np.zeros(self.nnodes)\\n inlet_array[list(self.inlet_list)] = 200.\\n\\n outlet_array = np.zeros(self.nnodes)\\n outlet_array[list(self.outlet_list)] = 300.\\n\\n solid_array = np.zeros(self.nnodes)\\n solid_array[list(self.solid_list)] = 500.\\n \\n dims = [int(self.Nx), int(self.Ny), int(self.Nz)]\\n origin = [0., 0., 0.]\\n dx = self.x[1] - self.x[0]\\n spacing = [dx, dx, dx] #uniform lattice\\n \\n print \\\"Writing boundary conditions to VTK files\\\"\\n writeVTK(inlet_array,'inlet','inlet.vtk',dims,origin,spacing)\\n writeVTK(outlet_array,'outlet','outlet.vtk',dims,origin,spacing)\\n writeVTK(obst_array,'obst','obst.vtk',dims,origin,spacing)\\n writeVTK(solid_array,'solid','solid.vtk',dims,origin,spacing)\",\n \"def write_bc_vtk(self):\\n print \\\"Creating boundary condition arrays\\\"\\n obst_array = np.zeros(self.nnodes)\\n obst_array[list(self.obst_list)] = 100.\\n\\n #print type(self.inlet_list)\\n inlet_array = np.zeros(self.nnodes)\\n inlet_array[list(self.inlet_list)] = 200.\\n\\n outlet_array = np.zeros(self.nnodes)\\n outlet_array[list(self.outlet_list)] = 300.\\n\\n solid_array = np.zeros(self.nnodes)\\n solid_array[list(self.solid_list)] = 500.\\n \\n dims = [int(self.Nx), int(self.Ny), int(self.Nz)]\\n origin = [0., 0., 0.]\\n dx = self.x[1] - self.x[0]\\n spacing = [dx, dx, dx] #uniform lattice\\n \\n print \\\"Writing boundary conditions to VTK files\\\"\\n writeVTK(inlet_array,'inlet','inlet.vtk',dims,origin,spacing)\\n writeVTK(outlet_array,'outlet','outlet.vtk',dims,origin,spacing)\\n writeVTK(obst_array,'obst','obst.vtk',dims,origin,spacing)\\n writeVTK(solid_array,'solid','solid.vtk',dims,origin,spacing)\",\n \"def feature_extract(self, CT_pairs):\\n instances = []\\n for pair in CT_pairs:\\n config = pair[0]\\n label = pair[1]\\n data = []\\n featureset = {}\\n \\n # for nltk NaiveBayes feature selection stuff when doing MaxEnt decoding parser commit this\\n# featureset[\\\"topOfBuffer\\\"] = self.token_dict[config.beta.top()]\\n# featureset[\\\"topOfStack\\\"] = self.token_dict[config.sigma.top()]\\n# featureset[\\\"bufferStackPair\\\"] = (self.token_dict[config.sigma.top()], self.token_dict[config.beta.top()])\\n# featureset[\\\"topOfBuffer\\\"] = self.POS_dict[config.beta.top()]\\n# featureset[\\\"topOfStack\\\"] = self.POS_dict[config.sigma.top()]\\n# featureset[\\\"bufferStackPair\\\"] = tuple((self.POS_dict[config.sigma.top()], self.POS_dict[config.beta.top()]))\\n \\n # add the (StackTopPOS,BufferTopPOS,bufferchildren_POS) feature\\n #value_set = tuple([self.POS_dict[config.sigma.top()], self.POS_dict[config.beta.top()]] + [self.POS_dict[child] for child in self.getBufferChildren(config.beta.top())])\\n #featureset[\\\"bufferStackbufferChildrenPair\\\"] = value_set\\n \\n # for MaxEnt decoding stuff\\n # token variants\\n data.append((\\\"topOfBuffer\\\",self.token_dict[config.beta.top()]))\\n data.append((\\\"topOfStack\\\",self.token_dict[config.sigma.top()]))\\n data.append((\\\"bufferStackPair\\\",self.token_dict[config.sigma.top()],self.token_dict[config.beta.top()]))\\n #POS variants\\n data.append((\\\"topOfBuffer\\\",self.POS_dict[config.beta.top()]))\\n data.append((\\\"topOfStack\\\",self.POS_dict[config.sigma.top()]))\\n data.append((\\\"bufferStackPair\\\",self.POS_dict[config.sigma.top()],self.POS_dict[config.beta.top()]))\\n ins = Instance(label=label, data=data)\\n #ins = Instance(label=label, data=featureset)\\n instances.append(ins)\\n \\n return instances\",\n \"def update_heads(info,\\n heads):\\n\\n info[\\\"model_params\\\"][\\\"boltzmann_dict\\\"][\\\"num_heads\\\"] = heads\\n # Concatenate the fingerprints produced by the different heads\\n info[\\\"model_params\\\"][\\\"boltzmann_dict\\\"][\\\"head_pool\\\"] = \\\"concatenate\\\"\\n\\n readoutdict = info[\\\"model_params\\\"][\\\"readoutdict\\\"]\\n feat_dim = info[\\\"model_params\\\"][\\\"mol_basis\\\"]\\n\\n for key, lst in readoutdict.items():\\n for i, dic in enumerate(lst):\\n if \\\"param\\\" in dic and \\\"in_features\\\" in dic.get(\\\"param\\\", {}):\\n # make sure that the input dimension to the readout is equal to\\n # `heads * feat_dim`, where `feat_dim` is the feature dimension\\n # produced by each head\\n readoutdict[key][i][\\\"param\\\"][\\\"in_features\\\"] = feat_dim * heads\\n break\\n info[\\\"model_params\\\"][\\\"readoutdict\\\"] = readoutdict\",\n \"def detection_head_graph(self, feature_map, filters):\\n x = KL.Conv2D(filters, (1, 1), strides=(1, 1),\\n name=\\\"detection_head_\\\" + \\\"stage_1\\\", use_bias=True, padding=\\\"same\\\")(feature_map)\\n x = KL.Activation('relu', name='detection_head_stage_1_activation')(x)\\n x = KL.Conv2D(filters, (1, 1), strides=(1, 1),\\n name=\\\"detection_head_\\\" + \\\"stage_2\\\", use_bias=True, padding=\\\"same\\\")(x)\\n x = KL.Activation('relu', name='detection_head_stage_2_activation')(x)\\n x = KL.Conv2D(3, (1, 1), strides=(1, 1),\\n name=\\\"detection_head_\\\" + \\\"final_stage\\\", use_bias=True, padding=\\\"same\\\")(x)\\n return x\",\n \"def gexf_graph():\\n # you must replace these lines and supply your own graph\\n gexf = Gexf(\\\"author\\\", \\\"title\\\")\\n mygraph = gexf.addGraph(\\\"undirected\\\", \\\"static\\\", \\\"A web network\\\")\\n atr_type = mygraph.addNodeAttribute('Type', type='string')\\n atr_id = mygraph.addNodeAttribute('id', type='string')\\n atr_label = mygraph.addNodeAttribute('label', type='string')\\n atr_color_r = mygraph.addNodeAttribute('color_r', type='string', defaultValue='0')\\n atr_color_g = mygraph.addNodeAttribute('color_g', type='string', defaultValue='0')\\n atr_color_b = mygraph.addNodeAttribute('color_b', type='string', defaultValue='0')\\n k = 0\\n for i in range(min_parts()):\\n tmp = mygraph.addNode(set_num[i], name[i], r=\\\"0\\\", g=\\\"0\\\", b=\\\"0\\\")\\n tmp.addAttribute(atr_type, \\\"set\\\")\\n tmp.addAttribute(atr_id, set_num[i])\\n tmp.addAttribute(atr_label, name[i])\\n for j in range(len(Parts[i][\\\"Parts\\\"])):\\n if mygraph.nodeExists(Parts[i][\\\"Parts\\\"][j][\\\"number\\\"]+\\\"_\\\"+Parts[i][\\\"Parts\\\"][j][\\\"color\\\"][\\\"rgb\\\"])==0:\\n temp = mygraph.addNode((Parts[i][\\\"Parts\\\"][j][\\\"number\\\"]+\\\"_\\\"+Parts[i][\\\"Parts\\\"][j][\\\"color\\\"][\\\"rgb\\\"]), Parts[i][\\\"Parts\\\"][j][\\\"name\\\"], r=str(int(Parts[i][\\\"Parts\\\"][j][\\\"color\\\"][\\\"rgb\\\"][0:2], 16)), g=str(int(Parts[i][\\\"Parts\\\"][j][\\\"color\\\"][\\\"rgb\\\"][2:4], 16)), b=str(int(Parts[i][\\\"Parts\\\"][j][\\\"color\\\"][\\\"rgb\\\"][4:6], 16)))\\n temp.addAttribute(atr_type, \\\"part\\\")\\n temp.addAttribute(atr_id, (Parts[i][\\\"Parts\\\"][j][\\\"number\\\"]+\\\"_\\\"+Parts[i][\\\"Parts\\\"][j][\\\"color\\\"][\\\"rgb\\\"]))\\n temp.addAttribute(atr_label, Parts[i][\\\"Parts\\\"][j][\\\"name\\\"])\\n temp.addAttribute(atr_color_r, Parts[i][\\\"Parts\\\"][j][\\\"color\\\"][\\\"rgb\\\"][0:2])\\n temp.addAttribute(atr_color_g, Parts[i][\\\"Parts\\\"][j][\\\"color\\\"][\\\"rgb\\\"][2:4])\\n temp.addAttribute(atr_color_b, Parts[i][\\\"Parts\\\"][j][\\\"color\\\"][\\\"rgb\\\"][4:6])\\n mygraph.addEdge(str(k), set_num[i], (Parts[i][\\\"Parts\\\"][j][\\\"number\\\"]+\\\"_\\\"+Parts[i][\\\"Parts\\\"][j][\\\"color\\\"][\\\"rgb\\\"]), weight=Parts[i][\\\"Parts\\\"][j][\\\"quantity\\\"])\\n k = k+1\\n output_file = open(\\\"bricks_graph.gexf\\\", \\\"wb\\\")\\n gexf.write(output_file)\\n return -1\",\n \"def _viterbi_decode(self, feats):\\n backpointers = []\\n\\n init_vvars = torch.full((self.batch_size, 1, self.tagset_size), -10000.).to(self.device)\\n init_vvars[:, 0, self.tag2idx[START_TAG]] = 0.\\n\\n forward_var = init_vvars\\n for i in range(feats.shape[1]):\\n feat = feats[:,i,:]\\n\\n next_tag_var = forward_var + self.transitions + feat.view(self.batch_size, self.tagset_size, 1)\\n best_tag_var, best_tag_id = torch.max(next_tag_var, dim=-1)\\n backpointers.append(best_tag_id)\\n forward_var = best_tag_var.view(self.batch_size, 1, self.tagset_size)\\n\\n # Transition to STOP_TAG\\n terminal_var = forward_var + self.transitions[self.tag2idx[STOP_TAG]]\\n path_score, best_tag_id = torch.max(terminal_var, dim=-1)\\n\\n # Follow the back pointers to decode the best path.\\n best_path = [best_tag_id]\\n for bptrs_t in reversed(backpointers):\\n # gather the value in bptrs_t according to best_tag_id\\n best_tag_id = bptrs_t.gather(dim=-1,index=best_tag_id)\\n best_path.append(best_tag_id)\\n \\n # Pop off the start tag (we dont want to return that to the caller)\\n best_path.pop()\\n best_path.reverse()\\n best_path = torch.cat(best_path, dim=1)\\n # best_path = [[self.idx2tag[j] for j in i] for i in best_path.tolist()]\\n \\n return path_score, best_path\",\n \"def encodeToCartBoxesLabels(self, gt_instances):\\n raw_boxes_xywh = np.zeros((self.config_data[\\\"max_boxes_per_frame\\\"], 5))\\n ### initialize gronud truth labels as np.zeros ###\\n gt_labels = np.zeros(list(self.cart_shape[1:3]) + \\\\\\n [len(self.anchor_boxes_cart)] + \\\\\\n [len(self.config_data[\\\"all_classes\\\"]) + 5]) \\n\\n ### start transferring box to ground turth label format ###\\n for i in range(len(gt_instances[\\\"classes\\\"])):\\n if i > self.config_data[\\\"max_boxes_per_frame\\\"]:\\n continue\\n class_name = gt_instances[\\\"classes\\\"][i]\\n box_xywh = gt_instances[\\\"cart_boxes\\\"][i]\\n class_id = self.config_data[\\\"all_classes\\\"].index(class_name)\\n if i <= self.config_data[\\\"max_boxes_per_frame\\\"]:\\n raw_boxes_xywh[i, :4] = box_xywh\\n raw_boxes_xywh[i, 4] = class_id\\n class_onehot = helper.smoothOnehot(class_id, \\\\\\n len(self.config_data[\\\"all_classes\\\"]))\\n exist_positive = False\\n grid_strid = self.cart_grid_strides\\n anchors = self.anchor_boxes_cart\\n box_xywh_scaled = box_xywh[np.newaxis, :].astype(np.float32)\\n box_xywh_scaled[:, :2] /= grid_strid\\n anchors_xywh = np.zeros([len(anchors), 4])\\n anchors_xywh[:, :2] = np.floor(box_xywh_scaled[:, :2]) + 0.5\\n anchors_xywh[:, 2:] = anchors.astype(np.float32)\\n\\n iou_scaled = helper.iou2d(box_xywh_scaled, anchors_xywh)\\n ### NOTE: 0.3 is from YOLOv4, maybe this should be different here ###\\n ### it means, as long as iou is over 0.3 with an anchor, the anchor\\n ### should be taken into consideration as a ground truth label\\n iou_mask = iou_scaled > 0.3\\n\\n if np.any(iou_mask):\\n xind, yind = np.floor(np.squeeze(box_xywh_scaled)[:2]).astype(np.int32)\\n ### TODO: consider changing the box to raw yolohead output format ###\\n gt_labels[xind, yind, iou_mask, 0:4] = box_xywh\\n gt_labels[xind, yind, iou_mask, 4:5] = 1.\\n gt_labels[xind, yind, iou_mask, 5:] = class_onehot\\n exist_positive = True\\n\\n if not exist_positive:\\n ### NOTE: this is the normal one ###\\n ### it means take the anchor box with maximum iou to the raw\\n ### box as the ground truth label\\n iou_mask = iou_scaled == iou_scaled.max()\\n\\n if np.any(iou_mask):\\n xind, yind = np.floor(np.squeeze(box_xywh_scaled)[:2]).astype(np.int32)\\n ### TODO: consider changing the box to raw yolohead output format ###\\n gt_labels[xind, yind, iou_mask, 0:4] = box_xywh\\n gt_labels[xind, yind, iou_mask, 4:5] = 1.\\n gt_labels[xind, yind, iou_mask, 5:] = class_onehot\\n\\n has_label = False\\n if gt_labels.max() != 0:\\n has_label = True\\n gt_labels = np.where(gt_labels == 0, 1e-16, gt_labels)\\n return gt_labels, has_label, raw_boxes_xywh\",\n \"def _fusion(self, expert_outputs):\\n raise NotImplementedError\",\n \"def reagent_label_data(bcl_step):\\n\\n define_step = None\\n indexes = {}\\n flowcell_total_reads = 0\\n\\n for inp, outp in bcl_step.input_output_maps:\\n pre_bcl_steps = MASTER_STEPS_UDFS['reagent_labels']['steps']['pre_bcl']\\n if inp['parent-process'].type.name not in pre_bcl_steps:\\n continue\\n\\n if outp['output-generation-type'] != 'PerReagentLabel':\\n continue\\n\\n lane = inp['uri']\\n art = outp['uri']\\n\\n index_reads = art.udf.get(\\n MASTER_STEPS_UDFS['reagent_labels']['udfs']['reads'])\\n\\n if index_reads is None or art.qc_flag == 'FAILED':\\n continue\\n\\n flowcell_total_reads += index_reads\\n\\n sample = art.samples[0] # Will always be only one sample in the list\\n application_tag = sample.udf.get('Sequencing Analysis')\\n\\n if application_tag[0:2] in MASTER_STEPS_UDFS['reagent_labels'][\\n 'exclue_tags']:\\n continue\\n\\n if not define_step:\\n define_step_outputs, flowcell_target_reads, define_step = get_define_step_data(\\n lane)\\n\\n if not sample.id in define_step_outputs:\\n LOG.info('This sample whas put as a pool into the define step: ' +\\n sample.id + ' ' + application_tag)\\n continue\\n\\n index = art.reagent_labels[0]\\n\\n container, lane_nr = lane.location\\n if index not in indexes:\\n indexes[index] = {\\n '_id': '_'.join([index, container.name]),\\n 'url': index.replace(' ', ''),\\n 'index_total_reads': index_reads,\\n 'index_target_reads': define_step_outputs[sample.id],\\n 'flowcell_target_reads': flowcell_target_reads,\\n 'index': index,\\n 'sample': sample.id,\\n 'lanes': {\\n lane_nr: dict(art.udf.items())\\n },\\n 'flowcell_id': container.name,\\n 'flowcell_type': container.type.name,\\n 'define_step_udfs': dict(define_step.udf.items()),\\n 'define_step_id': define_step.id,\\n 'bcl_step_id': bcl_step.id\\n }\\n else:\\n indexes[index]['lanes'][lane_nr] = dict(art.udf.items())\\n indexes[index]['index_total_reads'] += index_reads\\n\\n for index, data in indexes.items():\\n data['flowcell_total_reads'] = flowcell_total_reads\\n indexes[index] = filter_none(data)\\n\\n return indexes\",\n \"def create_pipeline_flow(\\n self, cmp_deriv_subject_directory, nipype_deriv_subject_directory\\n ):\\n acquisition_model = self.stages[\\\"Diffusion\\\"].config.diffusion_imaging_model\\n recon_tool = self.stages[\\\"Diffusion\\\"].config.recon_processing_tool\\n\\n recon_model = \\\"DTI\\\"\\n\\n if acquisition_model == \\\"DSI\\\":\\n recon_model = \\\"SHORE\\\"\\n else:\\n if recon_tool == \\\"Dipy\\\" and self.stages[\\\"Diffusion\\\"].config.dipy_recon_config.local_model:\\n recon_model = \\\"CSD\\\"\\n elif recon_tool == \\\"MRtrix\\\" and self.stages[\\\"Diffusion\\\"].config.mrtrix_recon_config.local_model:\\n recon_model = \\\"CSD\\\"\\n\\n tracking_model = self.stages[\\\"Diffusion\\\"].config.diffusion_model\\n\\n if tracking_model == \\\"Deterministic\\\":\\n tracking_model = \\\"DET\\\"\\n elif tracking_model == \\\"Probabilistic\\\":\\n tracking_model = \\\"PROB\\\"\\n\\n if self.parcellation_scheme == \\\"Lausanne2018\\\":\\n bids_atlas_label = \\\"L2018\\\"\\n elif self.parcellation_scheme == \\\"NativeFreesurfer\\\":\\n bids_atlas_label = \\\"Desikan\\\"\\n elif self.parcellation_scheme == \\\"Custom\\\":\\n bids_atlas_label = self.custom_atlas_name\\n if self.custom_atlas_res is not None and self.custom_atlas_res != \\\"\\\":\\n bids_atlas_label += f'_res-{self.custom_atlas_res}'\\n\\n # Clear previous outputs\\n self.clear_stages_outputs()\\n\\n # Create diffusion workflow with input and output Identityinterface nodes\\n diffusion_flow = pe.Workflow(\\n name=\\\"diffusion_pipeline\\\",\\n base_dir=os.path.abspath(nipype_deriv_subject_directory),\\n )\\n\\n diffusion_inputnode = pe.Node(\\n interface=util.IdentityInterface(\\n fields=[\\n \\\"diffusion\\\",\\n \\\"bvecs\\\",\\n \\\"bvals\\\",\\n \\\"T1\\\",\\n \\\"aseg\\\",\\n \\\"aparc_aseg\\\",\\n \\\"brain\\\",\\n \\\"T2\\\",\\n \\\"brain_mask\\\",\\n \\\"wm_mask_file\\\",\\n \\\"roi_volumes\\\",\\n \\\"roi_graphMLs\\\",\\n \\\"subjects_dir\\\",\\n \\\"subject_id\\\",\\n \\\"parcellation_scheme\\\",\\n ]\\n ),\\n name=\\\"inputnode\\\",\\n )\\n diffusion_inputnode.inputs.parcellation_scheme = self.parcellation_scheme\\n diffusion_inputnode.inputs.atlas_info = self.atlas_info\\n\\n diffusion_outputnode = pe.Node(\\n interface=util.IdentityInterface(fields=[\\\"connectivity_matrices\\\"]),\\n name=\\\"outputnode\\\",\\n )\\n\\n diffusion_flow.add_nodes([diffusion_inputnode, diffusion_outputnode])\\n\\n # Data import\\n datasource = self.create_datagrabber_node(\\n base_directory=cmp_deriv_subject_directory,\\n bids_atlas_label=bids_atlas_label\\n )\\n\\n # Data sinker for output\\n sinker = self.create_datasinker_node(\\n base_directory=cmp_deriv_subject_directory,\\n bids_atlas_label=bids_atlas_label,\\n recon_model=recon_model,\\n tracking_model=tracking_model\\n )\\n\\n # fmt:off\\n diffusion_flow.connect(\\n [\\n (datasource, diffusion_inputnode, [(\\\"diffusion\\\", \\\"diffusion\\\"),\\n (\\\"bvecs\\\", \\\"bvecs\\\"),\\n (\\\"bvals\\\", \\\"bvals\\\"),\\n (\\\"T1\\\", \\\"T1\\\"),\\n (\\\"aseg\\\", \\\"aseg\\\"),\\n (\\\"aparc_aseg\\\", \\\"aparc_aseg\\\"),\\n (\\\"brain\\\", \\\"brain\\\"),\\n (\\\"brain_mask\\\", \\\"brain_mask\\\"),\\n (\\\"wm_mask_file\\\", \\\"wm_mask_file\\\")]),\\n ]\\n )\\n # fmt:on\\n\\n merge_roi_volumes = pe.Node(interface=Merge(5), name=\\\"merge_roi_volumes\\\")\\n merge_roi_graphmls = pe.Node(interface=Merge(5), name=\\\"merge_roi_graphmls\\\")\\n\\n def remove_non_existing_scales(roi_volumes):\\n \\\"\\\"\\\"Returns a list which do not contained any empty element.\\n\\n Parameters\\n ----------\\n roi_volumes : list\\n A list of output parcellations that might contain empty element\\n in the case of the monoscale Desikan scheme for instance\\n\\n Returns\\n -------\\n out_roi_volumes : list\\n The list with no empty element\\n \\\"\\\"\\\"\\n out_roi_volumes = []\\n for vol in roi_volumes:\\n if vol is not None:\\n out_roi_volumes.append(vol)\\n return out_roi_volumes\\n\\n # fmt:off\\n diffusion_flow.connect(\\n [\\n (datasource, merge_roi_volumes, [(\\\"roi_volume_s1\\\", \\\"in1\\\"),\\n (\\\"roi_volume_s2\\\", \\\"in2\\\"),\\n (\\\"roi_volume_s3\\\", \\\"in3\\\"),\\n (\\\"roi_volume_s4\\\", \\\"in4\\\"),\\n (\\\"roi_volume_s5\\\", \\\"in5\\\")]),\\n (datasource, merge_roi_graphmls, [(\\\"roi_graphml_s1\\\", \\\"in1\\\"),\\n (\\\"roi_graphml_s2\\\", \\\"in2\\\"),\\n (\\\"roi_graphml_s3\\\", \\\"in3\\\"),\\n (\\\"roi_graphml_s4\\\", \\\"in4\\\"),\\n (\\\"roi_graphml_s5\\\", \\\"in5\\\")]),\\n (merge_roi_volumes, diffusion_inputnode, [((\\\"out\\\", remove_non_existing_scales), \\\"roi_volumes\\\")],),\\n (merge_roi_graphmls, diffusion_inputnode, [((\\\"out\\\", remove_non_existing_scales), \\\"roi_graphMLs\\\")],),\\n ]\\n )\\n # fmt:on\\n\\n if self.stages[\\\"Preprocessing\\\"].enabled:\\n preproc_flow = self.create_stage_flow(\\\"Preprocessing\\\")\\n # fmt:off\\n diffusion_flow.connect(\\n [\\n (diffusion_inputnode, preproc_flow, [(\\\"diffusion\\\", \\\"inputnode.diffusion\\\"),\\n (\\\"brain\\\", \\\"inputnode.brain\\\"),\\n (\\\"aseg\\\", \\\"inputnode.aseg\\\"),\\n (\\\"aparc_aseg\\\", \\\"inputnode.aparc_aseg\\\"),\\n (\\\"brain_mask\\\", \\\"inputnode.brain_mask\\\"),\\n (\\\"wm_mask_file\\\", \\\"inputnode.wm_mask_file\\\"),\\n (\\\"roi_volumes\\\", \\\"inputnode.roi_volumes\\\"),\\n (\\\"bvecs\\\", \\\"inputnode.bvecs\\\"),\\n (\\\"bvals\\\", \\\"inputnode.bvals\\\"),\\n (\\\"T1\\\", \\\"inputnode.T1\\\")]),\\n ]\\n )\\n # fmt:on\\n\\n if self.stages[\\\"Registration\\\"].enabled:\\n reg_flow = self.create_stage_flow(\\\"Registration\\\")\\n # fmt:off\\n diffusion_flow.connect(\\n [\\n # (diffusion_inputnode,reg_flow,[('T2','inputnode.T2')]),\\n (preproc_flow, reg_flow, [(\\\"outputnode.T1\\\", \\\"inputnode.T1\\\"),\\n (\\\"outputnode.act_5TT\\\", \\\"inputnode.act_5TT\\\"),\\n (\\\"outputnode.gmwmi\\\", \\\"inputnode.gmwmi\\\"),\\n (\\\"outputnode.bvecs_rot\\\", \\\"inputnode.bvecs\\\"),\\n (\\\"outputnode.bvals\\\", \\\"inputnode.bvals\\\"),\\n (\\\"outputnode.wm_mask_file\\\", \\\"inputnode.wm_mask\\\"),\\n (\\\"outputnode.partial_volume_files\\\", \\\"inputnode.partial_volume_files\\\",),\\n (\\\"outputnode.roi_volumes\\\", \\\"inputnode.roi_volumes\\\"),\\n (\\\"outputnode.brain\\\", \\\"inputnode.brain\\\"),\\n (\\\"outputnode.brain_mask\\\", \\\"inputnode.brain_mask\\\"),\\n (\\\"outputnode.brain_mask_full\\\", \\\"inputnode.brain_mask_full\\\"),\\n (\\\"outputnode.diffusion_preproc\\\", \\\"inputnode.target\\\"),\\n (\\\"outputnode.dwi_brain_mask\\\", \\\"inputnode.target_mask\\\")]),\\n (preproc_flow, sinker, [(\\\"outputnode.bvecs_rot\\\", \\\"dwi.@bvecs_rot\\\"),\\n (\\\"outputnode.diffusion_preproc\\\", \\\"dwi.@diffusion_preproc\\\"),\\n (\\\"outputnode.dwi_brain_mask\\\", \\\"dwi.@diffusion_brainmask\\\")]),\\n ]\\n )\\n # fmt:on\\n if self.stages[\\\"Registration\\\"].config.registration_mode == \\\"BBregister (FS)\\\":\\n # fmt:off\\n diffusion_flow.connect(\\n [\\n (diffusion_inputnode, reg_flow, [(\\\"subjects_dir\\\", \\\"inputnode.subjects_dir\\\"), (\\\"subject_id\\\", \\\"inputnode.subject_id\\\")]),\\n ]\\n )\\n # fmt:on\\n\\n if self.stages[\\\"Diffusion\\\"].enabled:\\n diff_flow = self.create_stage_flow(\\\"Diffusion\\\")\\n # fmt:off\\n diffusion_flow.connect(\\n [\\n (preproc_flow, diff_flow, [(\\\"outputnode.diffusion_preproc\\\", \\\"inputnode.diffusion\\\")]),\\n (reg_flow, diff_flow, [(\\\"outputnode.wm_mask_registered_crop\\\", \\\"inputnode.wm_mask_registered\\\",),\\n (\\\"outputnode.brain_mask_registered_crop\\\", \\\"inputnode.brain_mask_registered\\\",),\\n (\\\"outputnode.partial_volumes_registered_crop\\\", \\\"inputnode.partial_volumes\\\",),\\n (\\\"outputnode.roi_volumes_registered_crop\\\", \\\"inputnode.roi_volumes\\\",),\\n (\\\"outputnode.act_5tt_registered_crop\\\", \\\"inputnode.act_5tt_registered\\\",),\\n (\\\"outputnode.gmwmi_registered_crop\\\", \\\"inputnode.gmwmi_registered\\\",),\\n (\\\"outputnode.grad\\\", \\\"inputnode.grad\\\"),\\n (\\\"outputnode.bvals\\\", \\\"inputnode.bvals\\\"),\\n (\\\"outputnode.bvecs\\\", \\\"inputnode.bvecs\\\")]),\\n (reg_flow, sinker, [(\\\"outputnode.target_epicorrected\\\", \\\"dwi.@bdiffusion_reg_crop\\\",),\\n (\\\"outputnode.grad\\\", \\\"dwi.@diffusion_grad\\\"),\\n (\\\"outputnode.affine_transform\\\", \\\"xfm.@affine_transform\\\"),\\n (\\\"outputnode.warp_field\\\", \\\"xfm.@warp_field\\\"),\\n (\\\"outputnode.T1_registered_crop\\\", \\\"anat.@T1_reg_crop\\\"),\\n (\\\"outputnode.act_5tt_registered_crop\\\", \\\"anat.@act_5tt_reg_crop\\\",),\\n (\\\"outputnode.gmwmi_registered_crop\\\", \\\"anat.@gmwmi_reg_crop\\\"),\\n (\\\"outputnode.brain_registered_crop\\\", \\\"anat.@brain_reg_crop\\\"),\\n (\\\"outputnode.brain_mask_registered_crop\\\", \\\"anat.@brain_mask_reg_crop\\\",),\\n (\\\"outputnode.wm_mask_registered_crop\\\", \\\"anat.@wm_mask_reg_crop\\\",),\\n (\\\"outputnode.roi_volumes_registered_crop\\\", \\\"anat.@roivs_reg_crop\\\",),\\n (\\\"outputnode.partial_volumes_registered_crop\\\", \\\"anat.@pves_reg_crop\\\",)],),\\n ]\\n )\\n # fmt:on\\n\\n if self.stages[\\\"Connectome\\\"].enabled:\\n self.stages[\\\"Connectome\\\"].config.probtrackx = False\\n self.stages[\\\"Connectome\\\"].config.subject = self.global_conf.subject\\n con_flow = self.create_stage_flow(\\\"Connectome\\\")\\n # fmt:off\\n diffusion_flow.connect(\\n [\\n (diffusion_inputnode, con_flow, [(\\\"parcellation_scheme\\\", \\\"inputnode.parcellation_scheme\\\"),\\n (\\\"atlas_info\\\", \\\"inputnode.atlas_info\\\"),\\n (\\\"roi_graphMLs\\\", \\\"inputnode.roi_graphMLs\\\")]),\\n (diff_flow, con_flow, [(\\\"outputnode.track_file\\\", \\\"inputnode.track_file\\\"),\\n (\\\"outputnode.FA\\\", \\\"inputnode.FA\\\"),\\n (\\\"outputnode.ADC\\\", \\\"inputnode.ADC\\\"),\\n (\\\"outputnode.AD\\\", \\\"inputnode.AD\\\"),\\n (\\\"outputnode.RD\\\", \\\"inputnode.RD\\\"),\\n (\\\"outputnode.roi_volumes\\\", \\\"inputnode.roi_volumes_registered\\\",),\\n (\\\"outputnode.skewness\\\", \\\"inputnode.skewness\\\"),\\n (\\\"outputnode.kurtosis\\\", \\\"inputnode.kurtosis\\\"),\\n (\\\"outputnode.P0\\\", \\\"inputnode.P0\\\"),\\n (\\\"outputnode.mapmri_maps\\\", \\\"inputnode.mapmri_maps\\\"),\\n (\\\"outputnode.shore_maps\\\", \\\"inputnode.shore_maps\\\")]),\\n (con_flow, diffusion_outputnode, [(\\\"outputnode.connectivity_matrices\\\", \\\"connectivity_matrices\\\")]),\\n (diff_flow, sinker, [(\\\"outputnode.fod_file\\\", \\\"dwi.@fod_file\\\"),\\n (\\\"outputnode.FA\\\", \\\"dwi.@FA\\\"),\\n (\\\"outputnode.ADC\\\", \\\"dwi.@ADC\\\"),\\n (\\\"outputnode.AD\\\", \\\"dwi.@AD\\\"),\\n (\\\"outputnode.RD\\\", \\\"dwi.@RD\\\"),\\n (\\\"outputnode.skewness\\\", \\\"dwi.@skewness\\\"),\\n (\\\"outputnode.kurtosis\\\", \\\"dwi.@kurtosis\\\"),\\n (\\\"outputnode.P0\\\", \\\"dwi.@P0\\\"),\\n (\\\"outputnode.mapmri_maps\\\", \\\"dwi.@mapmri_maps\\\"),\\n (\\\"outputnode.shore_maps\\\", \\\"dwi.@shore_maps\\\")]),\\n (con_flow, sinker, [(\\\"outputnode.streamline_final_file\\\", \\\"dwi.@streamline_final_file\\\"),\\n (\\\"outputnode.connectivity_matrices\\\", \\\"dwi.@connectivity_matrices\\\")]),\\n ]\\n )\\n # fmt:on\\n\\n return diffusion_flow\",\n \"def pack_firmware(self, work_dir, jobclient, version_string=\\\"\\\"):\\n raise NotImplementedError(\\\"Abstract method not implemented\\\")\",\n \"def __call__(self, node):\\n\\n # should throw an error\\n if node.cfgInterface == None:\\n return\\n\\n # //\\n # // Extract LFN base from included WorkflowSpec parameters\\n #//\\n base = node.getParameter(\\\"UnmergedLFNBase\\\")[0]\\n\\n # //\\n # // iterate over outputmodules/data tiers\\n #// Generate LFN, PFN and Catalog for each module\\n for modName, outModule in node.cfgInterface.outputModules.items():\\n if ( not outModule.has_key('fileName') ):\\n msg = \\\"OutputModule %s does not contain a fileName entry\\\" % modName\\n raise RuntimeError, msg\\n outModule['logicalFileName'] = os.path.join(base, outModule['dataTier'], str(self.lfnGroup))\\n outModule['logicalFileName'] += '/'\\n outModule['logicalFileName'] += outModule['fileName']\\n\\n return\",\n \"def encodeToLabels(self, gt_instances):\\n raw_boxes_xyzwhd = np.zeros((self.config_data[\\\"max_boxes_per_frame\\\"], 7))\\n ### initialize gronud truth labels as np.zeors ###\\n gt_labels = np.zeros(list(self.headoutput_shape[1:4]) + \\\\\\n [len(self.anchor_boxes)] + \\\\\\n [len(self.config_data[\\\"all_classes\\\"]) + 7])\\n\\n ### start transferring box to ground turth label format ###\\n for i in range(len(gt_instances[\\\"classes\\\"])):\\n if i > self.config_data[\\\"max_boxes_per_frame\\\"]:\\n continue\\n class_name = gt_instances[\\\"classes\\\"][i]\\n box_xyzwhd = gt_instances[\\\"boxes\\\"][i]\\n class_id = self.config_data[\\\"all_classes\\\"].index(class_name)\\n if i < self.config_data[\\\"max_boxes_per_frame\\\"]:\\n raw_boxes_xyzwhd[i, :6] = box_xyzwhd\\n raw_boxes_xyzwhd[i, 6] = class_id\\n class_onehot = helper.smoothOnehot(class_id, len(self.config_data[\\\"all_classes\\\"]))\\n \\n exist_positive = False\\n\\n grid_strid = self.grid_strides\\n anchor_stage = self.anchor_boxes\\n box_xyzwhd_scaled = box_xyzwhd[np.newaxis, :].astype(np.float32)\\n box_xyzwhd_scaled[:, :3] /= grid_strid\\n anchorstage_xyzwhd = np.zeros([len(anchor_stage), 6])\\n anchorstage_xyzwhd[:, :3] = np.floor(box_xyzwhd_scaled[:, :3]) + 0.5\\n anchorstage_xyzwhd[:, 3:] = anchor_stage.astype(np.float32)\\n\\n iou_scaled = helper.iou3d(box_xyzwhd_scaled, anchorstage_xyzwhd, \\\\\\n self.input_size)\\n ### NOTE: 0.3 is from YOLOv4, maybe this should be different here ###\\n ### it means, as long as iou is over 0.3 with an anchor, the anchor\\n ### should be taken into consideration as a ground truth label\\n iou_mask = iou_scaled > 0.3\\n\\n if np.any(iou_mask):\\n xind, yind, zind = np.floor(np.squeeze(box_xyzwhd_scaled)[:3]).\\\\\\n astype(np.int32)\\n ### TODO: consider changing the box to raw yolohead output format ###\\n gt_labels[xind, yind, zind, iou_mask, 0:6] = box_xyzwhd\\n gt_labels[xind, yind, zind, iou_mask, 6:7] = 1.\\n gt_labels[xind, yind, zind, iou_mask, 7:] = class_onehot\\n exist_positive = True\\n\\n if not exist_positive:\\n ### NOTE: this is the normal one ###\\n ### it means take the anchor box with maximum iou to the raw\\n ### box as the ground truth label\\n anchor_ind = np.argmax(iou_scaled)\\n xind, yind, zind = np.floor(np.squeeze(box_xyzwhd_scaled)[:3]).\\\\\\n astype(np.int32)\\n gt_labels[xind, yind, zind, anchor_ind, 0:6] = box_xyzwhd\\n gt_labels[xind, yind, zind, anchor_ind, 6:7] = 1.\\n gt_labels[xind, yind, zind, anchor_ind, 7:] = class_onehot\\n\\n has_label = False\\n for label_stage in gt_labels:\\n if label_stage.max() != 0:\\n has_label = True\\n gt_labels = [np.where(gt_i == 0, 1e-16, gt_i) for gt_i in gt_labels]\\n return gt_labels, has_label, raw_boxes_xyzwhd\",\n \"def worker(selection_idx, results_table):\\n randgen = np.random.RandomState()\\n \\n # Data-specific positive set partition (the real-world dataset consists of multiple motif classes, always exactly 3 instances of each class stored consequently).\\n # The partition assures that the training and test sets do not share instances of the same motif class\\n positive_n_train = round(0.8 * len(positive_set_) / 3) * 3\\n block_start_idx = randgen.randint(positive_n_train / 3 + 1) * 3 \\n block_end_idx = block_start_idx + len(positive_set_) - positive_n_train\\n positive_set_part_train, positive_set_part_test = (np.concatenate((positive_set_[: block_start_idx], positive_set_[block_end_idx: ])), positive_set_[block_start_idx: block_end_idx])\\n \\n # Negative set partition with random selection of elements to match the size of the positive set\\n negative_set = negative_set_[randgen.choice(len(negative_set_), size = positive_set_.shape[0], replace = False)]\\n negative_n = len(negative_set)\\n negative_n_train = round(negative_n * 0.8)\\n negative_set_part_train, negative_set_part_test = (negative_set[: negative_n_train], negative_set[negative_n_train: ])\\n \\n data_part_train = np.float64(np.concatenate((positive_set_part_train, negative_set_part_train)))\\n labels_part_train = np.concatenate((np.ones(len(positive_set_part_train), dtype = 'i1'), np.zeros(len(negative_set_part_train), dtype = 'i1')))\\n data_part_test = np.float64(np.concatenate((positive_set_part_test, negative_set_part_test)))\\n labels_part_test = np.concatenate((np.ones(len(positive_set_part_test), dtype = 'i1'), np.zeros(len(negative_set_part_test), dtype = 'i1')))\\n \\n # Specifying the pipeline and the CV structure\\n pruner = feature_selection.VarianceThreshold()\\n scaler = preprocessing.StandardScaler()\\n feature_selector = feature_selection.SelectKBest(feature_selection.f_classif)\\n classifier = svm.SVC(kernel = 'rbf', gamma = 0.01, class_weight = 'balanced')\\n pipeline0 = pipeline.Pipeline([\\n ('pruning', pruner),\\n ('scaling', scaler),\\n ('selection', feature_selector),\\n ('classification', classifier)\\n ])\\n cv_structure = model_selection.StratifiedShuffleSplit(n_splits = 10, test_size = 0.2)\\n scoring = 'recall_macro' #same as balanced accuracy\\n grid = model_selection.GridSearchCV(pipeline0, scoring = scoring, param_grid = param_grid, cv = cv_structure, n_jobs = 1)\\n \\n # Training the pipeline, saving the data\\n grid.fit(data_part_train, labels_part_train)\\n results_table[selection_idx][0] = np.log10(grid.best_params_['classification__C'])\\n results_table[selection_idx][1] = grid.best_params_['selection__k']\\n results_table[selection_idx][2] = grid.best_score_\\n \\n # Testing the pipeline, saving the data\\n results_table[selection_idx][3] = grid.score(data_part_test, labels_part_test)\",\n \"def _vVBEL_XXXX(self,vKNOT=None,OBJTYPE=None):\\r\\n\\r\\n logStr = \\\"{0:s}.{1:s}: \\\".format(self.__class__.__name__, sys._getframe().f_code.co_name)\\r\\n logger.debug(\\\"{0:s}{1:s}\\\".format(logStr,'Start.')) \\r\\n \\r\\n try: \\r\\n \\r\\n #'KVR','PZON_NAME', 'FSTF_NAME', 'STOF_NAME', 'GMIX_NAME','UTMP_NAME'\\r\\n\\r\\n\\r\\n\\r\\n vXXXX=None\\r\\n\\r\\n vXXXX=pd.merge(self.dataFrames[OBJTYPE],vKNOT,left_on='fkKI',right_on='pk',suffixes=('','_i')) \\r\\n vXXXX=vXXXX[['fkKK','BESCHREIBUNG','IDREFERENZ','pk','tk','NAME','CONT','CONT_VKNO','pk_i','ZKOR']]\\r\\n vXXXX.rename(columns={'NAME':'NAME_i','CONT':'CONT_i','CONT_VKNO':'CONT_VKNO_i','ZKOR':'Z_i'},inplace=True)\\r\\n\\r\\n vXXXX=pd.merge(vXXXX,vKNOT,left_on='fkKK',right_on='pk',suffixes=('','_k'))\\r\\n vXXXX=vXXXX[['BESCHREIBUNG','IDREFERENZ','pk','tk','NAME_i','CONT_i','CONT_VKNO_i','Z_i','pk_i','NAME','CONT','CONT_VKNO','pk_k','ZKOR']]\\r\\n vXXXX.rename(columns={'NAME':'NAME_k','CONT':'CONT_k','CONT_VKNO':'CONT_VKNO_k','ZKOR':'Z_k'},inplace=True)\\r\\n \\r\\n vXXXX=vXXXX.assign(OBJTYPE=lambda x: OBJTYPE)\\r\\n vXXXX=vXXXX[['OBJTYPE','BESCHREIBUNG','IDREFERENZ','pk','tk','NAME_i','CONT_i','CONT_VKNO_i','Z_i','pk_i','NAME_k','CONT_k','CONT_VKNO_k','Z_k','pk_k']]\\r\\n\\r\\n except Exception as e:\\r\\n logStrFinal=\\\"{:s}Exception: Line: {:d}: {!s:s}: {:s}\\\".format(logStr,sys.exc_info()[-1].tb_lineno,type(e),str(e))\\r\\n logger.debug(logStrFinal) \\r\\n vXXXX=None\\r\\n \\r\\n finally:\\r\\n logger.debug(\\\"{0:s}{1:s}\\\".format(logStr,'_Done.'))\\r\\n return vXXXX\",\n \"def process_circuits(self, processor_fn, updated_aliases=None):\\n P = processor_fn # shorthand\\n cpy = LsGermsSerialStructure(self.Ls, list(map(P, self.germs)),\\n self.nMinorRows, self.nMinorCols,\\n updated_aliases, self.sequenceRules)\\n cpy.allstrs = list(map(P, self.allstrs))\\n cpy.allstrs_set = set(cpy.allstrs)\\n cpy.unindexed = list(map(P, self.unindexed))\\n cpy._plaquettes = {k: v.process_circuits(P, updated_aliases) for k, v in self._plaquettes.items()}\\n cpy._firsts = [(L, P(germ)) for (L, germ) in self._firsts]\\n cpy._baseStrToLGerm = {P(base): (L, P(germ)) for base, (L, germ) in self._baseStrToLGerm.items()}\\n return cpy\",\n \"def build(self):\\n super(VaporStateBlockData, self).build()\\n\\n # Object reference for molecular weight if needed by CV1D\\n # Molecular weights\\n self.mw_comp = Reference(self.params.mw_comp)\\n\\n self.flow_mol = Var(initialize=1.0,\\n domain=NonNegativeReals,\\n units=pyunits.mol / pyunits.s,\\n doc='Total molar flowrate')\\n\\n self.mole_frac_comp = Var(self.component_list,\\n domain=NonNegativeReals,\\n bounds=(0, 1),\\n units=None,\\n initialize=1 / len(self.component_list),\\n doc='Component mole fractions [-]')\\n\\n self.pressure = Var(initialize=101325,\\n domain=NonNegativeReals,\\n units=pyunits.Pa,\\n doc='Pressure [Pa]')\\n\\n self.temperature = Var(initialize=298.15,\\n domain=NonNegativeReals,\\n units=pyunits.K,\\n doc='Temperature [K]')\\n\\n # Sum mole fractions if not inlet block\\n if self.config.defined_state is False:\\n def sum_component_eqn(b):\\n return b.flow_mol == sum(b.flow_mol_comp[j]\\n for j in b._params.component_list)\\n self.sum_component_eqn = Constraint(rule=sum_component_eqn)\",\n \"def exec_attention(self,curr_step): \\n\\n assert(self.curr_step_idx > 0 and self.dlist is not None), \\\"Step Error: Must call init before combine\\\" \\n \\n detectType = curr_step[\\\"detectionNetwork\\\"]\\n paramsFile = curr_step[\\\"paramsFile\\\"]\\n funclist = curr_step[\\\"funclist\\\"]\\n\\n #verify raw data & dlist\\n # self.B_VER(self.sess_path, self.dlist)\\n raw_datadir = self.sess_path\\n dest_datadir = self.sess_path \\n\\n model_dict = {\\\"detectType\\\": detectType, \\\"paramsFile\\\" : paramsFile} \\n\\n for i, folder in enumerate(self.dlist):\\n flist = funclist[i]\\n self.data_utils.DETECT(raw_datadir, folder, dest_datadir, model_dict, flist=[], preview=False)\\n self.default_vis(curr_step)\",\n \"def encode(self):\\n payload = []\\n\\n # Generate Payload\\n if self.IsEnsembleData:\\n payload += self.EnsembleData.encode()\\n if self.IsAncillaryData:\\n payload += self.AncillaryData.encode()\\n if self.IsAmplitude:\\n payload += self.Amplitude.encode()\\n if self.IsCorrelation:\\n payload += self.Correlation.encode()\\n if self.IsBeamVelocity:\\n payload += self.BeamVelocity.encode()\\n if self.IsInstrumentVelocity:\\n payload += self.InstrumentVelocity.encode()\\n if self.IsEarthVelocity:\\n payload += self.EarthVelocity.encode()\\n if self.IsGoodBeam:\\n payload += self.GoodBeam.encode()\\n if self.IsGoodEarth:\\n payload += self.GoodEarth.encode()\\n if self.IsBottomTrack:\\n payload += self.BottomTrack.encode()\\n if self.IsRangeTracking:\\n payload += self.RangeTracking.encode()\\n if self.IsSystemSetup:\\n payload += self.SystemSetup.encode()\\n if self.IsNmeaData:\\n payload += self.NmeaData.encode()\\n\\n # Generate the header\\n # Get the ensemble number\\n ens_num = 0\\n if self.IsEnsembleData:\\n ens_num = self.EnsembleData.EnsembleNumber\\n\\n # Get the payload size\\n payload_size = len(payload)\\n\\n header = Ensemble.generate_ens_header(ens_num, payload_size)\\n\\n # Generate the Checksum CITT\\n # Parameters found at https: // pycrc.org / models.html\\n #crc = pycrc.algorithms.Crc(width=16, poly=0x1021,\\n # reflect_in=False, xor_in=0x1d0f,\\n # reflect_out=False, xor_out=0x0000)\\n #checksum = crc.bit_by_bit_fast(binascii.a2b_hex(bytes(payload)))\\n #checksum = Ensemble.int32_to_bytes(CRCCCITT().calculate(input_data=bytes(payload)))\\n checksum = crc16.crc16xmodem(payload)\\n\\n\\n result = []\\n result += header\\n result += payload\\n result += checksum\\n\\n return bytearray(result)\",\n \"def transform(self, inputs: list, stage: str) -> datapack.DataPack:\",\n \"def predict_structure(prefix, model_runner_1: alphafold.model.model.RunModel,\\n model_runner_3: alphafold.model.model.RunModel,\\n feature_dict, Ls: list[int], model_params: haiku.Params, use_model, do_relax=False,\\n random_seed=0):\\n\\n # Minkyung's code\\n # add big enough number to residue index to indicate chain breaks\\n idx_res = feature_dict['residue_index']\\n L_prev = 0\\n # Ls: number of residues in each chain\\n for L_i in Ls[:-1]:\\n idx_res[L_prev + L_i:] += 200\\n L_prev += L_i\\n chains = list(\\\"\\\".join([ascii_uppercase[n] * L for n, L in enumerate(Ls)]))\\n feature_dict['residue_index'] = idx_res\\n\\n # Run the models.\\n plddts, paes = [], []\\n unrelaxed_pdb_lines = []\\n relaxed_pdb_lines = []\\n\\n print(f\\\"Use_model {use_model}\\\")\\n\\n for model_name, params in model_params.items():\\n if model_name in use_model:\\n print(f\\\"running {model_name}\\\")\\n # swap params to avoid recompiling\\n # note: models 1,2 have diff number of params compared to models 3,4,5\\n if any(str(m) in model_name for m in [1, 2]): model_runner = model_runner_1\\n if any(str(m) in model_name for m in [3, 4, 5]): model_runner = model_runner_3\\n model_runner.params = params\\n\\n processed_feature_dict: affeatures.FeatureDict = model_runner.process_features(feature_dict,\\n random_seed=random_seed)\\n # prediction_result is a dictionary of NumPy feature arrays\\n prediction_result: dict = model_runner.predict(processed_feature_dict)\\n unrelaxed_protein: protein.Protein = protein.from_prediction(processed_feature_dict, prediction_result)\\n unrelaxed_pdb_lines.append(protein.to_pdb(unrelaxed_protein))\\n plddts.append(prediction_result['plddt'])\\n paes.append(prediction_result['predicted_aligned_error'])\\n\\n if do_relax:\\n # Relax the prediction.\\n amber_relaxer: relax.AmberRelaxation = relax.AmberRelaxation(max_iterations=0, tolerance=2.39,\\n stiffness=10.0, exclude_residues=[],\\n max_outer_iterations=20)\\n relaxed_pdb_str, _, _ = amber_relaxer.process(prot=unrelaxed_protein)\\n relaxed_pdb_lines.append(relaxed_pdb_str)\\n\\n # rerank models based on predicted lddt\\n lddt_rank = np.mean(plddts, -1).argsort()[::-1]\\n out = {}\\n print(\\\"reranking models based on avg. predicted lDDT\\\")\\n for n, r in enumerate(lddt_rank):\\n print(f\\\"model_{n + 1} {np.mean(plddts[r])}\\\")\\n\\n unrelaxed_pdb_path = f'{prefix}_unrelaxed_model_{n + 1}.pdb'\\n with open(unrelaxed_pdb_path, 'w') as f:\\n f.write(unrelaxed_pdb_lines[r])\\n set_bfactor(unrelaxed_pdb_path, plddts[r], idx_res, chains)\\n\\n if do_relax:\\n relaxed_pdb_path = f'{prefix}_relaxed_model_{n + 1}.pdb'\\n with open(relaxed_pdb_path, 'w') as f: f.write(relaxed_pdb_lines[r])\\n set_bfactor(relaxed_pdb_path, plddts[r], idx_res, chains)\\n\\n out[f\\\"model_{n + 1}\\\"] = {\\\"plddt\\\": plddts[r], \\\"pae\\\": paes[r]}\\n return out\",\n \"def __init__(self, objects=()):\\n\\n vtk.vtkPropAssembly.__init__(self)\\n\\n self.name = \\\"\\\"\\n self.created = \\\"\\\"\\n self.trail = None\\n self.trail_points = []\\n self.trail_segment_size = 0\\n self.trail_offset = None\\n self.shadows = []\\n self.info = {}\\n self.rendered_at = set()\\n self.transform = None\\n self.scalarbar = None\\n\\n for a in vedo.utils.flatten(objects):\\n if a:\\n self.AddPart(a)\\n\\n self.PickableOff()\",\n \"def dovisitcomb(allv) :\\n allvisits = allv[0]\\n load = allv[1]\\n field = allv[2][0]\\n apogee_id = allv[2][1]\\n clobber = allv[2][2]\\n pixelmask=bitmask.PixelBitMask()\\n\\n # already done?\\n outdir=os.path.dirname(load.filename('Field',field=field))\\n outdir=outdir.replace('/stars/','/rv/')\\n if os.path.exists(outdir+'/'+apogee_id+'.pkl') and not clobber:\\n print(apogee_id,' already done visitcomb')\\n fp=open(outdir+'/'+apogee_id+'.pkl','rb')\\n try: \\n out=pickle.load(fp)\\n fp.close()\\n return out\\n except: \\n print('error loading: ', apogee_id+'.pkl')\\n pass\\n\\n # do the combination\\n apstar=visitcomb(allvisits,load=load,plot=False)\\n\\n # dump\\n pickle.dump(apstar,open(outdir+'/'+apogee_id+'.pkl','wb'))\\n\\n return apstar\",\n \"def _form_computation_graph(self, idx):\\n _list, _set = list, set\\n if type(idx) is int:\\n node_layers = [np.array([idx], dtype=np.int64)]\\n elif type(idx) is list:\\n node_layers = [np.array(idx, dtype=np.int64)]\\n\\n for _ in range(self.n_layers):\\n prev = node_layers[-1]\\n arr = [node for node in prev]\\n arr.extend([e[0] for node in arr for e in self.nbrs_t[node]])\\n arr = np.array(_list(_set(arr)), dtype=np.int64)\\n node_layers.append(arr)\\n node_layers.reverse()\\n\\n mappings = [{j: i for (i, j) in enumerate(arr)} for arr in node_layers]\\n\\n return node_layers, mappings\",\n \"def genereate_echo_picklist(self):\\n sample_names = []\\n sample_wells = []\\n indices = {'i5 name': {}, 'i5 plate': {}, 'i5 sequence': {},\\n 'i5 well': {}, 'i7 name': {}, 'i7 plate': {},\\n 'i7 sequence': {}, 'i7 well': {}, 'index combo': {},\\n 'index combo seq': {}}\\n\\n for idx, well in enumerate(chain.from_iterable(self.plates[0].layout)):\\n # Add the sample well\\n sample_wells.append(well.well_id)\\n # Get the sample name - we need to go back to the SampleComposition\\n lib_comp = well.composition\\n sample_comp = lib_comp.normalized_gdna_composition\\\\\\n .gdna_composition.sample_composition\\n sample_names.append(sample_comp.content)\\n # Retrieve all the information about the indices\\n i5_comp = lib_comp.i5_composition.primer_set_composition\\n i5_well = i5_comp.container\\n indices['i5 name'][idx] = i5_comp.external_id\\n indices['i5 plate'][idx] = i5_well.plate.external_id\\n indices['i5 sequence'][idx] = i5_comp.barcode\\n indices['i5 well'][idx] = i5_well.well_id\\n\\n i7_comp = lib_comp.i7_composition.primer_set_composition\\n i7_well = i7_comp.container\\n indices['i7 name'][idx] = i7_comp.external_id\\n indices['i7 plate'][idx] = i7_well.plate.external_id\\n indices['i7 sequence'][idx] = i7_comp.barcode\\n indices['i7 well'][idx] = i7_well.well_id\\n\\n indices['index combo seq'][idx] = '%s%s' % (\\n indices['i5 sequence'][idx], indices['i7 sequence'][idx])\\n\\n sample_names = np.asarray(sample_names)\\n sample_wells = np.asarray(sample_wells)\\n indices = pd.DataFrame(indices)\\n\\n return LibraryPrepShotgunProcess._format_picklist(\\n sample_names, sample_wells, indices)\",\n \"def __rechaindict__(c):\\n from TriggerMenu.menu.DictFromChainName import DictFromChainName\\n dfcn = DictFromChainName()\\n\\n pl1 = []\\n for pch in c['chainParts']:\\n pl1.append(pch['L1item'])\\n\\n newname = c['chainName'].replace('dv_','').replace('TestChain','j')\\n nchlist = [ newname ,c['chainCounter'],c['L1item'],pl1,c['stream'],\\n c['groups'],c['EBstep'] ]\\n \\n return dfcn.getChainDict(nchlist)\",\n \"def hierarchical( x, output_prefix, labels_to_register=[2,3,4,5], is_test=False, verbose=True ):\\n if verbose:\\n print(\\\"Read\\\")\\n tfn = get_data('T_template0', target_extension='.nii.gz' )\\n tfnw = get_data('T_template0_WMP', target_extension='.nii.gz' )\\n tlrfn = get_data('T_template0_LR', target_extension='.nii.gz' )\\n bfn = antspynet.get_antsxnet_data( \\\"croppedMni152\\\" )\\n\\n ##### read images and do simple bxt ops\\n templatea = ants.image_read( tfn )\\n if verbose:\\n print(\\\"bxt\\\")\\n templatea = ( templatea * antspynet.brain_extraction( templatea, 't1' ) ).iMath( \\\"Normalize\\\" )\\n templateawmprior = ants.image_read( tfnw )\\n templatealr = ants.image_read( tlrfn )\\n templateb = ants.image_read( bfn )\\n templateb = ( templateb * antspynet.brain_extraction( templateb, 't1' ) ).iMath( \\\"Normalize\\\" )\\n imgbxt = brain_extraction( x )\\n img = x * imgbxt\\n\\n if verbose:\\n print(\\\"rbp\\\")\\n\\n # this is an unbiased method for identifying predictors that can be used to\\n # rank / sort data into clusters, some of which may be associated\\n # with outlierness or low-quality data\\n templatesmall = ants.resample_image( templateb, (91,109,91), use_voxels=True )\\n rbp = random_basis_projection( img, templatesmall )\\n\\n if verbose:\\n print(\\\"intensity\\\")\\n\\n ##### intensity modifications\\n img = ants.iMath( img, \\\"Normalize\\\" ) * 255.0\\n img = ants.denoise_image( img, imgbxt, noise_model='Gaussian')\\n img = ants.n4_bias_field_correction( img ).iMath(\\\"Normalize\\\")\\n\\n # optional - quick look at result\\n bxt_png = output_prefix + \\\"_brain_extraction_dnz_n4_view.png\\\"\\n ants.plot(img,axis=2,ncol=8,nslices=24, crop=True, black_bg=False,\\n filename = bxt_png )\\n\\n if verbose:\\n print(\\\"hemi\\\")\\n\\n # assuming data is reasonable quality, we should proceed with the rest ...\\n mylr = label_hemispheres( img, templatea, templatealr )\\n\\n if verbose:\\n print(\\\"parcellation\\\")\\n\\n ##### hierarchical labeling\\n myparc = deep_brain_parcellation( img, templateb,\\n do_cortical_propagation = not is_test, verbose=False )\\n\\n ##### accumulate data into data frames\\n hemi = map_segmentation_to_dataframe( \\\"hemisphere\\\", myparc['hemisphere_labels'] )\\n tissue = map_segmentation_to_dataframe( \\\"tissues\\\", myparc['tissue_segmentation'] )\\n dktl = map_segmentation_to_dataframe( \\\"lobes\\\", myparc['dkt_lobes'] )\\n dktp = map_segmentation_to_dataframe( \\\"dkt\\\", myparc['dkt_parcellation'] )\\n dktc = None\\n if not is_test:\\n dktc = map_segmentation_to_dataframe( \\\"dkt\\\", myparc['dkt_cortex'] )\\n\\n tissue_seg_png = output_prefix + \\\"_seg.png\\\"\\n ants.plot( img, myparc['tissue_segmentation'], axis=2, nslices=21, ncol=7,\\n alpha=0.6, filename=tissue_seg_png,\\n crop=True, black_bg=False )\\n\\n if verbose:\\n print(\\\"WMH\\\")\\n\\n ##### below here are more exploratory nice to have outputs\\n myhypo = t1_hypointensity(\\n img,\\n myparc['tissue_segmentation'], # segmentation\\n myparc['tissue_probabilities'][3], # wm posteriors\\n templatea,\\n templateawmprior )\\n\\n if verbose:\\n print(\\\"registration\\\")\\n\\n ##### traditional deformable registration as a high-resolution complement to above\\n wm_tractsL = None\\n wm_tractsR = None\\n wmtdfL = None\\n wmtdfR = None\\n reg = None\\n if labels_to_register is not None:\\n reg = hemi_reg(\\n input_image = img,\\n input_image_tissue_segmentation = myparc['tissue_segmentation'],\\n input_image_hemisphere_segmentation = mylr,\\n input_template=templatea,\\n input_template_hemisphere_labels=templatealr,\\n output_prefix = output_prefix + \\\"_SYN\\\",\\n labels_to_register = labels_to_register,\\n is_test=is_test )\\n if verbose:\\n print(\\\"wm tracts\\\")\\n ##### how to use the hemi-reg output to generate any roi value from a template roi\\n wm_tracts = ants.image_read( get_data( \\\"wm_major_tracts\\\", target_extension='.nii.gz' ) )\\n wm_tractsL = ants.apply_transforms( img, wm_tracts, reg['synL']['invtransforms'],\\n interpolator='genericLabel' ) * ants.threshold_image( mylr, 1, 1 )\\n wm_tractsR = ants.apply_transforms( img, wm_tracts, reg['synR']['invtransforms'],\\n interpolator='genericLabel' ) * ants.threshold_image( mylr, 2, 2 )\\n wmtdfL = map_segmentation_to_dataframe( \\\"wm_major_tracts\\\", wm_tractsL )\\n wmtdfR = map_segmentation_to_dataframe( \\\"wm_major_tracts\\\", wm_tractsR )\\n\\n if verbose:\\n print(\\\"hippocampus\\\")\\n\\n ##### specialized labeling for hippocampus\\n ntries = 10\\n if is_test:\\n ntries = 1\\n hippLR = deep_hippo( img, templateb, ntries )\\n\\n mydataframes = {\\n \\\"hemispheres\\\":hemi,\\n \\\"tissues\\\":tissue,\\n \\\"dktlobes\\\":dktl,\\n \\\"dktregions\\\":dktp,\\n \\\"dktcortex\\\":dktc,\\n \\\"wmtracts_left\\\":wmtdfL,\\n \\\"wmtracts_right\\\":wmtdfR,\\n \\\"wmh\\\":myhypo['wmh_summary']\\n }\\n\\n outputs = {\\n \\\"brain_n4_dnz\\\": img,\\n \\\"brain_n4_dnz_png\\\": bxt_png,\\n \\\"brain_extraction\\\": imgbxt,\\n \\\"tissue_seg_png\\\": tissue_seg_png,\\n \\\"rbp\\\": rbp,\\n \\\"left_right\\\": mylr,\\n \\\"dkt_parc\\\": myparc,\\n \\\"registration\\\":reg,\\n \\\"hippLR\\\":hippLR,\\n \\\"white_matter_hypointensity\\\":myhypo,\\n \\\"wm_tractsL\\\":wm_tractsL,\\n \\\"wm_tractsR\\\":wm_tractsR,\\n \\\"dataframes\\\": mydataframes\\n }\\n\\n return outputs\",\n \"def label(gt_dataset, volume_dim, voxel_dim, labeling_params):\\n labeled_volumes = dict()\\n labeled_cells = dict()\\n #Use global density and reduce the size of gt_dataset here\\n global_density = labeling_params[\\\"global_density\\\"]\\n gt_dataset = {k: v for k,v in gt_dataset.items() if random_sample() < global_density}\\n #Label in the order specified in the configuration\\n layers = sorted(labeling_params.keys())\\n #Remove global_density\\n layers.remove(\\\"global_density\\\")\\n for layer in layers:\\n print \\\"Labeling {}\\\".format(layer)\\n fluorophore = labeling_params[layer]['fluorophore']\\n volume, cells = brainbow(gt_dataset, volume_dim, voxel_dim, **labeling_params[layer])\\n if fluorophore in labeled_volumes:\\n labeled_volumes[fluorophore] += volume\\n labeled_cells[fluorophore] |= cells\\n else:\\n labeled_volumes[fluorophore] = volume\\n labeled_cells[fluorophore] = cells\\n return labeled_volumes, labeled_cells\",\n \"def mapping_image_to_label (self, labels_df, polygons, fpath_tiff): \\n \\n unread_tiff = rasterio.open(fpath_tiff)\\n\\n #Projecting the coordinates to that CRS \\n proj = Proj(init='epsg:32618')\\n data = []\\n labels = []\\n failed = []\\n \\n src = rasterio.open(fpath_tiff, 'r')\\n outfolder = '/train/batch'\\n \\n print (\\\"Hold on tight! Mapping each image to its respective label...\\\")\\n \\n \\n for num, row in labels_df.iterrows():\\n try:\\n \\n \\n roof_material_num = 0\\n polygon0 = polygons [num]\\n polygon0['coordinates'] = self.transforming_coordinates(polygon0['coordinates'], proj)\\n masked_image, out_transform = rasterio.mask.mask(src,[polygon0], filled = True, crop=True, nodata = 0)\\n img_image = reshape_as_image (masked_image)\\n \\n #Defining the name of the image file as \\\"buildingID+roofMaterial+png\\\" and its path \\n img_path = os.path.join (outfolder, str (row['id'])+'-'+ str (row['roof_material'])+'.png')\\n \\n #swapping the color channels from RGB2BGR\\n img_image = cv2.cvtColor (img_image, cv2.COLOR_RGB2BGR) #img_image is a numpy array\\n \\n #resizing the image dimensions to 128x128 to match ImageNet dimensions\\n img_image = cv2.resize(img_image, (128, 128))\\n \\n #writing the image in the file\\n #cv2.imwrite (img_path, img_image)\\n # update the data and labels lists, respectively\\n data.append(img_image) #data is a list\\n labels.append(row['roof_material'])\\n \\n except Exception as e:\\n print (e)\\n failed.append (num)\\n \\n \\n #print number of images we failed to crop and write \\n print (\\\"Bad News First: Failed to write\\\", len(failed), \\\"Images.\\\")\\n print (\\\"Good News: Successfully mapped\\\", len (data), \\\"Images.\\\")\\n data = np.array(data)\\n labels = np.array(labels)\\n #batch = data.sample(frac=0.5, replace=False, random_state=1)\\n #print(\\\"Size and shape of validY: {}\\\\n\\\".format(batch.shape))\\n return data, labels\",\n \"def case():\\r\\n #ppc = {\\\"version\\\": '2'}\\r\\n ppc = {}\\r\\n ##----- Power Flow Data -----##\\r\\n ## system MVA base\\r\\n ppc[\\\"baseMVA\\\"] = 100.0\\r\\n\\r\\n ## bus data\\r\\n # bus_i type Pd Qd Gs Bs area Vm Va baseKV zone Vmax Vmin\\r\\n ppc[\\\"bus\\\"] = array([\\r\\n [1, 3, 0, 0, 0, 0, 1, 1, 0, 0.4, 1, 1.1, 0.9, 0,0, 0, 0],\\r\\n [2, 1, 0, 0, 0, 0, 1, 1, 0, 0.4, 1, 1.1, 0.9, 0,0, 0, 0],\\r\\n [3, 1, 0, 0, 0, 0, 1, 1, 0, 0.4, 1, 1.1, 0.9, 0,0, 0, 0],\\r\\n [4, 1, 0, 0, 0, 0, 1, 1, 0, 0.4, 1, 1.1, 0.9, 0,0, 0, 0],\\r\\n [5, 1, 0, 0, 0, 0, 1, 1, 0, 0.4, 1, 1.1, 0.9, 0,0, 0, 0],\\r\\n [6, 1, 0, 0, 0, 0, 1, 1, 0, 0.4, 1, 1.1, 0.9, 0,0, 0, 0],\\r\\n [7, 1, 0, 0, 0, 0, 1, 1, 0, 0.4, 1, 1.1, 0.9, 0,0, 0, 0],\\r\\n [8, 1, 0, 0, 0, 0, 1, 1, 0, 0.4, 1, 1.1, 0.9, 0,0, 0, 0],\\r\\n [9, 1, 0, 0, 0, 0, 1, 1, 0, 0.4, 1, 1.1, 0.9, 0,0, 0, 0],\\r\\n [10, 1, 0, 0, 0, 0, 1, 1, 0, 0.4, 1, 1.1, 0.9, 0,0, 0, 0],\\r\\n [11, 1, 0, 0, 0, 0, 1, 1, 0, 0.4, 1, 1.1, 0.9, 0,0, 0, 0],\\r\\n [12, 1, 0, 0, 0, 0, 1, 1, 0, 0.4, 1, 1.1, 0.9, 0,0, 0, 0],\\r\\n [13, 1, 0, 0, 0, 0, 1, 1, 0, 0.4, 1, 1.1, 0.9, 0,0, 0, 0],\\r\\n [14, 1, 0, 0, 0, 0, 1, 1, 0, 0.4, 1, 1.1, 0.9, 0,0, 0, 0],\\r\\n [15, 1, 0, 0, 0, 0, 1, 1, 0, 0.4, 1, 1.1, 0.9, 0,0, 0, 0],\\r\\n [16, 1, 0, 0, 0, 0, 1, 1, 0, 0.4, 1, 1.1, 0.9, 0,0, 0, 0]\\r\\n ])\\r\\n\\r\\n ## generator data\\r\\n # bus, Pg, Qg, Qmax, Qmin, Vg, mBase, status, Pmax, Pmin, Pc1, Pc2,\\r\\n # Qc1min, Qc1max, Qc2min, Qc2max, ramp_agc, ramp_10, ramp_30, ramp_q, apf\\r\\n ppc[\\\"gen\\\"] = array([\\r\\n [1,\\t0,\\t0,\\t10,\\t-10,\\t1.0224,\\t100,\\t1,\\t10,\\t-10,\\t0,\\t0,\\t0,\\t0,\\t0,\\t0,\\t0,\\t0,\\t0,\\t0, 0, 0,0, 0, 0],\\r\\n [3 ,0, 0, 50e-3, -50e-3, 1, 100, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0],\\r\\n [5 , 0, 0, 10e-3, -10e-3, 1, 100, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0],\\r\\n [10 , 0, 0, 10e-3, -10e-3, 1, 100, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0],\\r\\n [13 ,0, 0, 10e-3, -10e-3, 1, 100, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0],\\r\\n [15 , 0, 0, 50e-3, -50e-3, 1, 100, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0]\\r\\n ])\\r\\n load_b = array([2, 4, 9, 12, 14])\\r\\n ppc[\\\"bus\\\"][load_b, 2] = multiply(array([-2.1125, -0.2231, -0.1664, -0.0719, -1.4633]).T, 0.03)\\r\\n ppc[\\\"bus\\\"][load_b, 3] = multiply(array([1.6492, 0.4054, 0.8599, 0.8845, 0.6778]).T, 0.03)\\r\\n ## branch data\\r\\n # fbus, tbus, r, x, b, rateA, rateB, rateC, ratio, angle, status, angmin, angmax\\r\\n ppc[\\\"branch\\\"] = array([\\r\\n [1, 2, 0.0, 0.0, 0.0, 250, 250, 250, 0, 0, 1, -360, 360, 0,0, 0, 0, 0,0, 0, 0],\\r\\n [1, 8, 0.0, 0.0, 0.0, 250, 250, 250, 0, 0, 1, -360, 360, 0,0, 0, 0, 0,0, 0, 0],\\r\\n [1, 15, 0.0, 0.0, 0.0, 250, 250, 250, 0, 0, 1, -360, 360, 0,0, 0, 0, 0,0, 0, 0],\\r\\n [2, 3, 0.0, 0.0, 0.0, 250, 250, 250, 0, 0, 1, -360, 360, 0,0, 0, 0, 0,0, 0, 0],\\r\\n [2, 6, 0.0, 0.0, 0.0, 250, 250, 250, 0, 0, 1, -360, 360, 0,0, 0, 0, 0,0, 0, 0],\\r\\n [2, 7, 0.0, 0.0, 0.0, 250, 250, 250, 0, 0, 1, -360, 360, 0,0, 0, 0, 0,0, 0, 0],\\r\\n [3, 4, 0.0, 0.0, 0.0, 250, 250, 250, 0, 0, 1, -360, 360, 0,0, 0, 0, 0,0, 0, 0],\\r\\n [4, 5, 0.0, 0.0, 0.0, 250, 250, 250, 0, 0, 1, -360, 360, 0,0, 0, 0, 0,0, 0, 0],\\r\\n [8, 9, 0.0, 0.0, 0.0, 250, 250, 250, 0, 0, 1, -360, 360, 0,0, 0, 0, 0,0, 0, 0],\\r\\n [8, 12, 0.0, 0.0, 0.0, 250, 250, 250, 0, 0, 1, -360, 360, 0,0, 0, 0, 0,0, 0, 0],\\r\\n [8, 13, 0.0, 0.0, 0.0, 250, 250, 250, 0, 0, 1, -360, 360, 0,0, 0, 0, 0,0, 0, 0],\\r\\n [9, 10, 0.0, 0.0, 0.0, 250, 250, 250, 0, 0, 1, -360, 360, 0,0, 0, 0, 0,0, 0, 0],\\r\\n [9, 14, 0.0, 0.0, 0.0, 250, 250, 250, 0, 0, 1, -360, 360, 0,0, 0, 0, 0,0, 0, 0],\\r\\n [10, 11, 0.0, 0.0, 0.0, 250, 250, 250, 0, 0, 1, -360, 360, 0,0, 0, 0, 0,0, 0, 0],\\r\\n [15, 16, 0.0, 0.0, 0.0, 250, 250, 250, 0, 0, 1, -360, 360, 0,0, 0, 0, 0,0, 0, 0]\\r\\n ])\\r\\n R1 = 0.43\\r\\n L1 = 0.4e-3\\r\\n RS1 = 0.32\\r\\n LS1 = 0.39e-3\\r\\n Zbase = (0.4*0.4/100)\\r\\n branch_phase =array([\\r\\n [1, 1, 2, 188, R1, L1],\\r\\n [2, 1 ,8, 346, R1, L1],\\r\\n [3 ,1 ,15,501, R1 ,L1],\\r\\n [4, 2, 3, 130, RS1,LS1],\\r\\n [5, 2, 6, 145, RS1,LS1],\\r\\n [6, 2 ,7, 157, RS1,LS1],\\r\\n [7, 3, 4, 185, RS1,LS1],\\r\\n [8, 4, 5, 1000,RS1,LS1],\\r\\n [9, 8 ,9, 416, RS1,LS1],\\r\\n [10,8 ,12,130, RS1,LS1],\\r\\n [11,8 ,13,121, RS1,LS1],\\r\\n [12,9 ,10,130, RS1,LS1],\\r\\n [13,9 ,14,127, RS1,LS1],\\r\\n [14,10,11,251, RS1,LS1],\\r\\n [15,15,16,345, RS1,LS1]\\r\\n ])\\r\\n ppc[\\\"branch\\\"][:, [2,3]] = multiply(array([branch_phase[:, 4]*branch_phase[:, 3], branch_phase[:, 4]*branch_phase[:, 4]*100*pi]).T,0.001/Zbase)\\r\\n\\r\\n ##----- OPF Data -----##\\r\\n ## area data\\r\\n # area refbus\\r\\n\\r\\n\\r\\n ## generator cost data\\r\\n # 1 startup shutdown n x1 y1 ... xn yn\\r\\n # 2 startup shutdown n c(n-1) ... c0\\r\\n\\r\\n\\r\\n return ppc\",\n \"def _label_encoding(self):\\n for feat in self.cat_feats:\\n if self.train:\\n lbl = preprocessing.LabelEncoder()\\n lbl.fit(self.dataframe[feat].values)\\n self.dataframe_d_copy.loc[:,feat] = lbl.transform(self.dataframe[feat].values)\\n self.label_encoders[feat] = lbl\\n else:\\n lbl = self.encoders[feat]\\n self.dataframe_d_copy.loc[:,feat] = lbl.transform(self.dataframe[feat].values)\\n \\n if self.train:\\n encoder_path = f\\\"{self.output_path}/_label_encoder.pkl\\\"\\n self.cat_feats_cfg['encoder_path'] = encoder_path\\n joblib.dump(self.label_encoders, encoder_path)\\n \\n return self.dataframe_d_copy\",\n \"def convert2EbnerParamOriginalParam(listSlice,list_prefix,directory,paramAx,paramCor,paramSag):\\n paramAx=np.load(paramAx)\\n paramCor=np.load(paramCor)\\n paramSag=np.load(paramSag)\\n param=[]\\n param.append(paramAx)\\n param.append(paramCor)\\n param.append(paramSag)\\n \\n images,mask = createVolumesFromAlist(listSlice.copy()) #list of images corresponding to differents original stacks\\n \\n \\n mat = np.array([[-1,0,0,0],[0,-1,0,0],[0,0,1,0],[0,0,0,1]]) #matrix to convert affine matrix from nibabel to itk\\n\\n for n in range(len(images)): #for each stack\\n \\n imagen = images[n]\\n \\n for i_slice in range(len(images[n])): #for each slices (in each stacks)\\n \\n slicei=imagen[i_slice]\\n dimension=3\\n X,Y,Z= slicei.get_slice().get_fdata().shape\\n transfo = param[n][slicei.get_index_slice(),:,:]\\n #print()\\n matrix = mat @ transfo @ mat\\n #print(matrix)\\n test = sitk.AffineTransform(dimension)\\n test.SetMatrix(matrix[0:3,0:3].flatten())\\n test.SetTranslation(matrix[0:3,3])\\n images_index = slicei.get_index_image()\\n\\n sitk.WriteTransform(test,\\\"%s/%s_slice%d.tfm\\\" %(directory,list_prefix[images_index],slicei.get_index_slice())) #save rigid transformation, computed at the barycenter of the image, adatpted to itk\",\n \"def nodeSeparate(self,compInfo, ifSub, subname, subcktName,numNodesSub):\\n node = []\\n nodeTemp = []\\n nodeDic = {}\\n pinInit = 'Modelica.Electrical.Analog.Interfaces.Pin '\\n pinProtectedInit = 'Modelica.Electrical.Analog.Interfaces.Pin '\\n protectedNode = []\\n print \\\"CompInfo coming to nodeSeparate function: compInfo\\\",compInfo\\n \\n #Removing '[' and ']' from compInfo for Digital node\\n for i in range(0,len(compInfo),1):\\n compInfo[i] = compInfo[i].replace(\\\"[\\\",\\\"\\\").replace(\\\"]\\\",\\\"\\\")\\n \\n \\n for eachline in compInfo:\\n words = eachline.split()\\n if eachline[0] in ['m', 'e', 'g', 't','M','E','G','T']:\\n nodeTemp.append(words[1])\\n nodeTemp.append(words[2])\\n nodeTemp.append(words[3])\\n nodeTemp.append(words[4])\\n elif eachline[0] in ['q', 'j','J','Q']:\\n nodeTemp.append(words[1])\\n nodeTemp.append(words[2])\\n nodeTemp.append(words[3])\\n elif eachline[0]=='x' or eachline[0]=='X':\\n templine = eachline.split()\\n for i in range(0,len(templine),1):\\n if templine[i] in subcktName:\\n point = i \\n nodeTemp.extend(words[1:point])\\n else:\\n nodeTemp.append(words[1])\\n nodeTemp.append(words[2])\\n for i in nodeTemp:\\n if i not in node:\\n node.append(i)\\n \\n for i in range(0, len(node),1):\\n nodeDic[node[i]] = 'n' + node[i]\\n if ifSub == '0':\\n if i != len(node)-1:\\n pinInit = pinInit + nodeDic[node[i]] + ', '\\n else:\\n pinInit = pinInit + nodeDic[node[i]]\\n else:\\n nonprotectedNode = self.getSubInterface(subname, numNodesSub) \\n if node[i] in nonprotectedNode:\\n continue\\n else:\\n protectedNode.append(node[i])\\n if ifSub == '1':\\n if len(nonprotectedNode) > 0:\\n for i in range(0, len(nonprotectedNode),1):\\n if i != len(nonprotectedNode)-1:\\n pinProtectedInit = pinProtectedInit + nodeDic[nonprotectedNode[i]] + ','\\n else:\\n pinProtectedInit = pinProtectedInit + nodeDic[nonprotectedNode[i]]\\n if len(protectedNode) > 0:\\n for i in range(0, len(protectedNode),1):\\n if i != len(protectedNode)-1: \\n pinInit = pinInit + nodeDic[protectedNode[i]] + ','\\n else:\\n pinInit = pinInit + nodeDic[protectedNode[i]]\\n pinInit = pinInit + ';'\\n pinProtectedInit = pinProtectedInit + ';'\\n print \\\"Node---->\\\",node\\n print \\\"nodeDic----->\\\",nodeDic\\n print \\\"PinInit----->\\\",pinInit\\n print \\\"pinProtectedinit--->\\\",pinProtectedInit\\n return node, nodeDic, pinInit, pinProtectedInit\",\n \"def __repr__(self):\\n data = sorted(\\n (state, pos, tape_cache, outputs)\\n for pos, states in self.iteritems()\\n for state, (tape_cache, outputs) in states.iteritems())\\n branch = \\\"branch\\\" if len(data) == 1 else \\\"branches\\\"\\n result = \\\"process (%s %s)\\\" % (len(data), branch)\\n for s, sdata in itertools.groupby(data, lambda x: x[0]):\\n result += \\\"\\\\n+ at state %s\\\" % (s,)\\n for state, pos, tape_cache, outputs in sdata:\\n result += \\\"\\\\n+-- %s, %s\\\" % (tape_cache, outputs)\\n return result\",\n \"def _vVBEL(self,vKNOT=None,edges=vVBEL_edges,edgesD=vVBEL_edgesD,mColNames=['OBJTYPE','pk'],mIdxNames=['OBJTYPE','OBJID']):\\r\\n\\r\\n logStr = \\\"{0:s}.{1:s}: \\\".format(self.__class__.__name__, sys._getframe().f_code.co_name)\\r\\n logger.debug(\\\"{0:s}{1:s}\\\".format(logStr,'Start.')) \\r\\n \\r\\n try: \\r\\n # construct \\r\\n vVBEL=None\\r\\n vVBEL_UnionList=[]\\r\\n\\r\\n for VBEL in edges:\\r\\n if VBEL in self.dataFrames:\\r\\n vXXXX=self._vVBEL_XXXX(vKNOT=vKNOT,OBJTYPE=VBEL)\\r\\n if vXXXX is None:\\r\\n pass\\r\\n else:\\r\\n vVBEL_UnionList.append(vXXXX)\\r\\n vVBEL=pd.concat(vVBEL_UnionList)\\r\\n\\r\\n # MIndices\\r\\n vVBEL=Xm.constructNewMultiindexFromCols(df=vVBEL,mColNames=mColNames,mIdxNames=mIdxNames)\\r\\n\\r\\n # Gruppenzugeh. ergaenzen\\r\\n vVBEL['LAYR']=[list() for dummy in vVBEL['tk']]\\r\\n dfLayr=self.dataFrames['vLAYR']\\r\\n if not dfLayr.empty:\\r\\n dfLayr=dfLayr.rename(columns={'OBJTYPE':'TYPE'}) \\r\\n dfLayr=pd.merge(\\r\\n vVBEL\\r\\n ,dfLayr\\r\\n ,how='inner' # nur die VBEL die eine Gruppenzugehoerigkeit haben\\r\\n ,left_index=True \\r\\n ,right_on=['TYPE','OBJID'] \\r\\n ,suffixes=('', '_y'))[['NAME','TYPE','OBJID','nrObjInGroup','nrObjtypeInGroup']]\\r\\n dfLayr=dfLayr[dfLayr.nrObjInGroup <= 1] # pro VBEL und Gruppe nur 1 Zeile\\r\\n\\r\\n for index, row in vVBEL.merge(dfLayr.sort_values(by=['NAME','OBJID']),how='left',left_index=True ,right_on=['TYPE','OBJID'],suffixes=('', '_y')).iterrows(): \\r\\n if pd.isnull(row.NAME):\\r\\n continue\\r\\n row.LAYR.append(row.NAME)\\r\\n\\r\\n # L ergaenzen\\r\\n Rohr=self.dataFrames['ROHR']\\r\\n VbelL=vVBEL.join(Rohr.set_index('pk').rename_axis('OBJID', axis='index'),rsuffix='_y')[['L']] \\r\\n vVBEL['L']=VbelL['L'].fillna(0) \\r\\n\\r\\n # D ergaenzen\\r\\n # Spalte erzeugen ... \\r\\n vRohr=self.dataFrames['vROHR']\\r\\n VbelD=vVBEL.join(vRohr.set_index('pk').rename_axis('OBJID', axis='index'),rsuffix='_y')[['DI']]\\r\\n vVBEL['D']=VbelD['DI'] # ... mit ROHR\\r\\n\\r\\n # ueber alle ausser ROHR\\r\\n for eIdx,edge in enumerate(edges):\\r\\n if edge == 'ROHR':\\r\\n continue\\r\\n edgeDCol=edgesD[eIdx]\\r\\n if edgeDCol=='':\\r\\n continue \\r\\n if edge not in self.dataFrames:\\r\\n continue\\r\\n Edge=self.dataFrames[edge] \\r\\n if edgeDCol not in Edge.columns.tolist():\\r\\n continue\\r\\n edgeD=vVBEL.join(Edge.set_index('pk').rename_axis('OBJID', axis='index'),rsuffix='_y',how='inner')[[edgeDCol]]\\r\\n vVBEL.loc[[edge],'D']=edgeD.loc[[edge],:].values\\r\\n\\r\\n\\r\\n # fehlende Spaltenwerte zuweisen\\r\\n #Vent=self.dataFrames['VENT']\\r\\n #VentD=vVBEL.join(Vent.set_index('pk'),rsuffix='_y',how='inner')[['DN']]\\r\\n #vVBEL.loc[['VENT'],'D']=VentD.loc[['VENT'],:].values\\r\\n\\r\\n # Finish\\r\\n vVBEL.sort_index(level=0,inplace=True)\\r\\n\\r\\n except Exception as e:\\r\\n logStrFinal=\\\"{:s}Exception: Line: {:d}: {!s:s}: {:s}\\\".format(logStr,sys.exc_info()[-1].tb_lineno,type(e),str(e))\\r\\n logger.debug(logStrFinal) \\r\\n finally:\\r\\n logger.debug(\\\"{0:s}{1:s}\\\".format(logStr,'_Done.'))\\r\\n return vVBEL\",\n \"def apply_grub_cmdline(self):\\n\\n for i in self._nodes.items():\\n node = i[1]\\n\\n # Get the isolated CPUs\\n other_workers = node[\\\"cpu\\\"][\\\"other_workers\\\"]\\n vpp_workers = node[\\\"cpu\\\"][\\\"vpp_workers\\\"]\\n if \\\"vpp_main_core\\\" in node[\\\"cpu\\\"]:\\n vpp_main_core = node[\\\"cpu\\\"][\\\"vpp_main_core\\\"]\\n else:\\n vpp_main_core = 0\\n all_workers = []\\n if other_workers is not None:\\n all_workers = [other_workers]\\n if vpp_main_core != 0:\\n all_workers += [(vpp_main_core, vpp_main_core)]\\n all_workers += vpp_workers\\n isolated_cpus = \\\"\\\"\\n for idx, worker in enumerate(all_workers):\\n if worker is None:\\n continue\\n if idx > 0:\\n isolated_cpus += \\\",\\\"\\n if worker[0] == worker[1]:\\n isolated_cpus += \\\"{}\\\".format(worker[0])\\n else:\\n isolated_cpus += \\\"{}-{}\\\".format(worker[0], worker[1])\\n\\n vppgrb = VppGrubUtil(node)\\n current_cmdline = vppgrb.get_current_cmdline()\\n if \\\"grub\\\" not in node:\\n node[\\\"grub\\\"] = {}\\n node[\\\"grub\\\"][\\\"current_cmdline\\\"] = current_cmdline\\n node[\\\"grub\\\"][\\\"default_cmdline\\\"] = vppgrb.apply_cmdline(node, isolated_cpus)\\n\\n self.updateconfig()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.53284836","0.52070326","0.50032526","0.4924041","0.48997957","0.48227805","0.4819547","0.4782699","0.47695082","0.4746857","0.4743185","0.47308764","0.4726845","0.46611047","0.46597615","0.463954","0.46242067","0.46234703","0.45942166","0.45858887","0.4571889","0.45699766","0.45352846","0.45307684","0.45059124","0.44992357","0.4491267","0.44876143","0.44860741","0.4449634","0.4436323","0.4420826","0.4415709","0.44151866","0.44132257","0.44119504","0.44111606","0.4409967","0.4408976","0.44019982","0.44017988","0.44003794","0.43899447","0.43819338","0.43688822","0.4354956","0.43437353","0.43380022","0.43350187","0.43290702","0.4328562","0.43279904","0.43196777","0.43035686","0.43007937","0.43005908","0.42981583","0.42862144","0.42832178","0.42798436","0.42769793","0.42730308","0.42673436","0.42671657","0.42671657","0.42641827","0.42627034","0.42608324","0.42561105","0.42515945","0.42507425","0.42477784","0.42443958","0.424284","0.4238558","0.42339242","0.42317352","0.42286026","0.4222909","0.42208576","0.4217499","0.4213684","0.42129332","0.42101938","0.4209228","0.42056566","0.42052203","0.42037198","0.41966754","0.4193763","0.41932732","0.41926092","0.41910368","0.419061","0.41901353","0.4189429","0.41860756","0.4182849","0.41811472","0.41706634"],"string":"[\n \"0.53284836\",\n \"0.52070326\",\n \"0.50032526\",\n \"0.4924041\",\n \"0.48997957\",\n \"0.48227805\",\n \"0.4819547\",\n \"0.4782699\",\n \"0.47695082\",\n \"0.4746857\",\n \"0.4743185\",\n \"0.47308764\",\n \"0.4726845\",\n \"0.46611047\",\n \"0.46597615\",\n \"0.463954\",\n \"0.46242067\",\n \"0.46234703\",\n \"0.45942166\",\n \"0.45858887\",\n \"0.4571889\",\n \"0.45699766\",\n \"0.45352846\",\n \"0.45307684\",\n \"0.45059124\",\n \"0.44992357\",\n \"0.4491267\",\n \"0.44876143\",\n \"0.44860741\",\n \"0.4449634\",\n \"0.4436323\",\n \"0.4420826\",\n \"0.4415709\",\n \"0.44151866\",\n \"0.44132257\",\n \"0.44119504\",\n \"0.44111606\",\n \"0.4409967\",\n \"0.4408976\",\n \"0.44019982\",\n \"0.44017988\",\n \"0.44003794\",\n \"0.43899447\",\n \"0.43819338\",\n \"0.43688822\",\n \"0.4354956\",\n \"0.43437353\",\n \"0.43380022\",\n \"0.43350187\",\n \"0.43290702\",\n \"0.4328562\",\n \"0.43279904\",\n \"0.43196777\",\n \"0.43035686\",\n \"0.43007937\",\n \"0.43005908\",\n \"0.42981583\",\n \"0.42862144\",\n \"0.42832178\",\n \"0.42798436\",\n \"0.42769793\",\n \"0.42730308\",\n \"0.42673436\",\n \"0.42671657\",\n \"0.42671657\",\n \"0.42641827\",\n \"0.42627034\",\n \"0.42608324\",\n \"0.42561105\",\n \"0.42515945\",\n \"0.42507425\",\n \"0.42477784\",\n \"0.42443958\",\n \"0.424284\",\n \"0.4238558\",\n \"0.42339242\",\n \"0.42317352\",\n \"0.42286026\",\n \"0.4222909\",\n \"0.42208576\",\n \"0.4217499\",\n \"0.4213684\",\n \"0.42129332\",\n \"0.42101938\",\n \"0.4209228\",\n \"0.42056566\",\n \"0.42052203\",\n \"0.42037198\",\n \"0.41966754\",\n \"0.4193763\",\n \"0.41932732\",\n \"0.41926092\",\n \"0.41910368\",\n \"0.419061\",\n \"0.41901353\",\n \"0.4189429\",\n \"0.41860756\",\n \"0.4182849\",\n \"0.41811472\",\n \"0.41706634\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.61593163"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":8788,"cells":{"query":{"kind":"string","value":"dijet label. supports dijet cuts, and cuts on particpating jets"},"document":{"kind":"string","value":"def _make_dijet_label(chain_parts):\n\n assert len(chain_parts) == 1\n scenario = chain_parts[0]['hypoScenario']\n \n assert scenario.startswith('dijet')\n\n arg_res = [\n re.compile(r'^(?P<lo>\\d*)(?P<key>djmass)(?P<hi>\\d*)$'),\n re.compile(r'^(?P<lo>\\d*)(?P<key>j1et)(?P<hi>\\d*)$'),\n re.compile(r'^(?P<lo>\\d*)(?P<key>j1eta)(?P<hi>\\d*)$'),\n re.compile(r'^(?P<lo>\\d*)(?P<key>j2et)(?P<hi>\\d*)$'),\n re.compile(r'^(?P<lo>\\d*)(?P<key>j2eta)(?P<hi>\\d*)$'),\n ]\n\n defaults = {\n 'j1et': ('100', 'inf'),\n 'j2et': ('100', 'inf'),\n 'j1eta': ('0', '320'),\n 'j2eta': ('0', '320'),\n 'djmass': ('1000', 'inf'),\n }\n\n\n args = _args_from_scenario(scenario)\n argvals = {}\n while args:\n assert len(args) == len(arg_res)\n arg = args.pop()\n for r in arg_res:\n m = r.match(arg)\n if m is not None:\n arg_res.remove(r)\n gd = m.groupdict()\n key = gd['key']\n\n try:\n lo = float(gd['lo'])\n except ValueError:\n lo = defaults[key][0]\n argvals[key+'lo'] = lo \n try:\n hi = float(gd['hi'])\n except ValueError:\n hi = defaults[key][1]\n argvals[key+'hi'] = hi\n\n assert len(args) == len(arg_res)\n assert len(args) == 0\n\n return \"\"\"\n combgen(\n [(2)(%(j1etlo).0fet, %(j1etalo).0feta%(j1etahi).0f)\n (%(j1etlo).0fet, %(j1etalo).0feta%(j1etahi).0f)\n ]\n \n dijet(\n [(%(djmasslo).0fdjmass)])\n simple([(%(j1etlo).0fet, %(j1etalo).0feta%(j1etahi).0f)\n (%(j2etlo).0fet, %(j2etalo).0feta%(j2etahi).0f)])\n )\"\"\" % argvals"},"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 extract_info(config, cut, label):\n cfg = filter(lambda c: c['name'] == cut, config['physics']['cuts'])[0]\n text = \"\"\n if 'max' not in cfg:\n text += \"#geq \"\n text += str(cfg['min'])\n if 'max' in cfg and cfg['max'] != cfg['min']:\n text += '-' + str(cfg['max']) + ' ' + label + 's'\n elif cfg['min'] != 1:\n text += ' ' + label + 's'\n else:\n text += ' ' + label\n return text","def makeDPartial( name\n , config\n , DecayDescriptor\n , inputSel\n ) :\n\n _Kcuts1 = \"~ISMUON & (PT > %(DaugPtLoose)s* MeV) & (MIPCHI2DV(PRIMARY) > %(DaugIPChi2Loose)s)\" % locals()['config']\n _KcutsPIDK = \" & (PIDK > %(HighPIDK)s)\" % locals()['config']\n _Kcuts2 = \" & (ISLONG) & (P > %(DaugPLoose)s* MeV) & (TRCHI2DOF < %(DaugTrkChi2Loose)s)\" % locals()['config']\n _Kcuts = _Kcuts1 + _KcutsPIDK + _Kcuts2\n _Picuts1 = \"~ISMUON & (PT > %(DaugPtMin)s* MeV) & (MIPCHI2DV(PRIMARY) > %(DaugIPChi2)s)\" % locals()['config']\n _PicutsPIDK = \" & (PIDK < %(LowPIDK)s)\" % locals()['config']\n _Picuts2 = \" & (ISLONG) & (P > %(DaugP)s* MeV) & (TRCHI2DOF < %(DaugTrkChi2)s)\" % locals()['config']\n _Picuts = _Picuts1 + _PicutsPIDK + _Picuts2\n _dauCuts = { 'K+': _Kcuts, 'pi+': _Picuts }\n #_Kcuts1 = \"~ISMUON & (PT > 500* MeV) & (MIPCHI2DV(PRIMARY) > 4)\"\n #_KcutsPIDK = \" & (PIDK > 5)\"\n #_Kcuts2 = \" & (ISLONG) & (P > 5000* MeV) & (TRCHI2DOF < 5)\"\n #_Kcuts = _Kcuts1 + _KcutsPIDK + _Kcuts2\n #_Picuts1 = \"~ISMUON & (PT > 500* MeV) & (MIPCHI2DV(PRIMARY) > 4)\"\n #_PicutsPIDK = \" & (PIDK < 0)\"\n #_Picuts2 = \" & (ISLONG) & (P > 5000* MeV) & (TRCHI2DOF < 5)\"\n #_Picuts = _Picuts1 + _PicutsPIDK + _Picuts2\n #_dauCuts = { 'K+': _Kcuts, 'pi+': _Picuts }\n\n _combCuts = \"(APT > %(D0PtLoose)s* MeV)\" \\\n \"& (AP > %(D0P)s* MeV)\" % locals()['config']\n\n _motherCuts = \"(VFASPF(VCHI2PDOF) < %(D0VtxChi2Ndof)s)\" \\\n \"& (BPVVDCHI2 > %(D0FDChi2)s)\" % locals()['config']\n\n\n _Dminus = CombineParticles( DecayDescriptor = DecayDescriptor\n , DaughtersCuts = _dauCuts\n , CombinationCut = _combCuts\n , MotherCut = _motherCuts\n )\n\n return Selection( name+'Sel',\n Algorithm = _Dminus,\n RequiredSelections = inputSel\n )","def x_group_label(\n x_gr: int, cut: int = 20, name_dict: Dict[AnyStr, AnyStr] = names_dict\n) -> AnyStr:\n name = name_dict[str(x_gr)]\n if len(name) > cut:\n return f\"{name[:cut-3]}...\"\n else:\n return name","def assignLabels(self):\n clusters = np.arange(0, len(self.V))[self.V < self.V1] #indexes self.V, volumes_sorted, and oldOrder\n self.clusterV = self.volumes_sorted[clusters]\n clusters = self.oldOrder[clusters] #indexes volumes\n self.clusters = self.nonBI[clusters] #indexes self.vor and self.data\n self.easyLabel = np.zeros(len(self.data))\n self.easyLabel[self.clusters] = 1\n print('Out of ' + str(len(self.data)) + ' particles, ' + str(len(self.clusters)) + ' (' + str(round(len(self.clusters)*100/len(self.data), 3)) +' %) are labelled as cluster particles.')","def __init__(self, data_cfg, pipeline_cfg, root_path, sel_index=0):\n\n super(DetRetailOneDataset, self).__init__(\n data_cfg, pipeline_cfg, root_path, sel_index\n )\n\n self.cat2label = {cat: i for i, cat in enumerate(self.class_names)}\n self.ORI_CLASSES = (\n \"asamu\",\n \"baishikele\",\n \"baokuangli\",\n \"aoliao\",\n \"bingqilinniunai\",\n \"chapai\",\n \"fenda\",\n \"guolicheng\",\n \"haoliyou\",\n \"heweidao\",\n \"hongniu\",\n \"hongniu2\",\n \"hongshaoniurou\",\n \"kafei\",\n \"kaomo_gali\",\n \"kaomo_jiaoyan\",\n \"kaomo_shaokao\",\n \"kaomo_xiangcon\",\n \"kele\",\n \"laotansuancai\",\n \"liaomian\",\n \"lingdukele\",\n \"maidong\",\n \"mangguoxiaolao\",\n \"moliqingcha\",\n \"niunai\",\n \"qinningshui\",\n \"quchenshixiangcao\",\n \"rousongbing\",\n \"suanlafen\",\n \"tangdaren\",\n \"wangzainiunai\",\n \"weic\",\n \"weitanai\",\n \"weitaningmeng\",\n \"wulongcha\",\n \"xuebi\",\n \"xuebi2\",\n \"yingyangkuaixian\",\n \"yuanqishui\",\n \"xuebi-b\",\n \"kebike\",\n \"tangdaren3\",\n \"chacui\",\n \"heweidao2\",\n \"youyanggudong\",\n \"baishikele-2\",\n \"heweidao3\",\n \"yibao\",\n \"kele-b\",\n \"AD\",\n \"jianjiao\",\n \"yezhi\",\n \"libaojian\",\n \"nongfushanquan\",\n \"weitanaiditang\",\n \"ufo\",\n \"zihaiguo\",\n \"nfc\",\n \"yitengyuan\",\n \"xianglaniurou\",\n \"gudasao\",\n \"buding\",\n \"ufo2\",\n \"damaicha\",\n \"chapai2\",\n \"tangdaren2\",\n \"suanlaniurou\",\n \"bingtangxueli\",\n \"weitaningmeng-bottle\",\n \"liziyuan\",\n \"yousuanru\",\n \"rancha-1\",\n \"rancha-2\",\n \"wanglaoji\",\n \"weitanai2\",\n \"qingdaowangzi-1\",\n \"qingdaowangzi-2\",\n \"binghongcha\",\n \"aerbeisi\",\n \"lujikafei\",\n \"kele-b-2\",\n \"anmuxi\",\n \"xianguolao\",\n \"haitai\",\n \"youlemei\",\n \"weiweidounai\",\n \"jindian\",\n \"3jia2\",\n \"meiniye\",\n \"rusuanjunqishui\",\n \"taipingshuda\",\n \"yida\",\n \"haochidian\",\n \"wuhounaicha\",\n \"baicha\",\n \"lingdukele-b\",\n \"jianlibao\",\n \"lujiaoxiang\",\n \"3+2-2\",\n \"luxiangniurou\",\n \"dongpeng\",\n \"dongpeng-b\",\n \"xianxiayuban\",\n \"niudufen\",\n \"zaocanmofang\",\n \"wanglaoji-c\",\n \"mengniu\",\n \"mengniuzaocan\",\n \"guolicheng2\",\n \"daofandian1\",\n \"daofandian2\",\n \"daofandian3\",\n \"daofandian4\",\n \"yingyingquqi\",\n \"lefuqiu\",\n )","def _make_vbenf_label(chain_parts):\n\n # toy label for development: run simple and dijet independently.\n # simple makes Et cuts on two jets. Independently (sharing possible)\n # of jets choosean by simple, the dijet\n # scenario requires a dijet of mass > 900, and opening angle in phi > 2.6\n\n assert len(chain_parts) == 1\n scenario = chain_parts[0]['hypoScenario']\n assert scenario.startswith('vbenf')\n args = _args_from_scenario(scenario)\n if not args:\n return 'and([]simple([(50et)(70et)])combgen([(2)] dijet([(900djmass, 26djdphi)])))' \n arg_res = [\n re.compile(r'(?P<lo>\\d*)(?P<key>fbet)(?P<hi>\\d*)'),\n re.compile(r'(?P<lo>\\d*)(?P<key>mass)(?P<hi>\\d*)'),\n re.compile(r'(?P<lo>\\d*)(?P<key>et)(?P<hi>\\d*)'),\n ]\n\n defaults = {\n 'et': ('101', 'inf'),\n 'mass': ('800', 'inf'),\n 'fbet': ('501', 'inf'),\n }\n\n argvals = {}\n while args:\n assert len(args) == len(arg_res)\n arg = args.pop()\n for r in arg_res:\n m = r.match(arg)\n if m is not None:\n arg_res.remove(r)\n gd = m.groupdict()\n key = gd['key']\n try:\n lo = float(gd['lo'])\n except ValueError:\n lo = defaults[key][0]\n argvals[key+'lo'] = lo \n try:\n hi = float(gd['hi'])\n except ValueError:\n hi = defaults[key][1]\n argvals[key+'hi'] = hi\n\n assert len(args) == len(arg_res)\n assert len(args) == 0\n\n return \"\"\"\n and\n (\n []\n simple\n (\n [(%(etlo).0fet, 500neta)(%(etlo).0fet, peta500)]\n )\n combgen\n (\n [(10et, 0eta320)]\n dijet\n (\n [(%(masslo).0fdjmass, 26djdphi)]\n ) \n simple\n (\n [(10et, 0eta320)(20et, 0eta320)]\n )\n )\n )\"\"\" % argvals","def create_labelled_dataset(self):\n\n print(\"-------------------------------------------------------------------\")\n print(\" How to Use the Pole Hull Label Tool\")\n print(\"-------------------------------------------------------------------\")\n print(\"- If a hull is NOT associated to a pole: press the 1 button\")\n print(\"- If a hull IS associated to a pole: press the 2 button\")\n print(\"\\n- If any other key is pressed, the program EXITS\")\n print(\"-------------------------------------------------------------------\")\n\n detector = gate_detector.GateDetector(im_resize=3.0/4)\n\n imgs = []\n labels = []\n directory = os.path.dirname(os.getcwd())\n \n # Get absolute path of all images in the images folder\n for dirpath,_,filenames in os.walk(os.path.join(directory, 'images', 'gate')):\n for f in filenames:\n imgs.append(os.path.abspath(os.path.join(dirpath, f)))\n\n # Get the hulls from the segmented image and run the display and label program for each image\n for img in imgs:\n src = cv.imread(img, 1)\n pre = detector.preprocess(src)\n seg = detector.segment(pre)\n mor = detector.morphological(seg)\n hulls = detector.create_convex_hulls(seg)\n labels += self.display_and_label_hulls(hulls, pre)\n return labels","def setContourLabels(mode='none', ndigits=1):\n odict = {'none':'NONE', 'float':'FLOAT', 'string':'CONLAB'}\n dislin.labdig(ndigits, 'CONTUR')\n dislin.labels(odict[mode], 'CONTUR')","def _add_labels(self):\n coords = self['pore.coords']\n self['pore.front'] = coords[:,0]<(0.1*self._Lx)\n self['pore.back'] = coords[:,0]>(0.9*self._Lx)\n self['pore.left'] = coords[:,1]<(0.1*self._Ly)\n self['pore.right'] = coords[:,1]>(0.9*self._Ly)\n self['pore.bottom'] = coords[:,2]<(0.1*self._Lz)\n self['pore.top'] = coords[:,2]>(0.9*self._Lz)\n bnds = self.pores(labels=['front','back','left','right','bottom','top'])\n self['pore.boundary'] = False\n self['pore.boundary'] = bnds","def plot_data_assemble(self,kwargs_seg, add_mask ,img_name='data.pdf',cutout_text='lensed image',font_size=28):\n mask = self.data_mask\n image = self.raw_image\n picked_data = self.data\n selem = np.ones((add_mask, add_mask))\n img_mask = ndimage.binary_dilation(mask.astype(np.bool), selem)\n fig, (ax1, ax2, ax3,ax4) = plt.subplots(1, 4, figsize=(19, 10))\n ax1.imshow(image, origin='lower', cmap=\"gist_heat\")\n ax1.set_title('Cutout Image',fontsize =font_size)\n ax1.text(image.shape[0] * 0.2, image.shape[0] * 0.05, cutout_text,size=20, color='white',weight=\"bold\")\n ax1.axis('off')\n segments_deblend_list, xcenter, ycenter, c_index=kwargs_seg\n ax2.imshow(segments_deblend_list, origin='lower')\n for i in range(len(xcenter)):\n ax2.text(xcenter[i] * 1.1, ycenter[i], 'Seg' + repr(i), size=20,color='w',weight=\"bold\")\n ax2.text(image.shape[0] * 0.2, image.shape[0] * 0.9, 'Seg' + repr(c_index) + ' ' + 'in center',\n size=20, color='white',weight=\"bold\")\n ax2.set_title('Segmentations',fontsize =font_size)\n ax2.axis('off')\n ax3.imshow(img_mask+mask, origin='lower',cmap=\"gist_heat\")\n ax3.set_title('Selected pixels',fontsize =font_size)\n ax3.text(image.shape[0] * 0.1, image.shape[0] * 0.05, 'pixels (S/N >' + repr(self.snr) + ')',size=20, color='white',weight=\"bold\")\n ax3.text(image.shape[0] * 0.1, image.shape[0] * 0.9, 'additional pixels', size=20, color='r',weight=\"bold\")\n ax3.axis('off')\n ax4.imshow(picked_data, origin='lower',cmap=\"gist_heat\")\n ax4.set_title('Processed Image',fontsize =font_size)\n ax4.axis('off')\n plt.show()\n fig.savefig(img_name)\n return 0","def BaseLabel(self, *args):\n return _XCAFDoc.XCAFDoc_DimTolTool_BaseLabel(self, *args)","def main():\n # Directory where the DICOM files are being stored (in this\n input_path = './Inputs/valve'\n\n # Original image from the filepath\n img_original = read_image(input_path)\n\n # Image with smoothing applied to reduce noise\n img_smooth = sitk.CurvatureFlow(image1=img_original, timeStep=0.125, numberOfIterations=10)\n\n # Create labels on our smoothed image for cardiac tissue and tissue with blood\n labels_tissue = sitk.BinaryThreshold(image1=img_smooth, lowerThreshold=325, upperThreshold=470, insideValue=1)\n labels_blood = sitk.BinaryThreshold(image1=img_smooth, lowerThreshold=450, upperThreshold=800, insideValue=1, outsideValue=0)\n\n # IMPORTANT STEP: essentially, this is the key to our algorithm. By finding the \"blood\" without cardiac tissue,\n # and then using binary hole filling with a fairly large radius, we are able to label a lot of the mitral valve\n # area without labeling too much of the other cardiac tissue. Thus, THIS is what lets us single out the mitral\n # valve tissue from the rest - all we need is the overlap of the two labels\n labels_tissue_no_holes = sitk.VotingBinaryHoleFilling(image1=labels_tissue, radius=[2] * 3, majorityThreshold=1, backgroundValue=0, foregroundValue=1)\n labels_blood_no_holes = sitk.VotingBinaryHoleFilling(image1=labels_blood, radius=[4] * 3, majorityThreshold=1, backgroundValue=0, foregroundValue=1)\n labels_valve = retrieve_overlap(labels_blood_no_holes, labels_tissue_no_holes)\n labels_valve_no_holes = sitk.VotingBinaryHoleFilling(image1=labels_valve, radius=[2] * 3, majorityThreshold=1, backgroundValue=0, foregroundValue=1)\n labels_valve_no_holes = sitk.VotingBinaryHoleFilling(image1=labels_valve_no_holes, radius=[1] * 3, majorityThreshold=0, backgroundValue=1, foregroundValue=0)\n\n # Fix intensity scaling on our original smoothed image for pretty diagram purposes\n img_smooth = sitk.Cast(sitk.RescaleIntensity(img_smooth), labels_tissue_no_holes.GetPixelID())\n\n # Use a density-based clustering algorithm to attempt to remove as much noise as possible\n labels_valve_filtered = dbscan_filter(labels_valve_no_holes, eps=2, use_z=False)\n labels_valve_filtered = dbscan_filter(labels_valve_filtered, eps=4)\n\n # Find likely start and end points of our image by setting a mininum number of labeled pixels\n start, end = filter_by_label_count(labels_valve_filtered, 10)\n img_smooth = img_smooth[:, :, start:end]\n labels_valve_filtered = labels_valve_filtered[:, :, start:end]\n\n # Remove all values distant from the center of our starting location by taking advantage of kmeans\n df = get_df_from_img(labels_valve_filtered[:, :, 0], dimensions=2)\n x_mid = df['x'].mean()\n y_mid = df['y'].mean()\n df = get_df_from_img(labels_valve_filtered)\n distance_df = df.drop('z', axis=1)\n distance_df['x_dist'] = abs(distance_df['x'] - x_mid)\n distance_df['y_dist'] = abs(distance_df['y'] - y_mid)\n fit = cluster.KMeans(n_clusters=2).fit(distance_df.drop(['x', 'y'], axis=1))\n labels = fit.labels_\n df['label'] = pd.Series(labels)\n counts = df['label'].value_counts().to_dict()\n largest_cluster = max(counts.iterkeys(), key=(lambda key: counts[key]))\n update_img_from_df(df, labels_valve_filtered, keep=largest_cluster)\n\n # Find likely start and end points of our image by setting a mininum number of labeled pixels\n start, end = filter_by_label_count(labels_valve_filtered, 10)\n img_smooth = img_smooth[:, :, start:end]\n labels_valve_filtered = labels_valve_filtered[:, :, start:end]\n\n # Use a segmentation-based clustering algorithm to attempt to find each valve\n label_segments, x_max = kmeans_segment(labels_valve_filtered, use_z=False)\n\n left, right = (label_segments[0], label_segments[1])\n if x_max[0] > x_max[1]:\n left, right = right, left\n\n # Finally, we can simply take the furthest point from the likely start/end points in order to get our annulus\n # this can be done by every z value\n left_points = {'x': [], 'y': [], 'z': []}\n right_points = {'x': [], 'y': [], 'z': []}\n zlen = len(sitk.GetArrayFromImage(left))\n for z in xrange(zlen):\n left_df = get_df_from_img(left[:, :, z], dimensions=2)\n if len(left_df['y']) > 0:\n index = left_df['y'].idxmin()\n row = left_df.iloc[index]\n left_points['x'].append(int(row['x']))\n left_points['y'].append(int(row['y']))\n left_points['z'].append(z)\n\n right_df = get_df_from_img(right[:, :, z], dimensions=2)\n if len(right_df['x']) > 0:\n index = right_df['x'].idxmax()\n row = right_df.iloc[index]\n right_points['x'].append(int(row['x']))\n right_points['y'].append(int(row['y']))\n right_points['z'].append(z)\n\n # These both represent the coordinates of our annulus ring. A simple spline can be used for interpolation between\n # points\n final_left = pd.DataFrame.from_dict(left_points)\n final_right = pd.DataFrame.from_dict(right_points)\n print('Coordinates for one side of the ring')\n print(final_left)\n print('\\n\\nCoordinates for the other side of the ring')\n print(final_right)\n\n final_image = make_empty_img_from_img(left)\n x = left_points['x'] + right_points['x']\n y = left_points['y'] + right_points['y']\n z = left_points['z'] + right_points['z']\n for x, y, z in zip(x, y, z):\n final_image.SetPixel(x, y, z, 1)\n\n show_all(img_smooth, final_image)","def label(self, cfg):\n rep = \"\"\n nl = \"\"\n for node in cfg.nodes:\n rep += nl + \"{}\\tgen={}\\tkill={}\\tout={}\".format(\n node, \n set(self.gen.get(node)),\n set(self.kill.get(node)),\n set(self.out.get(node)))\n nl = \"\\n\"\n return rep","def test_get_dim_label_with_label(self):\n\n dim = self.oecd_datasets['oecd']['dimension']['id'][0]\n dims_df = pyjstat.get_dim_label(self.oecd_datasets['oecd'], dim)\n self.assertTrue(dims_df.iloc[0]['id'] == 'UNR')\n self.assertTrue(dims_df.iloc[-1]['label'] == 'Unemployment rate')","def LabelDisks(self):\n pass","def visualize_detection(self, img, dets, seg, classes=[], thresh=0.6):\n from dataset.cs_labels import labels\n lut = np.zeros((256,3))\n for l in labels:\n if l.trainId<255 and l.trainId>=0:\n lut[l.trainId,:]=list(l.color)\n palette = lut\n # det2seg = {0:6,1:7,2:11,3:12,4:13,5:14,6:15,7:16,8:17,9:18,}\n det2seg = {0:11,1:12,2:13,3:14,4:15,5:16,6:17,7:18,}\n \n import cv2\n import random\n tic = time.time()\n color_white = (255, 255, 255)\n im = cv2.cvtColor(img, cv2.COLOR_RGB2BGR) # change to bgr\n yscale, xscale, ch = im.shape\n color = (0,0,128)\n fontFace = cv2.FONT_HERSHEY_PLAIN\n fontScale = .8*(yscale/float(320))\n thickness = 2 if yscale>320 else 1\n idx = np.argsort(dets[:,6],axis=0)[::-1] ## draw nearest first !!\n dets = dets[idx,:]\n for det in dets:\n cls_id = int(det[0])\n bbox = [det[2]*xscale,det[3]*yscale,det[4]*xscale,det[5]*yscale]\n score = det[1]\n distance = det[-1]\n if score > thresh:\n bbox = map(int, bbox)\n color = palette[det2seg[int(det[0])],(2,1,0)]\n cv2.rectangle(im, (bbox[0], bbox[1]), (bbox[2], bbox[3]), color=color, thickness=thickness)\n text = '%s %.0fm' % (short_class_name[classes[cls_id]], distance*255., )\n textSize, baseLine = cv2.getTextSize(text, fontFace, fontScale, thickness=1)\n cv2.rectangle(im, (bbox[0], bbox[1]-textSize[1]), (bbox[0]+textSize[0], bbox[1]), color=(128,0,0), thickness=-1)\n cv2.putText(im, text, (bbox[0], bbox[1]),\n color=color_white, fontFace=fontFace, fontScale=fontScale, thickness=1)\n disp = im.copy()\n if False: #disp.shape[1]>1000:\n hh, ww, ch = disp.shape\n resized = cv2.resize(disp, (int(round(ww*.92)),int(round(hh*.92))))\n else:\n resized = disp\n cv2.imshow(\"result\", resized)\n # cv2.imwrite(\"data/cityscapes/Results/stuttgart_%06d.png\" % (self.imgidx,), resized)\n # self.imgidx += 1","def kohonen():\n# plb.close('all')\n \n dim = 28*28\n data_range = 255.0\n \n # load in data and labels \n data = np.array(np.loadtxt('data.txt'))\n labels = np.loadtxt('labels.txt')\n\n # select 4 digits \n name = \"Stettler\"\n targetdigits = name2digits(name) # assign the four digits that should be used\n print(targetdigits) # output the digits that were selected\n\n # this selects all data vectors that corresponds to one of the four digits\n data = data[np.logical_or.reduce([labels==x for x in targetdigits]),:]\n \n dy, dx = data.shape\n \n #set the size of the Kohonen map. In this case it will be 6 X 6\n size_k = 6\n \n #set the width of the neighborhood via the width of the gaussian that\n #describes it\n sigma = 2.0\n \n #initialise the centers randomly\n centers = np.random.rand(size_k**2, dim) * data_range\n \n #build a neighborhood matrix\n neighbor = np.arange(size_k**2).reshape((size_k, size_k))\n\n #set the learning rate\n eta = 0.9 # HERE YOU HAVE TO SET YOUR OWN LEARNING RATE\n \n #set the maximal iteration count\n tmax = 5000 # this might or might not work; use your own convergence criterion\n \n #set the random order in which the datapoints should be presented\n i_random = np.arange(tmax) % dy\n np.random.shuffle(i_random)\n \n for t, i in enumerate(i_random):\n som_step(centers, data[i,:],neighbor,eta,sigma)\n\n # for visualization, you can use this:\n for i in range(size_k**2):\n plb.subplot(size_k,size_k,i)\n \n plb.imshow(np.reshape(centers[i,:], [28, 28]),interpolation='bilinear')\n plb.axis('off')\n \n # leave the window open at the end of the loop\n plb.show()\n plb.draw()","def convert_kicad_coor(edif_pt):\n scale = 10\n return [edif_pt[0] * scale, +edif_pt[1] * scale]","def create_dimension_labels(gll, parameters: list):\n dimstr = '[ ' + ' | '.join(parameters) + ' ]'\n gll['MODEL/data'].dims[0].label = 'element'\n gll['MODEL/data'].dims[1].label = dimstr\n gll['MODEL/data'].dims[2].label = 'point'","def add_hdv(self, ROI_id, type_hdv='cum', checkbox_mode=False):\n\n appartenance_contourage = self.dicom_navigation.slice.get_appartenance_contourage(ROI_id)\n \n contourage = Contourage_from_matrice(appartenance_contourage, ROI_id) # On crée un objet 'Contourage_from_matrice' à partir du de la matrice booléenne\n\n dose_matrix = self.dicom_navigation.slice.get_dose_matrix()\n\n # Cas ou on ajoute pour la premiere fois un contourage\n if dose_matrix is None:\n return\n \n doses = Doses_from_matrice(dose_matrix) # On crée un objet 'Doses_from_matrice' à partir de la matrice de doses mise à jour\n\n var = tk.StringVar() # À VENIR... VARIABLE D'ÉTAT QUI INDIQUE SI ON EST EN MODE 'VOLUME RELATF' OU 'VOLUME ABSOLU'. CODÉ EN DUR POUR LE MOMENT\n var.set('r')\n\n self.ddc = Doses_dans_contourage(doses, contourage) # Triage des doses qui sont dans le contourage.\n\n if self.ddc.dose_max == 0: # Si la dose max est 0, on sait qu'on est à l'extérieur de la zone réduite. *** \n return\n\n if not ROI_id in self.dict_graph: \n self.dict_graph[ROI_id] = {} \n self.dict_plot[ROI_id] = {} \n self.dict_doses_max[ROI_id] = {} \n if self.dicom_navigation.var_etat_abs_rel.get() == 'a':\n self.dict_volumes_max[ROI_id] = {} \n\n self.dict_doses_max[ROI_id][type_hdv] = self.ddc.dose_max\n\n ###\n\n if self.dicom_navigation.var_etat_abs_rel.get() == 'r': # si on est en mode 'volume relatif', le range des axes sera définit différemment\n facteur = 100.0/self.ddc.nb_voxels # comme l'instance 'axe_volume' créée par les classes hdv_cumulatif et hdv_differentiel contient des données en NOMBRE DE VOXELS\n # (et non en pourcentage ou en volume réel), il faut multiplier ces données par le facteur de conversion approprié (il dépend\n # de si l'on est en mode 'relatf' ou 'absolu').\n\n if self.dicom_navigation.var_etat_abs_rel.get() == 'a': # si on est en mode 'volume absolu'.\n facteur = self.ddc.v_voxel\n self.dict_volumes_max[ROI_id][type_hdv] = self.ddc.v_voxel * self.ddc.nb_voxels \n self.y_lim = get_max_2D_dic(self.dict_volumes_max)\n\n ###\n\n if type_hdv == 'cum':\n hdv = HDV_cumulatif(self.ddc, 100)\n\n if type_hdv == 'diff':\n hdv = HDV_differentiel(self.ddc, 50)\n\n\n self.dict_graph[ROI_id][type_hdv] = hdv\n self.dict_plot[ROI_id][type_hdv], = self.fig.plot(hdv.axe_doses, facteur * hdv.axe_volume)\n\n ###\n\n self.x_lim = get_max_2D_dic(self.dict_doses_max) \n\n self.fig.set_xlim([0, 1.02*self.x_lim]) # dimension de l'axe des x\n self.fig.set_ylim([0, 1.02*self.y_lim]) # dimension de l'axe des y\n\n # Contraintes\n if self.got_contraintes and type_hdv == 'cum': # 'got_contraintes' SERA INITALISÉE À 'TRUE' LORSQUE L'ON AURA RÉCUPÉRÉ LE FICHIER DE CONTRAINTES\n self.dicom_navigation.get_dicom_contraintes().verifier_contraintes_sur_une_ROI(ROI_id)\n\n # Modifier\n if checkbox_mode:\n self.refresh_HDV()","def instance_label(task, pred, k=15, n_iters=1, dist_thresh=5, watershed=False):\n mask = pred\n\n # noise removal\n if k > 1 and n_iters > 0:\n kernel = np.ones((k, k), np.uint8)\n mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel,\n iterations=n_iters)\n\n if watershed:\n from clab.live import filters\n mask = filters.watershed_filter(mask, dist_thresh=dist_thresh)\n\n mask = mask.astype(np.uint8)\n n_ccs, cc_labels = cv2.connectedComponents(mask, connectivity=4)\n return cc_labels","def old_ideal_label(I):\n a, c, d = ideal_HNF(I)\n return \"%s.%s.%s\" % (a * d, c, d)","def setContourLabelString(text=''):\n dislin.conlab(text)","def label(cmd):\r\n cmd = cmd.replace('make][.DP', 'make1][.NP')\r\n cmd = cmd.replace('make][.SC', 'make2][.SC')\r\n cmd = re.sub('(draw.*)one','\\\\1one1',cmd)\r\n cmd = re.sub('(make1.*)one','\\\\1one1',cmd)\r\n cmd = re.sub('(make2.*)one','\\\\1one2',cmd)\r\n cmd = re.sub('(move.*)one','\\\\1one2',cmd)\r\n cmd = re.sub('(hide.*)one','\\\\1one2',cmd)\r\n cmd = '[result ' + cmd + ']' #dummy function for plop\r\n return cmd","def label(gt_dataset, volume_dim, voxel_dim, labeling_params):\n labeled_volumes = dict()\n labeled_cells = dict()\n #Use global density and reduce the size of gt_dataset here\n global_density = labeling_params[\"global_density\"]\n gt_dataset = {k: v for k,v in gt_dataset.items() if random_sample() < global_density}\n #Label in the order specified in the configuration\n layers = sorted(labeling_params.keys())\n #Remove global_density\n layers.remove(\"global_density\")\n for layer in layers:\n print \"Labeling {}\".format(layer)\n fluorophore = labeling_params[layer]['fluorophore']\n volume, cells = brainbow(gt_dataset, volume_dim, voxel_dim, **labeling_params[layer])\n if fluorophore in labeled_volumes:\n labeled_volumes[fluorophore] += volume\n labeled_cells[fluorophore] |= cells\n else:\n labeled_volumes[fluorophore] = volume\n labeled_cells[fluorophore] = cells\n return labeled_volumes, labeled_cells","def make_data_label(self):\n data_label = \"\"\n if self.detector is not None:\n data_label += \"%s \"%self.detector\n if self.selection is not None:\n data_label += \"%s Event Selection\"%self.selection\n if data_label == \"\":\n data_label = \"IceCube\"\n return data_label","def write_label(self, contig_name, width, height, font, title_width, upper_left, vertical_label,\n strand, canvas, horizontal_centering=False, center_vertical=False, chop_text=True,\n label_color=(50, 50, 50, 255)):\n upper_left = list(upper_left) # to make it mutable\n shortened = contig_name[-title_width:] # max length 18. Last characters are most unique\n txt = Image.new('RGBA', (width, height))#, color=(0,0,0,50))\n txt_canvas = ImageDraw.Draw(txt)\n text_width = txt_canvas.textsize(shortened, font)[0]\n if not chop_text and text_width > width:\n txt = Image.new('RGBA', (text_width, height)) # TODO performance around txt_canvas\n txt_canvas = ImageDraw.Draw(txt)\n if center_vertical or vertical_label: # Large labels are centered in the column to look nice,\n # rotation indicates strand in big text\n vertically_centered = (height // 2) - multi_line_height(font, shortened, txt)//2\n else: # Place label at the beginning of gene based on strand\n vertically_centered = height - multi_line_height(font, shortened, txt) # bottom\n if strand == \"+\":\n vertically_centered = 0 # top of the box\n txt_canvas.multiline_text((0, max(0, vertically_centered)), shortened, font=font,\n fill=label_color)\n if vertical_label:\n rotation_direction = 90 if strand == '-' else -90\n txt = txt.rotate(rotation_direction, expand=True)\n upper_left[1] += -4 if strand == '-' else 4\n if horizontal_centering:\n margin = width - text_width\n upper_left[0] += margin // 2\n canvas.paste(txt, (upper_left[0], upper_left[1]), txt)","def convert_medical_decathlon_labels(mask, cohort, keep_all_label=False):\n label = 12*[0]\n if keep_all_label:\n label += [0,0]\n \n if cohort == 'liver':\n mask[mask == 2] = 6\n mask[mask == 1] = 6\n label[6] = 1\n \n elif cohort == 'pancreas':\n mask[mask == 2] = 11\n mask[mask == 1] = 11\n label[11] = 1\n\n elif cohort == 'spleen':\n mask[mask != 1] = 0\n label[1] = 1 \n\n elif cohort == 'hepatic':\n mask[mask == 2] = 0\n mask[mask == 1] = 0\n \n return mask, label","def get_labels(self):\n if self.option == \"term\":\n return ['platform characteristics', 'atmospheric winds', 'radio wave','weather events', 'geomagnetism', 'atmospheric electricity','microwave', 'atmospheric temperature', 'atmospheric water vapor','atmospheric pressure', 'aerosols', 'atmospheric radiation','atmospheric chemistry', 'precipitation', 'sensor characteristics','radar', 'infrared wavelengths', 'visible wavelengths','weather/climate advisories', 'clouds', 'lidar', 'ocean optics','ultraviolet wavelengths', 'cryospheric indicators','land use/land cover', 'topography', 'surface thermal properties','spectral/engineering', 'soils', 'snow/ice', 'geothermal dynamics','natural hazards', 'surface water', 'vegetation','land surface/agriculture indicators','gravity/gravitational field', 'marine advisories', 'altitude','water quality/water chemistry', 'ocean temperature','ocean winds', 'atmospheric/ocean indicators', 'coastal processes','erosion/sedimentation', 'marine sediments', 'ocean chemistry','salinity/density', 'ocean color', 'aquatic ecosystems','vegetation2', 'landscape', 'cloud properties','surface radiative properties', 'geodetics','agricultural plant science', 'forest science','ecological dynamics', 'environmental impacts', 'sustainability','boundaries', 'ecosystems', 'air quality', 'population','infrastructure', 'environmental governance/management','public health', 'economic resources', 'socioeconomics','environmental vulnerability index (evi)', 'human settlements','agricultural chemicals', 'animal science','habitat conversion/fragmentation', 'animals/vertebrates','earth gases/liquids', 'rocks/minerals/crystals','social behavior', 'ground water', 'frozen ground','terrestrial hydrosphere indicators', 'ocean heat budget','biospheric indicators', 'animal commodities', 'fungi', 'plants','carbon flux', 'geomorphic landforms/processes','paleoclimate indicators', 'ocean circulation', 'sea ice','geochemistry', 'visualization/image processing','subsetting/supersetting', 'transformation/conversion','ocean pressure', 'glaciers/ice sheets', 'protists','solar activity', 'sun-earth interactions','sea surface topography', 'solar energetic particle properties','solar energetic particle flux','ionosphere/magnetosphere dynamics']\n elif self.option == \"mostdepth\":\n return ['flight data logs', 'turbulence', 'radio wave flux', 'lightning', 'magnetic field', 'atmospheric conductivity', 'electric field', 'data synchronization time', 'brightness temperature', 'vertical profiles', 'water vapor profiles', 'air temperature', 'upper level winds', 'atmospheric pressure measurements', 'upper air temperature', 'humidity', 'dew point temperature', 'aerosol particle properties', 'emissivity', 'trace gases/trace species', 'liquid precipitation', 'cloud liquid water/ice', 'microwave radiance', 'sensor counts', 'total pressure', 'airspeed/ground speed', 'total temperature', 'static pressure', 'wind speed', 'wind direction', 'radar reflectivity', 'doppler velocity', 'infrared imagery', 'visible imagery', 'water vapor', 'vertical wind velocity/speed', 'aerosol backscatter', 'weather forecast', 'tropical cyclones', 'visible radiance', 'infrared radiance', 'total precipitable water', 'boundary layer temperature', 'atmospheric temperature indices', 'cloud height', 'flight level winds', 'cloud droplet distribution', 'cloud droplet concentration/size', 'cloud condensation nuclei', 'cloud microphysics', 'hydrometeors', 'ozone', 'wind profiles', 'cloud base temperature', 'cloud base height', 'liquid water equivalent', 'solar radiation', 'planetary boundary layer height', 'surface winds', 'precipitation amount', 'precipitation rate', 'surface pressure', 'rain', 'cloud optical depth/thickness', 'aerosol extinction', 'aerosol optical depth/thickness', 'cirrus cloud systems', 'lidar depolarization ratio', 'radar backscatter', 'radar cross-section', 'return power', 'mean radial velocity', 'radiance', 'air quality', 'climate advisories', 'atmospheric emitted radiation', 'optical depth/thickness', 'surface temperature', 'ultraviolet flux', 'spectrum width', 'microwave imagery', 'lidar backscatter', 'relative humidity', 'u/v wind components', 'wind speed/wind direction', 'radar imagery', 'snow depth', 'land use/land cover classification', 'digital elevation/terrain model (dem)', 'snow', 'droplet size', 'droplet concentration/size', 'drizzle', 'precipitation anomalies', 'snow water equivalent', 'solid precipitation', 'total surface precipitation rate', 'particle size distribution', 'skin temperature', 'attitude characteristics', 'land surface temperature', 'hail', 'reflectance', 'soil moisture/water content', 'soil temperature', 'soil bulk density', 'surface roughness', 'present weather', 'snow density', 'ambient temperature', 'aerosol forward scatter', 'floods', 'snow cover', 'sigma naught', 'precipitable water', 'stage height', 'rivers/streams', 'shortwave radiation', 'photosynthetically active radiation', 'longwave radiation', 'net radiation', 'hourly precipitation amount', '24 hour precipitation amount', 'soil moisture', 'satellite orbits/revolution', 'sea surface temperature', 'heat flux', 'latent heat flux', 'cloud fraction', '3 and 6 hour precipitation amount', 'geopotential height', 'particulate matter', 'particle images', 'water vapor indices', 'horizontal wind velocity/speed', 'electrical conductivity', 'dissolved carbon dioxide', 'hurricanes', 'tropical cyclone track', 'convective clouds/systems (observed/analyzed)', 'cloud top height', 'viewing geometry', 'temperature profiles', 'vertical wind shear', 'wind shear', 'carbon monoxide', 'sea level pressure', 'water vapor tendency', 'potential temperature', 'angstrom exponent', 'ultraviolet radiation', 'solar irradiance', 'scattering', 'absorption', 'water vapor mixing ratio profiles', 'sea surface temperature indices', 'extreme eastern tropical pacific sst', 'sedimentation', 'erosion', 'sediment transport', 'sediments', 'tropopause', 'ocean chemistry', 'ocean optics', 'ocean temperature', 'salinity/density', 'pigments', 'ocean color', 'attenuation/transmission', 'inorganic carbon', 'organic carbon', 'photosynthetically available radiation', 'chlorophyll', 'optical depth', 'fluorescence', 'vegetation index', 'gelbstoff', 'phytoplankton', 'vegetation index2', 'cloud precipitable water', 'landscape ecology', 'ultraviolet radiance', 'cloud ceiling', 'aerosol radiance', 'carbonaceous aerosols', 'dust/ash/smoke', 'nitrate particles', 'organic particles', 'sulfate particles', 'radiative flux', 'transmittance', 'atmospheric stability', 'cloud asymmetry', 'cloud frequency', 'cloud top pressure', 'cloud top temperature', 'cloud vertical distribution', 'cloud emissivity', 'cloud radiative forcing', 'cloud reflectance', 'rain storms', 'reflected infrared', 'thermal infrared', 'incoming solar radiation', 'clouds', 'cloud properties', 'cloud types', 'orbital characteristics', 'sensor characteristics', 'maximum/minimum temperature', 'condensation', 'platform characteristics', 'geolocation', 'geodetics', 'coordinate reference system', 'aerosols', 'topographical relief maps', 'terrain elevation', 'normalized difference vegetation index (ndvi)', 'infrared flux', 'visible flux', 'albedo', 'land use/land cover', 'topography', 'lidar', 'lidar waveform', 'plant phenology', 'vegetation cover', 'crop/plant yields', 'land use classes', 'landscape patterns', 'forest harvesting and engineering', 'forest management', 'total surface water', 'agricultural plant science', 'photosynthesis', 'primary production', 'leaf characteristics', 'evapotranspiration', 'fire occurrence', 'surface thermal properties', 'canopy characteristics', 'evergreen vegetation', 'crown', 'deciduous vegetation', 'anisotropy', 'fire ecology', 'biomass burning', 'wildfires', 'topographical relief', 'burned area', 'surface radiative properties', 'environmental sustainability', 'boundaries', 'anthropogenic/human influenced ecosystems', 'emissions', 'sulfur dioxide', 'population', 'infrastructure', 'environmental assessments', 'public health', 'conservation', 'agriculture production', 'administrative divisions', 'economic resources', 'socioeconomics', 'lake/pond', 'rivers/stream', 'political divisions', 'environmental vulnerability index (evi)', 'ecosystems', 'urban areas', 'sustainability', 'treaty agreements/results', 'human settlements', 'population estimates', 'nitrogen dioxide', 'cropland', 'pasture', 'particulates', 'cyclones', 'mortality', 'environmental impacts', 'droughts', 'earthquakes', 'population distribution', 'fertilizers', 'animal manure and waste', 'urbanization/urban sprawl', 'landslides', 'avalanche', 'urban lands', 'mangroves', 'volcanic eruptions', 'pesticides', 'population size', 'population density', 'lakes/reservoirs', 'surface water', 'rural areas', 'infant mortality rates', 'amphibians', 'mammals', 'carbon', 'sulfur oxides', 'methane', 'non-methane hydrocarbons/volatile organic compounds', 'nitrogen oxides', 'natural gas', 'coal', 'coastal elevation', 'biodiversity functions', 'nuclear radiation exposure', 'radiation exposure', 'poverty levels', 'malnutrition', 'wetlands', 'sea level rise', 'vulnerability levels/index', 'ground water', 'snow/ice', 'electricity', 'energy production/use', 'sustainable development', 'deforestation', 'household income', 'discharge/flow', 'hydropattern', 'nitrogen', 'phosphorus', 'carbon dioxide', 'alpine/tundra', 'forests', 'vegetation', 'permafrost', 'nutrients', 'plant characteristics', 'leaf area index (lai)', 'soil gas/air', 'ammonia', 'nitrous oxide', 'ecosystem functions', 'litter characteristics', 'soil chemistry', 'soil respiration', 'active layer', 'soil depth', 'cation exchange capacity', 'organic matter', 'soil porosity', 'soil texture', 'permafrost melt', 'land subsidence', 'freeze/thaw', 'surface water features', 'chlorinated hydrocarbons', 'methyl bromide', 'methyl chloride', 'molecular hydrogen', 'sulfur compounds', 'fire models', 'biomass', 'dominant species', 'vegetation species', 'sulfur', 'tree rings', 'soil classification', 'heat index', 'sea ice concentration', 'ocean heat budget', 'reforestation', 'even-toed ungulates', 'species recruitment', 'population dynamics', 'range changes', 'topographic effects', 'land resources', 'river ice depth/extent', 'snow melt', 'river ice', 'animal commodities', 'animal ecology and behavior', 'phenological changes', 'water depth', 'inundation', 'forest fire science', 'biogeochemical cycles', 'radiative forcing', 'soil heat budget', 'drainage', 'respiration rate', 'river/lake ice breakup', 'river/lake ice freeze', 'reclamation/revegetation/restoration', 'permafrost temperature', 'indigenous/native species', 'fire dynamics', 'lichens', 'plants', 'plant succession', 'carbon flux', 'coastal', 'salt marsh', 'degradation', 'altitude', 'carbon and hydrocarbon compounds', 'halocarbons and halogens', 'forest composition/vegetation structure', 'water vapor indicators', 'barometric altitude', 'atmospheric water vapor', 'terrestrial ecosystems', 'volatile organic compounds', 'boundary layer winds', 'forest fire danger index', 'periglacial processes', 'landscape processes', 'evaporation', 'soil horizons/profile', 'shrubland/scrub', 'soil ph', 'soils', 'soil water holding capacity', 'community structure', 'pingo', 'soil color', 'virtual temperature', 'formaldehyde', 'hydroxyl', 'photolysis rates', 'cloud dynamics', 'nitric oxide', 'molecular oxygen', 'smog', 'peroxyacyl nitrate', 'hydrogen compounds', 'nitrogen compounds', 'oxygen compounds', 'stable isotopes', 'chemical composition', 'actinic flux', 'tropospheric ozone', 'fossil fuel burning', 'industrial emissions', 'denitrification rate', 'sunshine', 'runoff', 'soil structure', 'mosses/hornworts/liverworts', 'peatlands', 'hydraulic conductivity', 'snow/ice temperature', 'vegetation water content', 'discharge', 'chlorophyll concentrations', 'outgoing longwave radiation', 'geomorphic landforms/processes', 'soil compaction', 'soil impedance', 'canopy transmittance', 'water table', 'decomposition', 'water temperature', 'dissolved gases', 'total dissolved solids', 'agricultural expansion', 'forest science', 'pressure tendency', 'visibility', 'biomass dynamics', 'agricultural lands', 'grasslands', 'savannas', 'grazing dynamics/plant herbivory', 'herbivory', 'paleoclimate reconstructions', 'drought indices', 'fire weather index', 'animal yields', 'multivariate enso index', 'dissolved solids', 'ocean currents', 'salinity', 'coastal processes', 'atmospheric pressure', 'afforestation/reforestation', 'fresh water river discharge', 'surface water chemistry', 'drainage basins', 'resource development site', 'dunes', 'flood plain', 'endangered species', 'precipitation indices', 'temperature indices', 'forest yields', 'stratigraphic sequence', 'freeze/frost', 'frost', 'hydrogen cyanide', 'land management', 'nutrient cycling', 'industrialization', 'suspended solids', 'deserts', 'weathering', 'gas flaring', 'atmospheric temperature', 'ice extent', 'fraction of absorbed photosynthetically active radiation (fapar)', 'marshes', 'swamps', 'lake ice', 'atmospheric winds', 'watershed characteristics', 'transportation', 'soil rooting depth', 'isotopes', 'cultural features', 'consumer behavior', 'boundary surveys', 'aquifers', 'land productivity', 'water quality/water chemistry', 'sediment composition', 'dissolved oxygen', 'surface water processes/measurements', 'turbidity', 'conductivity', 'ph', 'calcium', 'magnesium', 'potassium', 'micronutrients/trace elements', 'social behavior', 'sulfate', 'sediment chemistry', 'biogeochemical processes', 'water ion concentrations', 'cropping systems', 'percolation', 'groundwater chemistry', 'reforestation/revegetation', 'species/population interactions', 'soil infiltration', 'alkalinity', 'soil fertility', 'phosphorous compounds', 'radioisotopes', 'cooling degree days', 'angiosperms (flowering plants)', 'glacial landforms', 'glacial processes', 'contour maps', 'estuaries', 'methane production/use', 'natural gas production/use', 'petroleum production/use', 'visualization/image processing', 'subsetting/supersetting', 'transformation/conversion', 'forest mensuration', 'acid deposition', 'differential pressure', 'precipitation', 'marine ecosystems', 'consumption rates', 'radio wave', 'soil organic carbon (soc)', 'soil erosion', 'halocarbons', 'trace elements/trace metals', 'biomass energy production/use', 'riparian wetlands', 'soil consistence', 'snow stratigraphy', 'thermal conductivity', 'estuary', 'tidal height', 'plant diseases/disorders/pests', 'layered precipitable water', 'atmospheric chemistry', 'water vapor concentration profiles', 'specific humidity', 'total runoff', 'pressure thickness', 'wind stress', 'atmospheric heating', 'conduction', 'hydrogen chloride', 'nitric acid', 'radar', 'land surface/agriculture indicators', 'satellite soil moisture index', 'chlorine nitrate', 'chlorofluorocarbons', 'dinitrogen pentoxide', 'antenna temperature', 'glaciers', 'ice sheets', 'dimethyl sulfide', 'potential vorticity', 'ice fraction', 'atmospheric radiation', 'runoff rate', 'temperature tendency', 'wind dynamics', 'wind direction tendency', 'base flow', 'bromine monoxide', 'chlorine monoxide', 'methyl cyanide', 'hypochlorous acid', 'methanol', 'hydroperoxy', 'cloud base pressure', 'temperature anomalies', 'nitrate', 'ocean mixed layer', 'precipitation trends', 'temperature trends', 'convection', 'ground ice', 'oxygen', 'phosphate', 'solar induced fluorescence', 'chlorine dioxide', 'sun-earth interactions', 'uv aerosol index', 'volcanic activity', 'potential evapotranspiration', 'ultraviolet wavelengths', 'ice temperature', 'sea surface skin temperature', 'sea surface height', 'sublimation', 'convective surface precipitation rate', 'hydrogen fluoride', 'airglow', 'energy deposition', 'x-ray flux', 'electron flux', 'proton flux', 'magnetic fields/magnetic currents']\n else:\n return ['platform characteristics', 'atmospheric winds','radio wave', 'weather events', 'geomagnetism','atmospheric electricity', 'microwave', 'atmospheric temperature','atmospheric water vapor', 'atmospheric pressure', 'aerosols','atmospheric radiation', 'atmospheric chemistry', 'precipitation','sensor characteristics', 'radar', 'infrared wavelengths','visible wavelengths', 'weather/climate advisories', 'clouds','lidar', 'ocean optics', 'ultraviolet wavelengths','cryospheric indicators', 'land use/land cover', 'topography','surface thermal properties', 'spectral/engineering', 'soils','snow/ice', 'geothermal dynamics', 'natural hazards','surface water', 'vegetation','land surface/agriculture indicators','gravity/gravitational field', 'marine advisories', 'altitude','water quality/water chemistry', 'ocean temperature','ocean winds', 'atmospheric/ocean indicators', 'coastal processes','erosion/sedimentation', 'marine sediments', 'ocean chemistry','salinity/density', 'ocean color', 'aquatic ecosystems','vegetation2', 'landscape', 'cloud properties','surface radiative properties', 'geodetics','agricultural plant science', 'forest science','ecological dynamics', 'environmental impacts', 'sustainability','boundaries', 'ecosystems', 'air quality', 'population','infrastructure', 'environmental governance/management','public health', 'economic resources', 'socioeconomics','environmental vulnerability index (evi)', 'human settlements','agricultural chemicals', 'animal science','habitat conversion/fragmentation', 'animals/vertebrates','earth gases/liquids', 'rocks/minerals/crystals','social behavior', 'ground water', 'frozen ground','terrestrial hydrosphere indicators', 'ocean heat budget','biospheric indicators', 'animal commodities', 'fungi', 'plants','carbon flux', 'geomorphic landforms/processes','paleoclimate indicators', 'ocean circulation', 'sea ice','geochemistry', 'visualization/image processing','subsetting/supersetting', 'transformation/conversion','ocean pressure', 'glaciers/ice sheets', 'protists','solar activity', 'sun-earth interactions','sea surface topography', 'solar energetic particle properties','solar energetic particle flux','ionosphere/magnetosphere dynamics','flight data logs','wind dynamics', 'radio wave flux', 'lightning', 'magnetic field','atmospheric conductivity', 'electric field','data synchronization time', 'brightness temperature','upper air temperature', 'water vapor profiles','surface temperature', 'upper level winds','atmospheric pressure measurements', 'water vapor indicators','aerosol particle properties', 'emissivity','trace gases/trace species', 'liquid precipitation','cloud microphysics', 'microwave radiance', 'sensor counts','total pressure', 'airspeed/ground speed', 'total temperature','static pressure', 'humidity', 'radar reflectivity','doppler velocity', 'infrared imagery', 'visible imagery','aerosol backscatter', 'weather forecast', 'tropical cyclones','visible radiance', 'infrared radiance','atmospheric temperature indices', 'cloud droplet distribution','cloud condensation nuclei', 'hydrometeors', 'oxygen compounds','wind profiles', 'liquid water equivalent', 'solar radiation','planetary boundary layer height', 'surface winds','precipitation amount', 'precipitation rate', 'surface pressure','aerosol extinction', 'aerosol optical depth/thickness','tropospheric/high-level clouds (observed/analyzed)','lidar depolarization ratio', 'radar backscatter','radar cross-section', 'return power', 'radial velocity','radiance', 'climate advisories', 'atmospheric emitted radiation','optical depth/thickness', 'ultraviolet flux', 'spectrum width','microwave imagery', 'lidar backscatter', 'radar imagery','snow depth', 'land use/land cover classification','terrain elevation', 'solid precipitation', 'droplet size','droplet concentration/size', 'precipitation anomalies','snow water equivalent', 'total surface precipitation rate','skin temperature', 'water vapor', 'attitude characteristics','land surface temperature', 'reflectance','soil moisture/water content', 'soil temperature','soil bulk density', 'surface roughness', 'present weather','snow density', 'geothermal temperature','aerosol forward scatter', 'floods', 'snow cover', 'sigma naught','precipitable water', 'surface water processes/measurements','surface water features', 'shortwave radiation','photosynthetically active radiation', 'longwave radiation','net radiation', 'flight level winds', 'soil moisture','satellite orbits/revolution', 'heat flux','precipitation profiles', 'geopotential height','particulate matter', 'particle images', 'water vapor indices','electrical conductivity', 'gases', 'sea surface temperature','convective clouds/systems (observed/analyzed)','viewing geometry', 'wind shear','carbon and hydrocarbon compounds', 'sea level pressure','water vapor processes', 'ultraviolet radiation','solar irradiance', 'scattering', 'absorption','sea surface temperature indices', 'sedimentation', 'erosion','sediment transport', 'sediments', 'tropopause', 'nan', 'pigments','attenuation/transmission', 'inorganic carbon', 'organic carbon','photosynthetically available radiation', 'chlorophyll','optical depth', 'fluorescence', 'vegetation index', 'gelbstoff','plankton', 'vegetation index2', 'landscape ecology','ultraviolet radiance', 'aerosol radiance','carbonaceous aerosols', 'dust/ash/smoke', 'nitrate particles','organic particles', 'sulfate particles', 'radiative flux','transmittance', 'atmospheric stability','cloud radiative transfer', 'rain storms', 'reflected infrared','thermal infrared', 'incoming solar radiation', 'cloud types','orbital characteristics', 'geolocation','coordinate reference system', 'infrared flux', 'visible flux','albedo', 'lidar waveform', 'plant phenology', 'vegetation cover','crop/plant yields', 'land use classes', 'landscape patterns','forest harvesting and engineering', 'forest management','ecosystem functions', 'leaf characteristics', 'fire ecology','total surface water', 'primary production', 'photosynthesis','canopy characteristics', 'evergreen vegetation', 'crown','deciduous vegetation', 'anisotropy', 'biomass burning','wildfires', 'topographical relief','environmental sustainability','anthropogenic/human influenced ecosystems', 'emissions','sulfur compounds', 'environmental assessments', 'conservation','agriculture production', 'administrative divisions','freshwater ecosystems', 'political divisions', 'urban areas','treaty agreements/results', 'population estimates','nitrogen compounds', 'particulates', 'mortality', 'droughts','earthquakes', 'population distribution', 'fertilizers','animal manure and waste', 'urbanization/urban sprawl','landslides', 'avalanche', 'mangroves', 'volcanic eruptions','pesticides', 'population size', 'population density','rural areas', 'amphibians', 'mammals', 'carbon', 'sulfur oxides','land management', 'natural gas', 'sedimentary rocks','coastal elevation', 'community dynamics','nuclear radiation exposure', 'radiation exposure','poverty levels', 'malnutrition', 'sea level rise','vulnerability levels/index', 'electricity','energy production/use', 'sustainable development','deforestation', 'household income', 'nitrogen', 'phosphorus','terrestrial ecosystems', 'permafrost', 'nutrients','plant characteristics', 'soil gas/air', 'litter characteristics','soil chemistry', 'soil respiration', 'active layer', 'soil depth','cation exchange capacity', 'organic matter', 'soil porosity','soil texture', 'permafrost melt','ground water processes/measurements', 'freeze/thaw','halocarbons and halogens', 'hydrogen compounds', 'biomass','dominant species', 'vegetation species', 'sulfur', 'tree rings','soil classification', 'sea ice concentration', 'reforestation','species/population interactions', 'range changes','topographic effects', 'land resources', 'river ice depth/extent','snow melt', 'river ice', 'animal ecology and behavior','phenological changes', 'forest fire science', 'radiative forcing','soil heat budget', 'river/lake ice breakup','river/lake ice freeze', 'reclamation/revegetation/restoration','lichens', 'marine ecosystems', 'coastal landforms', 'degradation','forest composition/vegetation structure', 'barometric altitude','volatile organic compounds', 'forest fire danger index','periglacial processes', 'landscape processes','soil horizons/profile', 'soil ph', 'soil water holding capacity','fluvial landforms', 'soil color', 'glacial processes','photochemistry', 'cloud dynamics', 'nitrogen oxides', 'smog','chemical composition', 'actinic flux', 'tropospheric ozone','fossil fuel burning', 'industrial emissions','denitrification rate', 'sunshine', 'soil structure','mosses/hornworts/liverworts', 'hydraulic conductivity','snow/ice temperature', 'water characteristics','outgoing longwave radiation', 'soil compaction', 'soil impedance','canopy transmittance', 'ground water features', 'solids','agricultural expansion', 'pressure tendency', 'visibility','herbivory', 'paleoclimate reconstructions', 'drought indices','fire weather index', 'animal yields', 'teleconnections','carbon dioxide', 'dissolved solids', 'ocean currents', 'salinity','afforestation/reforestation', 'fresh water river discharge','surface water chemistry', 'aeolian landforms','precipitation indices', 'temperature indices', 'forest yields','stratigraphic sequence', 'freeze/frost', 'frost','industrialization', 'ice core records', 'suspended solids','weathering', 'gas flaring', 'ice extent', 'biogeochemical cycles','lake ice', 'isotopes', 'watershed characteristics','transportation', 'soil rooting depth', 'geochemical properties','carbon monoxide', 'cultural features', 'consumer behavior','boundary surveys', 'land productivity', 'sediment composition','calcium', 'magnesium', 'potassium','micronutrients/trace elements', 'sediment chemistry','biogeochemical processes', 'cropping systems','groundwater chemistry', 'reforestation/revegetation','soil infiltration', 'soil fertility','angiosperms (flowering plants)', 'glacial landforms','forest mensuration', 'acid deposition', 'differential pressure','soil erosion', 'trace elements/trace metals', 'soil consistence','snow stratigraphy', 'thermal conductivity', 'estuaries','tidal height', 'plant diseases/disorders/pests','pressure thickness', 'atmospheric heating', 'conduction','evaporation', 'turbulence', 'wind stress','satellite soil moisture index', 'antenna temperature', 'glaciers','ice sheets', 'nitrate', 'ocean mixed layer','precipitation indicators', 'temperature indicators', 'ground ice','alkalinity', 'dissolved gases', 'oxygen', 'ph', 'phosphate','solar induced fluorescence', 'volcanic activity','ice temperature', 'sea surface height', 'airglow','energy deposition', 'x-ray flux', 'electron flux', 'proton flux','magnetic fields/magnetic currents', 'vertical profiles','air temperature', 'dew point temperature','cloud liquid water/ice', 'wind speed', 'wind direction','vertical wind velocity/speed', 'total precipitable water','boundary layer temperature', 'cloud height','cloud droplet concentration/size', 'ozone','cloud base temperature', 'cloud base height', 'rain','cloud optical depth/thickness', 'cirrus/systems','mean radial velocity', 'relative humidity', 'u/v wind components','wind speed/wind direction','digital elevation/terrain model (dem)', 'snow', 'drizzle','particle size distribution', 'hail', 'ambient temperature','stage height', 'rivers/streams', 'hourly precipitation amount','24 hour precipitation amount', 'latent heat flux','cloud fraction', '3 and 6 hour precipitation amount','horizontal wind velocity/speed', 'dissolved carbon dioxide','hurricanes', 'tropical cyclone track', 'cloud top height','temperature profiles', 'vertical wind shear','water vapor tendency', 'potential temperature','angstrom exponent', 'water vapor mixing ratio profiles','extreme eastern tropical pacific sst', 'phytoplankton','cloud precipitable water', 'cloud asymmetry', 'cloud ceiling','cloud frequency', 'cloud top pressure', 'cloud top temperature','cloud vertical distribution', 'cloud emissivity','cloud radiative forcing', 'cloud reflectance','maximum/minimum temperature', 'condensation','topographical relief maps', 'evapotranspiration','fire occurrence', 'burned area', 'sulfur dioxide', 'lake/pond','rivers/stream', 'nitrogen dioxide', 'agricultural lands','cyclones', 'urban lands', 'lakes/reservoirs','infant mortality rates', 'methane','non-methane hydrocarbons/volatile organic compounds', 'coal','biodiversity functions', 'wetlands', 'discharge/flow','hydropattern', 'alpine/tundra', 'forests','leaf area index (lai)', 'ammonia', 'nitrous oxide','land subsidence', 'normalized difference vegetation index (ndvi)','chlorinated hydrocarbons', 'methyl bromide', 'methyl chloride','molecular hydrogen', 'fire models', 'heat index','even-toed ungulates', 'species recruitment','population dynamics', 'water depth', 'inundation', 'drainage','respiration rate', 'permafrost temperature','indigenous/native species', 'fire dynamics', 'plant succession','coastal', 'salt marsh', 'boundary layer winds', 'shrubland/scrub','community structure', 'pingo', 'virtual temperature','formaldehyde', 'hydroxyl', 'photolysis rates', 'nitric oxide','molecular oxygen', 'peroxyacyl nitrate', 'stable isotopes','runoff', 'vegetation water content', 'discharge','chlorophyll concentrations', 'water table', 'decomposition','water temperature', 'total dissolved solids', 'biomass dynamics','grasslands', 'savannas', 'grazing dynamics/plant herbivory','multivariate enso index', 'drainage basins','resource development site', 'dunes', 'flood plain','endangered species', 'hydrogen cyanide', 'nutrient cycling','deserts','fraction of absorbed photosynthetically active radiation (fapar)','aquifers', 'dissolved oxygen', 'turbidity', 'conductivity','sulfate', 'water ion concentrations', 'percolation','phosphorous compounds', 'radioisotopes', 'cooling degree days','contour maps', 'methane production/use','natural gas production/use', 'petroleum production/use','consumption rates', 'soil organic carbon (soc)', 'halocarbons','biomass energy production/use', 'estuary','layered precipitable water', 'water vapor concentration profiles','hydrogen chloride', 'nitric acid', 'chlorine nitrate','chlorofluorocarbons', 'dinitrogen pentoxide', 'dimethyl sulfide','vorticity', 'ice fraction', 'temperature tendency','wind direction tendency', 'bromine monoxide', 'chlorine monoxide','methyl cyanide', 'hypochlorous acid', 'methanol', 'hydroperoxy','cloud base pressure', 'temperature anomalies','precipitation trends', 'temperature trends', 'convection','chlorine dioxide', 'uv aerosol index','sea surface skin temperature', 'sublimation','convective surface precipitation rate', 'hydrogen fluoride']","def setContourLabelDistance(distance=500):\n dislin.labdis(distance, 'CONTUR')","def eval_final_label(args):\n cfg, lbl = util.get_label_cfg_by_args(args)\n uid = cfg['uniqueid']\n print('We are playing with %s' % uid)\n outdir='models/%s/gate_expert' % uid\n outname='gate_expert_model.pt'\n if KLLOSS:\n outname = 'gate_expert_kldiv_model.pt'\n if args.warm:\n outname = outname.replace('.pt', '_warm.pt')\n mdl_path = os.path.join(outdir, outname)\n gate_expert = GateExpertNet(mdl_path, False)\n eval_fun = gate_expert.get_p_y\n\n data = npload(cfg['file_path'], uid)\n datax = data[cfg['x_name']]\n p, v = eval_fun(datax)\n\n label = np.argmax(p, axis=1)\n\n if args.draw:\n fig, ax = plt.subplots()\n n_expert = np.amax(label) + 1\n for i in range(n_expert):\n mask = label == i\n ax.scatter(datax[mask, 0], datax[mask, 1])\n plt.show()\n\n label_name = 'data/pen/gate_expert_label.npy'\n if KLLOSS:\n label_name = label_name.replace('_label', '_kldiv_label')\n if args.warm:\n label_name = label_name.replace('.npy', '_warm.npy')\n np.save(label_name, label)","def donut_highD(N=1500, V=1500, binary=True, d=3):\n X = torch.randn(N + V, d)\n R = torch.sqrt(torch.sum(X ** 2, dim=1))\n ind_class0 = (R < 1.0).nonzero()[:, 0]\n ind_class1 = (R >= 1.0).nonzero()[:, 0]\n X = X * 1.2 # rescale data\n X.add_(0.2 * torch.randn_like(X)) # add some noise to the data\n \n return label(d, X, ind_class0, ind_class1, N, V, binary)","def label(self):\r\n raise NotImplementedError","def cell_description(self, gid):\n\n tree = arbor.segment_tree()\n\n tree.append(\n arbor.mnpos,\n arbor.mpoint(0, 0, 0, self.radius),\n arbor.mpoint(self.length, 0, 0, self.radius),\n tag=1,\n )\n\n labels = arbor.label_dict({\"cable\": \"(tag 1)\", \"start\": \"(location 0 0)\"})\n\n decor = (\n arbor.decor()\n .set_property(Vm=self.Vm, cm=self.cm, rL=self.rL)\n .paint('\"cable\"', arbor.density(f\"pas/e={self.Vm}\", g=self.g))\n .place(\n '\"start\"',\n arbor.iclamp(\n self.stimulus_start, self.stimulus_duration, self.stimulus_amplitude\n ),\n \"iclamp\",\n )\n )\n\n policy = arbor.cv_policy_max_extent(self.cv_policy_max_extent)\n decor.discretization(policy)\n\n return arbor.cable_cell(tree, decor, labels)","def label(cmd):\n cmd = cmd.replace('make][.DP', 'make1][.NP')\n cmd = cmd.replace('make][.SC', 'make2][.SC')\n cmd = re.sub('(draw.*)one','\\\\1one1',cmd)\n cmd = re.sub('(make1.*)one','\\\\1one1',cmd)\n cmd = re.sub('(make2.*)one','\\\\1one2',cmd)\n cmd = re.sub('(move.*)one','\\\\1one2',cmd)\n cmd = re.sub('(hide.*)one','\\\\1one2',cmd)\n cmd = '[result ' + cmd + ']' #dummy function for plop\n return cmd","def plot_countryperskill(data_df, **args):\n name = args.get('name', 'VARIABLE NAME')\n idx = args.get('idx', data_df.index.values)\n order = args.get('order', np.array([9, 0, 1, 2, 3, 4, 5, 6, 8, 7], int))\n dd = args.get('dd', .7) # 3.3\n wdth = args.get('wdth', 8) # 7\n hght = args.get('hght', 4)\n markersize = 60\n target_y = args.get('target_y', 1)\n label_y = args.get('label_y', r'$\\rho$')\n colors14 = args.get('colors14', ['#a6cee3', '#1f78b4', '#b2df8a', '#33a02c', \\\n '#fb9a99', '#e31a1c', '#fdbf6f', '#ff7f00', \\\n '#cab2d6', '#6a3d9a', '#ffff99', '#b15928', \\\n '#dd1c77', '#8dd3c7'])\n plt.figure(facecolor='w', figsize=(wdth, hght))\n meth_labels = [r'$Lit$', r'$Lit^2$', r'$Lit^3$', r'$Lit^4$', r'$Lit^5$', \\\n r'$Pop$', r'$Pop^2$', r'$Lit^3Pop$', r'$Lit^2Pop$', r'$LitPop$']\n idx = idx[order]\n meth_labels = [meth_labels[i] for i in order]\n # empty plots for legend handlers:\n for i in np.arange(0, len(countries_sel)): # country\n plt.scatter([], [], marker='o', s=markersize, edgecolor='black', linewidth='.4',\\\n c=colors14[i], label=countries[countries_sel[i]])\n plt.legend()\n\n plt.scatter([0, len(idx)+dd], [0.7, 0.7], marker='.', lw=1, c='white') # legendspace\n\n # actual plotting:\n for i in np.arange(0, len(countries_sel)): # country\n for j in np.arange(0, len(idx)):\n # rp - pearson correlation:\n plt.scatter([j], data_df[countries[countries_sel[i]]][idx[j]], marker='o', \\\n s=markersize, edgecolor='black', linewidth='.4',\\\n alpha=1., c=colors14[i], zorder=j+10)\n if not target_y == 'none':\n plt.plot([0, j], [target_y, target_y], c='#d3d3d3', lw=5, ls='-', zorder=1)\n\n plt.xticks(np.arange(0, len(idx)), meth_labels, color='black', rotation=30)\n plt.grid(axis='y')\n # plt.xlabel('Method')\n plt.ylabel(label_y)\n plt.title(name)\n\n plt.savefig(os.path.join(output_path, experiment_name + '_' + 'allcountries_perScore_v4_' + name + '.pdf'),\\\n dpi=600, facecolor='w', edgecolor='w',\n orientation='portrait', papertype=None, format='pdf',\n transparent=False, bbox_inches=None, pad_inches=0.1,\n frameon=None, metadata=None)\n plt.show()","def showOneNeedle(self,i,visibility):\n #obsolete\n profbox()\n fidname = \"fid\"+self.option[i]\n pNode = self.parameterNode()\n needleID = pNode.GetParameter(self.option[i]+'.vtp')\n fidID = pNode.GetParameter(fidname) \n NeedleNode = slicer.mrmlScene.GetNodeByID(needleID)\n fiducialNode = slicer.mrmlScene.GetNodeByID(fidID) \n \n if NeedleNode !=None:\n displayNode =NeedleNode.GetModelDisplayNode()\n nVisibility=displayNode.GetVisibility() \n\n if fiducialNode == None:\n displayNode.SetVisibility(1) \n displayNode.SetOpacity(0.9)\n polyData = NeedleNode.GetPolyData()\n polyData.Update()\n nb = int(polyData.GetNumberOfPoints()-1)\n coord = [0,0,0]\n if nb>100:\n fiducialNode = slicer.vtkMRMLAnnotationFiducialNode()\n polyData.GetPoint(nb,coord) \n fiducialNode.SetName(self.option[i])\n fiducialNode.SetFiducialCoordinates(coord) \n fiducialNode.Initialize(slicer.mrmlScene)\n fiducialNode.SetLocked(1)\n fiducialNode.SetSelectable(0)\n fidDN = fiducialNode.GetDisplayNode()\n fidDN.SetColor(NeedleNode.GetDisplayNode().GetColor())\n fidDN.SetGlyphScale(0)\n fidTN = fiducialNode.GetAnnotationTextDisplayNode()\n fidTN.SetTextScale(3)\n fidTN.SetColor(NeedleNode.GetDisplayNode().GetColor())\n fiducialNode.SetDisplayVisibility(0)\n pNode.SetParameter(fidname,fiducialNode.GetID())\n fiducialNode.SetDisplayVisibility(1)\n\n if visibility ==0:\n\n displayNode.SetVisibility(0)\n displayNode.SetSliceIntersectionVisibility(0)\n if fiducialNode!=None:\n fiducialNode.SetDisplayVisibility(0)\n\n else:\n\n displayNode.SetVisibility(1)\n displayNode.SetSliceIntersectionVisibility(1)\n if fiducialNode!=None:\n fiducialNode.SetDisplayVisibility(1)\n\n else:\n vtkmat = vtk.vtkMatrix4x4()\n vtkmat.DeepCopy(self.m_vtkmat)\n vtkmat.SetElement(0,3,self.m_vtkmat.GetElement(0,3)+self.p[0][i])\n vtkmat.SetElement(1,3,self.m_vtkmat.GetElement(1,3)+self.p[1][i])\n vtkmat.SetElement(2,3,self.m_vtkmat.GetElement(2,3)+(30.0-150.0)/2.0)\n\n TransformPolyDataFilter=vtk.vtkTransformPolyDataFilter()\n Transform=vtk.vtkTransform() \n TransformPolyDataFilter.SetInput(self.m_polyCylinder)\n Transform.SetMatrix(vtkmat)\n TransformPolyDataFilter.SetTransform(Transform)\n TransformPolyDataFilter.Update()\n\n triangles=vtk.vtkTriangleFilter()\n triangles.SetInput(TransformPolyDataFilter.GetOutput()) \n self.AddModel(i,triangles.GetOutput())\n self.showOneNeedle(i,visibility)","def getLabel(*args):","def getLabel(*args):","def getLabel(*args):","def drawlabels(t, t1):\r\n t.fd(250)\r\n t.pd()\r\n t.write(\"Life\", font=(\"Arial\", 10, \"bold\"))\r\n t.pu()\r\n t.back(12)\r\n t.pd()\r\n t.write(\"Exp.\", font=(\"Arial\", 10, \"bold\"))\r\n t.pu()\r\n t.back(238)\r\n t.right(90)\r\n t.fd(80)\r\n t1.pu()\r\n t1.back(50)\r\n t1.rt(90)\r\n t1.fd(250)\r\n t1.pd()\r\n t1.write(\"Year\", font=(\"Arial\", 10, \"bold\"))\r\n t1.pu()\r\n t1.back(250)\r\n t1.left(90)\r\n t1.fd(50)","def ex_label(self,label,argl):\n if len(label) > 0 and label[0] != '_':\n return label\n comment = ''\n for i in argl:\n phrase = ''\n if i == 'l':\n phrase = label\n elif i in self._labels.keys():\n phrase = self._labels[i]\n comment += phrase\n return comment","def efficient_tagged_jets_hist(datalist,discriminant, discriminant_cut, CSV_cut, bins, Difference=False, mode=\"pT_jet\",Save=False):\n title = \"tagged_jets_vs_\"+mode\n AllJetsHistlist = []\n CSVHistlist = []\n DiscriminantHistlist = []\n if mode == \"pT_hadron\":\n feature = 2\n elif mode == \"pT_jet\":\n feature = 3\n elif mode == \"decay_vx\":\n feature = 4\n for n,data in enumerate(datalist):\n print \"working on\",data[1]\n ran = data[2]\n AllJetsHistlist.append(rt.TH1D(data[1]+\"_AllJets\",data[1]+\"_\"+title,bins,ran[0],ran[1]))\n AllJetsHistlist[n].SetLineColor(4)\n CSVHistlist.append(rt.TH1D(data[1]+\"_CSV\",data[1]+\"_\"+title,bins,ran[0],ran[1]))\n CSVHistlist[n].SetLineColor(3)\n DiscriminantHistlist.append(rt.TH1D(data[1]+\"_Discriminant\",data[1]+\"_\"+title,bins,ran[0],ran[1]))\n DiscriminantHistlist[n].SetLineColor(2)\n for particle in data[0]:\n AllJetsHistlist[n].Fill(particle[feature])\n if particle[1] >= CSV_cut: CSVHistlist[n].Fill(particle[feature])\n if Difference:\n L = particle[8]-particle[5]\n else:\n if particle[13] != 0:\n L = particle[16]/float(particle[13])\n else:\n continue\n if L >= discriminant_cut: DiscriminantHistlist[n].Fill(particle[feature])\n canvaslist = []\n legendlist = []\n Tfilelist = []\n for n,data in enumerate(datalist):\n canvaslist.append(rt.TCanvas(data[1]+\"_canvas\",\"canvas\",600,600))\n canvaslist[n].SetTitle(data[1]+\"_\"+title)\n rt.gStyle.SetOptStat(0)\n legendlist.append(rt.TLegend(0.9,0.9,0.65,0.75))\n legendlist[n].AddEntry(AllJetsHistlist[n], \"All jets\")\n legendlist[n].AddEntry(CSVHistlist[n], \"CSV\")\n legendlist[n].AddEntry(DiscriminantHistlist[n], discriminant)\n AllJetsHistlist[n].GetXaxis().SetTitle(mode)\n AllJetsHistlist[n].GetYaxis().SetTitle('# jets')\n AllJetsHistlist[n].GetYaxis().SetTitleOffset(1.5)\n #AllJetsHistlist[n].Draw()\n #CSVHistlist[n].Draw(\"SAME\")\n #DiscriminantHistlist[n].Draw(\"SAME\")\n #legendlist[n].Draw()\n if Save:\n #canvaslist[n].SaveAs(\"Thesis_Plots/\"+title+\"_\"+data[1]+discriminant+\".png\")\n Tfilelist.append(rt.TFile(\"Thesis_Plots/root_files/\"+title+\"_\"+data[1]+discriminant+\".root\",\"recreate\"))\n AllJetsHistlist[n].Write()\n CSVHistlist[n].Write()\n DiscriminantHistlist[n].Write()","def autolabel(rects):","def __init__(self, label_num, des_dir, des_dim=48):\n self.label_num = label_num\n self.des_dir = des_dir\n self.des_dim = 48","def _get_labels(self, ind):\n pass","def diet_label(self, diet_label):\n\n self._diet_label = diet_label","def dim_reduction_plot(data, label, block_flag):\n \n PCA_model = TruncatedSVD(n_components=3).fit(data)\n data_PCA = PCA_model.transform(data)\n idxc1 = np.where(label==0)\n idxc2 = np.where(label==1)\n plt.scatter(data_PCA[idxc1,0],data_PCA[idxc1,1],s=80,c='r', marker='^',linewidths = 0, label='healthy')\n plt.scatter(data_PCA[idxc2,0],data_PCA[idxc2,1],s=80,c='y', marker='o',linewidths = 0, label='infected')\n plt.gca().axes.get_xaxis().set_ticks([])\n plt.gca().axes.get_yaxis().set_ticks([])\n plt.title('PCA of the codes')\n plt.legend(scatterpoints=1,loc='best')\n plt.show(block=block_flag)","def plotrgcloud(self):\n print self.kpunten\n for i in range(len(self.kpunten[0])):\n self.writetext('sen ='+ self.kpunten[0][i][0], (0.65,0.85), axnum = 0, hor = None ,ver = None , rot = None ,fs =14 , transform = self.fig.axes[0].transAxes)\n if i == len(self.kpunten[0]) -1 :\n end = None\n else:\n end = self.kpunten[0][i+1][1] + 1\n print end\n self.plotrgwrap( self.rgindex,2*self.reader.npair+self.rgindex,'real part of rgvars (a.u)' , 'imaginary part of rgvars (a.u.)', tit ='RG vars g = %f all states'%(self.chardata) , begin = self.kpunten[0][i][1] , stop = end , name = 'cpcloud'+ self.kpunten[0][i][0] , filenum = 0)","def makeD2hhAsymm(name,\n config,\n KPIDK_string,\n PiPIDK_string,\n Mass_low_string,\n Mass_high_string,\n CombPIDK_string,\n DecayDescriptor,\n inputSel,\n useTOS,\n Hlt1TOS,\n Hlt2TOS\n ) :\n\n def makeTISTOS( name, _input, _hlttos ) :\n from Configurables import TisTosParticleTagger\n _tisTosFilter = TisTosParticleTagger( name + \"Tagger\" )\n _tisTosFilter.TisTosSpecs = _hlttos\n return Selection( name\n , Algorithm = _tisTosFilter\n , RequiredSelections = [ _input ]\n ) \n\n _Kcuts1 = \"~ISMUON & (PT > %(DaugPtMin)s* MeV) & (MIPCHI2DV(PRIMARY) > %(DaugIPChi2)s)\" % locals()['config']\n _KcutsPIDK = KPIDK_string % locals()['config']\n _Kcuts2 = \" & (ISLONG) & (P > %(DaugP)s* MeV) & (TRCHI2DOF < %(DaugTrkChi2)s)\" % locals()['config']\n _Kcuts = _Kcuts1 + _KcutsPIDK + _Kcuts2\n _Picuts1 = \"~ISMUON & (PT > %(DaugPtMin)s* MeV) & (MIPCHI2DV(PRIMARY) > %(DaugIPChi2)s)\" % locals()['config']\n _PicutsPIDK = PiPIDK_string % locals()['config']\n _Picuts2 = \" & (ISLONG) & (P > %(DaugP)s* MeV) & (TRCHI2DOF < %(DaugTrkChi2)s)\" % locals()['config']\n _Picuts = _Picuts1 + _PicutsPIDK + _Picuts2\n _dauCuts = { 'K+': _Kcuts, 'pi+': _Picuts }\n\n _massLow = Mass_low_string % locals()['config']\n _massHigh = Mass_high_string % locals()['config']\n _combCuts1 = \"(APT > %(D0Pt)s* MeV)\" \\\n \"& (AHASCHILD( PT > %(DaugPtMax)s* MeV ) )\" \\\n \"& (ADOCA(1,2)< %(D0DOCA)s* mm)\" \\\n \"& (AP > %(D0P)s* MeV)\" % locals()['config']\n _combCutsPIDK = CombPIDK_string % locals()['config']\n _combCuts = _combCuts1 + _combCutsPIDK + _massLow + _massHigh\n\n _motherCuts = \"(VFASPF(VCHI2PDOF) < %(D0VtxChi2Ndof)s)\" \\\n \"& (BPVVDCHI2 > %(D0FDChi2)s)\" \\\n \"& (BPVLTIME() > %(D0Tau)s)\" \\\n \"& (BPVDIRA > %(D0BPVDira)s)\" % locals()['config']\n\n _D0 = CombineParticles( DecayDescriptor = DecayDescriptor,\n MotherCut = _motherCuts,\n CombinationCut = _combCuts,\n DaughtersCuts = _dauCuts)\n\n _sel = Selection ( name+'Sel',\n Algorithm = _D0,\n RequiredSelections = inputSel )\n\n if not useTOS:\n return _sel\n\n _selD2hhHlt1TOS = makeTISTOS( name + \"D2hhHlt1TOS\"\n , _sel\n , Hlt1TOS\n )\n _selD2hhHlt2TOS = makeTISTOS( name + \"D2hhHlt2TOS\"\n , _selD2hhHlt1TOS\n , Hlt2TOS\n )\n \n return _selD2hhHlt2TOS","def efficient_binned_tagged_jets_hist(datalist,discriminant, discriminant_cuts, CSV_cuts, bins, nbins, Difference=False, mode=\"pT_jet\",Save=False):\n title = \"binned_tagged_jets_vs_\"+mode\n AllJetsHistlist = []\n CSVHistlist = []\n DiscriminantHistlist = []\n if mode == \"pT_hadron\":\n feature = 2\n elif mode == \"pT_jet\":\n feature = 3\n elif mode == \"decay_vx\":\n feature = 4\n for n,data in enumerate(datalist):\n print \"working on\",data[1]\n ran = data[2]\n AllJetsHistlist.append(rt.TH1D(data[1]+\"_AllJets\",data[1]+\"_\"+title,nbins,ran[0],ran[1]))\n AllJetsHistlist[n].SetLineColor(4)\n CSVHistlist.append(rt.TH1D(data[1]+\"_CSV\",data[1]+\"_\"+title,nbins,ran[0],ran[1]))\n CSVHistlist[n].SetLineColor(3)\n DiscriminantHistlist.append(rt.TH1D(data[1]+\"_Discriminant\",data[1]+\"_\"+title,nbins,ran[0],ran[1]))\n DiscriminantHistlist[n].SetLineColor(2)\n for particle in data[0]:\n bin_number = FCM.bin_selection(particle,bins)\n if bin_number == -100: continue\n AllJetsHistlist[n].Fill(particle[feature])\n if particle[1] >= CSV_cuts[bin_number]: CSVHistlist[n].Fill(particle[feature])\n if Difference:\n L = particle[8]-particle[5]\n else:\n if particle[17] != 0:\n L = particle[20]/float(particle[17])\n else:\n continue\n if L >= discriminant_cuts[bin_number]: DiscriminantHistlist[n].Fill(particle[feature])\n canvaslist = []\n legendlist = []\n Tfilelist = []\n for n,data in enumerate(datalist):\n canvaslist.append(rt.TCanvas(data[1]+\"_canvas\",\"canvas\",600,600))\n canvaslist[n].SetTitle(data[1]+\"_\"+title)\n rt.gStyle.SetOptStat(0)\n legendlist.append(rt.TLegend(0.9,0.9,0.65,0.75))\n legendlist[n].AddEntry(AllJetsHistlist[n], \"All jets\")\n legendlist[n].AddEntry(CSVHistlist[n], \"CSV\")\n legendlist[n].AddEntry(DiscriminantHistlist[n], discriminant)\n AllJetsHistlist[n].GetXaxis().SetTitle(\"jet p_{T} (GeV)\")\n AllJetsHistlist[n].GetYaxis().SetTitle('# jets')\n AllJetsHistlist[n].GetYaxis().SetTitleOffset(1.5)\n #AllJetsHistlist[n].Draw()\n #CSVHistlist[n].Draw(\"SAME\")\n #DiscriminantHistlist[n].Draw(\"SAME\")\n #legendlist[n].Draw()\n if Save:\n #canvaslist[n].SaveAs(title+\"_\"+data[1]+discriminant+\".png\")\n Tfilelist.append(rt.TFile(\"Thesis_Plots/root_files/\"+title+\"_\"+data[1]+discriminant+\".root\",\"recreate\"))\n print \"saved histogram as Thesis_Plots/root_files/\"+title+\"_\"+data[1]+discriminant+\".root\"\n AllJetsHistlist[n].Write()\n CSVHistlist[n].Write()\n DiscriminantHistlist[n].Write()","def fid_cuts(ptname, etaname):\n cuts = []\n cuts.append(combine_cuts([ptname + ' > 4.5',\n 'TMath::Abs(' + etaname + ') < 1.2']))\n cuts.append(combine_cuts([ptname + ' > 4.0',\n var_selection('TMath::Abs('+etaname+')', 1.2, 1.4)\n ]))\n cuts.append(combine_cuts([ptname + ' > 3.5',\n var_selection('TMath::Abs('+etaname+')', 1.4, 1.6)\n ]))\n return combine_cuts(cuts, ' || ')","def showComponents(self, mask):\n\n from skimage import measure\n\n thresh = cv2.threshold(mask, 0, 255, cv2.THRESH_BINARY)[1]\n labels = measure.label(thresh, neighbors=8, background=0)\n for label in range(0,len(labels)):\n img = np.zeros(mask.shape)\n # if this is the background label, ignore it\n if label == 0:\n continue\n img[labels==label]=255\n numPixels = cv2.countNonZero(img)\n\n \t# if the number of pixels in the component is sufficiently\n \t# large, then add it to our mask of \"large blobs\"\n if numPixels > 500:\n showme(img, 'Contour '+str(label))","def getLabel2(*args):","def getLabel2(*args):","def DGTsLabel(*args):\n return _XCAFDoc.XCAFDoc_DocumentTool_DGTsLabel(*args)","def _get_component_label(self):\n labels = df_parser(self.workflow.builder.df_path, workflow=self.workflow).labels\n if self.pdc_component_df_label not in labels:\n raise PluginFailedException('No %s label in Dockerfile, can\\'t get PDC component',\n self.pdc_component_df_label)\n return labels[self.pdc_component_df_label]","def tagview(tab,label,x,y):\r\n font = cv2.FONT_HERSHEY_SIMPLEX\r\n col=classifc[label]\r\n labnow=classif[label]\r\n# print (labnow, text)\r\n if label == 'back_ground':\r\n deltay=30\r\n else:\r\n# deltay=25*((labnow-1)%5)\r\n deltay=40+10*(labnow-1)\r\n\r\n viseg=cv2.putText(tab,label,(x, y+deltay), font,0.3,col,1)\r\n return viseg","def label(image,**kw):\n # default connectivity in OpenCV: 8 (which is equivalent to...)\n # default connectivity in scikit-image: 2\n n, labels = cv2.connectedComponents(image.astype(uint8), connectivity=4)\n #n, labels = cv2.connectedComponentsWithAlgorithm(image.astype(uint8), connectivity=4, ltype=2, ccltype=cv2.CCL_DEFAULT)\n return labels, n-1\n # try: return measurements.label(image,**kw)\n # except: pass\n # types = [\"int32\",\"uint32\",\"int64\",\"uint64\",\"int16\",\"uint16\"]\n # for t in types:\n # try: return measurements.label(array(image,dtype=t),**kw)\n # except: pass\n # # let it raise the same exception as before\n # return measurements.label(image,**kw)","def needleSegmentationCLIDEMO(self):\r\n # research\r\n profbox()\r\n widget = slicer.modules.NeedleFinderWidget\r\n scene = slicer.mrmlScene\r\n pNode = self.parameterNode()\r\n if slicer.mrmlScene.GetNodeByID(pNode.GetParameter(\"baselineVolumeID\")) == None:\r\n inputVolume = self.__volumeSelector.currentNode()\r\n inputVolumeID = self.__volumeSelector.currentNode().GetID()\r\n else:\r\n inputVolume = slicer.mrmlScene.GetNodeByID(pNode.GetParameter(\"baselineVolumeID\"))\r\n inputVolumeID = slicer.mrmlScene.GetNodeByID(pNode.GetParameter(\"baselineVolumeID\")).GetID()\r\n inputLabelID = self.__needleLabelSelector.currentNode().GetID()\r\n\r\n datetime = time.strftime(\"%Y-%m-%d-%H_%M_%S\", time.localtime())\r\n\r\n inputVolume.SetAttribute(\"foldername\", datetime)\r\n self.outputVolumeNode = slicer.mrmlScene.CreateNodeByClass('vtkMRMLModelNode')\r\n self.outputVolumeNode.SetName(\"Output Needle Model\")\r\n outputVolumeStorageNode = slicer.mrmlScene.CreateNodeByClass('vtkMRMLModelStorageNode')\r\n slicer.mrmlScene.AddNode(self.outputVolumeNode)\r\n slicer.mrmlScene.AddNode(outputVolumeStorageNode)\r\n self.outputVolumeNode.AddAndObserveStorageNodeID(outputVolumeStorageNode.GetID())\r\n outputVolumeStorageNode.WriteData(self.outputVolumeNode)\r\n\r\n outputID = self.outputVolumeNode.GetID()\r\n\r\n self.foldername = '/NeedleModels/' + datetime\r\n\r\n # Set the parameters for the CLI module\r\n parameters = {}\r\n parameters['inputVolume'] = inputVolumeID\r\n parameters['inputLabel'] = inputLabelID\r\n parameters['outputVtk'] = outputID\r\n parameters['outputFolderName'] = self.foldername\r\n parameters['nbPointsPerLine'] = self.nbPointsPerLine.value\r\n parameters['nbRadiusIterations'] = self.nbRadiusIterations.value\r\n parameters['radiusMax'] = self.radiusMax.value\r\n parameters['numberOfPointsPerNeedle'] = self.numberOfPointsPerNeedle.value\r\n parameters['nbRotatingIterations'] = self.nbRotatingIterations.value\r\n\r\n module = slicer.modules.mainlabelneedletrackingcli\r\n self.__cliNode = None\r\n self.__cliNode = slicer.cli.run(module, None, parameters, wait_for_completion=True)\r\n\r\n ##### match the needles ######\r\n\r\n self.setNeedleCoordinates()\r\n self.computerPolydataAndMatrix()\r\n xmin = min(self.p[0])\r\n xmax = max(self.p[0])\r\n ymin = min(self.p[1])\r\n ymax = max(self.p[1])\r\n xdelta = xmax - xmin\r\n ydelta = ymax - ymin\r\n k = 0\r\n\r\n self.base = [[0 for j in range(3)] for j in range(63)]\r\n self.tip = [[0 for j in range(3)] for j in range(63)]\r\n self.needlenode = [[0 for j in range(2)] for j in range(63)]\r\n self.bentNeedleNode = [[0 for j in range(2)] for j in range(63)]\r\n self.displaynode = [0 for j in range(63)]\r\n self.displaynodeB = [0 for j in range(63)]\r\n self.fiducialnode = [0 for j in range(63)]\r\n\r\n for i in xrange(63):\r\n\r\n pathneedle = self.foldername + '/' + str(i) + '.vtp'\r\n pathBentNeedle = self.foldername + '/' + str(i) + '_bent.vtp'\r\n self.needlenode[i] = slicer.util.loadModel(pathneedle, True)\r\n self.bentNeedleNode[i] = slicer.util.loadModel(pathBentNeedle, True)\r\n\r\n if self.needlenode[i][0] == True and self.needlenode[i][1] != None:\r\n self.displaynode[i] = self.needlenode[i][1].GetDisplayNode()\r\n self.displaynodeB[i] = self.bentNeedleNode[i][1].GetDisplayNode()\r\n\r\n\r\n polydata = self.needlenode[i][1].GetPolyData()\r\n polydata.GetPoint(0, self.base[i])\r\n\r\n self.displaynode[i].SliceIntersectionVisibilityOn()\r\n self.displaynodeB[i].SliceIntersectionVisibilityOn()\r\n bestmatch = None\r\n mindist = None\r\n for j in xrange(63):\r\n delta = ((self.p[0][j] - (self.base[i][0])) ** 2 + (self.p[1][j] - self.base[i][1]) ** 2) ** (0.5)\r\n if delta < mindist or mindist == None:\r\n bestmatch = j\r\n mindist = delta\r\n\r\n bestmatch = k\r\n k += 1\r\n self.displaynode[i].SetColor(self.color[bestmatch])\r\n self.displaynodeB[i].SetColor(self.color[bestmatch])\r\n self.needlenode[i][1].SetName(self.option[bestmatch] + \"_segmented\")\r\n self.bentNeedleNode[i][1].SetName(self.option[bestmatch] + \"_optimized\")\r\n self.needlenode[i][1].SetAttribute(\"segmented\", \"1\")\r\n self.bentNeedleNode[i][1].SetAttribute(\"optimized\", \"1\")\r\n self.needlenode[i][1].SetAttribute(\"nth\", str(bestmatch))\r\n self.bentNeedleNode[i][1].SetAttribute(\"nth\", str(bestmatch))\r\n self.needlenode[i][1].SetAttribute(\"needleID\", self.needlenode[i][1].GetID())\r\n self.bentNeedleNode[i][1].SetAttribute(\"needleID\", self.bentNeedleNode[i][1].GetID())\r\n\r\n if widget.removeDuplicates.isChecked():\r\n self.positionFilteringNeedles()\r\n\r\n d = slicer.mrmlScene.GetNodeByID(outputID).GetDisplayNode()\r\n d.SetVisibility(0)\r\n\r\n self.__editorFrame.collapsed = 1\r\n\r\n self.addButtons()","def nifti2dicom(seg_nifti, bk_nifti, ref_dicom_dir, save_dir, description, mode_RGB=False, zoom_num=4, watermarks=True): \n #Load nifti, here is segmentation and background\n seg_image = sitk.ReadImage(seg_nifti)\n seg_image = sitk.GetArrayFromImage(seg_image)\n seg_image = seg_image.astype(np.uint8)\n \n # print(nifti_image.shape)\n bk_image = sitk.ReadImage(bk_nifti)\n bk_image = sitk.GetArrayFromImage(bk_image)\n\n #Get Volume report from the seg_image, cubic ml, and the 95% CI:\n v_nonenhancing = round(seg_image[seg_image==1].sum()/1000,1)\n ci_nonenhancing = round(v_nonenhancing*0.2,1)\n v_enhancing = round(seg_image[seg_image==4].sum()/1000,1)\n ci_enhancing = round(v_enhancing*0.3,1)\n v_edema = round(seg_image[seg_image==2].sum()/1000,1)\n ci_edema = round(v_edema*0.1,1)\n\n #Loading the reference dicom, in order to get the headers of each slice. \n series_IDs = sitk.ImageSeriesReader.GetGDCMSeriesIDs(ref_dicom_dir)\n if not series_IDs:\n print(\"ERROR: given directory \\\"\"+data_directory+\"\\\" does not contain a DICOM series.\")\n sys.exit(1)\n\n series_file_names = sitk.ImageSeriesReader.GetGDCMSeriesFileNames(ref_dicom_dir, series_IDs[0])\n\n series_reader = sitk.ImageSeriesReader()\n series_reader.SetFileNames(series_file_names)\n\n # Configure the reader to load all of the DICOM tags (public+private):\n # By default tags are not loaded (saves time).\n # By default if tags are loaded, the private tags are not loaded.\n # We explicitly configure the reader to load tags, including the private ones.\n series_reader.MetaDataDictionaryArrayUpdateOn()\n series_reader.LoadPrivateTagsOn()\n ref_image = series_reader.Execute()\n \n #set reader for slice \n reader = sitk.ImageFileReader()\n reader.LoadPrivateTagsOn()\n \n writer = sitk.ImageFileWriter()\n # Use the study/series/frame of reference information given in the meta-data\n # dictionary and not the automatically generated information from the file IO\n writer.KeepOriginalImageUIDOn()\n\n # Copy some of the tags and add the relevant tags indicating the change.\n # For the series instance UID (0020|000e), each of the components is a number, cannot start\n # with zero, and separated by a '.' We create a unique series ID using the date and time. tags of interest:\n \n castFilter = sitk.CastImageFilter()\n castFilter.SetOutputPixelType(sitk.sitkInt16)\n ORG_ROOT=\"1.3.12.2\"\n #create SeriesInstanceUID and StudyInstanceUID\n SeriesInstanceUID = generateUID(org_root=ORG_ROOT)\n StudyInstanceUID = generateUID(org_root=ORG_ROOT)\n #create a prefix for the accession number\n acc='BTS'+series_reader.GetMetaData(0,\"0008|0050\")\n #changing spacing\n reader.SetFileName(series_file_names[0])\n reader.ReadImageInformation()\n\n if mode_RGB:\n customized_tag_values = [(\"0008|103e\", description),\n (\"0020|000e\", SeriesInstanceUID),\n (\"0008|0050\", acc),\n (\"0020|000d\", StudyInstanceUID), \n (\"0028|0004\", 'RGB'),\n (\"0028|0002\", \"3\")]\n else:\n customized_tag_values = [(\"0008|103e\", description),\n (\"0020|000e\", SeriesInstanceUID), \n (\"0008|0050\", acc),\n (\"0020|000d\", StudyInstanceUID)] \n\n os.makedirs(save_dir, exist_ok = True)\n\n #for nifti, the main axis is the first one, while for dicoms it is the last one\n for i in range(ref_image.GetDepth()):\n #zoom 2 times, todo need to figure out which axis to zoom, post is the 3rd\n #pre assume the first axis is the slice numbers\n bk_slice = ndimage.zoom(bk_image[i,:,:], zoom_num, order=0)\n seg_slice = ndimage.zoom(seg_image[i,:,:], zoom_num, order=0)\n \n #Due to the DICOM saving coordinate system is different with nifti,i.e mirrored, it is easier to flip array\n bk_slice = np.flip(bk_slice, (0, 1)) \n seg_slice = np.flip(seg_slice, (0, 1)) \n\n #get contours\n seg_idx = get_contours(seg_slice)\n \n #add watermarks\n if watermarks:\n canvas_tmp = np.zeros(list(bk_slice.shape), dtype=np.uint8)\n font = cv2.FONT_HERSHEY_PLAIN\n cv2.putText(canvas_tmp,'FOR RESEARCH ONLY;REFER TO OFFICIAL REPORT FOR DETAILS',(10,30), \n font,2,255,1)\n cv2.putText(canvas_tmp,'(This tool is intended for evaluation of gliomas, and results may be unreliable for other pathologies)',(90,50), \n font,1,255,1) \n #add Legend and volumes \n cv2.putText(canvas_tmp, 'Legend Volume(+/-95% CI)',(10,900), font,0.8,255,1)\n cv2.putText(canvas_tmp, f'Edema {v_edema}+/-{ci_edema} mL',(30,920), font,0.8,255,1)\n cv2.putText(canvas_tmp, f'Enhancing {v_enhancing}+/-{ci_enhancing} mL',(30,940), font,0.8,255,1)\n cv2.putText(canvas_tmp, f'Non- {v_nonenhancing}+/-{ci_nonenhancing} mL',(30,960), font,0.8,255,1)\n cv2.putText(canvas_tmp,'Enhancing', (30,975), font,0.8,255,1)\n cv2.putText(canvas_tmp,'(The error is based on testing of algorithm performance vs. manual segmentation)', (150,1000), font,1,255,1)\n\n \n \n #burning segmentation contour into slices\n cv2.line(seg_idx, (10,915), (20,915), 2, 2)\n cv2.line(seg_idx, (10,935), (20,935), 4, 2)\n cv2.line(seg_idx, (10,955), (20,955), 1, 2)\n \n if mode_RGB:\n #burning the watermarks\n bk_slice[canvas_tmp==255]=bk_slice.max()\n #convert dicom from nomogram to RGB\n bk_slice = toRGB(bk_slice)\n #colorize the bk_slice according to seg_idx\n bk_slice[0,:,:,0][seg_idx==1] = 255\n bk_slice[0,:,:,1][seg_idx==4] = 255\n bk_slice[0,:,:,2][seg_idx==2] = 255 \n else:\n #grey the ori_image_slice according to seg_idx\n bk_slice[canvas_tmp==255]=bk_slice.max()//2\n bk_slice[seg_idx==1] = bk_slice.max()*2//50\n bk_slice[seg_idx==2] = bk_slice.max()*1//50\n bk_slice[seg_idx==4] = bk_slice.max()*3//50\n\n converted_slice = sitk.GetImageFromArray(bk_slice)\n reader.SetFileName(series_file_names[i])\n reader.ReadImageInformation()\n spacing_new = [i/zoom_num for i in reader.GetSpacing()[:-1]] + [reader.GetSpacing()[-1]]\n \n #generate SOPInstanceUID\n SOPInstanceUID = generateUID(org_root=ORG_ROOT)\n series_tag_values = [(k, reader.GetMetaData(k)) for k in reader.GetMetaDataKeys()] + customized_tag_values + [(\"0008|0018\", SOPInstanceUID)]\n# print(series_tag_values)\n if '_seg_' in description:\n converted_slice = converted_slice \n \n # Tags shared by the series.\n for tag, value in series_tag_values:\n converted_slice.SetMetaData(tag, value)\n \n # especially set spacing tags\n # Image Position (Patient)\n converted_slice.SetMetaData(\"0020|0013\", str(i)) # Instance Number\n converted_slice.SetSpacing(spacing_new)\n \n # Write to the output directory and add the extension dcm, to force writing in DICOM format \n writer.SetFileName(os.path.join(save_dir, str(i)+'.dcm'))\n writer.Execute(converted_slice)","def needleSegmentationCLIDEMO(self):\n #research\n profbox()\n widget = slicer.modules.NeedleFinderWidget\n scene = slicer.mrmlScene\n pNode = self.parameterNode()\n if slicer.mrmlScene.GetNodeByID(pNode.GetParameter(\"baselineVolumeID\")) == None:\n inputVolume = self.__volumeSelector.currentNode()\n inputVolumeID = self.__volumeSelector.currentNode().GetID()\n else:\n inputVolume = slicer.mrmlScene.GetNodeByID(pNode.GetParameter(\"baselineVolumeID\"))\n inputVolumeID = slicer.mrmlScene.GetNodeByID(pNode.GetParameter(\"baselineVolumeID\")).GetID()\n inputLabelID = self.__needleLabelSelector.currentNode().GetID()\n \n datetime = time.strftime(\"%Y-%m-%d-%H_%M_%S\", time.localtime())\n \n inputVolume.SetAttribute(\"foldername\",datetime)\n self.outputVolumeNode = slicer.mrmlScene.CreateNodeByClass('vtkMRMLModelNode')\n self.outputVolumeNode.SetName(\"Output Needle Model\")\n outputVolumeStorageNode = slicer.mrmlScene.CreateNodeByClass('vtkMRMLModelStorageNode')\n slicer.mrmlScene.AddNode(self.outputVolumeNode)\n slicer.mrmlScene.AddNode(outputVolumeStorageNode)\n self.outputVolumeNode.AddAndObserveStorageNodeID(outputVolumeStorageNode.GetID())\n outputVolumeStorageNode.WriteData(self.outputVolumeNode)\n \n outputID = self.outputVolumeNode.GetID()\n \n self.foldername = '/NeedleModels/' + datetime\n \n # Set the parameters for the CLI module \n parameters = {} \n parameters['inputVolume'] = inputVolumeID\n parameters['inputLabel'] = inputLabelID\n parameters['outputVtk'] = outputID\n parameters['outputFolderName'] = self.foldername\n parameters['nbPointsPerLine'] = self.nbPointsPerLine.value\n parameters['nbRadiusIterations'] = self.nbRadiusIterations.value\n parameters['distanceMax'] = self.distanceMax.value\n parameters['numberOfPointsPerNeedle'] = self.numberOfPointsPerNeedle.value\n parameters['nbRotatingIterations'] = self.nbRotatingIterations.value\n \n module = slicer.modules.mainlabelneedletrackingcli \n self.__cliNode = None\n self.__cliNode = slicer.cli.run(module, None, parameters, wait_for_completion=True)\n \n ##### match the needles ######\n\n self.setNeedleCoordinates()\n self.computerPolydataAndMatrix()\n xmin = min(self.p[0])\n xmax = max(self.p[0])\n ymin = min(self.p[1])\n ymax = max(self.p[1])\n xdelta = xmax - xmin\n ydelta = ymax - ymin\n k = 0\n\n self.base = [[0 for j in range(3)] for j in range(63)]\n self.tip = [[0 for j in range(3)] for j in range(63)]\n self.needlenode = [[0 for j in range(2)] for j in range(63)]\n self.bentNeedleNode = [[0 for j in range(2)] for j in range(63)]\n self.displaynode = [0 for j in range(63)]\n self.displaynodeB = [0 for j in range(63)]\n self.fiducialnode = [0 for j in range(63)]\n \n for i in xrange(63):\n\n pathneedle = self.foldername+'/'+str(i)+'.vtp'\n pathBentNeedle = self.foldername+'/'+str(i)+'_bent.vtp'\n self.needlenode[i] = slicer.util.loadModel(pathneedle, True)\n self.bentNeedleNode[i] = slicer.util.loadModel(pathBentNeedle, True)\n\n if self.needlenode[i][0] == True and self.needlenode[i][1] != None:\n self.displaynode[i] = self.needlenode[i][1].GetDisplayNode()\n self.displaynodeB[i] = self.bentNeedleNode[i][1].GetDisplayNode()\n\n \n polydata = self.needlenode[i][1].GetPolyData()\n polydata.GetPoint(0,self.base[i]) \n \n self.displaynode[i].SliceIntersectionVisibilityOn()\n self.displaynodeB[i].SliceIntersectionVisibilityOn()\n bestmatch = None\n mindist = None\n for j in xrange(63):\n delta = ((self.p[0][j]-(self.base[i][0]))**2+(self.p[1][j]-self.base[i][1])**2)**(0.5)\n if delta < mindist or mindist == None:\n bestmatch = j\n mindist = delta\n \n bestmatch = k\n k += 1\n self.displaynode[i].SetColor(self.color[bestmatch])\n self.displaynodeB[i].SetColor(self.color[bestmatch])\n self.needlenode[i][1].SetName(self.option[bestmatch]+\"_segmented\")\n self.bentNeedleNode[i][1].SetName(self.option[bestmatch]+\"_optimized\")\n self.needlenode[i][1].SetAttribute(\"segmented\",\"1\")\n self.bentNeedleNode[i][1].SetAttribute(\"optimized\",\"1\")\n self.needlenode[i][1].SetAttribute(\"nth\",str(bestmatch))\n self.bentNeedleNode[i][1].SetAttribute(\"nth\",str(bestmatch))\n self.needlenode[i][1].SetAttribute(\"needleID\",self.needlenode[i][1].GetID())\n self.bentNeedleNode[i][1].SetAttribute(\"needleID\",self.bentNeedleNode[i][1].GetID())\n \n if widget.removeDuplicates.isChecked():\n self.positionFilteringNeedles()\n\n d = slicer.mrmlScene.GetNodeByID(outputID).GetDisplayNode()\n d.SetVisibility(0)\n \n self.__editorFrame.collapsed = 1\n \n self.addButtons()","def create_slice_labels(dataset, base_task_name, slice_name, verbose=False):\n # TODO: break this out into more modular pieces oncee we have multiple slices\n slice_fn = globals()[slice_name]\n slice_indicators = torch.tensor(\n [slice_fn(dataset, idx) for idx in range(len(dataset))], dtype=torch.uint8\n ).view(-1, 1)\n\n Y_base = dataset.labels[f\"{base_task_name}_gold\"]\n Y_slice = Y_base.clone().masked_fill_(slice_indicators == 0, 0)\n\n if verbose:\n if not any(Y_slice):\n warnings.warn(f\"No examples were found to belong to slice {slice_name}\")\n else:\n print(f\"Found {sum(slice_indicators)} examples in slice {slice_name}.\")\n\n # NOTE: we assume here that all slice labels are for sentence-level tasks only\n return Y_slice","def __do_split_haghverdi16(self, Dseg, tips):\n # sort distance from first tip point\n # then the sequence of distances Dseg[tips[0]][idcs] increases\n idcs = np.argsort(Dseg[tips[0]])\n # consider now the sequence of distances from the other\n # two tip points, which only increase when being close to `tips[0]`\n # where they become correlated\n # at the point where this happens, we define a branching point\n if True:\n imax = self.kendall_tau_split(Dseg[tips[1]][idcs],\n Dseg[tips[2]][idcs])\n if False:\n # if we were in euclidian space, the following should work\n # as well, but here, it doesn't because the scales in Dseg are\n # highly different, one would need to write the following equation\n # in terms of an ordering, such as exploited by the kendall\n # correlation method above\n imax = np.argmin(Dseg[tips[0]][idcs]\n + Dseg[tips[1]][idcs]\n + Dseg[tips[2]][idcs])\n # init list to store new segments\n ssegs = []\n # first new segment: all points until, but excluding the branching point\n # increasing the following slightly from imax is a more conservative choice\n # as the criterion based on normalized distances, which follows below,\n # is less stable\n ibranch = imax + 2 # this used to be imax + 1!\n # ibranch = int(0.95 * imax)\n return idcs[:ibranch]\n # ssegs.append(idcs[:ibranch])\n # TODO get rid of the following heuristics\n # define nomalized distances to tip points for the rest of the data\n # dist1 = Dseg[tips[1], idcs[ibranch:]] / Dseg[tips[1], idcs[ibranch-1]]\n # dist2 = Dseg[tips[2], idcs[ibranch:]] / Dseg[tips[2], idcs[ibranch-1]]\n # assign points according to whether being closer to tip cell 1 or 2\n # ssegs.append(idcs[ibranch:][dist1 <= dist2])\n # ssegs.append(idcs[ibranch:][dist1 > dist2])\n # return ssegs","def Problem11():\n return 'Ductile Coulomb-Mohr'","def ANN_binned_tagged_jets_hist(datalist, model, discriminant_cuts, CSV_cuts, bins, nbins, mode=\"pT_jet\",Save=False,addFeature=False):\n title = \"binned_tagged_jets_vs_\"+mode\n\tdiscriminant = \"ANN\"\n AllJetsHistlist = []\n CSVHistlist = []\n DiscriminantHistlist = []\n if mode == \"pT_hadron\":\n feature = 2\n elif mode == \"pT_jet\":\n feature = 3\n elif mode == \"decay_vx\":\n feature = 4\n for n,data in enumerate(datalist):\n\t\tdatatitle = data[3]\n print \"working on\",datatitle\n ran = data[4]\n\t\tCSV = data[2]\n\t\tpT = data[1]\n\t\tx_data = data[0]\n AllJetsHistlist.append(rt.TH1D(datatitle+\"_AllJets\",datatitle+\"_\"+title,nbins,ran[0],ran[1]))\n AllJetsHistlist[n].SetLineColor(4)\n CSVHistlist.append(rt.TH1D(datatitle+\"_CSV\",datatitle+\"_\"+title,nbins,ran[0],ran[1]))\n CSVHistlist[n].SetLineColor(3)\n DiscriminantHistlist.append(rt.TH1D(datatitle+\"_Discriminant\",datatitle+\"_\"+title,nbins,ran[0],ran[1]))\n DiscriminantHistlist[n].SetLineColor(2)\n\t\n\t\tif addFeature == False:\n\t\t\tpred_y = model.predict(ANN_functional_shape(x_data))\n\t\telif addFeature == \"pT\":\n\t\t\tpred_y = model.predict(ANN_functional_shape(x_data)+[pT/200])\n\t\telif addFeature == \"PV\":\n\t\t\tassert x_data.shape[1] == 21, \"wrong x_data format: PV cannot be found\"\n\t\t\tpred_y = model.predict(ANN_functional_shape(x_data)+[x_data[:,-1]/10.])\n\t\telse:\n\t\t\tprint \"invalid feature input\"\n\t\t\treturn None\n\t\tbin_numbers = ANN_bin_selection(pT,bins)\n\n\t for i,pT_value in enumerate(pT):\n\t if bin_numbers[i] == -100: continue\n\t\t\tAllJetsHistlist[n].Fill(pT_value)\n\t if pred_y[i] >= discriminant_cuts[bin_numbers[i]]: DiscriminantHistlist[n].Fill(pT_value)\n\t if CSV[i] >= CSV_cuts[bin_numbers[i]]: CSVHistlist[n].Fill(pT_value)\n\n canvaslist = []\n legendlist = []\n Tfilelist = []\n for n,data in enumerate(datalist):\n\t\tdatatitle = data[3]\n canvaslist.append(rt.TCanvas(datatitle+\"_canvas\",\"canvas\",600,600))\n canvaslist[n].SetTitle(datatitle+\"_\"+title)\n rt.gStyle.SetOptStat(0)\n legendlist.append(rt.TLegend(0.9,0.9,0.65,0.75))\n legendlist[n].AddEntry(AllJetsHistlist[n], \"All jets\")\n legendlist[n].AddEntry(CSVHistlist[n], \"CSV\")\n legendlist[n].AddEntry(DiscriminantHistlist[n], discriminant)\n AllJetsHistlist[n].GetXaxis().SetTitle(mode)\n AllJetsHistlist[n].GetYaxis().SetTitle('# jets')\n AllJetsHistlist[n].GetYaxis().SetTitleOffset(1.5)\n #AllJetsHistlist[n].Draw()\n #CSVHistlist[n].Draw(\"SAME\")\n #DiscriminantHistlist[n].Draw(\"SAME\")\n #legendlist[n].Draw()\n if Save:\n #canvaslist[n].SaveAs(title+\"_\"+datatitle+discriminant+\".png\")\n Tfilelist.append(rt.TFile(\"Thesis_Plots/root_files/\"+title+\"_\"+datatitle+discriminant+\".root\",\"recreate\"))\n print \"saved histogram as Thesis_Plots/root_files/\"+title+\"_\"+datatitle+discriminant+\".root\"\n AllJetsHistlist[n].Write()\n CSVHistlist[n].Write()\n DiscriminantHistlist[n].Write()","def mask_label_contour(image, seg):\n return sitk.Mask(image, sitk.LabelContour(seg+1)==0)","def adjust_labels(data_y, label):\n\n if label == 'locomotion': # Labels for locomotion are adjusted\n data_y[data_y == 4] = 3\n data_y[data_y == 5] = 4\n elif label == 'gestures': # Labels for gestures are adjusted\n data_y[data_y == 406516] = 1\n data_y[data_y == 406517] = 2\n data_y[data_y == 404516] = 3\n data_y[data_y == 404517] = 4\n data_y[data_y == 406520] = 5\n data_y[data_y == 404520] = 6\n data_y[data_y == 406505] = 7\n data_y[data_y == 404505] = 8\n data_y[data_y == 406519] = 9\n data_y[data_y == 404519] = 10\n data_y[data_y == 406511] = 11\n data_y[data_y == 404511] = 12\n data_y[data_y == 406508] = 13\n data_y[data_y == 404508] = 14\n data_y[data_y == 408512] = 15\n data_y[data_y == 407521] = 16\n data_y[data_y == 405506] = 17\n return data_y","def GetDatumLabels(self, *args):\n return _XCAFDoc.XCAFDoc_DimTolTool_GetDatumLabels(self, *args)","def get_labels(self):\r\n return [\"X\", \"O\", \"B-a\", \"I-a\", \"B-b\", \"I-b\", \"B-c\", \"I-c\", \"S-a\", \"S-b\", \"S-c\", \"[CLS]\", \"[SEP]\"]","def _labels_of_sentence(self, sentence, split):\n labels = torch.ones(1)\n labels[0] = self.category_int_of_label_string(sentence[0][self.name_to_index_dict['label']]) #\n return labels","def _get_label(self):\n if self.model.name == '':\n return \"KPI\"\n return \"KPI: {} ({})\".format(self.model.name, self.model.objective)","def get_labels(self):\n return [\"A轮\", \"B轮\",\"C轮\",\"天使轮\",\"战略融资\"]","def GetDatumTolerLabels(self, *args):\n return _XCAFDoc.XCAFDoc_DimTolTool_GetDatumTolerLabels(self, *args)","def test_get_dim_label_with_index(self):\n\n dim = self.oecd_datasets['oecd']['dimension']['id'][2]\n dims_df = pyjstat.get_dim_label(self.oecd_datasets['oecd'], dim)\n self.assertTrue(dims_df.iloc[0]['id'] == '2003')\n self.assertTrue(dims_df.iloc[-1]['label'] == '2014')","def addFid(data, Dim=.5, nodName=\"N\", lableName=\"1\", color=\"red\", GlyphType=1):\n\t\txyz = tuple(data)\n\t\ttipFiducial = slicer.mrmlScene.AddNode(slicer.vtkMRMLMarkupsFiducialNode())\n\t\ttipFiducial.SetName(nodName)\n\t\ttipFiducial.AddFiducial(xyz[0], xyz[1], xyz[2])\n\t\ttipFiducial.SetNthFiducialLabel(0, lableName)\n\t\tslicer.mrmlScene.AddNode(tipFiducial)\n\t\ttipFiducial.SetDisplayVisibility(True)\n\t\ttipFiducial.GetDisplayNode().SetGlyphType(GlyphType) # Vertex2D\n\t\ttipFiducial.GetDisplayNode().SetGlyphScale(Dim * 10)\n\t\ttipFiducial.GetDisplayNode().SetTextScale(3)\n\t\ttipFiducial.GetDisplayNode().SetSelectedColor(Helper.myColor(color))\n\t\t'''\tGlyphShapes {\n GlyphTypeInvalid = 0, 1-StarBurst2D, 2-Cross2D, 3-CrossDot2D,\n 4-ThickCross2D, 5-Dash2D, 6-Sphere3D, 7-Vertex2D,\n 8-Circle2D,9-Triangle2D, 10-Square2D, Diamond2D,\n Arrow2D, ThickArrow2D, HookedArrow2D, GlyphType_Last\n }'''","def label_for(self, *pp, unit=True, description=True):\n if len(pp) > 1 and np.all([re.match(r\"k\\d+l\", p) for p in pp]):\n label = \"$k_nl$\"\n if unit:\n label += \" / $m^{-n}$\"\n return label\n return super().label_for(*pp, unit=unit, description=description)","def make_label(self, label, units):\n nice_label = self.tex_axis_label(label)\n if not (units == 'dimensionless') and \\\n (units is not None) and (not units == []):\n nice_label += ' (%s)'%self.tex_axis_label(units)\n return nice_label","def kaons ( self ) :\n from GaudiConfUtils.ConfigurableGenerators import FilterDesktop\n ## \n if self['NOPIDHADRONS'] :\n from StandardParticles import StdAllNoPIDsKaons as inpts\n kaoncut = self['KaonCut']\n else :\n from StandardParticles import StdAllLooseANNKaons as inpts \n kaoncut = \"(%s)&(%s)\" % ( self['KaonCut'] , self['KaonPIDCut'] ) \n #\n ##\n return self.make_selection (\n 'Kaon' ,\n FilterDesktop ,\n [ inpts ] ,\n Code = kaoncut ,\n )","def classify_defect_clusters_modifier(frame, data):\n\n if data.particles.count == 0:\n # No particles there to classify, create empty properties anyway\n data.particles_.create_property('Si_V', dtype=int, components=1)\n data.particles_.create_property('Si_I', dtype=int, components=1)\n data.particles_.create_property('Si_C', dtype=int, components=1)\n data.particles_.create_property('C_V', dtype=int, components=1)\n data.particles_.create_property('C_I', dtype=int, components=1)\n data.particles_.create_property('C_Si', dtype=int, components=1)\n return\n\n # TODO Create numpy arrays containing the number of Si vacancies,\n # interstitials, etc for each particle site in `data.particles`. These\n # next lines are just placeholders!\n si_vacancy = data.particles[\"vacancy_mask\"][...] * data.particles[\"Is Si Site\"][...]\n si_interstitial = (data.particles[\"Is Si Site\"][...] & (data.particles[\"Si Occupancy\"][...] > 1)) * (\n data.particles[\"Si Occupancy\"][...] - 1) + (\n (data.particles[\"Is C Site\"][...]) * data.particles[\"Si Occupancy\"][...]) - (\n data.particles[\"Is C Site\"][...] & data.particles[\"antisite_mask\"][...])\n si_antisite = data.particles[\"antisite_mask\"][...] * data.particles[\"Is Si Site\"][...]\n c_vacancy = data.particles[\"vacancy_mask\"][...] * data.particles[\"Is C Site\"][...]\n c_interstitial = (data.particles[\"Is C Site\"][...] & (data.particles[\"C Occupancy\"][...] > 1)) * (\n data.particles[\"C Occupancy\"][...] - 1) + (\n (data.particles[\"Is Si Site\"][...]) * data.particles[\"C Occupancy\"][...]) - (\n data.particles[\"Is Si Site\"][...] & data.particles[\"antisite_mask\"][...])\n c_antisite = data.particles[\"antisite_mask\"][...] * data.particles[\"Is C Site\"][...]\n\n\n data.particles_.create_property('Si_V', data=si_vacancy.astype(int))\n data.particles_.create_property('Si_I', data=si_interstitial.astype(int))\n data.particles_.create_property('Si_C', data=si_antisite.astype(int))\n data.particles_.create_property('C_V', data=c_vacancy.astype(int))\n data.particles_.create_property('C_I', data=c_interstitial.astype(int))\n data.particles_.create_property('C_Si', data=c_antisite.astype(int))","def _label_commuter_rail_rider(self, rider):\n if (rider['servicebrand_Commuter Rail'] > 0) and (rider['zonecr_1a'] == 0):\n label = 'CR except zone 1A'\n else:\n label = 'others'\n return label","def showOneNeedle(self, i, visibility):\r\n # obsolete\r\n profbox()\r\n fidname = \"fid\" + self.option[i]\r\n pNode = self.parameterNode()\r\n needleID = pNode.GetParameter(self.option[i] + '.vtp')\r\n fidID = pNode.GetParameter(fidname)\r\n NeedleNode = slicer.mrmlScene.GetNodeByID(needleID)\r\n fiducialNode = slicer.mrmlScene.GetNodeByID(fidID)\r\n\r\n if NeedleNode != None:\r\n displayNode = NeedleNode.GetModelDisplayNode()\r\n nVisibility = displayNode.GetVisibility()\r\n\r\n if fiducialNode == None:\r\n displayNode.SetVisibility(1)\r\n displayNode.SetOpacity(0.9)\r\n polyData = NeedleNode.GetPolyData()\r\n polyData.Update()\r\n nb = int(polyData.GetNumberOfPoints() - 1)\r\n coord = [0, 0, 0]\r\n if nb > 100:\r\n fiducialNode = slicer.vtkMRMLAnnotationFiducialNode()\r\n polyData.GetPoint(nb, coord)\r\n fiducialNode.SetName(self.option[i])\r\n fiducialNode.SetFiducialCoordinates(coord)\r\n fiducialNode.Initialize(slicer.mrmlScene)\r\n fiducialNode.SetLocked(1)\r\n fiducialNode.SetSelectable(0)\r\n fidDN = fiducialNode.GetDisplayNode()\r\n fidDN.SetColor(NeedleNode.GetDisplayNode().GetColor())\r\n fidDN.SetGlyphScale(0)\r\n fidTN = fiducialNode.GetAnnotationTextDisplayNode()\r\n fidTN.SetTextScale(3)\r\n fidTN.SetColor(NeedleNode.GetDisplayNode().GetColor())\r\n fiducialNode.SetDisplayVisibility(0)\r\n pNode.SetParameter(fidname, fiducialNode.GetID())\r\n fiducialNode.SetDisplayVisibility(1)\r\n\r\n if visibility == 0:\r\n\r\n displayNode.SetVisibility(0)\r\n displayNode.SetSliceIntersectionVisibility(0)\r\n if fiducialNode != None:\r\n fiducialNode.SetDisplayVisibility(0)\r\n\r\n else:\r\n\r\n displayNode.SetVisibility(1)\r\n displayNode.SetSliceIntersectionVisibility(1)\r\n if fiducialNode != None:\r\n fiducialNode.SetDisplayVisibility(1)\r\n\r\n else:\r\n vtkmat = vtk.vtkMatrix4x4()\r\n vtkmat.DeepCopy(self.m_vtkmat)\r\n vtkmat.SetElement(0, 3, self.m_vtkmat.GetElement(0, 3) + self.p[0][i])\r\n vtkmat.SetElement(1, 3, self.m_vtkmat.GetElement(1, 3) + self.p[1][i])\r\n vtkmat.SetElement(2, 3, self.m_vtkmat.GetElement(2, 3) + (30.0 - 150.0) / 2.0)\r\n\r\n TransformPolyDataFilter = vtk.vtkTransformPolyDataFilter()\r\n Transform = vtk.vtkTransform()\r\n TransformPolyDataFilter.SetInput(self.m_polyCylinder)\r\n Transform.SetMatrix(vtkmat)\r\n TransformPolyDataFilter.SetTransform(Transform)\r\n TransformPolyDataFilter.Update()\r\n\r\n triangles = vtk.vtkTriangleFilter()\r\n triangles.SetInput(TransformPolyDataFilter.GetOutput())\r\n self.AddModel(i, triangles.GetOutput())\r\n self.showOneNeedle(i, visibility)","def cvpr2018_labels():\n\n return {\n 0: 'others',\n 33: 'car',\n 34: 'motorcycle',\n 35: 'bicycle',\n 36: 'pedestrian',\n 38: 'truck',\n 39: 'bus',\n 40: 'tricycle'\n }","def syed_dilation(data, vessel):","def _compute_labels(self, element, data, mapping):\n lidx = element.nodes.get_dimension(self.label_index)\n if element.vdims:\n edges = Dataset(element)[element[element.vdims[0].name]>0]\n nodes = list(np.unique([edges.dimension_values(i) for i in range(2)]))\n nodes = element.nodes.select(**{element.nodes.kdims[2].name: nodes})\n else:\n nodes = element\n\n value_dim = element.vdims[0]\n labels = [lidx.pprint_value(v) for v in nodes.dimension_values(lidx)]\n if self.show_values:\n value_labels = []\n for i, node in enumerate(element._sankey['nodes']):\n value = value_dim.pprint_value(node['value'])\n label = '%s - %s' % (labels[i], value)\n if value_dim.unit:\n label += ' %s' % value_dim.unit\n value_labels.append(label)\n labels = value_labels\n\n ys = nodes.dimension_values(1)\n nodes = element._sankey['nodes']\n offset = (nodes[0]['x1']-nodes[0]['x0'])/4.\n if self.label_position == 'right':\n xs = np.array([node['x1'] for node in nodes])+offset\n else:\n xs = np.array([node['x0'] for node in nodes])-offset\n data['text_1'] = dict(x=xs, y=ys, text=[str(l) for l in labels])\n align = 'left' if self.label_position == 'right' else 'right'\n mapping['text_1'] = dict(text='text', x='x', y='y', text_baseline='middle', text_align=align)","def chainDict2jetLabel(chain_dict):\n\n # suported scenarios \n router = {\n 'simple': _make_simple_label,\n 'HT': _make_ht_label,\n 'vbenf': _make_vbenf_label,\n 'dijet': _make_dijet_label,\n 'combinationsTest': _make_combinationsTest_label,\n 'partitionsTest': _make_partitionsTest_label,\n }\n\n # chain_part - scenario association\n cp_sorter = {}\n for k in router: cp_sorter[k] = []\n\n for cp in chain_dict['chainParts']:\n if cp['signature'] != 'Jet' and cp['signature'] != 'Bjet': \n continue\n for k in cp_sorter:\n if cp['hypoScenario'].startswith(k):\n cp_sorter[k].append(cp)\n break\n\n # obtain labels by scenario.\n labels = []\n for k, chain_parts in cp_sorter.items():\n if chain_parts: labels.append(router[k](chain_parts))\n\n assert labels\n nlabels = len(labels)\n if nlabels == 1: return labels[0]\n if nlabels == 2:\n alabel = \"\"\"\\\nand([]\n %s\n %s)\"\"\" % (tuple(labels))\n return alabel\n\n # more than 2 labels is not expected\n assert False","def get_diar_target_labels(self, uniq_id, sample, fr_level_target):\n seg_target_list, base_clus_label = [], []\n self.scale_n = len(self.multiscale_timestamp_dict[uniq_id]['scale_dict'])\n subseg_time_stamp_list = self.multiscale_timestamp_dict[uniq_id][\"scale_dict\"][self.scale_n - 1][\"time_stamps\"]\n for (seg_stt, seg_end) in subseg_time_stamp_list:\n seg_stt_fr, seg_end_fr = int(seg_stt * self.frame_per_sec), int(seg_end * self.frame_per_sec)\n soft_label_vec_sess = torch.sum(fr_level_target[seg_stt_fr:seg_end_fr, :], axis=0) / (\n seg_end_fr - seg_stt_fr\n )\n label_int_sess = torch.argmax(soft_label_vec_sess)\n soft_label_vec = soft_label_vec_sess.unsqueeze(0)[:, sample.target_spks].squeeze()\n if label_int_sess in sample.target_spks and torch.sum(soft_label_vec_sess) > 0:\n label_int = sample.target_spks.index(label_int_sess)\n else:\n label_int = -1\n label_vec = (soft_label_vec > self.soft_label_thres).float()\n seg_target_list.append(label_vec.detach())\n base_clus_label.append(label_int)\n seg_target = torch.stack(seg_target_list)\n base_clus_label = torch.tensor(base_clus_label)\n return seg_target, base_clus_label","def onCut(self):\n pass","def autolabel(X_pos,values,height_lift):\r\n\theight= np.round(np.nan_to_num(values),2);y_pos = height_lift*height\r\n\tfor i in range(len(height)):\r\n\t\tax.text(X_pos[i],y_pos[i],'%4.2f' % height[i], ha='center', va='bottom',size=4)","def labels(self):\n\n param=self\n\n l=len(param)\n\n sweep_label=[]\n\n for index,name in enumerate(param.names):\n\n sweep_label.append((\\\n ''.join([c for c in name if c.isupper()]))\\\n .replace(\"IDT\",\"\")\\\n .replace(\"S\",\"\")\\\n .replace(\"M\",\"\"))\n\n stringout=[]\n\n unique={name:list(dict.fromkeys(values)) for name,values in zip(param.names,param.values)}\n\n for i in range(l):\n\n tmp_lab=''\n\n for lab,name in zip(sweep_label,self.names):\n\n tmp_lab=tmp_lab+lab+str(unique[name].index(param()[name][i]))\n\n stringout.append(tmp_lab)\n\n return stringout","def _change_name(self, suff, info_extra):\n if 'cable-ring' in self.path:\n i1 = info_extra['convex_hull_area']\n i2 = info_extra['best_possible_area']\n f = i1 / i2\n suff = suff.replace('.png',\n f'-area-{i1:0.3f}-best-{i2:0.3f}-FRAC-{f:0.3f}.png')\n elif 'cloth-flat' in self.path:\n i1 = info_extra['cloth_coverage']\n suff = suff.replace('.png', f'-coverage-{i1:0.3f}.png')\n elif 'bag-alone' in self.path:\n i1 = info_extra['convex_hull_area']\n i2 = info_extra['best_possible_area']\n suff = suff.replace('.png', f'-area-{i1:0.3f}-best-{i2:0.3f}.png')\n else:\n pass\n return suff","def Label(self) -> str:","def setPieLabels(label, position):\n pdict = {'left':'LEFT', 'right':'RIGHT'}\n dislin.pielab(label, pdict[position])","def test_reneaming_old_default_labels_to_new_fixed_labels():\n from dtscalibration import DataStore\n\n cable_len = 100.0\n nt = 3\n time = np.arange(nt)\n x = np.linspace(0.0, cable_len, 8)\n ts_cold = np.ones(nt) * 4.0 + np.cos(time) * 4\n ts_warm = np.ones(nt) * 20.0 + -np.sin(time) * 4\n\n C_p = 1324 # 1/2 * E0 * v * K_+/lam_+^4\n eta_pf = np.cos(time) / 10 + 1 # eta_+ (gain factor forward channel)\n eta_pb = np.sin(time) / 10 + 1 # eta_- (gain factor backward channel)\n C_m = 5000.0\n eta_mf = np.cos(time + np.pi / 8) / 10 + 1\n eta_mb = np.sin(time + np.pi / 8) / 10 + 1\n dalpha_r = 0.005284\n dalpha_m = 0.004961\n dalpha_p = 0.005607\n gamma = 482.6\n\n temp_real_kelvin = np.zeros((len(x), nt)) + 273.15\n temp_real_kelvin[x < 0.2 * cable_len] += ts_cold[None]\n temp_real_kelvin[x > 0.85 * cable_len] += ts_warm[None]\n temp_real_celsius = temp_real_kelvin - 273.15\n\n st = (\n eta_pf[None]\n * C_p\n * np.exp(-dalpha_r * x[:, None])\n * np.exp(-dalpha_p * x[:, None])\n * np.exp(gamma / temp_real_kelvin)\n / (np.exp(gamma / temp_real_kelvin) - 1)\n )\n ast = (\n eta_mf[None]\n * C_m\n * np.exp(-dalpha_r * x[:, None])\n * np.exp(-dalpha_m * x[:, None])\n / (np.exp(gamma / temp_real_kelvin) - 1)\n )\n rst = (\n eta_pb[None]\n * C_p\n * np.exp(-dalpha_r * (-x[:, None] + cable_len))\n * np.exp(-dalpha_p * (-x[:, None] + cable_len))\n * np.exp(gamma / temp_real_kelvin)\n / (np.exp(gamma / temp_real_kelvin) - 1)\n )\n rast = (\n eta_mb[None]\n * C_m\n * np.exp(-dalpha_r * (-x[:, None] + cable_len))\n * np.exp(-dalpha_m * (-x[:, None] + cable_len))\n / (np.exp(gamma / temp_real_kelvin) - 1)\n )\n\n c_f = np.log(eta_mf * C_m / (eta_pf * C_p))\n c_b = np.log(eta_mb * C_m / (eta_pb * C_p))\n\n dalpha = dalpha_p - dalpha_m # \\Delta\\alpha\n alpha_int = cable_len * dalpha\n\n df = c_f # reference section starts at first x-index\n db = c_b + alpha_int\n i_fw = np.log(st / ast)\n i_bw = np.log(rst / rast)\n\n E_real = (i_bw - i_fw) / 2 + (db - df) / 2\n\n ds = DataStore(\n {\n \"ST\": ([\"x\", \"time\"], st),\n \"AST\": ([\"x\", \"time\"], ast),\n \"REV-ST\": ([\"x\", \"time\"], rst),\n \"REV-AST\": ([\"x\", \"time\"], rast),\n \"userAcquisitionTimeFW\": ([\"time\"], np.ones(nt)),\n \"userAcquisitionTimeBW\": ([\"time\"], np.ones(nt)),\n \"cold\": ([\"time\"], ts_cold),\n \"warm\": ([\"time\"], ts_warm),\n },\n coords={\"x\": x, \"time\": time},\n attrs={\"isDoubleEnded\": \"1\"},\n )\n ds = ds.rename_labels()\n\n sections = {\n \"cold\": [slice(0.0, 0.09 * cable_len)],\n \"warm\": [slice(0.9 * cable_len, cable_len)],\n }\n\n real_ans2 = np.concatenate(([gamma], df, db, E_real[:, 0]))\n\n ds.calibration_double_ended(\n sections=sections,\n st_var=1.5,\n ast_var=1.5,\n rst_var=1.0,\n rast_var=1.0,\n method=\"wls\",\n solver=\"sparse\",\n fix_gamma=(gamma, 0.0),\n )\n\n assert_almost_equal_verbose(df, ds.df.values, decimal=14)\n assert_almost_equal_verbose(db, ds.db.values, decimal=13)\n assert_almost_equal_verbose(\n x * (dalpha_p - dalpha_m), ds.alpha.values - ds.alpha.values[0], decimal=13\n )\n assert np.all(np.abs(real_ans2 - ds.p_val.values) < 1e-10)\n assert_almost_equal_verbose(temp_real_celsius, ds.tmpf.values, decimal=10)\n assert_almost_equal_verbose(temp_real_celsius, ds.tmpb.values, decimal=10)\n assert_almost_equal_verbose(temp_real_celsius, ds.tmpw.values, decimal=10)\n pass","def autolabel(rects,array,axis,dist):\n ctr = 0\n label_array = [EM.truncate(v*100,1) for v in array]\n for entry in range(len(label_array)):\n if(label_array[entry]>=0) and (label_array[entry]<=1):\n label_array[entry] = EM.truncate(array[entry]*100,2)\n\n\n for rect in rects:\n height = rect.get_height()\n if(axis=='1'):\n ax1.text(rect.get_x() + rect.get_width()/2., height+dist,\n label_array[ctr],fontsize=fonts[3],\n #'%d' % int(height),\n ha='center', va='bottom',rotation=90)\n elif(axis=='2'):\n ax2.text(rect.get_x() + rect.get_width()/2., height+dist,\n label_array[ctr],fontsize=fonts[3],\n #'%d' % int(height),\n ha='center', va='bottom',rotation=90)\n elif(axis=='3'):\n ax3.text(rect.get_x() + rect.get_width()/2., height+dist,\n label_array[ctr],fontsize=fonts[3],\n #'%d' % int(height),\n ha='center', va='bottom',rotation=90)\n elif(axis=='4'):\n ax4.text(rect.get_x() + rect.get_width()/2., height+dist,\n label_array[ctr],fontsize=fonts[3],\n #'%d' % int(height),\n ha='center', va='bottom',rotation=90)\n ctr = ctr + 1","def label(d, X, ind_class0, ind_class1, N, V, binary):\n if binary == True:\n K = 1\n C = torch.zeros(N + V, K)\n C[ind_class0, :] = 0.0\n C[ind_class1, :] = 1.0\n else:\n K = 2\n C = torch.zeros(N + V, K)\n C[ind_class0, :] = torch.tensor([1.0, 0.0])\n C[ind_class1, :] = torch.tensor([0.0, 1.0])\n\n X_train = X[:N, :]\n X_val = X[N:, :]\n C_train = C[:N, :]\n C_val = C[N:, :]\n\n return [X_train, C_train, X_val, C_val, d, K]","def Write_GCode_Drag_Knife(self, PostPro):\n\n # initialisation of the string\n exstr = \"\"\n\n # Get the mill settings defined in the GUI\n safe_retract_depth = self.parentLayer.axis3_retract\n safe_margin = self.parentLayer.axis3_safe_margin\n\n workpiece_top_Z = self.axis3_start_mill_depth\n f_g1_plane = self.f_g1_plane\n f_g1_depth = self.f_g1_depth\n\n \"\"\"\n Cutting in slices is not supported for Swivel Knife tool. All is cut at once.\n \"\"\"\n mom_depth = self.axis3_mill_depth\n drag_depth = self.axis3_slice_depth\n\n # Move the tool to the start.\n exstr += self.stmove.geos.abs_el(0).Write_GCode(PostPro)\n\n # Add string to be added before the shape will be cut.\n exstr += PostPro.write_pre_shape_cut()\n\n # Move into workpiece and start cutting into Z\n exstr += PostPro.rap_pos_z(\n workpiece_top_Z + abs(safe_margin)) # Compute the safe margin from the initial mill depth\n exstr += PostPro.chg_feed_rate(f_g1_depth)\n\n # Write the geometries for the first cut\n if isinstance(self.stmove.geos.abs_el(1), ArcGeo):\n if self.stmove.geos.abs_el(1).drag:\n exstr += PostPro.lin_pol_z(drag_depth)\n drag = True\n else:\n exstr += PostPro.lin_pol_z(mom_depth)\n drag = False\n else:\n exstr += PostPro.lin_pol_z(mom_depth)\n drag = False\n exstr += PostPro.chg_feed_rate(f_g1_plane)\n\n exstr += self.stmove.geos.abs_el(1).Write_GCode(PostPro)\n\n for geo in Geos(self.stmove.geos[2:]).abs_iter():\n if isinstance(geo, ArcGeo):\n if geo.drag:\n exstr += PostPro.chg_feed_rate(f_g1_depth)\n exstr += PostPro.lin_pol_z(drag_depth)\n exstr += PostPro.chg_feed_rate(f_g1_plane)\n drag = True\n elif drag:\n exstr += PostPro.chg_feed_rate(f_g1_depth)\n exstr += PostPro.lin_pol_z(mom_depth)\n exstr += PostPro.chg_feed_rate(f_g1_plane)\n drag = False\n elif drag:\n exstr += PostPro.chg_feed_rate(f_g1_depth)\n exstr += PostPro.lin_pol_z(mom_depth)\n exstr += PostPro.chg_feed_rate(f_g1_plane)\n drag = False\n\n exstr += self.Write_GCode_for_geo(geo, PostPro)\n\n # Do the tool retraction\n exstr += PostPro.chg_feed_rate(f_g1_depth)\n exstr += PostPro.lin_pol_z(workpiece_top_Z + abs(safe_margin))\n exstr += PostPro.rap_pos_z(safe_retract_depth)\n\n # Add string to be added before the shape will be cut.\n exstr += PostPro.write_post_shape_cut()\n\n return exstr","def get_label(name):\n lower = name.lower()\n vals = lower.split('_')\n if 'ho' in vals:\n name = 'Independent Estimate'\n elif 'alldata' in vals:\n name = 'Extra-Data Estimate'\n elif 'ris' in vals[0]:\n name = 'RIS'\n if 'w' in vals[0]:\n name += ' WIS'\n if 'pd' in vals[0]:\n name += ' PDIS'\n elif 'is' in vals[0]:\n name = 'OIS'\n if 'w' in vals[0]:\n name += ' WIS'\n if 'pd' in vals[0]:\n name += ' PDIS'\n if 'dr' in vals:\n name += ' DR'\n if 'wdr' in vals:\n name += ' WDR'\n return name","def setLabelDistance(dist=24, axes='XYZ'):\n dislin.labdis(dist, axes)","def onAddCutToolClicked(self, event):\n i_cube = self.cube_choice.GetSelection()\n i_dimension = self.cut_dimension_choice.GetSelection()\n\n if i_dimension <= 0:\n dlg_func.openWarningBox(_(u'CUT'), _(u'Cut dimension not selected'))\n else:\n value = self.cut_value_textCtrl.GetValue()\n if not value.strip():\n dlg_func.openWarningBox(_(u'CUT'), _(u'Cut value not specified'))\n else:\n cube = self._OLAP_server.getCubes()[i_cube]\n dimension = cube.getDimensions()[i_dimension - 1]\n row = (dimension.getLabel(), dimension.getName(), value)\n self.appendListCtrlRow(listctrl=self.cut_listCtrl, row=row)\n\n # After adding, clear the controls\n self.cut_dimension_choice.SetSelection(0)\n self.cut_value_textCtrl.SetValue(u'')\n\n event.Skip()"],"string":"[\n \"def extract_info(config, cut, label):\\n cfg = filter(lambda c: c['name'] == cut, config['physics']['cuts'])[0]\\n text = \\\"\\\"\\n if 'max' not in cfg:\\n text += \\\"#geq \\\"\\n text += str(cfg['min'])\\n if 'max' in cfg and cfg['max'] != cfg['min']:\\n text += '-' + str(cfg['max']) + ' ' + label + 's'\\n elif cfg['min'] != 1:\\n text += ' ' + label + 's'\\n else:\\n text += ' ' + label\\n return text\",\n \"def makeDPartial( name\\n , config\\n , DecayDescriptor\\n , inputSel\\n ) :\\n\\n _Kcuts1 = \\\"~ISMUON & (PT > %(DaugPtLoose)s* MeV) & (MIPCHI2DV(PRIMARY) > %(DaugIPChi2Loose)s)\\\" % locals()['config']\\n _KcutsPIDK = \\\" & (PIDK > %(HighPIDK)s)\\\" % locals()['config']\\n _Kcuts2 = \\\" & (ISLONG) & (P > %(DaugPLoose)s* MeV) & (TRCHI2DOF < %(DaugTrkChi2Loose)s)\\\" % locals()['config']\\n _Kcuts = _Kcuts1 + _KcutsPIDK + _Kcuts2\\n _Picuts1 = \\\"~ISMUON & (PT > %(DaugPtMin)s* MeV) & (MIPCHI2DV(PRIMARY) > %(DaugIPChi2)s)\\\" % locals()['config']\\n _PicutsPIDK = \\\" & (PIDK < %(LowPIDK)s)\\\" % locals()['config']\\n _Picuts2 = \\\" & (ISLONG) & (P > %(DaugP)s* MeV) & (TRCHI2DOF < %(DaugTrkChi2)s)\\\" % locals()['config']\\n _Picuts = _Picuts1 + _PicutsPIDK + _Picuts2\\n _dauCuts = { 'K+': _Kcuts, 'pi+': _Picuts }\\n #_Kcuts1 = \\\"~ISMUON & (PT > 500* MeV) & (MIPCHI2DV(PRIMARY) > 4)\\\"\\n #_KcutsPIDK = \\\" & (PIDK > 5)\\\"\\n #_Kcuts2 = \\\" & (ISLONG) & (P > 5000* MeV) & (TRCHI2DOF < 5)\\\"\\n #_Kcuts = _Kcuts1 + _KcutsPIDK + _Kcuts2\\n #_Picuts1 = \\\"~ISMUON & (PT > 500* MeV) & (MIPCHI2DV(PRIMARY) > 4)\\\"\\n #_PicutsPIDK = \\\" & (PIDK < 0)\\\"\\n #_Picuts2 = \\\" & (ISLONG) & (P > 5000* MeV) & (TRCHI2DOF < 5)\\\"\\n #_Picuts = _Picuts1 + _PicutsPIDK + _Picuts2\\n #_dauCuts = { 'K+': _Kcuts, 'pi+': _Picuts }\\n\\n _combCuts = \\\"(APT > %(D0PtLoose)s* MeV)\\\" \\\\\\n \\\"& (AP > %(D0P)s* MeV)\\\" % locals()['config']\\n\\n _motherCuts = \\\"(VFASPF(VCHI2PDOF) < %(D0VtxChi2Ndof)s)\\\" \\\\\\n \\\"& (BPVVDCHI2 > %(D0FDChi2)s)\\\" % locals()['config']\\n\\n\\n _Dminus = CombineParticles( DecayDescriptor = DecayDescriptor\\n , DaughtersCuts = _dauCuts\\n , CombinationCut = _combCuts\\n , MotherCut = _motherCuts\\n )\\n\\n return Selection( name+'Sel',\\n Algorithm = _Dminus,\\n RequiredSelections = inputSel\\n )\",\n \"def x_group_label(\\n x_gr: int, cut: int = 20, name_dict: Dict[AnyStr, AnyStr] = names_dict\\n) -> AnyStr:\\n name = name_dict[str(x_gr)]\\n if len(name) > cut:\\n return f\\\"{name[:cut-3]}...\\\"\\n else:\\n return name\",\n \"def assignLabels(self):\\n clusters = np.arange(0, len(self.V))[self.V < self.V1] #indexes self.V, volumes_sorted, and oldOrder\\n self.clusterV = self.volumes_sorted[clusters]\\n clusters = self.oldOrder[clusters] #indexes volumes\\n self.clusters = self.nonBI[clusters] #indexes self.vor and self.data\\n self.easyLabel = np.zeros(len(self.data))\\n self.easyLabel[self.clusters] = 1\\n print('Out of ' + str(len(self.data)) + ' particles, ' + str(len(self.clusters)) + ' (' + str(round(len(self.clusters)*100/len(self.data), 3)) +' %) are labelled as cluster particles.')\",\n \"def __init__(self, data_cfg, pipeline_cfg, root_path, sel_index=0):\\n\\n super(DetRetailOneDataset, self).__init__(\\n data_cfg, pipeline_cfg, root_path, sel_index\\n )\\n\\n self.cat2label = {cat: i for i, cat in enumerate(self.class_names)}\\n self.ORI_CLASSES = (\\n \\\"asamu\\\",\\n \\\"baishikele\\\",\\n \\\"baokuangli\\\",\\n \\\"aoliao\\\",\\n \\\"bingqilinniunai\\\",\\n \\\"chapai\\\",\\n \\\"fenda\\\",\\n \\\"guolicheng\\\",\\n \\\"haoliyou\\\",\\n \\\"heweidao\\\",\\n \\\"hongniu\\\",\\n \\\"hongniu2\\\",\\n \\\"hongshaoniurou\\\",\\n \\\"kafei\\\",\\n \\\"kaomo_gali\\\",\\n \\\"kaomo_jiaoyan\\\",\\n \\\"kaomo_shaokao\\\",\\n \\\"kaomo_xiangcon\\\",\\n \\\"kele\\\",\\n \\\"laotansuancai\\\",\\n \\\"liaomian\\\",\\n \\\"lingdukele\\\",\\n \\\"maidong\\\",\\n \\\"mangguoxiaolao\\\",\\n \\\"moliqingcha\\\",\\n \\\"niunai\\\",\\n \\\"qinningshui\\\",\\n \\\"quchenshixiangcao\\\",\\n \\\"rousongbing\\\",\\n \\\"suanlafen\\\",\\n \\\"tangdaren\\\",\\n \\\"wangzainiunai\\\",\\n \\\"weic\\\",\\n \\\"weitanai\\\",\\n \\\"weitaningmeng\\\",\\n \\\"wulongcha\\\",\\n \\\"xuebi\\\",\\n \\\"xuebi2\\\",\\n \\\"yingyangkuaixian\\\",\\n \\\"yuanqishui\\\",\\n \\\"xuebi-b\\\",\\n \\\"kebike\\\",\\n \\\"tangdaren3\\\",\\n \\\"chacui\\\",\\n \\\"heweidao2\\\",\\n \\\"youyanggudong\\\",\\n \\\"baishikele-2\\\",\\n \\\"heweidao3\\\",\\n \\\"yibao\\\",\\n \\\"kele-b\\\",\\n \\\"AD\\\",\\n \\\"jianjiao\\\",\\n \\\"yezhi\\\",\\n \\\"libaojian\\\",\\n \\\"nongfushanquan\\\",\\n \\\"weitanaiditang\\\",\\n \\\"ufo\\\",\\n \\\"zihaiguo\\\",\\n \\\"nfc\\\",\\n \\\"yitengyuan\\\",\\n \\\"xianglaniurou\\\",\\n \\\"gudasao\\\",\\n \\\"buding\\\",\\n \\\"ufo2\\\",\\n \\\"damaicha\\\",\\n \\\"chapai2\\\",\\n \\\"tangdaren2\\\",\\n \\\"suanlaniurou\\\",\\n \\\"bingtangxueli\\\",\\n \\\"weitaningmeng-bottle\\\",\\n \\\"liziyuan\\\",\\n \\\"yousuanru\\\",\\n \\\"rancha-1\\\",\\n \\\"rancha-2\\\",\\n \\\"wanglaoji\\\",\\n \\\"weitanai2\\\",\\n \\\"qingdaowangzi-1\\\",\\n \\\"qingdaowangzi-2\\\",\\n \\\"binghongcha\\\",\\n \\\"aerbeisi\\\",\\n \\\"lujikafei\\\",\\n \\\"kele-b-2\\\",\\n \\\"anmuxi\\\",\\n \\\"xianguolao\\\",\\n \\\"haitai\\\",\\n \\\"youlemei\\\",\\n \\\"weiweidounai\\\",\\n \\\"jindian\\\",\\n \\\"3jia2\\\",\\n \\\"meiniye\\\",\\n \\\"rusuanjunqishui\\\",\\n \\\"taipingshuda\\\",\\n \\\"yida\\\",\\n \\\"haochidian\\\",\\n \\\"wuhounaicha\\\",\\n \\\"baicha\\\",\\n \\\"lingdukele-b\\\",\\n \\\"jianlibao\\\",\\n \\\"lujiaoxiang\\\",\\n \\\"3+2-2\\\",\\n \\\"luxiangniurou\\\",\\n \\\"dongpeng\\\",\\n \\\"dongpeng-b\\\",\\n \\\"xianxiayuban\\\",\\n \\\"niudufen\\\",\\n \\\"zaocanmofang\\\",\\n \\\"wanglaoji-c\\\",\\n \\\"mengniu\\\",\\n \\\"mengniuzaocan\\\",\\n \\\"guolicheng2\\\",\\n \\\"daofandian1\\\",\\n \\\"daofandian2\\\",\\n \\\"daofandian3\\\",\\n \\\"daofandian4\\\",\\n \\\"yingyingquqi\\\",\\n \\\"lefuqiu\\\",\\n )\",\n \"def _make_vbenf_label(chain_parts):\\n\\n # toy label for development: run simple and dijet independently.\\n # simple makes Et cuts on two jets. Independently (sharing possible)\\n # of jets choosean by simple, the dijet\\n # scenario requires a dijet of mass > 900, and opening angle in phi > 2.6\\n\\n assert len(chain_parts) == 1\\n scenario = chain_parts[0]['hypoScenario']\\n assert scenario.startswith('vbenf')\\n args = _args_from_scenario(scenario)\\n if not args:\\n return 'and([]simple([(50et)(70et)])combgen([(2)] dijet([(900djmass, 26djdphi)])))' \\n arg_res = [\\n re.compile(r'(?P<lo>\\\\d*)(?P<key>fbet)(?P<hi>\\\\d*)'),\\n re.compile(r'(?P<lo>\\\\d*)(?P<key>mass)(?P<hi>\\\\d*)'),\\n re.compile(r'(?P<lo>\\\\d*)(?P<key>et)(?P<hi>\\\\d*)'),\\n ]\\n\\n defaults = {\\n 'et': ('101', 'inf'),\\n 'mass': ('800', 'inf'),\\n 'fbet': ('501', 'inf'),\\n }\\n\\n argvals = {}\\n while args:\\n assert len(args) == len(arg_res)\\n arg = args.pop()\\n for r in arg_res:\\n m = r.match(arg)\\n if m is not None:\\n arg_res.remove(r)\\n gd = m.groupdict()\\n key = gd['key']\\n try:\\n lo = float(gd['lo'])\\n except ValueError:\\n lo = defaults[key][0]\\n argvals[key+'lo'] = lo \\n try:\\n hi = float(gd['hi'])\\n except ValueError:\\n hi = defaults[key][1]\\n argvals[key+'hi'] = hi\\n\\n assert len(args) == len(arg_res)\\n assert len(args) == 0\\n\\n return \\\"\\\"\\\"\\n and\\n (\\n []\\n simple\\n (\\n [(%(etlo).0fet, 500neta)(%(etlo).0fet, peta500)]\\n )\\n combgen\\n (\\n [(10et, 0eta320)]\\n dijet\\n (\\n [(%(masslo).0fdjmass, 26djdphi)]\\n ) \\n simple\\n (\\n [(10et, 0eta320)(20et, 0eta320)]\\n )\\n )\\n )\\\"\\\"\\\" % argvals\",\n \"def create_labelled_dataset(self):\\n\\n print(\\\"-------------------------------------------------------------------\\\")\\n print(\\\" How to Use the Pole Hull Label Tool\\\")\\n print(\\\"-------------------------------------------------------------------\\\")\\n print(\\\"- If a hull is NOT associated to a pole: press the 1 button\\\")\\n print(\\\"- If a hull IS associated to a pole: press the 2 button\\\")\\n print(\\\"\\\\n- If any other key is pressed, the program EXITS\\\")\\n print(\\\"-------------------------------------------------------------------\\\")\\n\\n detector = gate_detector.GateDetector(im_resize=3.0/4)\\n\\n imgs = []\\n labels = []\\n directory = os.path.dirname(os.getcwd())\\n \\n # Get absolute path of all images in the images folder\\n for dirpath,_,filenames in os.walk(os.path.join(directory, 'images', 'gate')):\\n for f in filenames:\\n imgs.append(os.path.abspath(os.path.join(dirpath, f)))\\n\\n # Get the hulls from the segmented image and run the display and label program for each image\\n for img in imgs:\\n src = cv.imread(img, 1)\\n pre = detector.preprocess(src)\\n seg = detector.segment(pre)\\n mor = detector.morphological(seg)\\n hulls = detector.create_convex_hulls(seg)\\n labels += self.display_and_label_hulls(hulls, pre)\\n return labels\",\n \"def setContourLabels(mode='none', ndigits=1):\\n odict = {'none':'NONE', 'float':'FLOAT', 'string':'CONLAB'}\\n dislin.labdig(ndigits, 'CONTUR')\\n dislin.labels(odict[mode], 'CONTUR')\",\n \"def _add_labels(self):\\n coords = self['pore.coords']\\n self['pore.front'] = coords[:,0]<(0.1*self._Lx)\\n self['pore.back'] = coords[:,0]>(0.9*self._Lx)\\n self['pore.left'] = coords[:,1]<(0.1*self._Ly)\\n self['pore.right'] = coords[:,1]>(0.9*self._Ly)\\n self['pore.bottom'] = coords[:,2]<(0.1*self._Lz)\\n self['pore.top'] = coords[:,2]>(0.9*self._Lz)\\n bnds = self.pores(labels=['front','back','left','right','bottom','top'])\\n self['pore.boundary'] = False\\n self['pore.boundary'] = bnds\",\n \"def plot_data_assemble(self,kwargs_seg, add_mask ,img_name='data.pdf',cutout_text='lensed image',font_size=28):\\n mask = self.data_mask\\n image = self.raw_image\\n picked_data = self.data\\n selem = np.ones((add_mask, add_mask))\\n img_mask = ndimage.binary_dilation(mask.astype(np.bool), selem)\\n fig, (ax1, ax2, ax3,ax4) = plt.subplots(1, 4, figsize=(19, 10))\\n ax1.imshow(image, origin='lower', cmap=\\\"gist_heat\\\")\\n ax1.set_title('Cutout Image',fontsize =font_size)\\n ax1.text(image.shape[0] * 0.2, image.shape[0] * 0.05, cutout_text,size=20, color='white',weight=\\\"bold\\\")\\n ax1.axis('off')\\n segments_deblend_list, xcenter, ycenter, c_index=kwargs_seg\\n ax2.imshow(segments_deblend_list, origin='lower')\\n for i in range(len(xcenter)):\\n ax2.text(xcenter[i] * 1.1, ycenter[i], 'Seg' + repr(i), size=20,color='w',weight=\\\"bold\\\")\\n ax2.text(image.shape[0] * 0.2, image.shape[0] * 0.9, 'Seg' + repr(c_index) + ' ' + 'in center',\\n size=20, color='white',weight=\\\"bold\\\")\\n ax2.set_title('Segmentations',fontsize =font_size)\\n ax2.axis('off')\\n ax3.imshow(img_mask+mask, origin='lower',cmap=\\\"gist_heat\\\")\\n ax3.set_title('Selected pixels',fontsize =font_size)\\n ax3.text(image.shape[0] * 0.1, image.shape[0] * 0.05, 'pixels (S/N >' + repr(self.snr) + ')',size=20, color='white',weight=\\\"bold\\\")\\n ax3.text(image.shape[0] * 0.1, image.shape[0] * 0.9, 'additional pixels', size=20, color='r',weight=\\\"bold\\\")\\n ax3.axis('off')\\n ax4.imshow(picked_data, origin='lower',cmap=\\\"gist_heat\\\")\\n ax4.set_title('Processed Image',fontsize =font_size)\\n ax4.axis('off')\\n plt.show()\\n fig.savefig(img_name)\\n return 0\",\n \"def BaseLabel(self, *args):\\n return _XCAFDoc.XCAFDoc_DimTolTool_BaseLabel(self, *args)\",\n \"def main():\\n # Directory where the DICOM files are being stored (in this\\n input_path = './Inputs/valve'\\n\\n # Original image from the filepath\\n img_original = read_image(input_path)\\n\\n # Image with smoothing applied to reduce noise\\n img_smooth = sitk.CurvatureFlow(image1=img_original, timeStep=0.125, numberOfIterations=10)\\n\\n # Create labels on our smoothed image for cardiac tissue and tissue with blood\\n labels_tissue = sitk.BinaryThreshold(image1=img_smooth, lowerThreshold=325, upperThreshold=470, insideValue=1)\\n labels_blood = sitk.BinaryThreshold(image1=img_smooth, lowerThreshold=450, upperThreshold=800, insideValue=1, outsideValue=0)\\n\\n # IMPORTANT STEP: essentially, this is the key to our algorithm. By finding the \\\"blood\\\" without cardiac tissue,\\n # and then using binary hole filling with a fairly large radius, we are able to label a lot of the mitral valve\\n # area without labeling too much of the other cardiac tissue. Thus, THIS is what lets us single out the mitral\\n # valve tissue from the rest - all we need is the overlap of the two labels\\n labels_tissue_no_holes = sitk.VotingBinaryHoleFilling(image1=labels_tissue, radius=[2] * 3, majorityThreshold=1, backgroundValue=0, foregroundValue=1)\\n labels_blood_no_holes = sitk.VotingBinaryHoleFilling(image1=labels_blood, radius=[4] * 3, majorityThreshold=1, backgroundValue=0, foregroundValue=1)\\n labels_valve = retrieve_overlap(labels_blood_no_holes, labels_tissue_no_holes)\\n labels_valve_no_holes = sitk.VotingBinaryHoleFilling(image1=labels_valve, radius=[2] * 3, majorityThreshold=1, backgroundValue=0, foregroundValue=1)\\n labels_valve_no_holes = sitk.VotingBinaryHoleFilling(image1=labels_valve_no_holes, radius=[1] * 3, majorityThreshold=0, backgroundValue=1, foregroundValue=0)\\n\\n # Fix intensity scaling on our original smoothed image for pretty diagram purposes\\n img_smooth = sitk.Cast(sitk.RescaleIntensity(img_smooth), labels_tissue_no_holes.GetPixelID())\\n\\n # Use a density-based clustering algorithm to attempt to remove as much noise as possible\\n labels_valve_filtered = dbscan_filter(labels_valve_no_holes, eps=2, use_z=False)\\n labels_valve_filtered = dbscan_filter(labels_valve_filtered, eps=4)\\n\\n # Find likely start and end points of our image by setting a mininum number of labeled pixels\\n start, end = filter_by_label_count(labels_valve_filtered, 10)\\n img_smooth = img_smooth[:, :, start:end]\\n labels_valve_filtered = labels_valve_filtered[:, :, start:end]\\n\\n # Remove all values distant from the center of our starting location by taking advantage of kmeans\\n df = get_df_from_img(labels_valve_filtered[:, :, 0], dimensions=2)\\n x_mid = df['x'].mean()\\n y_mid = df['y'].mean()\\n df = get_df_from_img(labels_valve_filtered)\\n distance_df = df.drop('z', axis=1)\\n distance_df['x_dist'] = abs(distance_df['x'] - x_mid)\\n distance_df['y_dist'] = abs(distance_df['y'] - y_mid)\\n fit = cluster.KMeans(n_clusters=2).fit(distance_df.drop(['x', 'y'], axis=1))\\n labels = fit.labels_\\n df['label'] = pd.Series(labels)\\n counts = df['label'].value_counts().to_dict()\\n largest_cluster = max(counts.iterkeys(), key=(lambda key: counts[key]))\\n update_img_from_df(df, labels_valve_filtered, keep=largest_cluster)\\n\\n # Find likely start and end points of our image by setting a mininum number of labeled pixels\\n start, end = filter_by_label_count(labels_valve_filtered, 10)\\n img_smooth = img_smooth[:, :, start:end]\\n labels_valve_filtered = labels_valve_filtered[:, :, start:end]\\n\\n # Use a segmentation-based clustering algorithm to attempt to find each valve\\n label_segments, x_max = kmeans_segment(labels_valve_filtered, use_z=False)\\n\\n left, right = (label_segments[0], label_segments[1])\\n if x_max[0] > x_max[1]:\\n left, right = right, left\\n\\n # Finally, we can simply take the furthest point from the likely start/end points in order to get our annulus\\n # this can be done by every z value\\n left_points = {'x': [], 'y': [], 'z': []}\\n right_points = {'x': [], 'y': [], 'z': []}\\n zlen = len(sitk.GetArrayFromImage(left))\\n for z in xrange(zlen):\\n left_df = get_df_from_img(left[:, :, z], dimensions=2)\\n if len(left_df['y']) > 0:\\n index = left_df['y'].idxmin()\\n row = left_df.iloc[index]\\n left_points['x'].append(int(row['x']))\\n left_points['y'].append(int(row['y']))\\n left_points['z'].append(z)\\n\\n right_df = get_df_from_img(right[:, :, z], dimensions=2)\\n if len(right_df['x']) > 0:\\n index = right_df['x'].idxmax()\\n row = right_df.iloc[index]\\n right_points['x'].append(int(row['x']))\\n right_points['y'].append(int(row['y']))\\n right_points['z'].append(z)\\n\\n # These both represent the coordinates of our annulus ring. A simple spline can be used for interpolation between\\n # points\\n final_left = pd.DataFrame.from_dict(left_points)\\n final_right = pd.DataFrame.from_dict(right_points)\\n print('Coordinates for one side of the ring')\\n print(final_left)\\n print('\\\\n\\\\nCoordinates for the other side of the ring')\\n print(final_right)\\n\\n final_image = make_empty_img_from_img(left)\\n x = left_points['x'] + right_points['x']\\n y = left_points['y'] + right_points['y']\\n z = left_points['z'] + right_points['z']\\n for x, y, z in zip(x, y, z):\\n final_image.SetPixel(x, y, z, 1)\\n\\n show_all(img_smooth, final_image)\",\n \"def label(self, cfg):\\n rep = \\\"\\\"\\n nl = \\\"\\\"\\n for node in cfg.nodes:\\n rep += nl + \\\"{}\\\\tgen={}\\\\tkill={}\\\\tout={}\\\".format(\\n node, \\n set(self.gen.get(node)),\\n set(self.kill.get(node)),\\n set(self.out.get(node)))\\n nl = \\\"\\\\n\\\"\\n return rep\",\n \"def test_get_dim_label_with_label(self):\\n\\n dim = self.oecd_datasets['oecd']['dimension']['id'][0]\\n dims_df = pyjstat.get_dim_label(self.oecd_datasets['oecd'], dim)\\n self.assertTrue(dims_df.iloc[0]['id'] == 'UNR')\\n self.assertTrue(dims_df.iloc[-1]['label'] == 'Unemployment rate')\",\n \"def LabelDisks(self):\\n pass\",\n \"def visualize_detection(self, img, dets, seg, classes=[], thresh=0.6):\\n from dataset.cs_labels import labels\\n lut = np.zeros((256,3))\\n for l in labels:\\n if l.trainId<255 and l.trainId>=0:\\n lut[l.trainId,:]=list(l.color)\\n palette = lut\\n # det2seg = {0:6,1:7,2:11,3:12,4:13,5:14,6:15,7:16,8:17,9:18,}\\n det2seg = {0:11,1:12,2:13,3:14,4:15,5:16,6:17,7:18,}\\n \\n import cv2\\n import random\\n tic = time.time()\\n color_white = (255, 255, 255)\\n im = cv2.cvtColor(img, cv2.COLOR_RGB2BGR) # change to bgr\\n yscale, xscale, ch = im.shape\\n color = (0,0,128)\\n fontFace = cv2.FONT_HERSHEY_PLAIN\\n fontScale = .8*(yscale/float(320))\\n thickness = 2 if yscale>320 else 1\\n idx = np.argsort(dets[:,6],axis=0)[::-1] ## draw nearest first !!\\n dets = dets[idx,:]\\n for det in dets:\\n cls_id = int(det[0])\\n bbox = [det[2]*xscale,det[3]*yscale,det[4]*xscale,det[5]*yscale]\\n score = det[1]\\n distance = det[-1]\\n if score > thresh:\\n bbox = map(int, bbox)\\n color = palette[det2seg[int(det[0])],(2,1,0)]\\n cv2.rectangle(im, (bbox[0], bbox[1]), (bbox[2], bbox[3]), color=color, thickness=thickness)\\n text = '%s %.0fm' % (short_class_name[classes[cls_id]], distance*255., )\\n textSize, baseLine = cv2.getTextSize(text, fontFace, fontScale, thickness=1)\\n cv2.rectangle(im, (bbox[0], bbox[1]-textSize[1]), (bbox[0]+textSize[0], bbox[1]), color=(128,0,0), thickness=-1)\\n cv2.putText(im, text, (bbox[0], bbox[1]),\\n color=color_white, fontFace=fontFace, fontScale=fontScale, thickness=1)\\n disp = im.copy()\\n if False: #disp.shape[1]>1000:\\n hh, ww, ch = disp.shape\\n resized = cv2.resize(disp, (int(round(ww*.92)),int(round(hh*.92))))\\n else:\\n resized = disp\\n cv2.imshow(\\\"result\\\", resized)\\n # cv2.imwrite(\\\"data/cityscapes/Results/stuttgart_%06d.png\\\" % (self.imgidx,), resized)\\n # self.imgidx += 1\",\n \"def kohonen():\\n# plb.close('all')\\n \\n dim = 28*28\\n data_range = 255.0\\n \\n # load in data and labels \\n data = np.array(np.loadtxt('data.txt'))\\n labels = np.loadtxt('labels.txt')\\n\\n # select 4 digits \\n name = \\\"Stettler\\\"\\n targetdigits = name2digits(name) # assign the four digits that should be used\\n print(targetdigits) # output the digits that were selected\\n\\n # this selects all data vectors that corresponds to one of the four digits\\n data = data[np.logical_or.reduce([labels==x for x in targetdigits]),:]\\n \\n dy, dx = data.shape\\n \\n #set the size of the Kohonen map. In this case it will be 6 X 6\\n size_k = 6\\n \\n #set the width of the neighborhood via the width of the gaussian that\\n #describes it\\n sigma = 2.0\\n \\n #initialise the centers randomly\\n centers = np.random.rand(size_k**2, dim) * data_range\\n \\n #build a neighborhood matrix\\n neighbor = np.arange(size_k**2).reshape((size_k, size_k))\\n\\n #set the learning rate\\n eta = 0.9 # HERE YOU HAVE TO SET YOUR OWN LEARNING RATE\\n \\n #set the maximal iteration count\\n tmax = 5000 # this might or might not work; use your own convergence criterion\\n \\n #set the random order in which the datapoints should be presented\\n i_random = np.arange(tmax) % dy\\n np.random.shuffle(i_random)\\n \\n for t, i in enumerate(i_random):\\n som_step(centers, data[i,:],neighbor,eta,sigma)\\n\\n # for visualization, you can use this:\\n for i in range(size_k**2):\\n plb.subplot(size_k,size_k,i)\\n \\n plb.imshow(np.reshape(centers[i,:], [28, 28]),interpolation='bilinear')\\n plb.axis('off')\\n \\n # leave the window open at the end of the loop\\n plb.show()\\n plb.draw()\",\n \"def convert_kicad_coor(edif_pt):\\n scale = 10\\n return [edif_pt[0] * scale, +edif_pt[1] * scale]\",\n \"def create_dimension_labels(gll, parameters: list):\\n dimstr = '[ ' + ' | '.join(parameters) + ' ]'\\n gll['MODEL/data'].dims[0].label = 'element'\\n gll['MODEL/data'].dims[1].label = dimstr\\n gll['MODEL/data'].dims[2].label = 'point'\",\n \"def add_hdv(self, ROI_id, type_hdv='cum', checkbox_mode=False):\\n\\n appartenance_contourage = self.dicom_navigation.slice.get_appartenance_contourage(ROI_id)\\n \\n contourage = Contourage_from_matrice(appartenance_contourage, ROI_id) # On crée un objet 'Contourage_from_matrice' à partir du de la matrice booléenne\\n\\n dose_matrix = self.dicom_navigation.slice.get_dose_matrix()\\n\\n # Cas ou on ajoute pour la premiere fois un contourage\\n if dose_matrix is None:\\n return\\n \\n doses = Doses_from_matrice(dose_matrix) # On crée un objet 'Doses_from_matrice' à partir de la matrice de doses mise à jour\\n\\n var = tk.StringVar() # À VENIR... VARIABLE D'ÉTAT QUI INDIQUE SI ON EST EN MODE 'VOLUME RELATF' OU 'VOLUME ABSOLU'. CODÉ EN DUR POUR LE MOMENT\\n var.set('r')\\n\\n self.ddc = Doses_dans_contourage(doses, contourage) # Triage des doses qui sont dans le contourage.\\n\\n if self.ddc.dose_max == 0: # Si la dose max est 0, on sait qu'on est à l'extérieur de la zone réduite. *** \\n return\\n\\n if not ROI_id in self.dict_graph: \\n self.dict_graph[ROI_id] = {} \\n self.dict_plot[ROI_id] = {} \\n self.dict_doses_max[ROI_id] = {} \\n if self.dicom_navigation.var_etat_abs_rel.get() == 'a':\\n self.dict_volumes_max[ROI_id] = {} \\n\\n self.dict_doses_max[ROI_id][type_hdv] = self.ddc.dose_max\\n\\n ###\\n\\n if self.dicom_navigation.var_etat_abs_rel.get() == 'r': # si on est en mode 'volume relatif', le range des axes sera définit différemment\\n facteur = 100.0/self.ddc.nb_voxels # comme l'instance 'axe_volume' créée par les classes hdv_cumulatif et hdv_differentiel contient des données en NOMBRE DE VOXELS\\n # (et non en pourcentage ou en volume réel), il faut multiplier ces données par le facteur de conversion approprié (il dépend\\n # de si l'on est en mode 'relatf' ou 'absolu').\\n\\n if self.dicom_navigation.var_etat_abs_rel.get() == 'a': # si on est en mode 'volume absolu'.\\n facteur = self.ddc.v_voxel\\n self.dict_volumes_max[ROI_id][type_hdv] = self.ddc.v_voxel * self.ddc.nb_voxels \\n self.y_lim = get_max_2D_dic(self.dict_volumes_max)\\n\\n ###\\n\\n if type_hdv == 'cum':\\n hdv = HDV_cumulatif(self.ddc, 100)\\n\\n if type_hdv == 'diff':\\n hdv = HDV_differentiel(self.ddc, 50)\\n\\n\\n self.dict_graph[ROI_id][type_hdv] = hdv\\n self.dict_plot[ROI_id][type_hdv], = self.fig.plot(hdv.axe_doses, facteur * hdv.axe_volume)\\n\\n ###\\n\\n self.x_lim = get_max_2D_dic(self.dict_doses_max) \\n\\n self.fig.set_xlim([0, 1.02*self.x_lim]) # dimension de l'axe des x\\n self.fig.set_ylim([0, 1.02*self.y_lim]) # dimension de l'axe des y\\n\\n # Contraintes\\n if self.got_contraintes and type_hdv == 'cum': # 'got_contraintes' SERA INITALISÉE À 'TRUE' LORSQUE L'ON AURA RÉCUPÉRÉ LE FICHIER DE CONTRAINTES\\n self.dicom_navigation.get_dicom_contraintes().verifier_contraintes_sur_une_ROI(ROI_id)\\n\\n # Modifier\\n if checkbox_mode:\\n self.refresh_HDV()\",\n \"def instance_label(task, pred, k=15, n_iters=1, dist_thresh=5, watershed=False):\\n mask = pred\\n\\n # noise removal\\n if k > 1 and n_iters > 0:\\n kernel = np.ones((k, k), np.uint8)\\n mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel,\\n iterations=n_iters)\\n\\n if watershed:\\n from clab.live import filters\\n mask = filters.watershed_filter(mask, dist_thresh=dist_thresh)\\n\\n mask = mask.astype(np.uint8)\\n n_ccs, cc_labels = cv2.connectedComponents(mask, connectivity=4)\\n return cc_labels\",\n \"def old_ideal_label(I):\\n a, c, d = ideal_HNF(I)\\n return \\\"%s.%s.%s\\\" % (a * d, c, d)\",\n \"def setContourLabelString(text=''):\\n dislin.conlab(text)\",\n \"def label(cmd):\\r\\n cmd = cmd.replace('make][.DP', 'make1][.NP')\\r\\n cmd = cmd.replace('make][.SC', 'make2][.SC')\\r\\n cmd = re.sub('(draw.*)one','\\\\\\\\1one1',cmd)\\r\\n cmd = re.sub('(make1.*)one','\\\\\\\\1one1',cmd)\\r\\n cmd = re.sub('(make2.*)one','\\\\\\\\1one2',cmd)\\r\\n cmd = re.sub('(move.*)one','\\\\\\\\1one2',cmd)\\r\\n cmd = re.sub('(hide.*)one','\\\\\\\\1one2',cmd)\\r\\n cmd = '[result ' + cmd + ']' #dummy function for plop\\r\\n return cmd\",\n \"def label(gt_dataset, volume_dim, voxel_dim, labeling_params):\\n labeled_volumes = dict()\\n labeled_cells = dict()\\n #Use global density and reduce the size of gt_dataset here\\n global_density = labeling_params[\\\"global_density\\\"]\\n gt_dataset = {k: v for k,v in gt_dataset.items() if random_sample() < global_density}\\n #Label in the order specified in the configuration\\n layers = sorted(labeling_params.keys())\\n #Remove global_density\\n layers.remove(\\\"global_density\\\")\\n for layer in layers:\\n print \\\"Labeling {}\\\".format(layer)\\n fluorophore = labeling_params[layer]['fluorophore']\\n volume, cells = brainbow(gt_dataset, volume_dim, voxel_dim, **labeling_params[layer])\\n if fluorophore in labeled_volumes:\\n labeled_volumes[fluorophore] += volume\\n labeled_cells[fluorophore] |= cells\\n else:\\n labeled_volumes[fluorophore] = volume\\n labeled_cells[fluorophore] = cells\\n return labeled_volumes, labeled_cells\",\n \"def make_data_label(self):\\n data_label = \\\"\\\"\\n if self.detector is not None:\\n data_label += \\\"%s \\\"%self.detector\\n if self.selection is not None:\\n data_label += \\\"%s Event Selection\\\"%self.selection\\n if data_label == \\\"\\\":\\n data_label = \\\"IceCube\\\"\\n return data_label\",\n \"def write_label(self, contig_name, width, height, font, title_width, upper_left, vertical_label,\\n strand, canvas, horizontal_centering=False, center_vertical=False, chop_text=True,\\n label_color=(50, 50, 50, 255)):\\n upper_left = list(upper_left) # to make it mutable\\n shortened = contig_name[-title_width:] # max length 18. Last characters are most unique\\n txt = Image.new('RGBA', (width, height))#, color=(0,0,0,50))\\n txt_canvas = ImageDraw.Draw(txt)\\n text_width = txt_canvas.textsize(shortened, font)[0]\\n if not chop_text and text_width > width:\\n txt = Image.new('RGBA', (text_width, height)) # TODO performance around txt_canvas\\n txt_canvas = ImageDraw.Draw(txt)\\n if center_vertical or vertical_label: # Large labels are centered in the column to look nice,\\n # rotation indicates strand in big text\\n vertically_centered = (height // 2) - multi_line_height(font, shortened, txt)//2\\n else: # Place label at the beginning of gene based on strand\\n vertically_centered = height - multi_line_height(font, shortened, txt) # bottom\\n if strand == \\\"+\\\":\\n vertically_centered = 0 # top of the box\\n txt_canvas.multiline_text((0, max(0, vertically_centered)), shortened, font=font,\\n fill=label_color)\\n if vertical_label:\\n rotation_direction = 90 if strand == '-' else -90\\n txt = txt.rotate(rotation_direction, expand=True)\\n upper_left[1] += -4 if strand == '-' else 4\\n if horizontal_centering:\\n margin = width - text_width\\n upper_left[0] += margin // 2\\n canvas.paste(txt, (upper_left[0], upper_left[1]), txt)\",\n \"def convert_medical_decathlon_labels(mask, cohort, keep_all_label=False):\\n label = 12*[0]\\n if keep_all_label:\\n label += [0,0]\\n \\n if cohort == 'liver':\\n mask[mask == 2] = 6\\n mask[mask == 1] = 6\\n label[6] = 1\\n \\n elif cohort == 'pancreas':\\n mask[mask == 2] = 11\\n mask[mask == 1] = 11\\n label[11] = 1\\n\\n elif cohort == 'spleen':\\n mask[mask != 1] = 0\\n label[1] = 1 \\n\\n elif cohort == 'hepatic':\\n mask[mask == 2] = 0\\n mask[mask == 1] = 0\\n \\n return mask, label\",\n \"def get_labels(self):\\n if self.option == \\\"term\\\":\\n return ['platform characteristics', 'atmospheric winds', 'radio wave','weather events', 'geomagnetism', 'atmospheric electricity','microwave', 'atmospheric temperature', 'atmospheric water vapor','atmospheric pressure', 'aerosols', 'atmospheric radiation','atmospheric chemistry', 'precipitation', 'sensor characteristics','radar', 'infrared wavelengths', 'visible wavelengths','weather/climate advisories', 'clouds', 'lidar', 'ocean optics','ultraviolet wavelengths', 'cryospheric indicators','land use/land cover', 'topography', 'surface thermal properties','spectral/engineering', 'soils', 'snow/ice', 'geothermal dynamics','natural hazards', 'surface water', 'vegetation','land surface/agriculture indicators','gravity/gravitational field', 'marine advisories', 'altitude','water quality/water chemistry', 'ocean temperature','ocean winds', 'atmospheric/ocean indicators', 'coastal processes','erosion/sedimentation', 'marine sediments', 'ocean chemistry','salinity/density', 'ocean color', 'aquatic ecosystems','vegetation2', 'landscape', 'cloud properties','surface radiative properties', 'geodetics','agricultural plant science', 'forest science','ecological dynamics', 'environmental impacts', 'sustainability','boundaries', 'ecosystems', 'air quality', 'population','infrastructure', 'environmental governance/management','public health', 'economic resources', 'socioeconomics','environmental vulnerability index (evi)', 'human settlements','agricultural chemicals', 'animal science','habitat conversion/fragmentation', 'animals/vertebrates','earth gases/liquids', 'rocks/minerals/crystals','social behavior', 'ground water', 'frozen ground','terrestrial hydrosphere indicators', 'ocean heat budget','biospheric indicators', 'animal commodities', 'fungi', 'plants','carbon flux', 'geomorphic landforms/processes','paleoclimate indicators', 'ocean circulation', 'sea ice','geochemistry', 'visualization/image processing','subsetting/supersetting', 'transformation/conversion','ocean pressure', 'glaciers/ice sheets', 'protists','solar activity', 'sun-earth interactions','sea surface topography', 'solar energetic particle properties','solar energetic particle flux','ionosphere/magnetosphere dynamics']\\n elif self.option == \\\"mostdepth\\\":\\n return ['flight data logs', 'turbulence', 'radio wave flux', 'lightning', 'magnetic field', 'atmospheric conductivity', 'electric field', 'data synchronization time', 'brightness temperature', 'vertical profiles', 'water vapor profiles', 'air temperature', 'upper level winds', 'atmospheric pressure measurements', 'upper air temperature', 'humidity', 'dew point temperature', 'aerosol particle properties', 'emissivity', 'trace gases/trace species', 'liquid precipitation', 'cloud liquid water/ice', 'microwave radiance', 'sensor counts', 'total pressure', 'airspeed/ground speed', 'total temperature', 'static pressure', 'wind speed', 'wind direction', 'radar reflectivity', 'doppler velocity', 'infrared imagery', 'visible imagery', 'water vapor', 'vertical wind velocity/speed', 'aerosol backscatter', 'weather forecast', 'tropical cyclones', 'visible radiance', 'infrared radiance', 'total precipitable water', 'boundary layer temperature', 'atmospheric temperature indices', 'cloud height', 'flight level winds', 'cloud droplet distribution', 'cloud droplet concentration/size', 'cloud condensation nuclei', 'cloud microphysics', 'hydrometeors', 'ozone', 'wind profiles', 'cloud base temperature', 'cloud base height', 'liquid water equivalent', 'solar radiation', 'planetary boundary layer height', 'surface winds', 'precipitation amount', 'precipitation rate', 'surface pressure', 'rain', 'cloud optical depth/thickness', 'aerosol extinction', 'aerosol optical depth/thickness', 'cirrus cloud systems', 'lidar depolarization ratio', 'radar backscatter', 'radar cross-section', 'return power', 'mean radial velocity', 'radiance', 'air quality', 'climate advisories', 'atmospheric emitted radiation', 'optical depth/thickness', 'surface temperature', 'ultraviolet flux', 'spectrum width', 'microwave imagery', 'lidar backscatter', 'relative humidity', 'u/v wind components', 'wind speed/wind direction', 'radar imagery', 'snow depth', 'land use/land cover classification', 'digital elevation/terrain model (dem)', 'snow', 'droplet size', 'droplet concentration/size', 'drizzle', 'precipitation anomalies', 'snow water equivalent', 'solid precipitation', 'total surface precipitation rate', 'particle size distribution', 'skin temperature', 'attitude characteristics', 'land surface temperature', 'hail', 'reflectance', 'soil moisture/water content', 'soil temperature', 'soil bulk density', 'surface roughness', 'present weather', 'snow density', 'ambient temperature', 'aerosol forward scatter', 'floods', 'snow cover', 'sigma naught', 'precipitable water', 'stage height', 'rivers/streams', 'shortwave radiation', 'photosynthetically active radiation', 'longwave radiation', 'net radiation', 'hourly precipitation amount', '24 hour precipitation amount', 'soil moisture', 'satellite orbits/revolution', 'sea surface temperature', 'heat flux', 'latent heat flux', 'cloud fraction', '3 and 6 hour precipitation amount', 'geopotential height', 'particulate matter', 'particle images', 'water vapor indices', 'horizontal wind velocity/speed', 'electrical conductivity', 'dissolved carbon dioxide', 'hurricanes', 'tropical cyclone track', 'convective clouds/systems (observed/analyzed)', 'cloud top height', 'viewing geometry', 'temperature profiles', 'vertical wind shear', 'wind shear', 'carbon monoxide', 'sea level pressure', 'water vapor tendency', 'potential temperature', 'angstrom exponent', 'ultraviolet radiation', 'solar irradiance', 'scattering', 'absorption', 'water vapor mixing ratio profiles', 'sea surface temperature indices', 'extreme eastern tropical pacific sst', 'sedimentation', 'erosion', 'sediment transport', 'sediments', 'tropopause', 'ocean chemistry', 'ocean optics', 'ocean temperature', 'salinity/density', 'pigments', 'ocean color', 'attenuation/transmission', 'inorganic carbon', 'organic carbon', 'photosynthetically available radiation', 'chlorophyll', 'optical depth', 'fluorescence', 'vegetation index', 'gelbstoff', 'phytoplankton', 'vegetation index2', 'cloud precipitable water', 'landscape ecology', 'ultraviolet radiance', 'cloud ceiling', 'aerosol radiance', 'carbonaceous aerosols', 'dust/ash/smoke', 'nitrate particles', 'organic particles', 'sulfate particles', 'radiative flux', 'transmittance', 'atmospheric stability', 'cloud asymmetry', 'cloud frequency', 'cloud top pressure', 'cloud top temperature', 'cloud vertical distribution', 'cloud emissivity', 'cloud radiative forcing', 'cloud reflectance', 'rain storms', 'reflected infrared', 'thermal infrared', 'incoming solar radiation', 'clouds', 'cloud properties', 'cloud types', 'orbital characteristics', 'sensor characteristics', 'maximum/minimum temperature', 'condensation', 'platform characteristics', 'geolocation', 'geodetics', 'coordinate reference system', 'aerosols', 'topographical relief maps', 'terrain elevation', 'normalized difference vegetation index (ndvi)', 'infrared flux', 'visible flux', 'albedo', 'land use/land cover', 'topography', 'lidar', 'lidar waveform', 'plant phenology', 'vegetation cover', 'crop/plant yields', 'land use classes', 'landscape patterns', 'forest harvesting and engineering', 'forest management', 'total surface water', 'agricultural plant science', 'photosynthesis', 'primary production', 'leaf characteristics', 'evapotranspiration', 'fire occurrence', 'surface thermal properties', 'canopy characteristics', 'evergreen vegetation', 'crown', 'deciduous vegetation', 'anisotropy', 'fire ecology', 'biomass burning', 'wildfires', 'topographical relief', 'burned area', 'surface radiative properties', 'environmental sustainability', 'boundaries', 'anthropogenic/human influenced ecosystems', 'emissions', 'sulfur dioxide', 'population', 'infrastructure', 'environmental assessments', 'public health', 'conservation', 'agriculture production', 'administrative divisions', 'economic resources', 'socioeconomics', 'lake/pond', 'rivers/stream', 'political divisions', 'environmental vulnerability index (evi)', 'ecosystems', 'urban areas', 'sustainability', 'treaty agreements/results', 'human settlements', 'population estimates', 'nitrogen dioxide', 'cropland', 'pasture', 'particulates', 'cyclones', 'mortality', 'environmental impacts', 'droughts', 'earthquakes', 'population distribution', 'fertilizers', 'animal manure and waste', 'urbanization/urban sprawl', 'landslides', 'avalanche', 'urban lands', 'mangroves', 'volcanic eruptions', 'pesticides', 'population size', 'population density', 'lakes/reservoirs', 'surface water', 'rural areas', 'infant mortality rates', 'amphibians', 'mammals', 'carbon', 'sulfur oxides', 'methane', 'non-methane hydrocarbons/volatile organic compounds', 'nitrogen oxides', 'natural gas', 'coal', 'coastal elevation', 'biodiversity functions', 'nuclear radiation exposure', 'radiation exposure', 'poverty levels', 'malnutrition', 'wetlands', 'sea level rise', 'vulnerability levels/index', 'ground water', 'snow/ice', 'electricity', 'energy production/use', 'sustainable development', 'deforestation', 'household income', 'discharge/flow', 'hydropattern', 'nitrogen', 'phosphorus', 'carbon dioxide', 'alpine/tundra', 'forests', 'vegetation', 'permafrost', 'nutrients', 'plant characteristics', 'leaf area index (lai)', 'soil gas/air', 'ammonia', 'nitrous oxide', 'ecosystem functions', 'litter characteristics', 'soil chemistry', 'soil respiration', 'active layer', 'soil depth', 'cation exchange capacity', 'organic matter', 'soil porosity', 'soil texture', 'permafrost melt', 'land subsidence', 'freeze/thaw', 'surface water features', 'chlorinated hydrocarbons', 'methyl bromide', 'methyl chloride', 'molecular hydrogen', 'sulfur compounds', 'fire models', 'biomass', 'dominant species', 'vegetation species', 'sulfur', 'tree rings', 'soil classification', 'heat index', 'sea ice concentration', 'ocean heat budget', 'reforestation', 'even-toed ungulates', 'species recruitment', 'population dynamics', 'range changes', 'topographic effects', 'land resources', 'river ice depth/extent', 'snow melt', 'river ice', 'animal commodities', 'animal ecology and behavior', 'phenological changes', 'water depth', 'inundation', 'forest fire science', 'biogeochemical cycles', 'radiative forcing', 'soil heat budget', 'drainage', 'respiration rate', 'river/lake ice breakup', 'river/lake ice freeze', 'reclamation/revegetation/restoration', 'permafrost temperature', 'indigenous/native species', 'fire dynamics', 'lichens', 'plants', 'plant succession', 'carbon flux', 'coastal', 'salt marsh', 'degradation', 'altitude', 'carbon and hydrocarbon compounds', 'halocarbons and halogens', 'forest composition/vegetation structure', 'water vapor indicators', 'barometric altitude', 'atmospheric water vapor', 'terrestrial ecosystems', 'volatile organic compounds', 'boundary layer winds', 'forest fire danger index', 'periglacial processes', 'landscape processes', 'evaporation', 'soil horizons/profile', 'shrubland/scrub', 'soil ph', 'soils', 'soil water holding capacity', 'community structure', 'pingo', 'soil color', 'virtual temperature', 'formaldehyde', 'hydroxyl', 'photolysis rates', 'cloud dynamics', 'nitric oxide', 'molecular oxygen', 'smog', 'peroxyacyl nitrate', 'hydrogen compounds', 'nitrogen compounds', 'oxygen compounds', 'stable isotopes', 'chemical composition', 'actinic flux', 'tropospheric ozone', 'fossil fuel burning', 'industrial emissions', 'denitrification rate', 'sunshine', 'runoff', 'soil structure', 'mosses/hornworts/liverworts', 'peatlands', 'hydraulic conductivity', 'snow/ice temperature', 'vegetation water content', 'discharge', 'chlorophyll concentrations', 'outgoing longwave radiation', 'geomorphic landforms/processes', 'soil compaction', 'soil impedance', 'canopy transmittance', 'water table', 'decomposition', 'water temperature', 'dissolved gases', 'total dissolved solids', 'agricultural expansion', 'forest science', 'pressure tendency', 'visibility', 'biomass dynamics', 'agricultural lands', 'grasslands', 'savannas', 'grazing dynamics/plant herbivory', 'herbivory', 'paleoclimate reconstructions', 'drought indices', 'fire weather index', 'animal yields', 'multivariate enso index', 'dissolved solids', 'ocean currents', 'salinity', 'coastal processes', 'atmospheric pressure', 'afforestation/reforestation', 'fresh water river discharge', 'surface water chemistry', 'drainage basins', 'resource development site', 'dunes', 'flood plain', 'endangered species', 'precipitation indices', 'temperature indices', 'forest yields', 'stratigraphic sequence', 'freeze/frost', 'frost', 'hydrogen cyanide', 'land management', 'nutrient cycling', 'industrialization', 'suspended solids', 'deserts', 'weathering', 'gas flaring', 'atmospheric temperature', 'ice extent', 'fraction of absorbed photosynthetically active radiation (fapar)', 'marshes', 'swamps', 'lake ice', 'atmospheric winds', 'watershed characteristics', 'transportation', 'soil rooting depth', 'isotopes', 'cultural features', 'consumer behavior', 'boundary surveys', 'aquifers', 'land productivity', 'water quality/water chemistry', 'sediment composition', 'dissolved oxygen', 'surface water processes/measurements', 'turbidity', 'conductivity', 'ph', 'calcium', 'magnesium', 'potassium', 'micronutrients/trace elements', 'social behavior', 'sulfate', 'sediment chemistry', 'biogeochemical processes', 'water ion concentrations', 'cropping systems', 'percolation', 'groundwater chemistry', 'reforestation/revegetation', 'species/population interactions', 'soil infiltration', 'alkalinity', 'soil fertility', 'phosphorous compounds', 'radioisotopes', 'cooling degree days', 'angiosperms (flowering plants)', 'glacial landforms', 'glacial processes', 'contour maps', 'estuaries', 'methane production/use', 'natural gas production/use', 'petroleum production/use', 'visualization/image processing', 'subsetting/supersetting', 'transformation/conversion', 'forest mensuration', 'acid deposition', 'differential pressure', 'precipitation', 'marine ecosystems', 'consumption rates', 'radio wave', 'soil organic carbon (soc)', 'soil erosion', 'halocarbons', 'trace elements/trace metals', 'biomass energy production/use', 'riparian wetlands', 'soil consistence', 'snow stratigraphy', 'thermal conductivity', 'estuary', 'tidal height', 'plant diseases/disorders/pests', 'layered precipitable water', 'atmospheric chemistry', 'water vapor concentration profiles', 'specific humidity', 'total runoff', 'pressure thickness', 'wind stress', 'atmospheric heating', 'conduction', 'hydrogen chloride', 'nitric acid', 'radar', 'land surface/agriculture indicators', 'satellite soil moisture index', 'chlorine nitrate', 'chlorofluorocarbons', 'dinitrogen pentoxide', 'antenna temperature', 'glaciers', 'ice sheets', 'dimethyl sulfide', 'potential vorticity', 'ice fraction', 'atmospheric radiation', 'runoff rate', 'temperature tendency', 'wind dynamics', 'wind direction tendency', 'base flow', 'bromine monoxide', 'chlorine monoxide', 'methyl cyanide', 'hypochlorous acid', 'methanol', 'hydroperoxy', 'cloud base pressure', 'temperature anomalies', 'nitrate', 'ocean mixed layer', 'precipitation trends', 'temperature trends', 'convection', 'ground ice', 'oxygen', 'phosphate', 'solar induced fluorescence', 'chlorine dioxide', 'sun-earth interactions', 'uv aerosol index', 'volcanic activity', 'potential evapotranspiration', 'ultraviolet wavelengths', 'ice temperature', 'sea surface skin temperature', 'sea surface height', 'sublimation', 'convective surface precipitation rate', 'hydrogen fluoride', 'airglow', 'energy deposition', 'x-ray flux', 'electron flux', 'proton flux', 'magnetic fields/magnetic currents']\\n else:\\n return ['platform characteristics', 'atmospheric winds','radio wave', 'weather events', 'geomagnetism','atmospheric electricity', 'microwave', 'atmospheric temperature','atmospheric water vapor', 'atmospheric pressure', 'aerosols','atmospheric radiation', 'atmospheric chemistry', 'precipitation','sensor characteristics', 'radar', 'infrared wavelengths','visible wavelengths', 'weather/climate advisories', 'clouds','lidar', 'ocean optics', 'ultraviolet wavelengths','cryospheric indicators', 'land use/land cover', 'topography','surface thermal properties', 'spectral/engineering', 'soils','snow/ice', 'geothermal dynamics', 'natural hazards','surface water', 'vegetation','land surface/agriculture indicators','gravity/gravitational field', 'marine advisories', 'altitude','water quality/water chemistry', 'ocean temperature','ocean winds', 'atmospheric/ocean indicators', 'coastal processes','erosion/sedimentation', 'marine sediments', 'ocean chemistry','salinity/density', 'ocean color', 'aquatic ecosystems','vegetation2', 'landscape', 'cloud properties','surface radiative properties', 'geodetics','agricultural plant science', 'forest science','ecological dynamics', 'environmental impacts', 'sustainability','boundaries', 'ecosystems', 'air quality', 'population','infrastructure', 'environmental governance/management','public health', 'economic resources', 'socioeconomics','environmental vulnerability index (evi)', 'human settlements','agricultural chemicals', 'animal science','habitat conversion/fragmentation', 'animals/vertebrates','earth gases/liquids', 'rocks/minerals/crystals','social behavior', 'ground water', 'frozen ground','terrestrial hydrosphere indicators', 'ocean heat budget','biospheric indicators', 'animal commodities', 'fungi', 'plants','carbon flux', 'geomorphic landforms/processes','paleoclimate indicators', 'ocean circulation', 'sea ice','geochemistry', 'visualization/image processing','subsetting/supersetting', 'transformation/conversion','ocean pressure', 'glaciers/ice sheets', 'protists','solar activity', 'sun-earth interactions','sea surface topography', 'solar energetic particle properties','solar energetic particle flux','ionosphere/magnetosphere dynamics','flight data logs','wind dynamics', 'radio wave flux', 'lightning', 'magnetic field','atmospheric conductivity', 'electric field','data synchronization time', 'brightness temperature','upper air temperature', 'water vapor profiles','surface temperature', 'upper level winds','atmospheric pressure measurements', 'water vapor indicators','aerosol particle properties', 'emissivity','trace gases/trace species', 'liquid precipitation','cloud microphysics', 'microwave radiance', 'sensor counts','total pressure', 'airspeed/ground speed', 'total temperature','static pressure', 'humidity', 'radar reflectivity','doppler velocity', 'infrared imagery', 'visible imagery','aerosol backscatter', 'weather forecast', 'tropical cyclones','visible radiance', 'infrared radiance','atmospheric temperature indices', 'cloud droplet distribution','cloud condensation nuclei', 'hydrometeors', 'oxygen compounds','wind profiles', 'liquid water equivalent', 'solar radiation','planetary boundary layer height', 'surface winds','precipitation amount', 'precipitation rate', 'surface pressure','aerosol extinction', 'aerosol optical depth/thickness','tropospheric/high-level clouds (observed/analyzed)','lidar depolarization ratio', 'radar backscatter','radar cross-section', 'return power', 'radial velocity','radiance', 'climate advisories', 'atmospheric emitted radiation','optical depth/thickness', 'ultraviolet flux', 'spectrum width','microwave imagery', 'lidar backscatter', 'radar imagery','snow depth', 'land use/land cover classification','terrain elevation', 'solid precipitation', 'droplet size','droplet concentration/size', 'precipitation anomalies','snow water equivalent', 'total surface precipitation rate','skin temperature', 'water vapor', 'attitude characteristics','land surface temperature', 'reflectance','soil moisture/water content', 'soil temperature','soil bulk density', 'surface roughness', 'present weather','snow density', 'geothermal temperature','aerosol forward scatter', 'floods', 'snow cover', 'sigma naught','precipitable water', 'surface water processes/measurements','surface water features', 'shortwave radiation','photosynthetically active radiation', 'longwave radiation','net radiation', 'flight level winds', 'soil moisture','satellite orbits/revolution', 'heat flux','precipitation profiles', 'geopotential height','particulate matter', 'particle images', 'water vapor indices','electrical conductivity', 'gases', 'sea surface temperature','convective clouds/systems (observed/analyzed)','viewing geometry', 'wind shear','carbon and hydrocarbon compounds', 'sea level pressure','water vapor processes', 'ultraviolet radiation','solar irradiance', 'scattering', 'absorption','sea surface temperature indices', 'sedimentation', 'erosion','sediment transport', 'sediments', 'tropopause', 'nan', 'pigments','attenuation/transmission', 'inorganic carbon', 'organic carbon','photosynthetically available radiation', 'chlorophyll','optical depth', 'fluorescence', 'vegetation index', 'gelbstoff','plankton', 'vegetation index2', 'landscape ecology','ultraviolet radiance', 'aerosol radiance','carbonaceous aerosols', 'dust/ash/smoke', 'nitrate particles','organic particles', 'sulfate particles', 'radiative flux','transmittance', 'atmospheric stability','cloud radiative transfer', 'rain storms', 'reflected infrared','thermal infrared', 'incoming solar radiation', 'cloud types','orbital characteristics', 'geolocation','coordinate reference system', 'infrared flux', 'visible flux','albedo', 'lidar waveform', 'plant phenology', 'vegetation cover','crop/plant yields', 'land use classes', 'landscape patterns','forest harvesting and engineering', 'forest management','ecosystem functions', 'leaf characteristics', 'fire ecology','total surface water', 'primary production', 'photosynthesis','canopy characteristics', 'evergreen vegetation', 'crown','deciduous vegetation', 'anisotropy', 'biomass burning','wildfires', 'topographical relief','environmental sustainability','anthropogenic/human influenced ecosystems', 'emissions','sulfur compounds', 'environmental assessments', 'conservation','agriculture production', 'administrative divisions','freshwater ecosystems', 'political divisions', 'urban areas','treaty agreements/results', 'population estimates','nitrogen compounds', 'particulates', 'mortality', 'droughts','earthquakes', 'population distribution', 'fertilizers','animal manure and waste', 'urbanization/urban sprawl','landslides', 'avalanche', 'mangroves', 'volcanic eruptions','pesticides', 'population size', 'population density','rural areas', 'amphibians', 'mammals', 'carbon', 'sulfur oxides','land management', 'natural gas', 'sedimentary rocks','coastal elevation', 'community dynamics','nuclear radiation exposure', 'radiation exposure','poverty levels', 'malnutrition', 'sea level rise','vulnerability levels/index', 'electricity','energy production/use', 'sustainable development','deforestation', 'household income', 'nitrogen', 'phosphorus','terrestrial ecosystems', 'permafrost', 'nutrients','plant characteristics', 'soil gas/air', 'litter characteristics','soil chemistry', 'soil respiration', 'active layer', 'soil depth','cation exchange capacity', 'organic matter', 'soil porosity','soil texture', 'permafrost melt','ground water processes/measurements', 'freeze/thaw','halocarbons and halogens', 'hydrogen compounds', 'biomass','dominant species', 'vegetation species', 'sulfur', 'tree rings','soil classification', 'sea ice concentration', 'reforestation','species/population interactions', 'range changes','topographic effects', 'land resources', 'river ice depth/extent','snow melt', 'river ice', 'animal ecology and behavior','phenological changes', 'forest fire science', 'radiative forcing','soil heat budget', 'river/lake ice breakup','river/lake ice freeze', 'reclamation/revegetation/restoration','lichens', 'marine ecosystems', 'coastal landforms', 'degradation','forest composition/vegetation structure', 'barometric altitude','volatile organic compounds', 'forest fire danger index','periglacial processes', 'landscape processes','soil horizons/profile', 'soil ph', 'soil water holding capacity','fluvial landforms', 'soil color', 'glacial processes','photochemistry', 'cloud dynamics', 'nitrogen oxides', 'smog','chemical composition', 'actinic flux', 'tropospheric ozone','fossil fuel burning', 'industrial emissions','denitrification rate', 'sunshine', 'soil structure','mosses/hornworts/liverworts', 'hydraulic conductivity','snow/ice temperature', 'water characteristics','outgoing longwave radiation', 'soil compaction', 'soil impedance','canopy transmittance', 'ground water features', 'solids','agricultural expansion', 'pressure tendency', 'visibility','herbivory', 'paleoclimate reconstructions', 'drought indices','fire weather index', 'animal yields', 'teleconnections','carbon dioxide', 'dissolved solids', 'ocean currents', 'salinity','afforestation/reforestation', 'fresh water river discharge','surface water chemistry', 'aeolian landforms','precipitation indices', 'temperature indices', 'forest yields','stratigraphic sequence', 'freeze/frost', 'frost','industrialization', 'ice core records', 'suspended solids','weathering', 'gas flaring', 'ice extent', 'biogeochemical cycles','lake ice', 'isotopes', 'watershed characteristics','transportation', 'soil rooting depth', 'geochemical properties','carbon monoxide', 'cultural features', 'consumer behavior','boundary surveys', 'land productivity', 'sediment composition','calcium', 'magnesium', 'potassium','micronutrients/trace elements', 'sediment chemistry','biogeochemical processes', 'cropping systems','groundwater chemistry', 'reforestation/revegetation','soil infiltration', 'soil fertility','angiosperms (flowering plants)', 'glacial landforms','forest mensuration', 'acid deposition', 'differential pressure','soil erosion', 'trace elements/trace metals', 'soil consistence','snow stratigraphy', 'thermal conductivity', 'estuaries','tidal height', 'plant diseases/disorders/pests','pressure thickness', 'atmospheric heating', 'conduction','evaporation', 'turbulence', 'wind stress','satellite soil moisture index', 'antenna temperature', 'glaciers','ice sheets', 'nitrate', 'ocean mixed layer','precipitation indicators', 'temperature indicators', 'ground ice','alkalinity', 'dissolved gases', 'oxygen', 'ph', 'phosphate','solar induced fluorescence', 'volcanic activity','ice temperature', 'sea surface height', 'airglow','energy deposition', 'x-ray flux', 'electron flux', 'proton flux','magnetic fields/magnetic currents', 'vertical profiles','air temperature', 'dew point temperature','cloud liquid water/ice', 'wind speed', 'wind direction','vertical wind velocity/speed', 'total precipitable water','boundary layer temperature', 'cloud height','cloud droplet concentration/size', 'ozone','cloud base temperature', 'cloud base height', 'rain','cloud optical depth/thickness', 'cirrus/systems','mean radial velocity', 'relative humidity', 'u/v wind components','wind speed/wind direction','digital elevation/terrain model (dem)', 'snow', 'drizzle','particle size distribution', 'hail', 'ambient temperature','stage height', 'rivers/streams', 'hourly precipitation amount','24 hour precipitation amount', 'latent heat flux','cloud fraction', '3 and 6 hour precipitation amount','horizontal wind velocity/speed', 'dissolved carbon dioxide','hurricanes', 'tropical cyclone track', 'cloud top height','temperature profiles', 'vertical wind shear','water vapor tendency', 'potential temperature','angstrom exponent', 'water vapor mixing ratio profiles','extreme eastern tropical pacific sst', 'phytoplankton','cloud precipitable water', 'cloud asymmetry', 'cloud ceiling','cloud frequency', 'cloud top pressure', 'cloud top temperature','cloud vertical distribution', 'cloud emissivity','cloud radiative forcing', 'cloud reflectance','maximum/minimum temperature', 'condensation','topographical relief maps', 'evapotranspiration','fire occurrence', 'burned area', 'sulfur dioxide', 'lake/pond','rivers/stream', 'nitrogen dioxide', 'agricultural lands','cyclones', 'urban lands', 'lakes/reservoirs','infant mortality rates', 'methane','non-methane hydrocarbons/volatile organic compounds', 'coal','biodiversity functions', 'wetlands', 'discharge/flow','hydropattern', 'alpine/tundra', 'forests','leaf area index (lai)', 'ammonia', 'nitrous oxide','land subsidence', 'normalized difference vegetation index (ndvi)','chlorinated hydrocarbons', 'methyl bromide', 'methyl chloride','molecular hydrogen', 'fire models', 'heat index','even-toed ungulates', 'species recruitment','population dynamics', 'water depth', 'inundation', 'drainage','respiration rate', 'permafrost temperature','indigenous/native species', 'fire dynamics', 'plant succession','coastal', 'salt marsh', 'boundary layer winds', 'shrubland/scrub','community structure', 'pingo', 'virtual temperature','formaldehyde', 'hydroxyl', 'photolysis rates', 'nitric oxide','molecular oxygen', 'peroxyacyl nitrate', 'stable isotopes','runoff', 'vegetation water content', 'discharge','chlorophyll concentrations', 'water table', 'decomposition','water temperature', 'total dissolved solids', 'biomass dynamics','grasslands', 'savannas', 'grazing dynamics/plant herbivory','multivariate enso index', 'drainage basins','resource development site', 'dunes', 'flood plain','endangered species', 'hydrogen cyanide', 'nutrient cycling','deserts','fraction of absorbed photosynthetically active radiation (fapar)','aquifers', 'dissolved oxygen', 'turbidity', 'conductivity','sulfate', 'water ion concentrations', 'percolation','phosphorous compounds', 'radioisotopes', 'cooling degree days','contour maps', 'methane production/use','natural gas production/use', 'petroleum production/use','consumption rates', 'soil organic carbon (soc)', 'halocarbons','biomass energy production/use', 'estuary','layered precipitable water', 'water vapor concentration profiles','hydrogen chloride', 'nitric acid', 'chlorine nitrate','chlorofluorocarbons', 'dinitrogen pentoxide', 'dimethyl sulfide','vorticity', 'ice fraction', 'temperature tendency','wind direction tendency', 'bromine monoxide', 'chlorine monoxide','methyl cyanide', 'hypochlorous acid', 'methanol', 'hydroperoxy','cloud base pressure', 'temperature anomalies','precipitation trends', 'temperature trends', 'convection','chlorine dioxide', 'uv aerosol index','sea surface skin temperature', 'sublimation','convective surface precipitation rate', 'hydrogen fluoride']\",\n \"def setContourLabelDistance(distance=500):\\n dislin.labdis(distance, 'CONTUR')\",\n \"def eval_final_label(args):\\n cfg, lbl = util.get_label_cfg_by_args(args)\\n uid = cfg['uniqueid']\\n print('We are playing with %s' % uid)\\n outdir='models/%s/gate_expert' % uid\\n outname='gate_expert_model.pt'\\n if KLLOSS:\\n outname = 'gate_expert_kldiv_model.pt'\\n if args.warm:\\n outname = outname.replace('.pt', '_warm.pt')\\n mdl_path = os.path.join(outdir, outname)\\n gate_expert = GateExpertNet(mdl_path, False)\\n eval_fun = gate_expert.get_p_y\\n\\n data = npload(cfg['file_path'], uid)\\n datax = data[cfg['x_name']]\\n p, v = eval_fun(datax)\\n\\n label = np.argmax(p, axis=1)\\n\\n if args.draw:\\n fig, ax = plt.subplots()\\n n_expert = np.amax(label) + 1\\n for i in range(n_expert):\\n mask = label == i\\n ax.scatter(datax[mask, 0], datax[mask, 1])\\n plt.show()\\n\\n label_name = 'data/pen/gate_expert_label.npy'\\n if KLLOSS:\\n label_name = label_name.replace('_label', '_kldiv_label')\\n if args.warm:\\n label_name = label_name.replace('.npy', '_warm.npy')\\n np.save(label_name, label)\",\n \"def donut_highD(N=1500, V=1500, binary=True, d=3):\\n X = torch.randn(N + V, d)\\n R = torch.sqrt(torch.sum(X ** 2, dim=1))\\n ind_class0 = (R < 1.0).nonzero()[:, 0]\\n ind_class1 = (R >= 1.0).nonzero()[:, 0]\\n X = X * 1.2 # rescale data\\n X.add_(0.2 * torch.randn_like(X)) # add some noise to the data\\n \\n return label(d, X, ind_class0, ind_class1, N, V, binary)\",\n \"def label(self):\\r\\n raise NotImplementedError\",\n \"def cell_description(self, gid):\\n\\n tree = arbor.segment_tree()\\n\\n tree.append(\\n arbor.mnpos,\\n arbor.mpoint(0, 0, 0, self.radius),\\n arbor.mpoint(self.length, 0, 0, self.radius),\\n tag=1,\\n )\\n\\n labels = arbor.label_dict({\\\"cable\\\": \\\"(tag 1)\\\", \\\"start\\\": \\\"(location 0 0)\\\"})\\n\\n decor = (\\n arbor.decor()\\n .set_property(Vm=self.Vm, cm=self.cm, rL=self.rL)\\n .paint('\\\"cable\\\"', arbor.density(f\\\"pas/e={self.Vm}\\\", g=self.g))\\n .place(\\n '\\\"start\\\"',\\n arbor.iclamp(\\n self.stimulus_start, self.stimulus_duration, self.stimulus_amplitude\\n ),\\n \\\"iclamp\\\",\\n )\\n )\\n\\n policy = arbor.cv_policy_max_extent(self.cv_policy_max_extent)\\n decor.discretization(policy)\\n\\n return arbor.cable_cell(tree, decor, labels)\",\n \"def label(cmd):\\n cmd = cmd.replace('make][.DP', 'make1][.NP')\\n cmd = cmd.replace('make][.SC', 'make2][.SC')\\n cmd = re.sub('(draw.*)one','\\\\\\\\1one1',cmd)\\n cmd = re.sub('(make1.*)one','\\\\\\\\1one1',cmd)\\n cmd = re.sub('(make2.*)one','\\\\\\\\1one2',cmd)\\n cmd = re.sub('(move.*)one','\\\\\\\\1one2',cmd)\\n cmd = re.sub('(hide.*)one','\\\\\\\\1one2',cmd)\\n cmd = '[result ' + cmd + ']' #dummy function for plop\\n return cmd\",\n \"def plot_countryperskill(data_df, **args):\\n name = args.get('name', 'VARIABLE NAME')\\n idx = args.get('idx', data_df.index.values)\\n order = args.get('order', np.array([9, 0, 1, 2, 3, 4, 5, 6, 8, 7], int))\\n dd = args.get('dd', .7) # 3.3\\n wdth = args.get('wdth', 8) # 7\\n hght = args.get('hght', 4)\\n markersize = 60\\n target_y = args.get('target_y', 1)\\n label_y = args.get('label_y', r'$\\\\rho$')\\n colors14 = args.get('colors14', ['#a6cee3', '#1f78b4', '#b2df8a', '#33a02c', \\\\\\n '#fb9a99', '#e31a1c', '#fdbf6f', '#ff7f00', \\\\\\n '#cab2d6', '#6a3d9a', '#ffff99', '#b15928', \\\\\\n '#dd1c77', '#8dd3c7'])\\n plt.figure(facecolor='w', figsize=(wdth, hght))\\n meth_labels = [r'$Lit$', r'$Lit^2$', r'$Lit^3$', r'$Lit^4$', r'$Lit^5$', \\\\\\n r'$Pop$', r'$Pop^2$', r'$Lit^3Pop$', r'$Lit^2Pop$', r'$LitPop$']\\n idx = idx[order]\\n meth_labels = [meth_labels[i] for i in order]\\n # empty plots for legend handlers:\\n for i in np.arange(0, len(countries_sel)): # country\\n plt.scatter([], [], marker='o', s=markersize, edgecolor='black', linewidth='.4',\\\\\\n c=colors14[i], label=countries[countries_sel[i]])\\n plt.legend()\\n\\n plt.scatter([0, len(idx)+dd], [0.7, 0.7], marker='.', lw=1, c='white') # legendspace\\n\\n # actual plotting:\\n for i in np.arange(0, len(countries_sel)): # country\\n for j in np.arange(0, len(idx)):\\n # rp - pearson correlation:\\n plt.scatter([j], data_df[countries[countries_sel[i]]][idx[j]], marker='o', \\\\\\n s=markersize, edgecolor='black', linewidth='.4',\\\\\\n alpha=1., c=colors14[i], zorder=j+10)\\n if not target_y == 'none':\\n plt.plot([0, j], [target_y, target_y], c='#d3d3d3', lw=5, ls='-', zorder=1)\\n\\n plt.xticks(np.arange(0, len(idx)), meth_labels, color='black', rotation=30)\\n plt.grid(axis='y')\\n # plt.xlabel('Method')\\n plt.ylabel(label_y)\\n plt.title(name)\\n\\n plt.savefig(os.path.join(output_path, experiment_name + '_' + 'allcountries_perScore_v4_' + name + '.pdf'),\\\\\\n dpi=600, facecolor='w', edgecolor='w',\\n orientation='portrait', papertype=None, format='pdf',\\n transparent=False, bbox_inches=None, pad_inches=0.1,\\n frameon=None, metadata=None)\\n plt.show()\",\n \"def showOneNeedle(self,i,visibility):\\n #obsolete\\n profbox()\\n fidname = \\\"fid\\\"+self.option[i]\\n pNode = self.parameterNode()\\n needleID = pNode.GetParameter(self.option[i]+'.vtp')\\n fidID = pNode.GetParameter(fidname) \\n NeedleNode = slicer.mrmlScene.GetNodeByID(needleID)\\n fiducialNode = slicer.mrmlScene.GetNodeByID(fidID) \\n \\n if NeedleNode !=None:\\n displayNode =NeedleNode.GetModelDisplayNode()\\n nVisibility=displayNode.GetVisibility() \\n\\n if fiducialNode == None:\\n displayNode.SetVisibility(1) \\n displayNode.SetOpacity(0.9)\\n polyData = NeedleNode.GetPolyData()\\n polyData.Update()\\n nb = int(polyData.GetNumberOfPoints()-1)\\n coord = [0,0,0]\\n if nb>100:\\n fiducialNode = slicer.vtkMRMLAnnotationFiducialNode()\\n polyData.GetPoint(nb,coord) \\n fiducialNode.SetName(self.option[i])\\n fiducialNode.SetFiducialCoordinates(coord) \\n fiducialNode.Initialize(slicer.mrmlScene)\\n fiducialNode.SetLocked(1)\\n fiducialNode.SetSelectable(0)\\n fidDN = fiducialNode.GetDisplayNode()\\n fidDN.SetColor(NeedleNode.GetDisplayNode().GetColor())\\n fidDN.SetGlyphScale(0)\\n fidTN = fiducialNode.GetAnnotationTextDisplayNode()\\n fidTN.SetTextScale(3)\\n fidTN.SetColor(NeedleNode.GetDisplayNode().GetColor())\\n fiducialNode.SetDisplayVisibility(0)\\n pNode.SetParameter(fidname,fiducialNode.GetID())\\n fiducialNode.SetDisplayVisibility(1)\\n\\n if visibility ==0:\\n\\n displayNode.SetVisibility(0)\\n displayNode.SetSliceIntersectionVisibility(0)\\n if fiducialNode!=None:\\n fiducialNode.SetDisplayVisibility(0)\\n\\n else:\\n\\n displayNode.SetVisibility(1)\\n displayNode.SetSliceIntersectionVisibility(1)\\n if fiducialNode!=None:\\n fiducialNode.SetDisplayVisibility(1)\\n\\n else:\\n vtkmat = vtk.vtkMatrix4x4()\\n vtkmat.DeepCopy(self.m_vtkmat)\\n vtkmat.SetElement(0,3,self.m_vtkmat.GetElement(0,3)+self.p[0][i])\\n vtkmat.SetElement(1,3,self.m_vtkmat.GetElement(1,3)+self.p[1][i])\\n vtkmat.SetElement(2,3,self.m_vtkmat.GetElement(2,3)+(30.0-150.0)/2.0)\\n\\n TransformPolyDataFilter=vtk.vtkTransformPolyDataFilter()\\n Transform=vtk.vtkTransform() \\n TransformPolyDataFilter.SetInput(self.m_polyCylinder)\\n Transform.SetMatrix(vtkmat)\\n TransformPolyDataFilter.SetTransform(Transform)\\n TransformPolyDataFilter.Update()\\n\\n triangles=vtk.vtkTriangleFilter()\\n triangles.SetInput(TransformPolyDataFilter.GetOutput()) \\n self.AddModel(i,triangles.GetOutput())\\n self.showOneNeedle(i,visibility)\",\n \"def getLabel(*args):\",\n \"def getLabel(*args):\",\n \"def getLabel(*args):\",\n \"def drawlabels(t, t1):\\r\\n t.fd(250)\\r\\n t.pd()\\r\\n t.write(\\\"Life\\\", font=(\\\"Arial\\\", 10, \\\"bold\\\"))\\r\\n t.pu()\\r\\n t.back(12)\\r\\n t.pd()\\r\\n t.write(\\\"Exp.\\\", font=(\\\"Arial\\\", 10, \\\"bold\\\"))\\r\\n t.pu()\\r\\n t.back(238)\\r\\n t.right(90)\\r\\n t.fd(80)\\r\\n t1.pu()\\r\\n t1.back(50)\\r\\n t1.rt(90)\\r\\n t1.fd(250)\\r\\n t1.pd()\\r\\n t1.write(\\\"Year\\\", font=(\\\"Arial\\\", 10, \\\"bold\\\"))\\r\\n t1.pu()\\r\\n t1.back(250)\\r\\n t1.left(90)\\r\\n t1.fd(50)\",\n \"def ex_label(self,label,argl):\\n if len(label) > 0 and label[0] != '_':\\n return label\\n comment = ''\\n for i in argl:\\n phrase = ''\\n if i == 'l':\\n phrase = label\\n elif i in self._labels.keys():\\n phrase = self._labels[i]\\n comment += phrase\\n return comment\",\n \"def efficient_tagged_jets_hist(datalist,discriminant, discriminant_cut, CSV_cut, bins, Difference=False, mode=\\\"pT_jet\\\",Save=False):\\n title = \\\"tagged_jets_vs_\\\"+mode\\n AllJetsHistlist = []\\n CSVHistlist = []\\n DiscriminantHistlist = []\\n if mode == \\\"pT_hadron\\\":\\n feature = 2\\n elif mode == \\\"pT_jet\\\":\\n feature = 3\\n elif mode == \\\"decay_vx\\\":\\n feature = 4\\n for n,data in enumerate(datalist):\\n print \\\"working on\\\",data[1]\\n ran = data[2]\\n AllJetsHistlist.append(rt.TH1D(data[1]+\\\"_AllJets\\\",data[1]+\\\"_\\\"+title,bins,ran[0],ran[1]))\\n AllJetsHistlist[n].SetLineColor(4)\\n CSVHistlist.append(rt.TH1D(data[1]+\\\"_CSV\\\",data[1]+\\\"_\\\"+title,bins,ran[0],ran[1]))\\n CSVHistlist[n].SetLineColor(3)\\n DiscriminantHistlist.append(rt.TH1D(data[1]+\\\"_Discriminant\\\",data[1]+\\\"_\\\"+title,bins,ran[0],ran[1]))\\n DiscriminantHistlist[n].SetLineColor(2)\\n for particle in data[0]:\\n AllJetsHistlist[n].Fill(particle[feature])\\n if particle[1] >= CSV_cut: CSVHistlist[n].Fill(particle[feature])\\n if Difference:\\n L = particle[8]-particle[5]\\n else:\\n if particle[13] != 0:\\n L = particle[16]/float(particle[13])\\n else:\\n continue\\n if L >= discriminant_cut: DiscriminantHistlist[n].Fill(particle[feature])\\n canvaslist = []\\n legendlist = []\\n Tfilelist = []\\n for n,data in enumerate(datalist):\\n canvaslist.append(rt.TCanvas(data[1]+\\\"_canvas\\\",\\\"canvas\\\",600,600))\\n canvaslist[n].SetTitle(data[1]+\\\"_\\\"+title)\\n rt.gStyle.SetOptStat(0)\\n legendlist.append(rt.TLegend(0.9,0.9,0.65,0.75))\\n legendlist[n].AddEntry(AllJetsHistlist[n], \\\"All jets\\\")\\n legendlist[n].AddEntry(CSVHistlist[n], \\\"CSV\\\")\\n legendlist[n].AddEntry(DiscriminantHistlist[n], discriminant)\\n AllJetsHistlist[n].GetXaxis().SetTitle(mode)\\n AllJetsHistlist[n].GetYaxis().SetTitle('# jets')\\n AllJetsHistlist[n].GetYaxis().SetTitleOffset(1.5)\\n #AllJetsHistlist[n].Draw()\\n #CSVHistlist[n].Draw(\\\"SAME\\\")\\n #DiscriminantHistlist[n].Draw(\\\"SAME\\\")\\n #legendlist[n].Draw()\\n if Save:\\n #canvaslist[n].SaveAs(\\\"Thesis_Plots/\\\"+title+\\\"_\\\"+data[1]+discriminant+\\\".png\\\")\\n Tfilelist.append(rt.TFile(\\\"Thesis_Plots/root_files/\\\"+title+\\\"_\\\"+data[1]+discriminant+\\\".root\\\",\\\"recreate\\\"))\\n AllJetsHistlist[n].Write()\\n CSVHistlist[n].Write()\\n DiscriminantHistlist[n].Write()\",\n \"def autolabel(rects):\",\n \"def __init__(self, label_num, des_dir, des_dim=48):\\n self.label_num = label_num\\n self.des_dir = des_dir\\n self.des_dim = 48\",\n \"def _get_labels(self, ind):\\n pass\",\n \"def diet_label(self, diet_label):\\n\\n self._diet_label = diet_label\",\n \"def dim_reduction_plot(data, label, block_flag):\\n \\n PCA_model = TruncatedSVD(n_components=3).fit(data)\\n data_PCA = PCA_model.transform(data)\\n idxc1 = np.where(label==0)\\n idxc2 = np.where(label==1)\\n plt.scatter(data_PCA[idxc1,0],data_PCA[idxc1,1],s=80,c='r', marker='^',linewidths = 0, label='healthy')\\n plt.scatter(data_PCA[idxc2,0],data_PCA[idxc2,1],s=80,c='y', marker='o',linewidths = 0, label='infected')\\n plt.gca().axes.get_xaxis().set_ticks([])\\n plt.gca().axes.get_yaxis().set_ticks([])\\n plt.title('PCA of the codes')\\n plt.legend(scatterpoints=1,loc='best')\\n plt.show(block=block_flag)\",\n \"def plotrgcloud(self):\\n print self.kpunten\\n for i in range(len(self.kpunten[0])):\\n self.writetext('sen ='+ self.kpunten[0][i][0], (0.65,0.85), axnum = 0, hor = None ,ver = None , rot = None ,fs =14 , transform = self.fig.axes[0].transAxes)\\n if i == len(self.kpunten[0]) -1 :\\n end = None\\n else:\\n end = self.kpunten[0][i+1][1] + 1\\n print end\\n self.plotrgwrap( self.rgindex,2*self.reader.npair+self.rgindex,'real part of rgvars (a.u)' , 'imaginary part of rgvars (a.u.)', tit ='RG vars g = %f all states'%(self.chardata) , begin = self.kpunten[0][i][1] , stop = end , name = 'cpcloud'+ self.kpunten[0][i][0] , filenum = 0)\",\n \"def makeD2hhAsymm(name,\\n config,\\n KPIDK_string,\\n PiPIDK_string,\\n Mass_low_string,\\n Mass_high_string,\\n CombPIDK_string,\\n DecayDescriptor,\\n inputSel,\\n useTOS,\\n Hlt1TOS,\\n Hlt2TOS\\n ) :\\n\\n def makeTISTOS( name, _input, _hlttos ) :\\n from Configurables import TisTosParticleTagger\\n _tisTosFilter = TisTosParticleTagger( name + \\\"Tagger\\\" )\\n _tisTosFilter.TisTosSpecs = _hlttos\\n return Selection( name\\n , Algorithm = _tisTosFilter\\n , RequiredSelections = [ _input ]\\n ) \\n\\n _Kcuts1 = \\\"~ISMUON & (PT > %(DaugPtMin)s* MeV) & (MIPCHI2DV(PRIMARY) > %(DaugIPChi2)s)\\\" % locals()['config']\\n _KcutsPIDK = KPIDK_string % locals()['config']\\n _Kcuts2 = \\\" & (ISLONG) & (P > %(DaugP)s* MeV) & (TRCHI2DOF < %(DaugTrkChi2)s)\\\" % locals()['config']\\n _Kcuts = _Kcuts1 + _KcutsPIDK + _Kcuts2\\n _Picuts1 = \\\"~ISMUON & (PT > %(DaugPtMin)s* MeV) & (MIPCHI2DV(PRIMARY) > %(DaugIPChi2)s)\\\" % locals()['config']\\n _PicutsPIDK = PiPIDK_string % locals()['config']\\n _Picuts2 = \\\" & (ISLONG) & (P > %(DaugP)s* MeV) & (TRCHI2DOF < %(DaugTrkChi2)s)\\\" % locals()['config']\\n _Picuts = _Picuts1 + _PicutsPIDK + _Picuts2\\n _dauCuts = { 'K+': _Kcuts, 'pi+': _Picuts }\\n\\n _massLow = Mass_low_string % locals()['config']\\n _massHigh = Mass_high_string % locals()['config']\\n _combCuts1 = \\\"(APT > %(D0Pt)s* MeV)\\\" \\\\\\n \\\"& (AHASCHILD( PT > %(DaugPtMax)s* MeV ) )\\\" \\\\\\n \\\"& (ADOCA(1,2)< %(D0DOCA)s* mm)\\\" \\\\\\n \\\"& (AP > %(D0P)s* MeV)\\\" % locals()['config']\\n _combCutsPIDK = CombPIDK_string % locals()['config']\\n _combCuts = _combCuts1 + _combCutsPIDK + _massLow + _massHigh\\n\\n _motherCuts = \\\"(VFASPF(VCHI2PDOF) < %(D0VtxChi2Ndof)s)\\\" \\\\\\n \\\"& (BPVVDCHI2 > %(D0FDChi2)s)\\\" \\\\\\n \\\"& (BPVLTIME() > %(D0Tau)s)\\\" \\\\\\n \\\"& (BPVDIRA > %(D0BPVDira)s)\\\" % locals()['config']\\n\\n _D0 = CombineParticles( DecayDescriptor = DecayDescriptor,\\n MotherCut = _motherCuts,\\n CombinationCut = _combCuts,\\n DaughtersCuts = _dauCuts)\\n\\n _sel = Selection ( name+'Sel',\\n Algorithm = _D0,\\n RequiredSelections = inputSel )\\n\\n if not useTOS:\\n return _sel\\n\\n _selD2hhHlt1TOS = makeTISTOS( name + \\\"D2hhHlt1TOS\\\"\\n , _sel\\n , Hlt1TOS\\n )\\n _selD2hhHlt2TOS = makeTISTOS( name + \\\"D2hhHlt2TOS\\\"\\n , _selD2hhHlt1TOS\\n , Hlt2TOS\\n )\\n \\n return _selD2hhHlt2TOS\",\n \"def efficient_binned_tagged_jets_hist(datalist,discriminant, discriminant_cuts, CSV_cuts, bins, nbins, Difference=False, mode=\\\"pT_jet\\\",Save=False):\\n title = \\\"binned_tagged_jets_vs_\\\"+mode\\n AllJetsHistlist = []\\n CSVHistlist = []\\n DiscriminantHistlist = []\\n if mode == \\\"pT_hadron\\\":\\n feature = 2\\n elif mode == \\\"pT_jet\\\":\\n feature = 3\\n elif mode == \\\"decay_vx\\\":\\n feature = 4\\n for n,data in enumerate(datalist):\\n print \\\"working on\\\",data[1]\\n ran = data[2]\\n AllJetsHistlist.append(rt.TH1D(data[1]+\\\"_AllJets\\\",data[1]+\\\"_\\\"+title,nbins,ran[0],ran[1]))\\n AllJetsHistlist[n].SetLineColor(4)\\n CSVHistlist.append(rt.TH1D(data[1]+\\\"_CSV\\\",data[1]+\\\"_\\\"+title,nbins,ran[0],ran[1]))\\n CSVHistlist[n].SetLineColor(3)\\n DiscriminantHistlist.append(rt.TH1D(data[1]+\\\"_Discriminant\\\",data[1]+\\\"_\\\"+title,nbins,ran[0],ran[1]))\\n DiscriminantHistlist[n].SetLineColor(2)\\n for particle in data[0]:\\n bin_number = FCM.bin_selection(particle,bins)\\n if bin_number == -100: continue\\n AllJetsHistlist[n].Fill(particle[feature])\\n if particle[1] >= CSV_cuts[bin_number]: CSVHistlist[n].Fill(particle[feature])\\n if Difference:\\n L = particle[8]-particle[5]\\n else:\\n if particle[17] != 0:\\n L = particle[20]/float(particle[17])\\n else:\\n continue\\n if L >= discriminant_cuts[bin_number]: DiscriminantHistlist[n].Fill(particle[feature])\\n canvaslist = []\\n legendlist = []\\n Tfilelist = []\\n for n,data in enumerate(datalist):\\n canvaslist.append(rt.TCanvas(data[1]+\\\"_canvas\\\",\\\"canvas\\\",600,600))\\n canvaslist[n].SetTitle(data[1]+\\\"_\\\"+title)\\n rt.gStyle.SetOptStat(0)\\n legendlist.append(rt.TLegend(0.9,0.9,0.65,0.75))\\n legendlist[n].AddEntry(AllJetsHistlist[n], \\\"All jets\\\")\\n legendlist[n].AddEntry(CSVHistlist[n], \\\"CSV\\\")\\n legendlist[n].AddEntry(DiscriminantHistlist[n], discriminant)\\n AllJetsHistlist[n].GetXaxis().SetTitle(\\\"jet p_{T} (GeV)\\\")\\n AllJetsHistlist[n].GetYaxis().SetTitle('# jets')\\n AllJetsHistlist[n].GetYaxis().SetTitleOffset(1.5)\\n #AllJetsHistlist[n].Draw()\\n #CSVHistlist[n].Draw(\\\"SAME\\\")\\n #DiscriminantHistlist[n].Draw(\\\"SAME\\\")\\n #legendlist[n].Draw()\\n if Save:\\n #canvaslist[n].SaveAs(title+\\\"_\\\"+data[1]+discriminant+\\\".png\\\")\\n Tfilelist.append(rt.TFile(\\\"Thesis_Plots/root_files/\\\"+title+\\\"_\\\"+data[1]+discriminant+\\\".root\\\",\\\"recreate\\\"))\\n print \\\"saved histogram as Thesis_Plots/root_files/\\\"+title+\\\"_\\\"+data[1]+discriminant+\\\".root\\\"\\n AllJetsHistlist[n].Write()\\n CSVHistlist[n].Write()\\n DiscriminantHistlist[n].Write()\",\n \"def fid_cuts(ptname, etaname):\\n cuts = []\\n cuts.append(combine_cuts([ptname + ' > 4.5',\\n 'TMath::Abs(' + etaname + ') < 1.2']))\\n cuts.append(combine_cuts([ptname + ' > 4.0',\\n var_selection('TMath::Abs('+etaname+')', 1.2, 1.4)\\n ]))\\n cuts.append(combine_cuts([ptname + ' > 3.5',\\n var_selection('TMath::Abs('+etaname+')', 1.4, 1.6)\\n ]))\\n return combine_cuts(cuts, ' || ')\",\n \"def showComponents(self, mask):\\n\\n from skimage import measure\\n\\n thresh = cv2.threshold(mask, 0, 255, cv2.THRESH_BINARY)[1]\\n labels = measure.label(thresh, neighbors=8, background=0)\\n for label in range(0,len(labels)):\\n img = np.zeros(mask.shape)\\n # if this is the background label, ignore it\\n if label == 0:\\n continue\\n img[labels==label]=255\\n numPixels = cv2.countNonZero(img)\\n\\n \\t# if the number of pixels in the component is sufficiently\\n \\t# large, then add it to our mask of \\\"large blobs\\\"\\n if numPixels > 500:\\n showme(img, 'Contour '+str(label))\",\n \"def getLabel2(*args):\",\n \"def getLabel2(*args):\",\n \"def DGTsLabel(*args):\\n return _XCAFDoc.XCAFDoc_DocumentTool_DGTsLabel(*args)\",\n \"def _get_component_label(self):\\n labels = df_parser(self.workflow.builder.df_path, workflow=self.workflow).labels\\n if self.pdc_component_df_label not in labels:\\n raise PluginFailedException('No %s label in Dockerfile, can\\\\'t get PDC component',\\n self.pdc_component_df_label)\\n return labels[self.pdc_component_df_label]\",\n \"def tagview(tab,label,x,y):\\r\\n font = cv2.FONT_HERSHEY_SIMPLEX\\r\\n col=classifc[label]\\r\\n labnow=classif[label]\\r\\n# print (labnow, text)\\r\\n if label == 'back_ground':\\r\\n deltay=30\\r\\n else:\\r\\n# deltay=25*((labnow-1)%5)\\r\\n deltay=40+10*(labnow-1)\\r\\n\\r\\n viseg=cv2.putText(tab,label,(x, y+deltay), font,0.3,col,1)\\r\\n return viseg\",\n \"def label(image,**kw):\\n # default connectivity in OpenCV: 8 (which is equivalent to...)\\n # default connectivity in scikit-image: 2\\n n, labels = cv2.connectedComponents(image.astype(uint8), connectivity=4)\\n #n, labels = cv2.connectedComponentsWithAlgorithm(image.astype(uint8), connectivity=4, ltype=2, ccltype=cv2.CCL_DEFAULT)\\n return labels, n-1\\n # try: return measurements.label(image,**kw)\\n # except: pass\\n # types = [\\\"int32\\\",\\\"uint32\\\",\\\"int64\\\",\\\"uint64\\\",\\\"int16\\\",\\\"uint16\\\"]\\n # for t in types:\\n # try: return measurements.label(array(image,dtype=t),**kw)\\n # except: pass\\n # # let it raise the same exception as before\\n # return measurements.label(image,**kw)\",\n \"def needleSegmentationCLIDEMO(self):\\r\\n # research\\r\\n profbox()\\r\\n widget = slicer.modules.NeedleFinderWidget\\r\\n scene = slicer.mrmlScene\\r\\n pNode = self.parameterNode()\\r\\n if slicer.mrmlScene.GetNodeByID(pNode.GetParameter(\\\"baselineVolumeID\\\")) == None:\\r\\n inputVolume = self.__volumeSelector.currentNode()\\r\\n inputVolumeID = self.__volumeSelector.currentNode().GetID()\\r\\n else:\\r\\n inputVolume = slicer.mrmlScene.GetNodeByID(pNode.GetParameter(\\\"baselineVolumeID\\\"))\\r\\n inputVolumeID = slicer.mrmlScene.GetNodeByID(pNode.GetParameter(\\\"baselineVolumeID\\\")).GetID()\\r\\n inputLabelID = self.__needleLabelSelector.currentNode().GetID()\\r\\n\\r\\n datetime = time.strftime(\\\"%Y-%m-%d-%H_%M_%S\\\", time.localtime())\\r\\n\\r\\n inputVolume.SetAttribute(\\\"foldername\\\", datetime)\\r\\n self.outputVolumeNode = slicer.mrmlScene.CreateNodeByClass('vtkMRMLModelNode')\\r\\n self.outputVolumeNode.SetName(\\\"Output Needle Model\\\")\\r\\n outputVolumeStorageNode = slicer.mrmlScene.CreateNodeByClass('vtkMRMLModelStorageNode')\\r\\n slicer.mrmlScene.AddNode(self.outputVolumeNode)\\r\\n slicer.mrmlScene.AddNode(outputVolumeStorageNode)\\r\\n self.outputVolumeNode.AddAndObserveStorageNodeID(outputVolumeStorageNode.GetID())\\r\\n outputVolumeStorageNode.WriteData(self.outputVolumeNode)\\r\\n\\r\\n outputID = self.outputVolumeNode.GetID()\\r\\n\\r\\n self.foldername = '/NeedleModels/' + datetime\\r\\n\\r\\n # Set the parameters for the CLI module\\r\\n parameters = {}\\r\\n parameters['inputVolume'] = inputVolumeID\\r\\n parameters['inputLabel'] = inputLabelID\\r\\n parameters['outputVtk'] = outputID\\r\\n parameters['outputFolderName'] = self.foldername\\r\\n parameters['nbPointsPerLine'] = self.nbPointsPerLine.value\\r\\n parameters['nbRadiusIterations'] = self.nbRadiusIterations.value\\r\\n parameters['radiusMax'] = self.radiusMax.value\\r\\n parameters['numberOfPointsPerNeedle'] = self.numberOfPointsPerNeedle.value\\r\\n parameters['nbRotatingIterations'] = self.nbRotatingIterations.value\\r\\n\\r\\n module = slicer.modules.mainlabelneedletrackingcli\\r\\n self.__cliNode = None\\r\\n self.__cliNode = slicer.cli.run(module, None, parameters, wait_for_completion=True)\\r\\n\\r\\n ##### match the needles ######\\r\\n\\r\\n self.setNeedleCoordinates()\\r\\n self.computerPolydataAndMatrix()\\r\\n xmin = min(self.p[0])\\r\\n xmax = max(self.p[0])\\r\\n ymin = min(self.p[1])\\r\\n ymax = max(self.p[1])\\r\\n xdelta = xmax - xmin\\r\\n ydelta = ymax - ymin\\r\\n k = 0\\r\\n\\r\\n self.base = [[0 for j in range(3)] for j in range(63)]\\r\\n self.tip = [[0 for j in range(3)] for j in range(63)]\\r\\n self.needlenode = [[0 for j in range(2)] for j in range(63)]\\r\\n self.bentNeedleNode = [[0 for j in range(2)] for j in range(63)]\\r\\n self.displaynode = [0 for j in range(63)]\\r\\n self.displaynodeB = [0 for j in range(63)]\\r\\n self.fiducialnode = [0 for j in range(63)]\\r\\n\\r\\n for i in xrange(63):\\r\\n\\r\\n pathneedle = self.foldername + '/' + str(i) + '.vtp'\\r\\n pathBentNeedle = self.foldername + '/' + str(i) + '_bent.vtp'\\r\\n self.needlenode[i] = slicer.util.loadModel(pathneedle, True)\\r\\n self.bentNeedleNode[i] = slicer.util.loadModel(pathBentNeedle, True)\\r\\n\\r\\n if self.needlenode[i][0] == True and self.needlenode[i][1] != None:\\r\\n self.displaynode[i] = self.needlenode[i][1].GetDisplayNode()\\r\\n self.displaynodeB[i] = self.bentNeedleNode[i][1].GetDisplayNode()\\r\\n\\r\\n\\r\\n polydata = self.needlenode[i][1].GetPolyData()\\r\\n polydata.GetPoint(0, self.base[i])\\r\\n\\r\\n self.displaynode[i].SliceIntersectionVisibilityOn()\\r\\n self.displaynodeB[i].SliceIntersectionVisibilityOn()\\r\\n bestmatch = None\\r\\n mindist = None\\r\\n for j in xrange(63):\\r\\n delta = ((self.p[0][j] - (self.base[i][0])) ** 2 + (self.p[1][j] - self.base[i][1]) ** 2) ** (0.5)\\r\\n if delta < mindist or mindist == None:\\r\\n bestmatch = j\\r\\n mindist = delta\\r\\n\\r\\n bestmatch = k\\r\\n k += 1\\r\\n self.displaynode[i].SetColor(self.color[bestmatch])\\r\\n self.displaynodeB[i].SetColor(self.color[bestmatch])\\r\\n self.needlenode[i][1].SetName(self.option[bestmatch] + \\\"_segmented\\\")\\r\\n self.bentNeedleNode[i][1].SetName(self.option[bestmatch] + \\\"_optimized\\\")\\r\\n self.needlenode[i][1].SetAttribute(\\\"segmented\\\", \\\"1\\\")\\r\\n self.bentNeedleNode[i][1].SetAttribute(\\\"optimized\\\", \\\"1\\\")\\r\\n self.needlenode[i][1].SetAttribute(\\\"nth\\\", str(bestmatch))\\r\\n self.bentNeedleNode[i][1].SetAttribute(\\\"nth\\\", str(bestmatch))\\r\\n self.needlenode[i][1].SetAttribute(\\\"needleID\\\", self.needlenode[i][1].GetID())\\r\\n self.bentNeedleNode[i][1].SetAttribute(\\\"needleID\\\", self.bentNeedleNode[i][1].GetID())\\r\\n\\r\\n if widget.removeDuplicates.isChecked():\\r\\n self.positionFilteringNeedles()\\r\\n\\r\\n d = slicer.mrmlScene.GetNodeByID(outputID).GetDisplayNode()\\r\\n d.SetVisibility(0)\\r\\n\\r\\n self.__editorFrame.collapsed = 1\\r\\n\\r\\n self.addButtons()\",\n \"def nifti2dicom(seg_nifti, bk_nifti, ref_dicom_dir, save_dir, description, mode_RGB=False, zoom_num=4, watermarks=True): \\n #Load nifti, here is segmentation and background\\n seg_image = sitk.ReadImage(seg_nifti)\\n seg_image = sitk.GetArrayFromImage(seg_image)\\n seg_image = seg_image.astype(np.uint8)\\n \\n # print(nifti_image.shape)\\n bk_image = sitk.ReadImage(bk_nifti)\\n bk_image = sitk.GetArrayFromImage(bk_image)\\n\\n #Get Volume report from the seg_image, cubic ml, and the 95% CI:\\n v_nonenhancing = round(seg_image[seg_image==1].sum()/1000,1)\\n ci_nonenhancing = round(v_nonenhancing*0.2,1)\\n v_enhancing = round(seg_image[seg_image==4].sum()/1000,1)\\n ci_enhancing = round(v_enhancing*0.3,1)\\n v_edema = round(seg_image[seg_image==2].sum()/1000,1)\\n ci_edema = round(v_edema*0.1,1)\\n\\n #Loading the reference dicom, in order to get the headers of each slice. \\n series_IDs = sitk.ImageSeriesReader.GetGDCMSeriesIDs(ref_dicom_dir)\\n if not series_IDs:\\n print(\\\"ERROR: given directory \\\\\\\"\\\"+data_directory+\\\"\\\\\\\" does not contain a DICOM series.\\\")\\n sys.exit(1)\\n\\n series_file_names = sitk.ImageSeriesReader.GetGDCMSeriesFileNames(ref_dicom_dir, series_IDs[0])\\n\\n series_reader = sitk.ImageSeriesReader()\\n series_reader.SetFileNames(series_file_names)\\n\\n # Configure the reader to load all of the DICOM tags (public+private):\\n # By default tags are not loaded (saves time).\\n # By default if tags are loaded, the private tags are not loaded.\\n # We explicitly configure the reader to load tags, including the private ones.\\n series_reader.MetaDataDictionaryArrayUpdateOn()\\n series_reader.LoadPrivateTagsOn()\\n ref_image = series_reader.Execute()\\n \\n #set reader for slice \\n reader = sitk.ImageFileReader()\\n reader.LoadPrivateTagsOn()\\n \\n writer = sitk.ImageFileWriter()\\n # Use the study/series/frame of reference information given in the meta-data\\n # dictionary and not the automatically generated information from the file IO\\n writer.KeepOriginalImageUIDOn()\\n\\n # Copy some of the tags and add the relevant tags indicating the change.\\n # For the series instance UID (0020|000e), each of the components is a number, cannot start\\n # with zero, and separated by a '.' We create a unique series ID using the date and time. tags of interest:\\n \\n castFilter = sitk.CastImageFilter()\\n castFilter.SetOutputPixelType(sitk.sitkInt16)\\n ORG_ROOT=\\\"1.3.12.2\\\"\\n #create SeriesInstanceUID and StudyInstanceUID\\n SeriesInstanceUID = generateUID(org_root=ORG_ROOT)\\n StudyInstanceUID = generateUID(org_root=ORG_ROOT)\\n #create a prefix for the accession number\\n acc='BTS'+series_reader.GetMetaData(0,\\\"0008|0050\\\")\\n #changing spacing\\n reader.SetFileName(series_file_names[0])\\n reader.ReadImageInformation()\\n\\n if mode_RGB:\\n customized_tag_values = [(\\\"0008|103e\\\", description),\\n (\\\"0020|000e\\\", SeriesInstanceUID),\\n (\\\"0008|0050\\\", acc),\\n (\\\"0020|000d\\\", StudyInstanceUID), \\n (\\\"0028|0004\\\", 'RGB'),\\n (\\\"0028|0002\\\", \\\"3\\\")]\\n else:\\n customized_tag_values = [(\\\"0008|103e\\\", description),\\n (\\\"0020|000e\\\", SeriesInstanceUID), \\n (\\\"0008|0050\\\", acc),\\n (\\\"0020|000d\\\", StudyInstanceUID)] \\n\\n os.makedirs(save_dir, exist_ok = True)\\n\\n #for nifti, the main axis is the first one, while for dicoms it is the last one\\n for i in range(ref_image.GetDepth()):\\n #zoom 2 times, todo need to figure out which axis to zoom, post is the 3rd\\n #pre assume the first axis is the slice numbers\\n bk_slice = ndimage.zoom(bk_image[i,:,:], zoom_num, order=0)\\n seg_slice = ndimage.zoom(seg_image[i,:,:], zoom_num, order=0)\\n \\n #Due to the DICOM saving coordinate system is different with nifti,i.e mirrored, it is easier to flip array\\n bk_slice = np.flip(bk_slice, (0, 1)) \\n seg_slice = np.flip(seg_slice, (0, 1)) \\n\\n #get contours\\n seg_idx = get_contours(seg_slice)\\n \\n #add watermarks\\n if watermarks:\\n canvas_tmp = np.zeros(list(bk_slice.shape), dtype=np.uint8)\\n font = cv2.FONT_HERSHEY_PLAIN\\n cv2.putText(canvas_tmp,'FOR RESEARCH ONLY;REFER TO OFFICIAL REPORT FOR DETAILS',(10,30), \\n font,2,255,1)\\n cv2.putText(canvas_tmp,'(This tool is intended for evaluation of gliomas, and results may be unreliable for other pathologies)',(90,50), \\n font,1,255,1) \\n #add Legend and volumes \\n cv2.putText(canvas_tmp, 'Legend Volume(+/-95% CI)',(10,900), font,0.8,255,1)\\n cv2.putText(canvas_tmp, f'Edema {v_edema}+/-{ci_edema} mL',(30,920), font,0.8,255,1)\\n cv2.putText(canvas_tmp, f'Enhancing {v_enhancing}+/-{ci_enhancing} mL',(30,940), font,0.8,255,1)\\n cv2.putText(canvas_tmp, f'Non- {v_nonenhancing}+/-{ci_nonenhancing} mL',(30,960), font,0.8,255,1)\\n cv2.putText(canvas_tmp,'Enhancing', (30,975), font,0.8,255,1)\\n cv2.putText(canvas_tmp,'(The error is based on testing of algorithm performance vs. manual segmentation)', (150,1000), font,1,255,1)\\n\\n \\n \\n #burning segmentation contour into slices\\n cv2.line(seg_idx, (10,915), (20,915), 2, 2)\\n cv2.line(seg_idx, (10,935), (20,935), 4, 2)\\n cv2.line(seg_idx, (10,955), (20,955), 1, 2)\\n \\n if mode_RGB:\\n #burning the watermarks\\n bk_slice[canvas_tmp==255]=bk_slice.max()\\n #convert dicom from nomogram to RGB\\n bk_slice = toRGB(bk_slice)\\n #colorize the bk_slice according to seg_idx\\n bk_slice[0,:,:,0][seg_idx==1] = 255\\n bk_slice[0,:,:,1][seg_idx==4] = 255\\n bk_slice[0,:,:,2][seg_idx==2] = 255 \\n else:\\n #grey the ori_image_slice according to seg_idx\\n bk_slice[canvas_tmp==255]=bk_slice.max()//2\\n bk_slice[seg_idx==1] = bk_slice.max()*2//50\\n bk_slice[seg_idx==2] = bk_slice.max()*1//50\\n bk_slice[seg_idx==4] = bk_slice.max()*3//50\\n\\n converted_slice = sitk.GetImageFromArray(bk_slice)\\n reader.SetFileName(series_file_names[i])\\n reader.ReadImageInformation()\\n spacing_new = [i/zoom_num for i in reader.GetSpacing()[:-1]] + [reader.GetSpacing()[-1]]\\n \\n #generate SOPInstanceUID\\n SOPInstanceUID = generateUID(org_root=ORG_ROOT)\\n series_tag_values = [(k, reader.GetMetaData(k)) for k in reader.GetMetaDataKeys()] + customized_tag_values + [(\\\"0008|0018\\\", SOPInstanceUID)]\\n# print(series_tag_values)\\n if '_seg_' in description:\\n converted_slice = converted_slice \\n \\n # Tags shared by the series.\\n for tag, value in series_tag_values:\\n converted_slice.SetMetaData(tag, value)\\n \\n # especially set spacing tags\\n # Image Position (Patient)\\n converted_slice.SetMetaData(\\\"0020|0013\\\", str(i)) # Instance Number\\n converted_slice.SetSpacing(spacing_new)\\n \\n # Write to the output directory and add the extension dcm, to force writing in DICOM format \\n writer.SetFileName(os.path.join(save_dir, str(i)+'.dcm'))\\n writer.Execute(converted_slice)\",\n \"def needleSegmentationCLIDEMO(self):\\n #research\\n profbox()\\n widget = slicer.modules.NeedleFinderWidget\\n scene = slicer.mrmlScene\\n pNode = self.parameterNode()\\n if slicer.mrmlScene.GetNodeByID(pNode.GetParameter(\\\"baselineVolumeID\\\")) == None:\\n inputVolume = self.__volumeSelector.currentNode()\\n inputVolumeID = self.__volumeSelector.currentNode().GetID()\\n else:\\n inputVolume = slicer.mrmlScene.GetNodeByID(pNode.GetParameter(\\\"baselineVolumeID\\\"))\\n inputVolumeID = slicer.mrmlScene.GetNodeByID(pNode.GetParameter(\\\"baselineVolumeID\\\")).GetID()\\n inputLabelID = self.__needleLabelSelector.currentNode().GetID()\\n \\n datetime = time.strftime(\\\"%Y-%m-%d-%H_%M_%S\\\", time.localtime())\\n \\n inputVolume.SetAttribute(\\\"foldername\\\",datetime)\\n self.outputVolumeNode = slicer.mrmlScene.CreateNodeByClass('vtkMRMLModelNode')\\n self.outputVolumeNode.SetName(\\\"Output Needle Model\\\")\\n outputVolumeStorageNode = slicer.mrmlScene.CreateNodeByClass('vtkMRMLModelStorageNode')\\n slicer.mrmlScene.AddNode(self.outputVolumeNode)\\n slicer.mrmlScene.AddNode(outputVolumeStorageNode)\\n self.outputVolumeNode.AddAndObserveStorageNodeID(outputVolumeStorageNode.GetID())\\n outputVolumeStorageNode.WriteData(self.outputVolumeNode)\\n \\n outputID = self.outputVolumeNode.GetID()\\n \\n self.foldername = '/NeedleModels/' + datetime\\n \\n # Set the parameters for the CLI module \\n parameters = {} \\n parameters['inputVolume'] = inputVolumeID\\n parameters['inputLabel'] = inputLabelID\\n parameters['outputVtk'] = outputID\\n parameters['outputFolderName'] = self.foldername\\n parameters['nbPointsPerLine'] = self.nbPointsPerLine.value\\n parameters['nbRadiusIterations'] = self.nbRadiusIterations.value\\n parameters['distanceMax'] = self.distanceMax.value\\n parameters['numberOfPointsPerNeedle'] = self.numberOfPointsPerNeedle.value\\n parameters['nbRotatingIterations'] = self.nbRotatingIterations.value\\n \\n module = slicer.modules.mainlabelneedletrackingcli \\n self.__cliNode = None\\n self.__cliNode = slicer.cli.run(module, None, parameters, wait_for_completion=True)\\n \\n ##### match the needles ######\\n\\n self.setNeedleCoordinates()\\n self.computerPolydataAndMatrix()\\n xmin = min(self.p[0])\\n xmax = max(self.p[0])\\n ymin = min(self.p[1])\\n ymax = max(self.p[1])\\n xdelta = xmax - xmin\\n ydelta = ymax - ymin\\n k = 0\\n\\n self.base = [[0 for j in range(3)] for j in range(63)]\\n self.tip = [[0 for j in range(3)] for j in range(63)]\\n self.needlenode = [[0 for j in range(2)] for j in range(63)]\\n self.bentNeedleNode = [[0 for j in range(2)] for j in range(63)]\\n self.displaynode = [0 for j in range(63)]\\n self.displaynodeB = [0 for j in range(63)]\\n self.fiducialnode = [0 for j in range(63)]\\n \\n for i in xrange(63):\\n\\n pathneedle = self.foldername+'/'+str(i)+'.vtp'\\n pathBentNeedle = self.foldername+'/'+str(i)+'_bent.vtp'\\n self.needlenode[i] = slicer.util.loadModel(pathneedle, True)\\n self.bentNeedleNode[i] = slicer.util.loadModel(pathBentNeedle, True)\\n\\n if self.needlenode[i][0] == True and self.needlenode[i][1] != None:\\n self.displaynode[i] = self.needlenode[i][1].GetDisplayNode()\\n self.displaynodeB[i] = self.bentNeedleNode[i][1].GetDisplayNode()\\n\\n \\n polydata = self.needlenode[i][1].GetPolyData()\\n polydata.GetPoint(0,self.base[i]) \\n \\n self.displaynode[i].SliceIntersectionVisibilityOn()\\n self.displaynodeB[i].SliceIntersectionVisibilityOn()\\n bestmatch = None\\n mindist = None\\n for j in xrange(63):\\n delta = ((self.p[0][j]-(self.base[i][0]))**2+(self.p[1][j]-self.base[i][1])**2)**(0.5)\\n if delta < mindist or mindist == None:\\n bestmatch = j\\n mindist = delta\\n \\n bestmatch = k\\n k += 1\\n self.displaynode[i].SetColor(self.color[bestmatch])\\n self.displaynodeB[i].SetColor(self.color[bestmatch])\\n self.needlenode[i][1].SetName(self.option[bestmatch]+\\\"_segmented\\\")\\n self.bentNeedleNode[i][1].SetName(self.option[bestmatch]+\\\"_optimized\\\")\\n self.needlenode[i][1].SetAttribute(\\\"segmented\\\",\\\"1\\\")\\n self.bentNeedleNode[i][1].SetAttribute(\\\"optimized\\\",\\\"1\\\")\\n self.needlenode[i][1].SetAttribute(\\\"nth\\\",str(bestmatch))\\n self.bentNeedleNode[i][1].SetAttribute(\\\"nth\\\",str(bestmatch))\\n self.needlenode[i][1].SetAttribute(\\\"needleID\\\",self.needlenode[i][1].GetID())\\n self.bentNeedleNode[i][1].SetAttribute(\\\"needleID\\\",self.bentNeedleNode[i][1].GetID())\\n \\n if widget.removeDuplicates.isChecked():\\n self.positionFilteringNeedles()\\n\\n d = slicer.mrmlScene.GetNodeByID(outputID).GetDisplayNode()\\n d.SetVisibility(0)\\n \\n self.__editorFrame.collapsed = 1\\n \\n self.addButtons()\",\n \"def create_slice_labels(dataset, base_task_name, slice_name, verbose=False):\\n # TODO: break this out into more modular pieces oncee we have multiple slices\\n slice_fn = globals()[slice_name]\\n slice_indicators = torch.tensor(\\n [slice_fn(dataset, idx) for idx in range(len(dataset))], dtype=torch.uint8\\n ).view(-1, 1)\\n\\n Y_base = dataset.labels[f\\\"{base_task_name}_gold\\\"]\\n Y_slice = Y_base.clone().masked_fill_(slice_indicators == 0, 0)\\n\\n if verbose:\\n if not any(Y_slice):\\n warnings.warn(f\\\"No examples were found to belong to slice {slice_name}\\\")\\n else:\\n print(f\\\"Found {sum(slice_indicators)} examples in slice {slice_name}.\\\")\\n\\n # NOTE: we assume here that all slice labels are for sentence-level tasks only\\n return Y_slice\",\n \"def __do_split_haghverdi16(self, Dseg, tips):\\n # sort distance from first tip point\\n # then the sequence of distances Dseg[tips[0]][idcs] increases\\n idcs = np.argsort(Dseg[tips[0]])\\n # consider now the sequence of distances from the other\\n # two tip points, which only increase when being close to `tips[0]`\\n # where they become correlated\\n # at the point where this happens, we define a branching point\\n if True:\\n imax = self.kendall_tau_split(Dseg[tips[1]][idcs],\\n Dseg[tips[2]][idcs])\\n if False:\\n # if we were in euclidian space, the following should work\\n # as well, but here, it doesn't because the scales in Dseg are\\n # highly different, one would need to write the following equation\\n # in terms of an ordering, such as exploited by the kendall\\n # correlation method above\\n imax = np.argmin(Dseg[tips[0]][idcs]\\n + Dseg[tips[1]][idcs]\\n + Dseg[tips[2]][idcs])\\n # init list to store new segments\\n ssegs = []\\n # first new segment: all points until, but excluding the branching point\\n # increasing the following slightly from imax is a more conservative choice\\n # as the criterion based on normalized distances, which follows below,\\n # is less stable\\n ibranch = imax + 2 # this used to be imax + 1!\\n # ibranch = int(0.95 * imax)\\n return idcs[:ibranch]\\n # ssegs.append(idcs[:ibranch])\\n # TODO get rid of the following heuristics\\n # define nomalized distances to tip points for the rest of the data\\n # dist1 = Dseg[tips[1], idcs[ibranch:]] / Dseg[tips[1], idcs[ibranch-1]]\\n # dist2 = Dseg[tips[2], idcs[ibranch:]] / Dseg[tips[2], idcs[ibranch-1]]\\n # assign points according to whether being closer to tip cell 1 or 2\\n # ssegs.append(idcs[ibranch:][dist1 <= dist2])\\n # ssegs.append(idcs[ibranch:][dist1 > dist2])\\n # return ssegs\",\n \"def Problem11():\\n return 'Ductile Coulomb-Mohr'\",\n \"def ANN_binned_tagged_jets_hist(datalist, model, discriminant_cuts, CSV_cuts, bins, nbins, mode=\\\"pT_jet\\\",Save=False,addFeature=False):\\n title = \\\"binned_tagged_jets_vs_\\\"+mode\\n\\tdiscriminant = \\\"ANN\\\"\\n AllJetsHistlist = []\\n CSVHistlist = []\\n DiscriminantHistlist = []\\n if mode == \\\"pT_hadron\\\":\\n feature = 2\\n elif mode == \\\"pT_jet\\\":\\n feature = 3\\n elif mode == \\\"decay_vx\\\":\\n feature = 4\\n for n,data in enumerate(datalist):\\n\\t\\tdatatitle = data[3]\\n print \\\"working on\\\",datatitle\\n ran = data[4]\\n\\t\\tCSV = data[2]\\n\\t\\tpT = data[1]\\n\\t\\tx_data = data[0]\\n AllJetsHistlist.append(rt.TH1D(datatitle+\\\"_AllJets\\\",datatitle+\\\"_\\\"+title,nbins,ran[0],ran[1]))\\n AllJetsHistlist[n].SetLineColor(4)\\n CSVHistlist.append(rt.TH1D(datatitle+\\\"_CSV\\\",datatitle+\\\"_\\\"+title,nbins,ran[0],ran[1]))\\n CSVHistlist[n].SetLineColor(3)\\n DiscriminantHistlist.append(rt.TH1D(datatitle+\\\"_Discriminant\\\",datatitle+\\\"_\\\"+title,nbins,ran[0],ran[1]))\\n DiscriminantHistlist[n].SetLineColor(2)\\n\\t\\n\\t\\tif addFeature == False:\\n\\t\\t\\tpred_y = model.predict(ANN_functional_shape(x_data))\\n\\t\\telif addFeature == \\\"pT\\\":\\n\\t\\t\\tpred_y = model.predict(ANN_functional_shape(x_data)+[pT/200])\\n\\t\\telif addFeature == \\\"PV\\\":\\n\\t\\t\\tassert x_data.shape[1] == 21, \\\"wrong x_data format: PV cannot be found\\\"\\n\\t\\t\\tpred_y = model.predict(ANN_functional_shape(x_data)+[x_data[:,-1]/10.])\\n\\t\\telse:\\n\\t\\t\\tprint \\\"invalid feature input\\\"\\n\\t\\t\\treturn None\\n\\t\\tbin_numbers = ANN_bin_selection(pT,bins)\\n\\n\\t for i,pT_value in enumerate(pT):\\n\\t if bin_numbers[i] == -100: continue\\n\\t\\t\\tAllJetsHistlist[n].Fill(pT_value)\\n\\t if pred_y[i] >= discriminant_cuts[bin_numbers[i]]: DiscriminantHistlist[n].Fill(pT_value)\\n\\t if CSV[i] >= CSV_cuts[bin_numbers[i]]: CSVHistlist[n].Fill(pT_value)\\n\\n canvaslist = []\\n legendlist = []\\n Tfilelist = []\\n for n,data in enumerate(datalist):\\n\\t\\tdatatitle = data[3]\\n canvaslist.append(rt.TCanvas(datatitle+\\\"_canvas\\\",\\\"canvas\\\",600,600))\\n canvaslist[n].SetTitle(datatitle+\\\"_\\\"+title)\\n rt.gStyle.SetOptStat(0)\\n legendlist.append(rt.TLegend(0.9,0.9,0.65,0.75))\\n legendlist[n].AddEntry(AllJetsHistlist[n], \\\"All jets\\\")\\n legendlist[n].AddEntry(CSVHistlist[n], \\\"CSV\\\")\\n legendlist[n].AddEntry(DiscriminantHistlist[n], discriminant)\\n AllJetsHistlist[n].GetXaxis().SetTitle(mode)\\n AllJetsHistlist[n].GetYaxis().SetTitle('# jets')\\n AllJetsHistlist[n].GetYaxis().SetTitleOffset(1.5)\\n #AllJetsHistlist[n].Draw()\\n #CSVHistlist[n].Draw(\\\"SAME\\\")\\n #DiscriminantHistlist[n].Draw(\\\"SAME\\\")\\n #legendlist[n].Draw()\\n if Save:\\n #canvaslist[n].SaveAs(title+\\\"_\\\"+datatitle+discriminant+\\\".png\\\")\\n Tfilelist.append(rt.TFile(\\\"Thesis_Plots/root_files/\\\"+title+\\\"_\\\"+datatitle+discriminant+\\\".root\\\",\\\"recreate\\\"))\\n print \\\"saved histogram as Thesis_Plots/root_files/\\\"+title+\\\"_\\\"+datatitle+discriminant+\\\".root\\\"\\n AllJetsHistlist[n].Write()\\n CSVHistlist[n].Write()\\n DiscriminantHistlist[n].Write()\",\n \"def mask_label_contour(image, seg):\\n return sitk.Mask(image, sitk.LabelContour(seg+1)==0)\",\n \"def adjust_labels(data_y, label):\\n\\n if label == 'locomotion': # Labels for locomotion are adjusted\\n data_y[data_y == 4] = 3\\n data_y[data_y == 5] = 4\\n elif label == 'gestures': # Labels for gestures are adjusted\\n data_y[data_y == 406516] = 1\\n data_y[data_y == 406517] = 2\\n data_y[data_y == 404516] = 3\\n data_y[data_y == 404517] = 4\\n data_y[data_y == 406520] = 5\\n data_y[data_y == 404520] = 6\\n data_y[data_y == 406505] = 7\\n data_y[data_y == 404505] = 8\\n data_y[data_y == 406519] = 9\\n data_y[data_y == 404519] = 10\\n data_y[data_y == 406511] = 11\\n data_y[data_y == 404511] = 12\\n data_y[data_y == 406508] = 13\\n data_y[data_y == 404508] = 14\\n data_y[data_y == 408512] = 15\\n data_y[data_y == 407521] = 16\\n data_y[data_y == 405506] = 17\\n return data_y\",\n \"def GetDatumLabels(self, *args):\\n return _XCAFDoc.XCAFDoc_DimTolTool_GetDatumLabels(self, *args)\",\n \"def get_labels(self):\\r\\n return [\\\"X\\\", \\\"O\\\", \\\"B-a\\\", \\\"I-a\\\", \\\"B-b\\\", \\\"I-b\\\", \\\"B-c\\\", \\\"I-c\\\", \\\"S-a\\\", \\\"S-b\\\", \\\"S-c\\\", \\\"[CLS]\\\", \\\"[SEP]\\\"]\",\n \"def _labels_of_sentence(self, sentence, split):\\n labels = torch.ones(1)\\n labels[0] = self.category_int_of_label_string(sentence[0][self.name_to_index_dict['label']]) #\\n return labels\",\n \"def _get_label(self):\\n if self.model.name == '':\\n return \\\"KPI\\\"\\n return \\\"KPI: {} ({})\\\".format(self.model.name, self.model.objective)\",\n \"def get_labels(self):\\n return [\\\"A轮\\\", \\\"B轮\\\",\\\"C轮\\\",\\\"天使轮\\\",\\\"战略融资\\\"]\",\n \"def GetDatumTolerLabels(self, *args):\\n return _XCAFDoc.XCAFDoc_DimTolTool_GetDatumTolerLabels(self, *args)\",\n \"def test_get_dim_label_with_index(self):\\n\\n dim = self.oecd_datasets['oecd']['dimension']['id'][2]\\n dims_df = pyjstat.get_dim_label(self.oecd_datasets['oecd'], dim)\\n self.assertTrue(dims_df.iloc[0]['id'] == '2003')\\n self.assertTrue(dims_df.iloc[-1]['label'] == '2014')\",\n \"def addFid(data, Dim=.5, nodName=\\\"N\\\", lableName=\\\"1\\\", color=\\\"red\\\", GlyphType=1):\\n\\t\\txyz = tuple(data)\\n\\t\\ttipFiducial = slicer.mrmlScene.AddNode(slicer.vtkMRMLMarkupsFiducialNode())\\n\\t\\ttipFiducial.SetName(nodName)\\n\\t\\ttipFiducial.AddFiducial(xyz[0], xyz[1], xyz[2])\\n\\t\\ttipFiducial.SetNthFiducialLabel(0, lableName)\\n\\t\\tslicer.mrmlScene.AddNode(tipFiducial)\\n\\t\\ttipFiducial.SetDisplayVisibility(True)\\n\\t\\ttipFiducial.GetDisplayNode().SetGlyphType(GlyphType) # Vertex2D\\n\\t\\ttipFiducial.GetDisplayNode().SetGlyphScale(Dim * 10)\\n\\t\\ttipFiducial.GetDisplayNode().SetTextScale(3)\\n\\t\\ttipFiducial.GetDisplayNode().SetSelectedColor(Helper.myColor(color))\\n\\t\\t'''\\tGlyphShapes {\\n GlyphTypeInvalid = 0, 1-StarBurst2D, 2-Cross2D, 3-CrossDot2D,\\n 4-ThickCross2D, 5-Dash2D, 6-Sphere3D, 7-Vertex2D,\\n 8-Circle2D,9-Triangle2D, 10-Square2D, Diamond2D,\\n Arrow2D, ThickArrow2D, HookedArrow2D, GlyphType_Last\\n }'''\",\n \"def label_for(self, *pp, unit=True, description=True):\\n if len(pp) > 1 and np.all([re.match(r\\\"k\\\\d+l\\\", p) for p in pp]):\\n label = \\\"$k_nl$\\\"\\n if unit:\\n label += \\\" / $m^{-n}$\\\"\\n return label\\n return super().label_for(*pp, unit=unit, description=description)\",\n \"def make_label(self, label, units):\\n nice_label = self.tex_axis_label(label)\\n if not (units == 'dimensionless') and \\\\\\n (units is not None) and (not units == []):\\n nice_label += ' (%s)'%self.tex_axis_label(units)\\n return nice_label\",\n \"def kaons ( self ) :\\n from GaudiConfUtils.ConfigurableGenerators import FilterDesktop\\n ## \\n if self['NOPIDHADRONS'] :\\n from StandardParticles import StdAllNoPIDsKaons as inpts\\n kaoncut = self['KaonCut']\\n else :\\n from StandardParticles import StdAllLooseANNKaons as inpts \\n kaoncut = \\\"(%s)&(%s)\\\" % ( self['KaonCut'] , self['KaonPIDCut'] ) \\n #\\n ##\\n return self.make_selection (\\n 'Kaon' ,\\n FilterDesktop ,\\n [ inpts ] ,\\n Code = kaoncut ,\\n )\",\n \"def classify_defect_clusters_modifier(frame, data):\\n\\n if data.particles.count == 0:\\n # No particles there to classify, create empty properties anyway\\n data.particles_.create_property('Si_V', dtype=int, components=1)\\n data.particles_.create_property('Si_I', dtype=int, components=1)\\n data.particles_.create_property('Si_C', dtype=int, components=1)\\n data.particles_.create_property('C_V', dtype=int, components=1)\\n data.particles_.create_property('C_I', dtype=int, components=1)\\n data.particles_.create_property('C_Si', dtype=int, components=1)\\n return\\n\\n # TODO Create numpy arrays containing the number of Si vacancies,\\n # interstitials, etc for each particle site in `data.particles`. These\\n # next lines are just placeholders!\\n si_vacancy = data.particles[\\\"vacancy_mask\\\"][...] * data.particles[\\\"Is Si Site\\\"][...]\\n si_interstitial = (data.particles[\\\"Is Si Site\\\"][...] & (data.particles[\\\"Si Occupancy\\\"][...] > 1)) * (\\n data.particles[\\\"Si Occupancy\\\"][...] - 1) + (\\n (data.particles[\\\"Is C Site\\\"][...]) * data.particles[\\\"Si Occupancy\\\"][...]) - (\\n data.particles[\\\"Is C Site\\\"][...] & data.particles[\\\"antisite_mask\\\"][...])\\n si_antisite = data.particles[\\\"antisite_mask\\\"][...] * data.particles[\\\"Is Si Site\\\"][...]\\n c_vacancy = data.particles[\\\"vacancy_mask\\\"][...] * data.particles[\\\"Is C Site\\\"][...]\\n c_interstitial = (data.particles[\\\"Is C Site\\\"][...] & (data.particles[\\\"C Occupancy\\\"][...] > 1)) * (\\n data.particles[\\\"C Occupancy\\\"][...] - 1) + (\\n (data.particles[\\\"Is Si Site\\\"][...]) * data.particles[\\\"C Occupancy\\\"][...]) - (\\n data.particles[\\\"Is Si Site\\\"][...] & data.particles[\\\"antisite_mask\\\"][...])\\n c_antisite = data.particles[\\\"antisite_mask\\\"][...] * data.particles[\\\"Is C Site\\\"][...]\\n\\n\\n data.particles_.create_property('Si_V', data=si_vacancy.astype(int))\\n data.particles_.create_property('Si_I', data=si_interstitial.astype(int))\\n data.particles_.create_property('Si_C', data=si_antisite.astype(int))\\n data.particles_.create_property('C_V', data=c_vacancy.astype(int))\\n data.particles_.create_property('C_I', data=c_interstitial.astype(int))\\n data.particles_.create_property('C_Si', data=c_antisite.astype(int))\",\n \"def _label_commuter_rail_rider(self, rider):\\n if (rider['servicebrand_Commuter Rail'] > 0) and (rider['zonecr_1a'] == 0):\\n label = 'CR except zone 1A'\\n else:\\n label = 'others'\\n return label\",\n \"def showOneNeedle(self, i, visibility):\\r\\n # obsolete\\r\\n profbox()\\r\\n fidname = \\\"fid\\\" + self.option[i]\\r\\n pNode = self.parameterNode()\\r\\n needleID = pNode.GetParameter(self.option[i] + '.vtp')\\r\\n fidID = pNode.GetParameter(fidname)\\r\\n NeedleNode = slicer.mrmlScene.GetNodeByID(needleID)\\r\\n fiducialNode = slicer.mrmlScene.GetNodeByID(fidID)\\r\\n\\r\\n if NeedleNode != None:\\r\\n displayNode = NeedleNode.GetModelDisplayNode()\\r\\n nVisibility = displayNode.GetVisibility()\\r\\n\\r\\n if fiducialNode == None:\\r\\n displayNode.SetVisibility(1)\\r\\n displayNode.SetOpacity(0.9)\\r\\n polyData = NeedleNode.GetPolyData()\\r\\n polyData.Update()\\r\\n nb = int(polyData.GetNumberOfPoints() - 1)\\r\\n coord = [0, 0, 0]\\r\\n if nb > 100:\\r\\n fiducialNode = slicer.vtkMRMLAnnotationFiducialNode()\\r\\n polyData.GetPoint(nb, coord)\\r\\n fiducialNode.SetName(self.option[i])\\r\\n fiducialNode.SetFiducialCoordinates(coord)\\r\\n fiducialNode.Initialize(slicer.mrmlScene)\\r\\n fiducialNode.SetLocked(1)\\r\\n fiducialNode.SetSelectable(0)\\r\\n fidDN = fiducialNode.GetDisplayNode()\\r\\n fidDN.SetColor(NeedleNode.GetDisplayNode().GetColor())\\r\\n fidDN.SetGlyphScale(0)\\r\\n fidTN = fiducialNode.GetAnnotationTextDisplayNode()\\r\\n fidTN.SetTextScale(3)\\r\\n fidTN.SetColor(NeedleNode.GetDisplayNode().GetColor())\\r\\n fiducialNode.SetDisplayVisibility(0)\\r\\n pNode.SetParameter(fidname, fiducialNode.GetID())\\r\\n fiducialNode.SetDisplayVisibility(1)\\r\\n\\r\\n if visibility == 0:\\r\\n\\r\\n displayNode.SetVisibility(0)\\r\\n displayNode.SetSliceIntersectionVisibility(0)\\r\\n if fiducialNode != None:\\r\\n fiducialNode.SetDisplayVisibility(0)\\r\\n\\r\\n else:\\r\\n\\r\\n displayNode.SetVisibility(1)\\r\\n displayNode.SetSliceIntersectionVisibility(1)\\r\\n if fiducialNode != None:\\r\\n fiducialNode.SetDisplayVisibility(1)\\r\\n\\r\\n else:\\r\\n vtkmat = vtk.vtkMatrix4x4()\\r\\n vtkmat.DeepCopy(self.m_vtkmat)\\r\\n vtkmat.SetElement(0, 3, self.m_vtkmat.GetElement(0, 3) + self.p[0][i])\\r\\n vtkmat.SetElement(1, 3, self.m_vtkmat.GetElement(1, 3) + self.p[1][i])\\r\\n vtkmat.SetElement(2, 3, self.m_vtkmat.GetElement(2, 3) + (30.0 - 150.0) / 2.0)\\r\\n\\r\\n TransformPolyDataFilter = vtk.vtkTransformPolyDataFilter()\\r\\n Transform = vtk.vtkTransform()\\r\\n TransformPolyDataFilter.SetInput(self.m_polyCylinder)\\r\\n Transform.SetMatrix(vtkmat)\\r\\n TransformPolyDataFilter.SetTransform(Transform)\\r\\n TransformPolyDataFilter.Update()\\r\\n\\r\\n triangles = vtk.vtkTriangleFilter()\\r\\n triangles.SetInput(TransformPolyDataFilter.GetOutput())\\r\\n self.AddModel(i, triangles.GetOutput())\\r\\n self.showOneNeedle(i, visibility)\",\n \"def cvpr2018_labels():\\n\\n return {\\n 0: 'others',\\n 33: 'car',\\n 34: 'motorcycle',\\n 35: 'bicycle',\\n 36: 'pedestrian',\\n 38: 'truck',\\n 39: 'bus',\\n 40: 'tricycle'\\n }\",\n \"def syed_dilation(data, vessel):\",\n \"def _compute_labels(self, element, data, mapping):\\n lidx = element.nodes.get_dimension(self.label_index)\\n if element.vdims:\\n edges = Dataset(element)[element[element.vdims[0].name]>0]\\n nodes = list(np.unique([edges.dimension_values(i) for i in range(2)]))\\n nodes = element.nodes.select(**{element.nodes.kdims[2].name: nodes})\\n else:\\n nodes = element\\n\\n value_dim = element.vdims[0]\\n labels = [lidx.pprint_value(v) for v in nodes.dimension_values(lidx)]\\n if self.show_values:\\n value_labels = []\\n for i, node in enumerate(element._sankey['nodes']):\\n value = value_dim.pprint_value(node['value'])\\n label = '%s - %s' % (labels[i], value)\\n if value_dim.unit:\\n label += ' %s' % value_dim.unit\\n value_labels.append(label)\\n labels = value_labels\\n\\n ys = nodes.dimension_values(1)\\n nodes = element._sankey['nodes']\\n offset = (nodes[0]['x1']-nodes[0]['x0'])/4.\\n if self.label_position == 'right':\\n xs = np.array([node['x1'] for node in nodes])+offset\\n else:\\n xs = np.array([node['x0'] for node in nodes])-offset\\n data['text_1'] = dict(x=xs, y=ys, text=[str(l) for l in labels])\\n align = 'left' if self.label_position == 'right' else 'right'\\n mapping['text_1'] = dict(text='text', x='x', y='y', text_baseline='middle', text_align=align)\",\n \"def chainDict2jetLabel(chain_dict):\\n\\n # suported scenarios \\n router = {\\n 'simple': _make_simple_label,\\n 'HT': _make_ht_label,\\n 'vbenf': _make_vbenf_label,\\n 'dijet': _make_dijet_label,\\n 'combinationsTest': _make_combinationsTest_label,\\n 'partitionsTest': _make_partitionsTest_label,\\n }\\n\\n # chain_part - scenario association\\n cp_sorter = {}\\n for k in router: cp_sorter[k] = []\\n\\n for cp in chain_dict['chainParts']:\\n if cp['signature'] != 'Jet' and cp['signature'] != 'Bjet': \\n continue\\n for k in cp_sorter:\\n if cp['hypoScenario'].startswith(k):\\n cp_sorter[k].append(cp)\\n break\\n\\n # obtain labels by scenario.\\n labels = []\\n for k, chain_parts in cp_sorter.items():\\n if chain_parts: labels.append(router[k](chain_parts))\\n\\n assert labels\\n nlabels = len(labels)\\n if nlabels == 1: return labels[0]\\n if nlabels == 2:\\n alabel = \\\"\\\"\\\"\\\\\\nand([]\\n %s\\n %s)\\\"\\\"\\\" % (tuple(labels))\\n return alabel\\n\\n # more than 2 labels is not expected\\n assert False\",\n \"def get_diar_target_labels(self, uniq_id, sample, fr_level_target):\\n seg_target_list, base_clus_label = [], []\\n self.scale_n = len(self.multiscale_timestamp_dict[uniq_id]['scale_dict'])\\n subseg_time_stamp_list = self.multiscale_timestamp_dict[uniq_id][\\\"scale_dict\\\"][self.scale_n - 1][\\\"time_stamps\\\"]\\n for (seg_stt, seg_end) in subseg_time_stamp_list:\\n seg_stt_fr, seg_end_fr = int(seg_stt * self.frame_per_sec), int(seg_end * self.frame_per_sec)\\n soft_label_vec_sess = torch.sum(fr_level_target[seg_stt_fr:seg_end_fr, :], axis=0) / (\\n seg_end_fr - seg_stt_fr\\n )\\n label_int_sess = torch.argmax(soft_label_vec_sess)\\n soft_label_vec = soft_label_vec_sess.unsqueeze(0)[:, sample.target_spks].squeeze()\\n if label_int_sess in sample.target_spks and torch.sum(soft_label_vec_sess) > 0:\\n label_int = sample.target_spks.index(label_int_sess)\\n else:\\n label_int = -1\\n label_vec = (soft_label_vec > self.soft_label_thres).float()\\n seg_target_list.append(label_vec.detach())\\n base_clus_label.append(label_int)\\n seg_target = torch.stack(seg_target_list)\\n base_clus_label = torch.tensor(base_clus_label)\\n return seg_target, base_clus_label\",\n \"def onCut(self):\\n pass\",\n \"def autolabel(X_pos,values,height_lift):\\r\\n\\theight= np.round(np.nan_to_num(values),2);y_pos = height_lift*height\\r\\n\\tfor i in range(len(height)):\\r\\n\\t\\tax.text(X_pos[i],y_pos[i],'%4.2f' % height[i], ha='center', va='bottom',size=4)\",\n \"def labels(self):\\n\\n param=self\\n\\n l=len(param)\\n\\n sweep_label=[]\\n\\n for index,name in enumerate(param.names):\\n\\n sweep_label.append((\\\\\\n ''.join([c for c in name if c.isupper()]))\\\\\\n .replace(\\\"IDT\\\",\\\"\\\")\\\\\\n .replace(\\\"S\\\",\\\"\\\")\\\\\\n .replace(\\\"M\\\",\\\"\\\"))\\n\\n stringout=[]\\n\\n unique={name:list(dict.fromkeys(values)) for name,values in zip(param.names,param.values)}\\n\\n for i in range(l):\\n\\n tmp_lab=''\\n\\n for lab,name in zip(sweep_label,self.names):\\n\\n tmp_lab=tmp_lab+lab+str(unique[name].index(param()[name][i]))\\n\\n stringout.append(tmp_lab)\\n\\n return stringout\",\n \"def _change_name(self, suff, info_extra):\\n if 'cable-ring' in self.path:\\n i1 = info_extra['convex_hull_area']\\n i2 = info_extra['best_possible_area']\\n f = i1 / i2\\n suff = suff.replace('.png',\\n f'-area-{i1:0.3f}-best-{i2:0.3f}-FRAC-{f:0.3f}.png')\\n elif 'cloth-flat' in self.path:\\n i1 = info_extra['cloth_coverage']\\n suff = suff.replace('.png', f'-coverage-{i1:0.3f}.png')\\n elif 'bag-alone' in self.path:\\n i1 = info_extra['convex_hull_area']\\n i2 = info_extra['best_possible_area']\\n suff = suff.replace('.png', f'-area-{i1:0.3f}-best-{i2:0.3f}.png')\\n else:\\n pass\\n return suff\",\n \"def Label(self) -> str:\",\n \"def setPieLabels(label, position):\\n pdict = {'left':'LEFT', 'right':'RIGHT'}\\n dislin.pielab(label, pdict[position])\",\n \"def test_reneaming_old_default_labels_to_new_fixed_labels():\\n from dtscalibration import DataStore\\n\\n cable_len = 100.0\\n nt = 3\\n time = np.arange(nt)\\n x = np.linspace(0.0, cable_len, 8)\\n ts_cold = np.ones(nt) * 4.0 + np.cos(time) * 4\\n ts_warm = np.ones(nt) * 20.0 + -np.sin(time) * 4\\n\\n C_p = 1324 # 1/2 * E0 * v * K_+/lam_+^4\\n eta_pf = np.cos(time) / 10 + 1 # eta_+ (gain factor forward channel)\\n eta_pb = np.sin(time) / 10 + 1 # eta_- (gain factor backward channel)\\n C_m = 5000.0\\n eta_mf = np.cos(time + np.pi / 8) / 10 + 1\\n eta_mb = np.sin(time + np.pi / 8) / 10 + 1\\n dalpha_r = 0.005284\\n dalpha_m = 0.004961\\n dalpha_p = 0.005607\\n gamma = 482.6\\n\\n temp_real_kelvin = np.zeros((len(x), nt)) + 273.15\\n temp_real_kelvin[x < 0.2 * cable_len] += ts_cold[None]\\n temp_real_kelvin[x > 0.85 * cable_len] += ts_warm[None]\\n temp_real_celsius = temp_real_kelvin - 273.15\\n\\n st = (\\n eta_pf[None]\\n * C_p\\n * np.exp(-dalpha_r * x[:, None])\\n * np.exp(-dalpha_p * x[:, None])\\n * np.exp(gamma / temp_real_kelvin)\\n / (np.exp(gamma / temp_real_kelvin) - 1)\\n )\\n ast = (\\n eta_mf[None]\\n * C_m\\n * np.exp(-dalpha_r * x[:, None])\\n * np.exp(-dalpha_m * x[:, None])\\n / (np.exp(gamma / temp_real_kelvin) - 1)\\n )\\n rst = (\\n eta_pb[None]\\n * C_p\\n * np.exp(-dalpha_r * (-x[:, None] + cable_len))\\n * np.exp(-dalpha_p * (-x[:, None] + cable_len))\\n * np.exp(gamma / temp_real_kelvin)\\n / (np.exp(gamma / temp_real_kelvin) - 1)\\n )\\n rast = (\\n eta_mb[None]\\n * C_m\\n * np.exp(-dalpha_r * (-x[:, None] + cable_len))\\n * np.exp(-dalpha_m * (-x[:, None] + cable_len))\\n / (np.exp(gamma / temp_real_kelvin) - 1)\\n )\\n\\n c_f = np.log(eta_mf * C_m / (eta_pf * C_p))\\n c_b = np.log(eta_mb * C_m / (eta_pb * C_p))\\n\\n dalpha = dalpha_p - dalpha_m # \\\\Delta\\\\alpha\\n alpha_int = cable_len * dalpha\\n\\n df = c_f # reference section starts at first x-index\\n db = c_b + alpha_int\\n i_fw = np.log(st / ast)\\n i_bw = np.log(rst / rast)\\n\\n E_real = (i_bw - i_fw) / 2 + (db - df) / 2\\n\\n ds = DataStore(\\n {\\n \\\"ST\\\": ([\\\"x\\\", \\\"time\\\"], st),\\n \\\"AST\\\": ([\\\"x\\\", \\\"time\\\"], ast),\\n \\\"REV-ST\\\": ([\\\"x\\\", \\\"time\\\"], rst),\\n \\\"REV-AST\\\": ([\\\"x\\\", \\\"time\\\"], rast),\\n \\\"userAcquisitionTimeFW\\\": ([\\\"time\\\"], np.ones(nt)),\\n \\\"userAcquisitionTimeBW\\\": ([\\\"time\\\"], np.ones(nt)),\\n \\\"cold\\\": ([\\\"time\\\"], ts_cold),\\n \\\"warm\\\": ([\\\"time\\\"], ts_warm),\\n },\\n coords={\\\"x\\\": x, \\\"time\\\": time},\\n attrs={\\\"isDoubleEnded\\\": \\\"1\\\"},\\n )\\n ds = ds.rename_labels()\\n\\n sections = {\\n \\\"cold\\\": [slice(0.0, 0.09 * cable_len)],\\n \\\"warm\\\": [slice(0.9 * cable_len, cable_len)],\\n }\\n\\n real_ans2 = np.concatenate(([gamma], df, db, E_real[:, 0]))\\n\\n ds.calibration_double_ended(\\n sections=sections,\\n st_var=1.5,\\n ast_var=1.5,\\n rst_var=1.0,\\n rast_var=1.0,\\n method=\\\"wls\\\",\\n solver=\\\"sparse\\\",\\n fix_gamma=(gamma, 0.0),\\n )\\n\\n assert_almost_equal_verbose(df, ds.df.values, decimal=14)\\n assert_almost_equal_verbose(db, ds.db.values, decimal=13)\\n assert_almost_equal_verbose(\\n x * (dalpha_p - dalpha_m), ds.alpha.values - ds.alpha.values[0], decimal=13\\n )\\n assert np.all(np.abs(real_ans2 - ds.p_val.values) < 1e-10)\\n assert_almost_equal_verbose(temp_real_celsius, ds.tmpf.values, decimal=10)\\n assert_almost_equal_verbose(temp_real_celsius, ds.tmpb.values, decimal=10)\\n assert_almost_equal_verbose(temp_real_celsius, ds.tmpw.values, decimal=10)\\n pass\",\n \"def autolabel(rects,array,axis,dist):\\n ctr = 0\\n label_array = [EM.truncate(v*100,1) for v in array]\\n for entry in range(len(label_array)):\\n if(label_array[entry]>=0) and (label_array[entry]<=1):\\n label_array[entry] = EM.truncate(array[entry]*100,2)\\n\\n\\n for rect in rects:\\n height = rect.get_height()\\n if(axis=='1'):\\n ax1.text(rect.get_x() + rect.get_width()/2., height+dist,\\n label_array[ctr],fontsize=fonts[3],\\n #'%d' % int(height),\\n ha='center', va='bottom',rotation=90)\\n elif(axis=='2'):\\n ax2.text(rect.get_x() + rect.get_width()/2., height+dist,\\n label_array[ctr],fontsize=fonts[3],\\n #'%d' % int(height),\\n ha='center', va='bottom',rotation=90)\\n elif(axis=='3'):\\n ax3.text(rect.get_x() + rect.get_width()/2., height+dist,\\n label_array[ctr],fontsize=fonts[3],\\n #'%d' % int(height),\\n ha='center', va='bottom',rotation=90)\\n elif(axis=='4'):\\n ax4.text(rect.get_x() + rect.get_width()/2., height+dist,\\n label_array[ctr],fontsize=fonts[3],\\n #'%d' % int(height),\\n ha='center', va='bottom',rotation=90)\\n ctr = ctr + 1\",\n \"def label(d, X, ind_class0, ind_class1, N, V, binary):\\n if binary == True:\\n K = 1\\n C = torch.zeros(N + V, K)\\n C[ind_class0, :] = 0.0\\n C[ind_class1, :] = 1.0\\n else:\\n K = 2\\n C = torch.zeros(N + V, K)\\n C[ind_class0, :] = torch.tensor([1.0, 0.0])\\n C[ind_class1, :] = torch.tensor([0.0, 1.0])\\n\\n X_train = X[:N, :]\\n X_val = X[N:, :]\\n C_train = C[:N, :]\\n C_val = C[N:, :]\\n\\n return [X_train, C_train, X_val, C_val, d, K]\",\n \"def Write_GCode_Drag_Knife(self, PostPro):\\n\\n # initialisation of the string\\n exstr = \\\"\\\"\\n\\n # Get the mill settings defined in the GUI\\n safe_retract_depth = self.parentLayer.axis3_retract\\n safe_margin = self.parentLayer.axis3_safe_margin\\n\\n workpiece_top_Z = self.axis3_start_mill_depth\\n f_g1_plane = self.f_g1_plane\\n f_g1_depth = self.f_g1_depth\\n\\n \\\"\\\"\\\"\\n Cutting in slices is not supported for Swivel Knife tool. All is cut at once.\\n \\\"\\\"\\\"\\n mom_depth = self.axis3_mill_depth\\n drag_depth = self.axis3_slice_depth\\n\\n # Move the tool to the start.\\n exstr += self.stmove.geos.abs_el(0).Write_GCode(PostPro)\\n\\n # Add string to be added before the shape will be cut.\\n exstr += PostPro.write_pre_shape_cut()\\n\\n # Move into workpiece and start cutting into Z\\n exstr += PostPro.rap_pos_z(\\n workpiece_top_Z + abs(safe_margin)) # Compute the safe margin from the initial mill depth\\n exstr += PostPro.chg_feed_rate(f_g1_depth)\\n\\n # Write the geometries for the first cut\\n if isinstance(self.stmove.geos.abs_el(1), ArcGeo):\\n if self.stmove.geos.abs_el(1).drag:\\n exstr += PostPro.lin_pol_z(drag_depth)\\n drag = True\\n else:\\n exstr += PostPro.lin_pol_z(mom_depth)\\n drag = False\\n else:\\n exstr += PostPro.lin_pol_z(mom_depth)\\n drag = False\\n exstr += PostPro.chg_feed_rate(f_g1_plane)\\n\\n exstr += self.stmove.geos.abs_el(1).Write_GCode(PostPro)\\n\\n for geo in Geos(self.stmove.geos[2:]).abs_iter():\\n if isinstance(geo, ArcGeo):\\n if geo.drag:\\n exstr += PostPro.chg_feed_rate(f_g1_depth)\\n exstr += PostPro.lin_pol_z(drag_depth)\\n exstr += PostPro.chg_feed_rate(f_g1_plane)\\n drag = True\\n elif drag:\\n exstr += PostPro.chg_feed_rate(f_g1_depth)\\n exstr += PostPro.lin_pol_z(mom_depth)\\n exstr += PostPro.chg_feed_rate(f_g1_plane)\\n drag = False\\n elif drag:\\n exstr += PostPro.chg_feed_rate(f_g1_depth)\\n exstr += PostPro.lin_pol_z(mom_depth)\\n exstr += PostPro.chg_feed_rate(f_g1_plane)\\n drag = False\\n\\n exstr += self.Write_GCode_for_geo(geo, PostPro)\\n\\n # Do the tool retraction\\n exstr += PostPro.chg_feed_rate(f_g1_depth)\\n exstr += PostPro.lin_pol_z(workpiece_top_Z + abs(safe_margin))\\n exstr += PostPro.rap_pos_z(safe_retract_depth)\\n\\n # Add string to be added before the shape will be cut.\\n exstr += PostPro.write_post_shape_cut()\\n\\n return exstr\",\n \"def get_label(name):\\n lower = name.lower()\\n vals = lower.split('_')\\n if 'ho' in vals:\\n name = 'Independent Estimate'\\n elif 'alldata' in vals:\\n name = 'Extra-Data Estimate'\\n elif 'ris' in vals[0]:\\n name = 'RIS'\\n if 'w' in vals[0]:\\n name += ' WIS'\\n if 'pd' in vals[0]:\\n name += ' PDIS'\\n elif 'is' in vals[0]:\\n name = 'OIS'\\n if 'w' in vals[0]:\\n name += ' WIS'\\n if 'pd' in vals[0]:\\n name += ' PDIS'\\n if 'dr' in vals:\\n name += ' DR'\\n if 'wdr' in vals:\\n name += ' WDR'\\n return name\",\n \"def setLabelDistance(dist=24, axes='XYZ'):\\n dislin.labdis(dist, axes)\",\n \"def onAddCutToolClicked(self, event):\\n i_cube = self.cube_choice.GetSelection()\\n i_dimension = self.cut_dimension_choice.GetSelection()\\n\\n if i_dimension <= 0:\\n dlg_func.openWarningBox(_(u'CUT'), _(u'Cut dimension not selected'))\\n else:\\n value = self.cut_value_textCtrl.GetValue()\\n if not value.strip():\\n dlg_func.openWarningBox(_(u'CUT'), _(u'Cut value not specified'))\\n else:\\n cube = self._OLAP_server.getCubes()[i_cube]\\n dimension = cube.getDimensions()[i_dimension - 1]\\n row = (dimension.getLabel(), dimension.getName(), value)\\n self.appendListCtrlRow(listctrl=self.cut_listCtrl, row=row)\\n\\n # After adding, clear the controls\\n self.cut_dimension_choice.SetSelection(0)\\n self.cut_value_textCtrl.SetValue(u'')\\n\\n event.Skip()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5650385","0.54846936","0.54270923","0.5375306","0.53342646","0.5226105","0.5209129","0.51919734","0.51784825","0.5173263","0.5163355","0.51560795","0.5154937","0.51164854","0.5109441","0.5093374","0.50911057","0.5076122","0.50540954","0.50480634","0.50421095","0.5034301","0.5032512","0.5028899","0.50236046","0.50234383","0.50142574","0.50132155","0.500397","0.49963433","0.49924707","0.49883384","0.49860042","0.49729776","0.49658248","0.49618146","0.49567258","0.49540654","0.49540654","0.49540654","0.49483338","0.4944248","0.49440426","0.49428022","0.49410334","0.4940744","0.49205828","0.49146846","0.49107683","0.49019703","0.49014068","0.4897067","0.4896715","0.4887378","0.4887378","0.48800677","0.48689413","0.48567855","0.485127","0.48479623","0.48441973","0.48358923","0.48252445","0.4818517","0.4812086","0.4808856","0.48074234","0.48025966","0.47962397","0.47950944","0.47950405","0.47939527","0.47912276","0.47896543","0.47838947","0.47807014","0.47798583","0.4776863","0.47678357","0.47665718","0.475749","0.47557047","0.47531223","0.47501165","0.4749837","0.474615","0.4737223","0.47342587","0.47282302","0.47193056","0.4719002","0.47179413","0.47126937","0.47052646","0.47046396","0.4704533","0.47022855","0.4702027","0.47002992","0.4694844"],"string":"[\n \"0.5650385\",\n \"0.54846936\",\n \"0.54270923\",\n \"0.5375306\",\n \"0.53342646\",\n \"0.5226105\",\n \"0.5209129\",\n \"0.51919734\",\n \"0.51784825\",\n \"0.5173263\",\n \"0.5163355\",\n \"0.51560795\",\n \"0.5154937\",\n \"0.51164854\",\n \"0.5109441\",\n \"0.5093374\",\n \"0.50911057\",\n \"0.5076122\",\n \"0.50540954\",\n \"0.50480634\",\n \"0.50421095\",\n \"0.5034301\",\n \"0.5032512\",\n \"0.5028899\",\n \"0.50236046\",\n \"0.50234383\",\n \"0.50142574\",\n \"0.50132155\",\n \"0.500397\",\n \"0.49963433\",\n \"0.49924707\",\n \"0.49883384\",\n \"0.49860042\",\n \"0.49729776\",\n \"0.49658248\",\n \"0.49618146\",\n \"0.49567258\",\n \"0.49540654\",\n \"0.49540654\",\n \"0.49540654\",\n \"0.49483338\",\n \"0.4944248\",\n \"0.49440426\",\n \"0.49428022\",\n \"0.49410334\",\n \"0.4940744\",\n \"0.49205828\",\n \"0.49146846\",\n \"0.49107683\",\n \"0.49019703\",\n \"0.49014068\",\n \"0.4897067\",\n \"0.4896715\",\n \"0.4887378\",\n \"0.4887378\",\n \"0.48800677\",\n \"0.48689413\",\n \"0.48567855\",\n \"0.485127\",\n \"0.48479623\",\n \"0.48441973\",\n \"0.48358923\",\n \"0.48252445\",\n \"0.4818517\",\n \"0.4812086\",\n \"0.4808856\",\n \"0.48074234\",\n \"0.48025966\",\n \"0.47962397\",\n \"0.47950944\",\n \"0.47950405\",\n \"0.47939527\",\n \"0.47912276\",\n \"0.47896543\",\n \"0.47838947\",\n \"0.47807014\",\n \"0.47798583\",\n \"0.4776863\",\n \"0.47678357\",\n \"0.47665718\",\n \"0.475749\",\n \"0.47557047\",\n \"0.47531223\",\n \"0.47501165\",\n \"0.4749837\",\n \"0.474615\",\n \"0.4737223\",\n \"0.47342587\",\n \"0.47282302\",\n \"0.47193056\",\n \"0.4719002\",\n \"0.47179413\",\n \"0.47126937\",\n \"0.47052646\",\n \"0.47046396\",\n \"0.4704533\",\n \"0.47022855\",\n \"0.4702027\",\n \"0.47002992\",\n \"0.4694844\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6397082"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":8789,"cells":{"query":{"kind":"string","value":"ht label. ht cuts, and cuts on particpating jets"},"document":{"kind":"string","value":"def _make_ht_label(chain_parts):\n\n assert len(chain_parts) == 1, '_make_ht_label, no. of chain parts != 1'\n scenario = chain_parts[0]['hypoScenario']\n \n assert scenario.startswith('HT'), '_make_ht_label(): scenario does not start with HT'\n\n arg_res = [\n re.compile(r'^(?P<lo>\\d*)(?P<key>ht)(?P<hi>\\d*)$'),\n re.compile(r'^(?P<lo>\\d*)(?P<key>et)(?P<hi>\\d*)$'),\n re.compile(r'^(?P<lo>\\d*)(?P<key>eta)(?P<hi>\\d*)$'),\n ]\n\n defaults = {\n 'ht': ('0', 'inf'),\n 'et': ('0', 'inf'),\n 'eta': ('0', 'inf'),\n }\n\n\n args = _args_from_scenario(scenario)\n argvals = {}\n nargs = len(args)\n assert len(args) <= len(arg_res), 'bad num of args %d, expected < %d' % (len(args),\n len(arg_res))\n\n # obtain argument values frrom scenario\n while args:\n arg = args.pop()\n for r in arg_res:\n m = r.match(arg)\n if m is not None:\n arg_res.remove(r)\n gd = m.groupdict()\n key = gd['key']\n\n try:\n lo = float(gd['lo'])\n except ValueError:\n lo = float(defaults[key][0])\n argvals[key+'lo'] = lo \n try:\n hi = float(gd['hi'])\n except ValueError:\n hi = float(defaults[key][1])\n argvals[key+'hi'] = hi\n\n print (argvals)\n assert len(argvals) == 2*nargs, 'no of args: %d, expected %d' % (len(argvals), 2*nargs)\n\n print ('sent 100')\n result = \"\"\"\n ht([(%(htlo).0fht) \n (%(etlo).0fet)\n (%(etalo).0feta%(etahi).0f)\n ])\"\"\" % argvals\n print (result)\n return result"},"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 label_thin(self, orig_label):\n pil_thin = thin(orig_label)\n # Keep the original label and set non-thinning label as 0\n orig_label[~pil_thin] = 0\n\n return orig_label","def kohonen():\n# plb.close('all')\n \n dim = 28*28\n data_range = 255.0\n \n # load in data and labels \n data = np.array(np.loadtxt('data.txt'))\n labels = np.loadtxt('labels.txt')\n\n # select 4 digits \n name = \"Stettler\"\n targetdigits = name2digits(name) # assign the four digits that should be used\n print(targetdigits) # output the digits that were selected\n\n # this selects all data vectors that corresponds to one of the four digits\n data = data[np.logical_or.reduce([labels==x for x in targetdigits]),:]\n \n dy, dx = data.shape\n \n #set the size of the Kohonen map. In this case it will be 6 X 6\n size_k = 6\n \n #set the width of the neighborhood via the width of the gaussian that\n #describes it\n sigma = 2.0\n \n #initialise the centers randomly\n centers = np.random.rand(size_k**2, dim) * data_range\n \n #build a neighborhood matrix\n neighbor = np.arange(size_k**2).reshape((size_k, size_k))\n\n #set the learning rate\n eta = 0.9 # HERE YOU HAVE TO SET YOUR OWN LEARNING RATE\n \n #set the maximal iteration count\n tmax = 5000 # this might or might not work; use your own convergence criterion\n \n #set the random order in which the datapoints should be presented\n i_random = np.arange(tmax) % dy\n np.random.shuffle(i_random)\n \n for t, i in enumerate(i_random):\n som_step(centers, data[i,:],neighbor,eta,sigma)\n\n # for visualization, you can use this:\n for i in range(size_k**2):\n plb.subplot(size_k,size_k,i)\n \n plb.imshow(np.reshape(centers[i,:], [28, 28]),interpolation='bilinear')\n plb.axis('off')\n \n # leave the window open at the end of the loop\n plb.show()\n plb.draw()","def onCut(self):\n pass","def odemis_to_hyperspy(filename='sampledata/cltest.h5',specbin=1) :\r\n\r\n f=h5.File(filename,'r')\r\n shome = 'Acquisition2//ImageData/'\r\n x = f[shome + 'Image']\r\n cdesc =f['Acquisition2/PhysicalData/ChannelDescription'].value[0].decode('utf-8')\r\n #print(cdesc)\r\n\r\n cltype = None\r\n if 'Spectrum' in cdesc :\r\n cltype = 'spectrum'\r\n elif 'CL intensity' in cdesc:\r\n cltype = 'panchrom'\r\n\r\n print('<' + filename + '> original shape :' ,x.shape, cltype)\r\n\r\n # strip unused dimensions and transpose/ reverse index order\r\n if cltype == 'panchrom' :\r\n xx=x[0,0,0,:,:].transpose((1,0))\r\n # just an image..\r\n else :\r\n xx=x[:,0,0,:,:].transpose((2,1,0))\r\n\r\n if cltype == 'spectrum' :\r\n #interpolate data to linearize the wavelength scale\r\n w = f[shome + 'DimensionScaleC'].value *1e9\r\n wx = np.linspace(w.min(),w.max(),w.size)\r\n for i in np.arange(xx.shape[0]) :\r\n for k in np.arange(xx.shape[1]) :\r\n xx[i,k,:] = np.interp(wx,w,xx[i,k,:])\r\n\r\n wslope = wx[1]-wx[0]\r\n woffset = wx.min()\r\n #wx = np.arange(w.size)\r\n #wslope,woffset=np.polyfit(wx,w,1)\r\n s = hs.signals.Signal1D(xx)\r\n\r\n elif cltype == 'panchrom' :\r\n s = hs.signals.Signal2D(xx)\r\n else :\r\n print('unknown type')\r\n\r\n print('hyperspy shape :' ,s.data.shape)\r\n\r\n\r\n s.metadata.General.title = 'Odemis: ' + cdesc\r\n s.metadata.General.original_filename = filename\r\n s.metadata.General.notes = cltype\r\n s.axes_manager[0].name = 'pos x'\r\n s.axes_manager[0].scale = f[shome + 'DimensionScaleX'].value * 1e6\r\n s.axes_manager[0].offset = f[shome + 'XOffset'].value * 1e6\r\n s.axes_manager[0].units = 'um'\r\n\r\n\r\n s.axes_manager[1].name = 'pos y'\r\n s.axes_manager[1].scale = f[shome + 'DimensionScaleX'].value * 1e6\r\n s.axes_manager[1].offset = f[shome + 'YOffset'].value * 1e6\r\n s.axes_manager[1].units = 'um'\r\n\r\n if cltype == 'spectrum' :\r\n s.axes_manager[2].name = 'wavelength'\r\n s.axes_manager[2].units = 'nm'\r\n s.axes_manager[2].offset = woffset\r\n s.axes_manager[2].scale = wslope\r\n s.metadata.signal_type = 'CL'\r\n\r\n f.close()\r\n if (specbin > 1) and (cltype == 'spectrum'):\r\n return( s.rebin(scale=[1,1,specbin]) )\r\n else :\r\n return( s )\r\n #end odemis_to_hyperspy\r\n #######################\r","def cut(S, T, graph):\n ###TODO\n pass","def __init__(self, label=None):\n super().__init__(\"h\", 1, [], label=label)","def extract_info(config, cut, label):\n cfg = filter(lambda c: c['name'] == cut, config['physics']['cuts'])[0]\n text = \"\"\n if 'max' not in cfg:\n text += \"#geq \"\n text += str(cfg['min'])\n if 'max' in cfg and cfg['max'] != cfg['min']:\n text += '-' + str(cfg['max']) + ' ' + label + 's'\n elif cfg['min'] != 1:\n text += ' ' + label + 's'\n else:\n text += ' ' + label\n return text","def ch(h1):\n return -(pic_height / float(h)) * h1","def drawlabels(t, t1):\r\n t.fd(250)\r\n t.pd()\r\n t.write(\"Life\", font=(\"Arial\", 10, \"bold\"))\r\n t.pu()\r\n t.back(12)\r\n t.pd()\r\n t.write(\"Exp.\", font=(\"Arial\", 10, \"bold\"))\r\n t.pu()\r\n t.back(238)\r\n t.right(90)\r\n t.fd(80)\r\n t1.pu()\r\n t1.back(50)\r\n t1.rt(90)\r\n t1.fd(250)\r\n t1.pd()\r\n t1.write(\"Year\", font=(\"Arial\", 10, \"bold\"))\r\n t1.pu()\r\n t1.back(250)\r\n t1.left(90)\r\n t1.fd(50)","def hxlcut():\n run_script(hxlcut_main)","def write_label_ps(header_lines, base_lines, tail_lines, shape_list, title, outFn, cutofflist=[0.3,0.5,0.7], mode='fill'):\n OUT = open(outFn, \"w\")\n for header_line in header_lines:\n if r'{title}' in header_line:\n header_line = header_line.format(title=title)\n OUT.writelines(header_line)\n #print(len(shape_list), len())\n for shape,base_line in zip(shape_list,base_lines):\n if mode=='label':\n OUT.writelines( _color_command_segmented(shape, cutofflist)+\"\\n\" )\n elif mode=='heatmap':\n OUT.writelines( _color_command_heatmap(shape, Gradient_Colors, 0, 1)+\"\\n\" )\n else:\n raise RuntimeError(\"Sorry: mode='fill' Not applicant now\")\n OUT.writelines(base_line)\n for tail_line in tail_lines:\n OUT.writelines(tail_line)\n OUT.close()","def __get_ohe_label__(self, label_idx) -> List[int]:\n\n label = [0] * self.n_classes\n label[label_idx] = 1\n\n return label","def agglo_from_labelmask(\n h5path_in,\n h5path_lv='',\n ratio_threshold=0,\n h5path_out='',\n save_steps=False,\n protective=False,\n ):\n\n # check output paths\n outpaths = {'out': h5path_out}\n status = utils.output_check(outpaths, save_steps, protective)\n if status == \"CANCELLED\":\n return\n\n # open data for reading\n h5file_in, ds_in, elsize, axlab = utils.h5_load(h5path_in)\n h5file_lv, ds_lv, _, _ = utils.h5_load(h5path_lv)\n\n # open data for writing\n h5file_out, ds_out = utils.h5_write(None, ds_in.shape, ds_in.dtype,\n h5path_out,\n element_size_um=elsize,\n axislabels=axlab)\n\n ulabels = np.unique(ds_in)\n maxlabel = np.amax(ulabels)\n print(\"number of labels in watershed: {:d}\".format(maxlabel))\n\n fwmap = np.zeros(maxlabel + 1, dtype='i')\n\n areas_ws = np.bincount(ds_in.ravel())\n\n labelsets = {}\n rp_lw = regionprops(ds_lv, ds_in)\n for prop in rp_lw:\n\n maskedregion = prop.intensity_image[prop.image]\n counts = np.bincount(maskedregion)\n svoxs_in_label = [l for sl in np.argwhere(counts) for l in sl]\n\n ratios_svox_in_label = [float(counts[svox]) / float(areas_ws[svox])\n for svox in svoxs_in_label]\n fwmask = np.greater(ratios_svox_in_label, ratio_threshold)\n labelset = np.array(svoxs_in_label)[fwmask]\n labelsets[prop.label] = set(labelset) - set([0])\n\n basepath = h5path_in.split('.h5/')[0]\n utils.write_labelsets(labelsets, basepath + \"_svoxsets\",\n filetypes=['pickle'])\n\n ds_out[:] = utils.forward_map(np.array(fwmap), ds_in, labelsets)\n\n # close and return\n h5file_in.close()\n h5file_lv.close()\n try:\n h5file_out.close()\n except (ValueError, AttributeError):\n return ds_out","def cut(self,cell):\r\n self.grid[cell[0]][cell[1]] = 1","def o_wo_per_head(self):\n assert self.ff % self.heads == 0\n # fuse ff->e and projection layer of self-attention\n return (self.ff // (self.heads-self.padded_heads)) + self.qkv","def ksh(i,t,htanses):\n for (zs,ys,zx,yx) in htanses[i]:\n alex.penup()\n alex.goto((zs%m)*20-10*m,(zs//m)*20-10*n)\n alex.pendown()\n alex.goto((ys%m+1)*20-10*m,(ys//m)*20-10*n)\n alex.goto((yx%m+1)*20-10*m,(yx//m+1)*20-10*n)\n alex.goto((zx%m)*20-10*m,(zx//m+1)*20-10*n)\n alex.goto((zs%m)*20-10*m,(zs//m)*20-10*n)\n alex.hideturtle()","def create_teacher(self):\n\n #words = [\"one\", \"two\", \"three\", \"four\", \"five\", \"six\", \"seven\", \"eight\", \"nine\"]\n\n #print(\"self.length: \", self.length)\n for i, image in enumerate(self.images):\n if False:#i % 2 == 0:\n img = list(chunks(image, 10))\n plt.imshow(img, interpolation=\"nearest\", origin=\"upper\")\n plt.colorbar()\n plt.title(self.labels[i])\n plt.show()\n label = np.argmax(self.labels[i]) + 1\n label_vector = self.labels[i]\n timesteps = label + 1\n\n for chain in list(self.traces[i]):\n count_tensor = list()\n input_tensor = list()\n target_tensor = list()\n \n #count_tensor.append([0] * z_size)\n #input_tensor.append(image)\n #target_tensor.append([None, None])\n\n #count_padding = [0 for x in range(z_size)]\n \n for count, link in enumerate(chain):\n count_vector = [0 if x is not count else 1 for x in range(z_size)]\n count_tensor.append(count_vector)\n x, y = link\n image[y*200+x] = 255\n input_tensor.append(image)\n target_tensor.append(list(link))\n\n # Fill in the rest of the list with the same (current one doe\n #for cont in range(count + 1, z_size):\n for cont in range(count + 1, z_size + 1):\n #count_tensor.append(count_padding)\n count_tensor.append(count_vector)\n input_tensor.append(image)\n target_tensor.append(list(link))\n\n \n\n self.explode_lbls.append(label)\n self.explode_labels.append(label_vector)\n self.explode_counts.append(count_tensor)\n self.explode_images.append(input_tensor)\n self.explode_traces.append(target_tensor)\n #print(target_tensor)\n\n \n \n self.explode_length = len(self.explode_images)","def get_hbls_hbbl(self):\n [Ly,N] = self.b.shape\n z_u_w = self.grid_dict['z_u_w']\n z_u_r = self.grid_dict['z_u_r']\n u = self.u\n v = self.v\n \n v_upts = TTTW_func.v2u(v)\n Hz = z_u_w[:,1:] - z_u_w[:,:-1]\n\n\n\n # CALCULATE swr_frac\n self.swr_frac = TTTW_func.lmd_swr_frac(self.grid_dict)\n\n\n # WHOLE THING HAPPENS IN j loop through y-indices\n \n # INITIALIZE ARRAYS\n self.kmo = np.zeros([Ly])\n self.Cr = np.zeros([Ly])\n self.kbl = np.empty([Ly],dtype='int')\n self.C_h_MO = np.zeros([Ly])\n self.Cr = np.zeros([Ly,N+1]) # sum term\n self.FC = np.zeros([Ly,N+1])\n self.swdk_r = np.zeros([Ly,N+1])\n \n self.zscale = np.zeros([Ly,N])\n self.Kern = np.zeros([Ly,N])\n\n \n # --> LOOP THROUGH Y-INDICES\n for j in range(Ly):\n if self.LIMIT_MO_DEPTH:\n self.kmo[j] = 0\n self.C_h_MO[j] = self.C_MO *self.ustar[j]**3/self.vonKar\n \n self.kbl[j] = 0\n self.Cr[j,-1] = 0 # set top Cr\n self.Cr[j,0] = 0 # set bottom Cr\n \n # SEARCH FOR MIXED LAYER DEPTH\n self.FC[j,-1] = 0.\n\n\n # ---> LOOP TOP TO BOTTOM (FORTRAN ==> k=N-1,1,-1)\n for k in range(N-1,0,-1):\n # INDEX MAP\n k_r = k-1\n k_w = k\n\n \n zscale = z_u_w[j,N] - z_u_r[j,k_r]\n self.zscale[j,k_w] = zscale\n if self.LMD_KPP:\n if self.LMD_BKPP:\n zscaleb = z_u_r[j,k_r] - z_u_w[j,0]\n Kern = zscale * zscaleb**2 / ( (zscale + self.epssfcs*self.hbls_old[j]) * (zscaleb**2+(self.epssfcb**2*self.hbbl_old[j]**2)))\n else:\n Kern = zscale / (zscale + (self.epssfcs*self.hbls_old[j]))\n else:\n Kern = 1.\n \n\n\n self.Kern[j,k_w] = Kern\n self.FC[j,k_w] = self.FC[j,k_w+1] + Kern * (\\\n ( ( u[j,k_r+1] - u[j,k_r] )**2 + ( v_upts[j,k_r+1] - v_upts[j,k_r])**2 ) \\\n / (Hz[j,k_r] + Hz[j,k_r+1]) \\\n - 0.5 * ( Hz[j,k_r] + Hz[j,k_r+1]) * (self.Ri_inv * self.bvf[j,k_w] + self.C_Ek*self.f[j]*self.f[j]))\n\n\n #\t\tLOOP THAT FINDS BL DEPTH ##\n #----> LOOP TOP TO BOTTOM (start at free surface, w-level surface) \n \n if self.LMD_KPP:\n #swdk_r only used in this function so don't need to be class attribute\n # but for testing make it an attribute to see what it is\n \n # fortran equivlanet ===> k=N,1,-1 \n for k in range(N,0,-1):\n # INDEX MAP\n k_r = k-1\n k_w = k\n\n ###################################################################### \n self.swdk_r[j,k_w] = np.sqrt( self.swr_frac[j,k_w] * self.swr_frac[j,k_w-1])\n zscale = z_u_w[j,N] - z_u_r[j,k_r]\n Bfsfc = self.Bo[j] + self.Bosol[j] * (1-self.swdk_r[j,k_w])\n \n self.bvf_max = np.sqrt(np.max([0,self.bvf[j,k_w-1]]))\n \n # CALCULATE TURBULENT VELOCITY SCALE FOR TRACERS\n \t\t\t self.ws = self.lmd_wscale_ws_only(Bfsfc, zscale,self.hbls_old[j],self.ustar[j])\n \n self.Vtsq = self.Vtc * self.ws* self.bvf_max + self.V0\n \n\n self.Cr[j,k_w] = self.FC[j,k_w] + self.Vtsq\n \n\n #######################################################################\n \n # SEARCH FOR hbls vertical level #\n '''\n kbl is specified at vertical w-level (via Cr which is at\n vertical w-levels)\n '''\n if self.kbl[j] == 0 and self.Cr[j,k_w] < 0:\n self.kbl[j] = k_w\n if self.LIMIT_MO_DEPTH:\n if self.kmo[j] == 0 and Bfsfc*(z_u_w[j,N] - z_u_r[j,k_r]) > self.C_h_MO[j]:\n self.kmo[j] = k_w\n\n \n #--> still in j-loop\n #######################################################\n \n # \t\tGET SURFACE BOUNDARY LAYER DEPTH # \n self.hbls[j] = z_u_w[j,N] - z_u_w[j,0] + self.eps # set hbls as depth of entire water column\n if self.kbl[j] > 0:\n k_w = self.kbl[j]\n k_r = k_w - 1 \n if k_w == N: # set hbls at the surface btwn w- and rho-levels at surface\n self.hbls[j] = z_u_w[j,N] - z_u_r[j,N-1]\n \n else:\n self.hbls[j] = z_u_w[j,N] - ( z_u_r[j,k_r] * self.Cr[j,k_w+1] - z_u_r[j,k_r+1] * self.Cr[j,k_w]) / \\\n (self.Cr[j,k_w+1] - self.Cr[j,k_w])\n \n if self.LIMIT_MO_DEPTH:\n if self.kmo[j] > 0:\n k_w = self.kmo[j]\n k_r = k_w-1\n if k_w == N:\n z_up = z_u_w[j,N]\n cff_up = np.max([0,Bo[j]])\n else:\n z_up = z_r[j,k_w+1]\n cff_up = np.max([0, Bo[j] + self.Bosol[j]*(1-self.swdk_r[j,(k_w-1)+1])])\n \n cff_dn = np.max([0,Bo[j] + self.Bosol[j] * (1-self.swdk_r[j,k_w])]) \n h_MO = z_u_w[j,N] + self.C_h_MO[j] * ( cff_up*z_up - cff_dn * z_u_r[j,k_r] ) \\\n / ( cff_up * cff_dn * (z_up - z_u_r[j,k_r]) ) \\\n + self.C_h_MO[j] * (cff_dn - cff_up)\n\n self.hbls[j] = np.min([self.hbls[j],np.max([h_MO,0])])\n\n\n\n #### GET BOTTOM BOUNDARY LAYER DEPTH #######\n if self.LMD_BKPP:\n self.kbl[j] = 0 # reset Cr at bottom and kbl for BKPP\n self.Cr[j,0] = 0.\n self.FC[j,0] = 1.5 * self.FC[j,1] - 0.5 * self.FC[j,2] # linear extrapolation\n \n #---> LOOP BOTTOM TO TOP\n # FIND kbl for BBL\n for k in range(1,N+1):\n k_r = k-1\n k_w = k \n self.Cr[j,k_w] = self.FC[j,k_w] - self.FC[j,0]\n \n # LOOK FOR FIRST ZERO CROSSING FROM BOTTOM UP\n if self.kbl[j] == 0 and self.Cr[j,k_w] > 0:\n self.kbl[j] = k_w \n \n\n self.hbbl[j] = z_u_w[j,N] - z_u_w[j,0] # total depth\n if self.kbl[j] > 0 :\n k_w = self.kbl[j] \n k_r = k_w -1\n if k_w == 1: # NO BBL CASE\n self.hbbl[j] = z_u_r[j,0] - z_u_w[j,0] #in between bottom rho and w-level\n else:\n self.hbbl[j] = ( z_u_r[j,k_r-1] * self.Cr[j,k_w] - z_u_r[j,k_r] * self.Cr[j,k_w-1]) / \\\n (self.Cr[j,k_w] - self.Cr[j,k_w-1]) - z_u_w[j,0]","def process_labels(ctx, tex, chapter):\n headings = ['chapter'] + ['sub'*i + 'section' for i in range(4)]\n reh = r'(' + '|'.join(headings) + r'){(.+?)}'\n environments = ['thm', 'lem', 'exc', 'figure', 'equation']\n ree = r'begin{(' + '|'.join(environments) + r')}'\n rel = r'(\\w+)label{(.+?)}'\n rel2 = r'label{(.+?)}'\n bigone = r'\\\\({})|\\\\({})|\\\\({})|\\\\(caption)|\\\\({})'.format(reh, ree, rel, rel2)\n rx = re.compile(bigone)\n\n sec_ctr = [chapter] + [0]*(len(headings))\n env_ctr = [0]*len(environments)\n blocks = catlist()\n lastlabel = None\n lastidx = 0\n m = rx.search(tex, lastidx)\n while m:\n blocks.append(tex[lastidx:m.start()])\n lastidx = m.start()\n cmd = next_command(tex, lastidx)\n lastidx = cmd.end\n if m.group(2):\n # This is a sectioning command (chapter, subsection,...)\n name = m.group(2)\n i = headings.index(name)\n if i == 0:\n env_ctr = [0]*len(env_ctr)\n sec_ctr[i:] = [sec_ctr[i]+1]+[0]*(len(headings)-i-1)\n number = \".\".join([str(x) for x in sec_ctr[:i+1]])\n idd = \"{}:{}\".format(name, number)\n lastlabel = idd\n blocks.append(\"<a id='{}'></a>\".format(idd))\n\n title = '{} {}'.format(number, cmd.args[0])\n blocks.append(r'\\{}{{{}}}'.format(name, title))\n\n elif m.group(5):\n # This is an environment (thm, lem, ...)\n name = m.group(5)\n lastenv = name # save this for a caption command coming later...\n i = environments.index(name)\n env_ctr[i] += 1\n number = \"{}.{}\".format(sec_ctr[0], env_ctr[i])\n idd = \"{}:{}\".format(name, number)\n lastlabel = idd\n blocks.append(\"<a id='{}'></a>\".format(idd))\n\n if name in ctx.theoremlike_environments:\n nicename = ctx.named_entities[name]\n title = '{} {}'.format(nicename, number)\n blocks.append(r'\\begin{{{}}}[{}]'.format(name, title))\n else:\n blocks.append(r'\\begin{{{}}}'.format(name))\n\n elif m.group(6):\n # This is a labelling command (\\thmlabel, \\seclabel,...)\n label = \"{}:{}\".format(m.group(7), m.group(8))\n ctx.label_map[label] = (ctx.outputfile, lastlabel)\n\n elif m.group(9):\n # This is a caption command\n name = lastenv\n i = environments.index(name)\n number = \"{}.{}\".format(sec_ctr[0], env_ctr[i])\n idd = \"{}:{}\".format(name, number)\n lastlabel = idd\n nicename = ctx.named_entities[name]\n title = '<span class=\"title\">{} {}</span>'.format(nicename, number)\n text = '{} {}'.format(title, cmd.args[0])\n blocks.append(r'\\caption{{{}}}'.format(text))\n\n elif m.group(10):\n # This is a \\label command, probably the target of a pageref\n idd = gen_unique_id()\n blocks.append(\"<a id={}></a>\".format(idd))\n ctx.label_map[m.group(11)] = (ctx.outputfile, idd)\n\n m = rx.search(tex, lastidx)\n blocks.append(tex[lastidx:])\n return \"\".join(blocks)","def simple_core(block,cut,laser):\r\n\r\n\tlayers = int(block[\"thickness\"]/laser[\"z_spacing\"])\r\n\r\n\t#Since all cuts are square, the offsets are more obvious than in the general linear case.\r\n\ttaper = math.tan(math.radians(laser[\"kerf_angle\"]/2)) * laser[\"z_spacing\"]\r\n\tmax_delta = math.tan(math.radians(laser[\"kerf_angle\"]/2)) * (block[\"thickness\"] + laser[\"z_final_overshoot\"]) * 2\r\n\t\r\n\tcutlist = []\r\n\tcutlist.append([\"a_abs\", \"0\"])\r\n\tcutlist.append([\"c_abs\", str(block[\"physical_rotation\"])])\r\n\tcutlist.append([\"z_abs\", str(block[\"thickness\"])])\r\n\r\n\tfor a in range(layers):\r\n\t\tx1, y1 = cut[\"final_dimension_x\"]/2 + a*taper, cut[\"final_dimension_y\"]/2 + a*taper\r\n\t\twhile abs(x1-cut[\"final_dimension_x\"]/2) < abs(max_delta):\r\n\t\t\tcutlist.append([\"jump\", str(x1 + block[\"origin_x\"]), str(y1 + block[\"origin_y\"])])\r\n\t\t\tcutlist.append([\"mark\", str(x1 + block[\"origin_x\"]), str(-y1 + block[\"origin_y\"])])\r\n\t\t\tcutlist.append([\"mark\", str(-x1 + block[\"origin_x\"]), str(-y1 + block[\"origin_y\"])])\r\n\t\t\tcutlist.append([\"mark\", str(-x1 + block[\"origin_x\"]), str(y1 + block[\"origin_y\"])])\r\n\t\t\tcutlist.append([\"mark\", str(x1 + block[\"origin_x\"]), str(y1 + block[\"origin_y\"])])\r\n\t\t\tx1, y1 = x1 + laser[\"xy_spacing\"], y1 + laser[\"xy_spacing\"]\r\n\t\tcutlist.append([\"z_step\", str(-laser[\"z_spacing\"])])\r\n\t\tmax_delta = max_delta - taper \r\n\treturn json.dumps(cutlist)","def LabelDisks(self):\n pass","def split2(self, eccMap, patchName='patch00', cutStep=1, borderWidth=2, isplot=False):\r\n minMarker = localMin(eccMap, cutStep)\r\n\r\n connectivity = np.array([[1, 1, 1], [1, 1, 1], [1, 1, 1]])\r\n\r\n newLabel = sm.watershed(eccMap, minMarker, connectivity=connectivity, mask=self.array)\r\n\r\n border = ni.binary_dilation(self.array).astype(np.int8) - self.array\r\n\r\n for i in range(1, np.amax(newLabel) + 1):\r\n currArray = np.zeros(self.array.shape, dtype=np.int8)\r\n currArray[newLabel == i] = 1\r\n currBorder = ni.binary_dilation(currArray).astype(np.int8) - currArray\r\n border = border + currBorder\r\n\r\n border[border > 1] = 1\r\n border = sm.skeletonize(border)\r\n\r\n if borderWidth > 1:\r\n border = ni.binary_dilation(border, iterations=borderWidth - 1).astype(np.int8)\r\n\r\n newPatchMap = ni.binary_dilation(self.array).astype(np.int8) * (-1 * (border - 1))\r\n\r\n labeledNewPatchMap, patchNum = ni.label(newPatchMap)\r\n\r\n # if patchNum != np.amax(newLabel):\r\n # print 'number of patches: ', patchNum, '; number of local minimum:', np.amax(newLabel)\r\n # raise ValueError, \"Number of patches after splitting does not equal to number of local minimum!\"\r\n\r\n newPatchDict = {}\r\n\r\n for j in range(1, patchNum + 1):\r\n\r\n currPatchName = patchName + '.' + str(j)\r\n currArray = np.zeros(self.array.shape, dtype=np.int8)\r\n currArray[labeledNewPatchMap == j] = 1\r\n currArray = currArray * self.array\r\n\r\n if np.sum(currArray[:]) > 0:\r\n newPatchDict.update({currPatchName: Patch(currArray, self.sign)})\r\n\r\n if isplot:\r\n plt.figure()\r\n plt.subplot(121)\r\n plt.imshow(self.array, interpolation='nearest')\r\n plt.title(patchName + ': before split')\r\n plt.subplot(122)\r\n plt.imshow(labeledNewPatchMap, interpolation='nearest')\r\n plt.title(patchName + ': after split')\r\n\r\n return newPatchDict","def __init__(self, smoothing=0.1):\n super(LabelSmoothing, self).__init__()\n self.confidence = 1.0 - smoothing\n self.smoothing = smoothing","def hilfe(self):\n toto_hilfe(3)","def identify_leaflets(u, time_ts):\n z = u.select_atoms(\"all\").center_of_geometry()[2]\n COM_z= np.array([0,0,z]) #defines the global midplane position along z\n x, y, z = u.trajectory.ts.triclinic_dimensions[0][0], u.trajectory.ts.triclinic_dimensions[1][1], u.trajectory.ts.triclinic_dimensions[2][2]\n box = np.array([x, y, z, 90, 90, 90]) \n ### Determining side of the bilayer CHOL belongs to in this frame\n lipid1 = 'CHL'\n lipid2 = 'DLIP'\n lipid3 = 'SSM'\n lipid4 = 'DSPC'\n \n lpd1_atoms = u.select_atoms('resname %s and name O2'%lipid1) \n lpd2_atoms = u.select_atoms('resname %s and name P '%lipid2) \n lpd3_atoms = u.select_atoms('resname %s and name P '%lipid3) \n lpd4_atoms = u.select_atoms('resname %s and name P '%lipid4)\n \n num_lpd2 = lpd2_atoms.n_atoms\n num_lpd3 = lpd3_atoms.n_atoms\n num_lpd4 = lpd4_atoms.n_atoms \n # atoms in the upper leaflet as defined by insane.py or the CHARMM-GUI membrane builders\n # select cholesterol headgroups within 1.5 nm of lipid headgroups in the selected leaflet\n # this must be done because CHOL rapidly flip-flops between leaflets\n # so we must assign CHOL to each leaflet at every time step, and in large systems\n # with substantial membrane undulations, a simple cut-off in the z-axis just will not cut it\n if side == 'up':\n lpd2i = lpd2_atoms[:int((num_lpd2)/2)]\n lpd3i = lpd3_atoms[:int((num_lpd3)/2)]\n lpd4i = lpd4_atoms[:int((num_lpd4)/2)]\n \n\n lipids = lpd2i + lpd3i + lpd4i \n\n ns_lipids = NS.AtomNeighborSearch(lpd1_atoms, box=box) \n lpd1i = ns_lipids.search(lipids,15.0) #1.5 nm\n leaflet = lpd1i + lpd2i + lpd3i + lpd4i \n\n elif side == 'down':\n lpd2i = lpd2_atoms[int((num_lpd2)/2):]\n lpd3i = lpd3_atoms[int((num_lpd3)/2):]\n lpd4i = lpd4_atoms[int((num_lpd4)/2):]\n\n lipids = lpd2i + lpd3i + lpd4i #+ lpd3i\n \n ns_lipids = NS.AtomNeighborSearch(lpd1_atoms, box=box)\n lpd1i = ns_lipids.search(lipids,15.0) # 1.5nm\n leaflet = lpd1i + lpd2i + lpd3i+ lpd4i \n return lpd1i, lpd2i, lpd3i, lpd4i, COM_z, box, leaflet","def cmd_label_merged_boundaries(self,sun_dir,output_dir=None):\n sun=sunreader.SunReader(sun_dir)\n if output_dir is None:\n # defaults location of dense output\n output_dir=os.path.join(sun.datadir,'dwaq',\"global-dense\")\n \n hyd_fn=glob.glob(os.path.join(output_dir,'*.hyd'))[0]\n \n hydro=SunHydro(sun=sun,hyd_path=hyd_fn,flow_shps=[self.flows_shp])\n\n class SpliceScenario(waq_scenario.Scenario):\n base_path=output_dir\n name=\"spliced\"\n\n scen=SpliceScenario(hydro=hydro)\n\n self.log.info(\"Writing labels\")\n scen.hydro.write_boundary_links()","def __init__(self, smoothing=0.0):\n super(LabelSmoothing, self).__init__()\n self.confidence = 1.0 - smoothing\n self.smoothing = smoothing","def __init__(self, smoothing=0.0):\n super(LabelSmoothing, self).__init__()\n self.confidence = 1.0 - smoothing\n self.smoothing = smoothing","def make_stehle(self):\n\n temp_k = self.temp * e / k # temperature in K\n dens_cm = self.e_dens * 1.e-6 # electronic density in cm-3\n prefix = 'n_' + str(self.n_upper) + '_' + str(self.n_lower) + '_'\n\n # extract raw tabulated tabulated_data\n tab_temp_k = np.array(pystark.nc.variables[prefix + 'tempe'].data) # tabulated electron temperatures (K)\n olam0 = pystark.nc.variables[prefix + 'olam0'].data # line centre wavelength (A)\n num_tab_dens = pystark.nc.variables[prefix + 'id_max'].data\n fainom = pystark.nc.variables[prefix + 'fainom'].data\n tab_dens_cm = np.array(pystark.nc.variables[prefix + 'dense'].data) # tabulated electron densities (cm ** -3)\n f00 = np.array(pystark.nc.variables[prefix + 'f00'].data) # normal Holtsmark field strength (30 kV / m)\n dl12 = np.array(pystark.nc.variables[prefix + 'dl12'].data)\n dl12s = np.array(pystark.nc.variables[prefix + 'dl12s'].data)\n fainu = pystark.nc.variables[\n prefix + 'fainu'].data # Asymptotic value of iStark * (alpha ** 2.5) (\"wings factor in alfa units\")\n pr0 = np.array(pystark.nc.variables[\n prefix + 'pr0'].data) # Ratio of the mean interelectronic distance to the electronic Debye length\n jtot = np.array(pystark.nc.variables[prefix + 'jtot'].data,\n dtype=np.int) # \"number of wave lengths for the couple (T,Ne)\"\n dom = np.array(pystark.nc.variables[prefix + 'dom'].data) # frequency detunings in units (rad / (s*ues)\n d1om = np.array(pystark.nc.variables[prefix + 'd1om'].data)\n o1line = np.array(pystark.nc.variables[prefix + 'o1line'].data)\n o1lines = np.array(pystark.nc.variables[prefix + 'o1lines'].data)\n\n # ensure given temperature + density falls within tabulated values\n # change sligtly the value of the input density\n # dens_cm in order to remain , as far as possible, inside the tabulation\n # JSA: this first step seems bogus!\n\n if np.abs(dens_cm - tab_dens_cm[0]) / dens_cm <= 1.0E-3:\n dens_cm = tab_dens_cm[0] * 1.001\n\n for id in np.arange(1, num_tab_dens + 1):\n if np.abs(dens_cm - tab_dens_cm[id]) / dens_cm <= 1.0E-3:\n dens_cm = tab_dens_cm[id] * 0.999\n\n if dens_cm >= 2.0 * tab_dens_cm[num_tab_dens]:\n raise Exception(\n 'Your input density is higher than the largest tabulated value %f' % tab_dens_cm[num_tab_dens])\n\n if dens_cm <= tab_dens_cm[0]:\n raise Exception('Your input density is smaller than the smallest tabulated value %f' % tab_dens_cm[0])\n\n if temp_k >= tab_temp_k[9]:\n raise Exception('Your input temperature is higher than the largest tabulated value %f' % tab_temp_k[9])\n\n if temp_k <= tab_temp_k[0]:\n raise Exception('Your input temperature is lower than the smallest tabulated value %f' % tab_temp_k[0])\n\n normal_holtsmark_field = 1.25e-9 * (dens_cm ** (2. / 3.)) # normal field value in ues\n\n # calculate line centre wavelength and frequency using Rydberg formula\n # JSA: I have made this step clearer and corrected for deuteron mass in the Rydberg constant (though the effect is small)\n # TODO make sure this matches olam0 parameter above -- why were there two variables in the first place?!\n # rydberg_m = Rydberg / (1. + (electron_mass / physical_constants['deuteron mass'][0]))\n # wl_0_angst = 1e10 * (rydberg_m * (1 / n_lower ** 2 - 1 / n_upper ** 2)) ** -1\n\n wl_centre_angst = self.wl_centre * 1e10\n\n c_angst = c * 1e10 # velocity of light in Ansgtroms / s\n angular_freq_0 = 2 * np.pi * c_angst / wl_centre_angst # rad / s\n\n otrans = -2 * np.pi * c_angst / wl_centre_angst ** 2\n\n olines = o1lines / np.abs(otrans)\n oline = o1line / np.abs(otrans)\n\n # Limit analysis_tools to uncorrelated plasmas.\n # check that mean interelectronic distance is smaller than the electronic Debye length (equ. 10)\n PR0_exp = 0.0898 * (dens_cm ** (1. / 6.)) / np.sqrt(temp_k) # = (r0 / debye)\n if PR0_exp > 1.:\n raise Exception('The plasma is too strongly correlated\\ni.e. r0/debye=0.1\\nthe line cannot be computed.')\n\n # fainom_exp=fainom*(F00_exp**1.5)\n # fainum_exp=fainom_exp/( (OPI*2.)**1.5)\n\n # ========================\n # TABULATION Format CDS\n # si on veut ecrire\n # n -np lambda0 kalpha Ne E0 T R0/Debye Dalpha iDoppler iStark\n\n # IN_cds= N+0.01\n # INP_cds = NP+0.01\n\n # ***********************************************************\n # Don't edit the CDS format...\n # ***********************************************************\n\n # Skipped the code in the IF statement starting at line 470, since it\n # isn't used, if (.FALSE.) ...\n\n # ==============================================\n # define an unique detunings grid - domm - for the tabulated\n # profiles ( various temperatures , densities)\n # calculate all the line shapes for this common grid\n # units used at this points are Domega_new= Delta(omega)/F00\n # in rd/(s-1 ues)\n\n max_num_dens = 30 # Maximum number of densities\n max_num_tab_temp = 10\n max_num_detunings = 60 # Maximum number of detunings\n jtot = jtot.astype(np.int)\n domm = np.zeros(100000)\n dom0 = np.zeros(10000)\n tprof = np.zeros([max_num_dens, max_num_tab_temp, 10000])\n tprofs = np.zeros([max_num_dens, max_num_tab_temp, 10000])\n uprof = np.zeros([max_num_dens, 10000])\n uprofs = np.zeros([max_num_dens, 10000])\n\n inc = 0\n domm[inc] = 0.0\n # ---- Look to replace this loop\n for id in np.arange(num_tab_dens + 1): # loop over tab densities\n for j in np.arange(max_num_tab_temp): # loop over tab temperatures (?)\n for i in np.arange(1, jtot[id, j]):\n inc += 1\n dom0[inc] = dom[id, j, i]\n\n inc = np.count_nonzero(dom)\n npik = inc + 1\n # nut=10000\n\n # Calling numpy sort instead of piksrt\n tmp = np.sort(dom0[0:npik])\n dom0[0:npik] = tmp[0:npik]\n # dom0 seems to agree with the FORTRAN version\n\n inc = 0\n domm[0] = 0.0\n # print 'npik',npik\n # ---- Look to replace this loop\n for i in np.arange(1, npik):\n dif = (dom0[i] - dom0[i - 1])\n if dif <= 1.0E-6:\n continue\n if dif / np.abs(dom0[i]) <= 0.1:\n continue\n inc = inc + 1\n domm[inc] = dom0[i]\n\n jdom = inc + 1 # One line after marker 35\n\n for id in np.arange(num_tab_dens):\n for j in np.arange(10):\n if pr0[id, j] > 1.0:\n continue\n\n tprof[id, j, 0] = oline[id, j, 0]\n tprofs[id, j, 0] = olines[id, j, 0]\n\n if jtot[id, j] == 0:\n continue\n\n for i in np.arange(1, jdom + 1):\n skip1 = False\n skip2 = False\n # print 'i',i\n domeg = domm[i]\n ij_max = jtot[id, j]\n # print 'domeg,ij_max',domeg,ij_max\n for ij in np.arange(1, ij_max - 1):\n # print 'ij',ij\n test = (domeg - dom[id, j, ij]) * (domeg - dom[id, j, ij - 1])\n # print 'test1:',test\n if test <= 0.0:\n # print 'triggered test1'\n x1 = dom[id, j, ij - 1]\n x2 = dom[id, j, ij]\n x3 = dom[id, j, ij + 1]\n y1 = oline[id, j, ij - 1]\n y2 = oline[id, j, ij]\n y3 = oline[id, j, ij + 1]\n # print 'x1,x2,x3',x1,x2,x3\n # print 'y1,y2,y3',y1,y2,y3\n tprof[id, j, i] = pystark.FINTRP(x1, x2, x3, y1, y2, y3, domeg)\n y1 = olines[id, j, ij - 1]\n y2 = olines[id, j, ij]\n y3 = olines[id, j, ij + 1]\n tprofs[id, j, i] = pystark.FINTRP(x1, x2, x3, y1, y2, y3, domeg)\n # print 'tprof[id,j,i]',tprof[id,j,i]\n # print 'tprofs[id,j,i]',tprofs[id,j,i]\n skip1 = True\n skip2 = True\n break\n\n if skip1 is False:\n test = (domeg - dom[id, j, ij_max - 2]) * (domeg - dom[id, j, ij_max - 1])\n # print 'test2:',test\n # print 'domeg',domeg\n # print 'dom[id,j,ij_max-1]',dom[id,j,ij_max-2]\n # print 'dom[id,j,ij_max]',dom[id,j,ij_max-1]\n if test <= 0.0:\n # print 'triggered test2'\n x1 = dom[id, j, ij_max - 3]\n x2 = dom[id, j, ij_max - 2]\n x3 = dom[id, j, ij_max - 1]\n y1 = oline[id, j, ij_max - 3]\n y2 = oline[id, j, ij_max - 2]\n y3 = oline[id, j, ij_max - 1]\n tprof[id, j, i] = pystark.FINTRP(x1, x2, x3, y1, y2, y3, domeg)\n y1 = olines[id, j, ij_max - 3]\n y2 = olines[id, j, ij_max - 2]\n y3 = olines[id, j, ij_max - 1]\n tprofs[id, j, i] = pystark.FINTRP(x1, x2, x3, y1, y2, y3, domeg)\n skip2 = True\n # print 'x1,x2,x3',x1,x2,x3\n # print 'y1,y2,y3',y1,y2,y3\n # print 'tprof[id,j,i]',tprof[id,j,i]\n # print 'tprofs[id,j,i]',tprofs[id,j,i]\n continue\n\n if skip2 is False:\n if domeg > dom[id, j, ij_max]:\n # print 'triggered test3'\n tprof[id, j, i] = fainom / (domeg ** 2.5)\n tprofs[id, j, i] = tprof[id, j, i]\n continue\n\n # We can skip writing the intermediate file\n\n\n for id in np.arange(num_tab_dens):\n otest_dens = (dens_cm - tab_dens_cm[id]) * (dens_cm - tab_dens_cm[id + 1])\n if otest_dens <= 0.0:\n dense1 = tab_dens_cm[id]\n dense2 = tab_dens_cm[id + 1]\n id1 = id\n id2 = id + 1\n break\n\n if dens_cm >= tab_dens_cm[num_tab_dens]:\n dense1 = tab_dens_cm[num_tab_dens - 1]\n dense2 = tab_dens_cm[num_tab_dens]\n id1 = num_tab_dens - 1\n id2 = num_tab_dens\n\n for it in np.arange(10):\n otest = (temp_k - tab_temp_k[it]) * (temp_k - tab_temp_k[it + 1])\n if otest <= 0.0:\n it1 = it\n it2 = it + 1\n # pr01 = pr0[id2,it1] # max value of pr0 for T1,T2,dense1,dense2\n tempe1 = tab_temp_k[it]\n tempe2 = tab_temp_k[it + 1]\n break\n\n # interpolation in temperature\n for id in np.arange(id1, id2 + 1):\n for i in np.arange(jdom):\n uprof[id, i] = tprof[id, it1, i] + (temp_k - tempe1) * (tprof[id, it2, i] - tprof[id, it1, i]) / (\n tempe2 - tempe1)\n uprofs[id, i] = tprofs[id, it1, i] + (temp_k - tempe1) * (tprofs[id, it2, i] - tprofs[id, it1, i]) / (\n tempe2 - tempe1)\n\n delta_lambda = np.zeros(jdom)\n delta_nu = np.zeros(jdom)\n wprof_nu = np.zeros(jdom)\n wprofs_nu = np.zeros(jdom)\n\n for i in np.arange(jdom):\n wprof = uprof[id1, i] + (dens_cm - dense1) * (uprof[id2, i] - uprof[id1, i]) / (dense2 - dense1)\n wprofs = uprofs[id1, i] + (dens_cm - dense1) * (uprofs[id2, i] - uprofs[id1, i]) / (dense2 - dense1)\n delta_omega = domm[i] * normal_holtsmark_field\n delta_nu[i] = delta_omega / (2 * np.pi)\n delta_lambda[i] = wl_centre_angst * delta_omega / (angular_freq_0 + delta_omega)\n # print(delta_lambda[i])\n wprof_nu[i] = (wprof / normal_holtsmark_field) * (2. * np.pi)\n wprofs_nu[i] = (wprofs / normal_holtsmark_field) * (2. * np.pi)\n # print '%e %e %e %e' %(delta_lambda[i],delta_nu[i],wprof_nu[i],wprofs_nu[i])\n\n delta_lambda2 = np.concatenate((-delta_lambda[::-1], delta_lambda)) + wl_centre_angst # + olam0\n delta_nu2 = np.concatenate((-delta_nu[::-1], delta_nu))\n wprof_nu2 = np.concatenate((wprof_nu[::-1], wprof_nu))\n wprofs_nu2 = np.concatenate((wprofs_nu[::-1], wprofs_nu))\n\n # for some reason, i only get a good agreement with the other models if i take the pure Stark broadened Stehle\n # output and manually convolve it with the Doppler profile -- not sure why...\n ls_sd = wprofs_nu2\n\n # interpolate onto frequency axis\n ls_sd = np.interp(self.freq_axis, delta_nu2 + self.freq_centre, ls_sd)\n\n return ls_sd","def _add_labels(self):\n coords = self['pore.coords']\n self['pore.front'] = coords[:,0]<(0.1*self._Lx)\n self['pore.back'] = coords[:,0]>(0.9*self._Lx)\n self['pore.left'] = coords[:,1]<(0.1*self._Ly)\n self['pore.right'] = coords[:,1]>(0.9*self._Ly)\n self['pore.bottom'] = coords[:,2]<(0.1*self._Lz)\n self['pore.top'] = coords[:,2]>(0.9*self._Lz)\n bnds = self.pores(labels=['front','back','left','right','bottom','top'])\n self['pore.boundary'] = False\n self['pore.boundary'] = bnds","def __call__(self, src, label):\n\n h, w, _ = src.shape\n # interp = np.random.randint(0, 5)\n img = timage.resize_short_within(src, self._short, self._max_size, interp=1)\n img, flips = timage.random_flip(img, px=0.5)\n img = img.astype(np.float32)\n target_list_1 = []\n target_list_2 = []\n\n for k in range(self.teacher_num):\n if self.teacher_aug:\n target_image_1 = self.random_color_aug(img)\n else:\n target_image_1 = img\n\n target_image_2 = self.random_color_aug(img)\n\n target_image_1 = mx.nd.image.to_tensor(target_image_1)\n target_image_1 = mx.nd.image.normalize(target_image_1, mean=self._mean, std=self._std)\n\n target_image_2 = mx.nd.image.to_tensor(target_image_2)\n target_image_2 = mx.nd.image.normalize(target_image_2, mean=self._mean, std=self._std)\n target_list_1.append(target_image_1)\n target_list_2.append(target_image_2)\n target_list_1 = mx.nd.concat(*target_list_1, dim=0)\n target_list_2 = mx.nd.concat(*target_list_2, dim=0)\n return target_list_1, target_list_2","def _build_ham(self):\n path = self._solverpath.long_tail()\n print(path)\n current, k = self.snake.head(), 0\n for direc in path:\n self.information[current.x][current.y].idx = k\n self.information[current.x][current.y].direc = direc\n current = current.adj(direc)\n k += 1\n # Process snake bodies\n current = self.snake.tail()\n for _ in range(self.snake.len() - 1):\n self.information[current.x][current.y].idx = k\n self.information[current.x][current.y].direc = self.snake.direc\n current = current.adj(self.snake.direc)\n k += 1","def tagview(tab,label,x,y):\r\n font = cv2.FONT_HERSHEY_SIMPLEX\r\n col=classifc[label]\r\n labnow=classif[label]\r\n# print (labnow, text)\r\n if label == 'back_ground':\r\n deltay=30\r\n else:\r\n# deltay=25*((labnow-1)%5)\r\n deltay=40+10*(labnow-1)\r\n\r\n viseg=cv2.putText(tab,label,(x, y+deltay), font,0.3,col,1)\r\n return viseg","def split(self, eccMap, patchName='patch00', cutStep=1, borderWidth=2, isplot=False):\r\n minMarker = localMin(eccMap, cutStep)\r\n\r\n plt.figure()\r\n plt.imshow(minMarker, vmin=0, interpolation='nearest')\r\n plt.colorbar()\r\n plt.title('markers 1')\r\n plt.show()\r\n\r\n minMarker = minMarker.astype(np.int32)\r\n selfArray = self.array.astype(np.int32)\r\n minMarker = minMarker + 1\r\n minMarker[minMarker == 1] = 0\r\n minMarker = minMarker + (-1 * (selfArray - 1))\r\n # minMarker: marker type for opencv watershed,\r\n # sure background = 1\r\n # unknow = 0\r\n # sure forgrand = 2,3,4... etc\r\n\r\n plt.figure()\r\n plt.imshow(minMarker, vmin=0, interpolation='nearest')\r\n plt.colorbar()\r\n plt.title('markers 2')\r\n plt.show()\r\n\r\n eccMapNor = (np.round(ia.array_nor(eccMap) * 255)).astype(np.uint8)\r\n eccMapRGB = cv2.cvtColor(eccMapNor, cv2.COLOR_GRAY2RGB)\r\n # eccMapRGB: image type for opencv watershed, RGB, [uint8, uint8, uint8]\r\n\r\n newLabel = cv2.watershed(eccMapRGB, minMarker)\r\n\r\n plt.figure()\r\n plt.imshow(newLabel, vmin=0, interpolation='nearest')\r\n plt.colorbar()\r\n plt.title('markers 3')\r\n plt.show()\r\n\r\n newBorder = np.zeros(newLabel.shape).astype(np.int)\r\n\r\n newBorder[newLabel == -1] = 1\r\n\r\n border = ni.binary_dilation(self.array).astype(np.int) - self.array\r\n\r\n border = newBorder + border\r\n\r\n border[border > 1] = 1\r\n\r\n border = sm.skeletonize(border)\r\n\r\n if borderWidth > 1:\r\n border = ni.binary_dilation(border, iterations=borderWidth - 1).astype(np.int8)\r\n\r\n newPatchMap = ni.binary_dilation(self.array).astype(np.int8) * (-1 * (border - 1))\r\n\r\n labeledNewPatchMap, patchNum = ni.label(newPatchMap)\r\n\r\n # if patchNum != np.amax(newLabel):\r\n # print 'number of patches: ', patchNum, '; number of local minimum:', np.amax(newLabel)\r\n # raise ValueError, \"Number of patches after splitting does not equal to number of local minimum!\"\r\n\r\n newPatchDict = {}\r\n\r\n for j in range(1, patchNum + 1):\r\n\r\n currPatchName = patchName + '.' + str(j)\r\n currArray = np.zeros(self.array.shape, dtype=np.int8)\r\n currArray[labeledNewPatchMap == j] = 1\r\n currArray = currArray * self.array\r\n\r\n if np.sum(currArray[:]) > 0:\r\n newPatchDict.update({currPatchName: Patch(currArray, self.sign)})\r\n\r\n if isplot:\r\n plt.figure()\r\n plt.subplot(121)\r\n plt.imshow(self.array, interpolation='nearest')\r\n plt.title(patchName + ': before split')\r\n plt.subplot(122)\r\n plt.imshow(labeledNewPatchMap, interpolation='nearest')\r\n plt.title(patchName + ': after split')\r\n\r\n return newPatchDict","def do_htt_plots(tree, output_dir, cut=''):\n for logz in [True, False]:\n make_2d_plot(tree, 'httRef', HTT_REF_STR, NB_HTT, HTT_MIN, HTT_MAX, 'httL1', HTT_L1_STR, NB_HTT, HTT_MIN, HTT_MAX,\n os.path.join(output_dir, 'httRef_httL1.pdf'), logz=logz, normx=False,\n cut=cut, title=TITLE, diagonal_line=True)\n for normx in [True, False]:\n make_2d_plot(tree, 'httL1', HTT_L1_STR, NB_HTT, HTT_MIN, HTT_MAX, 'httL1/httRef', HTT_RATIO_STR, NB_HTT_RATIO, HTT_RATIO_MIN, HTT_RATIO_MAX,\n os.path.join(output_dir, 'httRatio_httL1.pdf'), logz=logz, normx=normx,\n cut=cut, title=TITLE, horizontal_line=True)\n make_2d_plot(tree, 'httRef', HTT_REF_STR, NB_HTT, HTT_MIN, HTT_MAX, 'httL1/httRef', HTT_RATIO_STR, NB_HTT_RATIO, HTT_RATIO_MIN, HTT_RATIO_MAX,\n os.path.join(output_dir, 'httRatio_httRef.pdf'), logz=logz, normx=normx,\n cut=cut, title=TITLE, horizontal_line=True)\n\n make_2d_plot(tree, 'httL1', HTT_L1_STR, NB_HTT, HTT_MIN, HTT_MAX, 'httL1-httRef', HTT_DIFF_STR, NB_HTT_DIFF, HTT_DIFF_MIN, HTT_DIFF_MAX,\n os.path.join(output_dir, 'httDiff_httL1.pdf'), logz=logz, normx=normx,\n cut=cut, title=TITLE, horizontal_line=True)\n make_2d_plot(tree, 'httRef', HTT_REF_STR, NB_HTT, HTT_MIN, HTT_MAX, 'httL1-httRef', HTT_DIFF_STR, NB_HTT_DIFF, HTT_DIFF_MIN, HTT_DIFF_MAX,\n os.path.join(output_dir, 'httDiff_httRef.pdf'), logz=logz, normx=normx,\n cut=cut, title=TITLE, horizontal_line=True)\n make_2d_plot(tree, 'httL1/httRef', HTT_RATIO_STR, NB_HTT_RATIO, HTT_RATIO_MIN, HTT_RATIO_MAX,\n 'httL1-httRef', HTT_DIFF_STR, NB_HTT_DIFF, HTT_DIFF_MIN, HTT_DIFF_MAX,\n os.path.join(output_dir, 'httDiff_httRatio.pdf'), logz=logz, normx=normx,\n cut=cut, title=TITLE, horizontal_line=True)","def __init__(self, trg_vocab_size, label_smoothing=0.1, reduction='mean', with_logits=True, ignore_index=0):\n super(LabelSmoothingLoss, self).__init__()\n self.with_logits = with_logits\n self.ignore_index = ignore_index\n self.kl_divergence = nn.KLDivLoss(reduction=reduction)\n\n self._create_one_hot(label_smoothing, trg_vocab_size)\n self.confidence = 1.0 - label_smoothing","def nodules_connection(label_data, label_header):\n\n\n las_labels = measure.label(label_data,\n neighbors=8,\n background=0,\n return_num=True)\n\n las_labels_nzero = np.nonzero(las_labels[0])\n [xdif, ydif, zdif] = [np.amax(las_labels_nzero[0])-np.amin(las_labels_nzero[0]),\n np.amax(las_labels_nzero[1])-np.amin(las_labels_nzero[1]),\n np.amax(las_labels_nzero[2])-np.amin(las_labels_nzero[2])]\n\n # conversion pixels to mm\n dims = label_header['pixdim']\n if label_header['xyzt_units'] == 10:\n #dimensions in mm\n print('xyzt_units=10')\n xdif=dims[1]*xdif\n ydif=dims[2]*ydif\n zdif=dims[3]*zdif\n\n\n return las_labels,[xdif,ydif,zdif]","def at_s2ncut(self):\n\n\t # Notch out the transit and recompute\n\t fmcut = self.fm.copy()\n\t fmcut.fill_value=0\n\t # Widen by twice the transit duration\n\t tmask = self.rLbl['tRegLbl'] >= 0\n\t tmask = np.convolve(\n\t tmask.astype(float),\n\t np.ones(self.header['tdurcad'] * 2),\n\t mode='same'\n\t )\n\t tmask = tmask.astype(bool)\n\t fmcut.mask = fmcut.mask | tmask\n\t grid = tfind.Grid(self.t,fmcut)\n\n\n\t pgram_params = [\n\t dict(Pcad1=self.Pcad - 1, Pcad2=self.Pcad + 1, twdG = [self.header['tdurcad']])\n\t ]\n\t pgram = grid.periodogram(pgram_params,mode='max')\n\t idxmax = pgram.s2n.idxmax()\n\n\t dkeys = 's2ncut s2ncut_t0 s2ncut_mean'.split()\n\t pkeys = 's2n t0 mean'.split()\n\n\t for dkey,pkey in zip(dkeys,pkeys):\n\t self.add_attr(dkey,pgram.ix[idxmax,pkey])","def at_s2ncut(self):\n\n\t # Notch out the transit and recompute\n\t fmcut = self.fm.copy()\n\t fmcut.fill_value=0\n\t # Widen by twice the transit duration\n\t tmask = self.rLbl['tRegLbl'] >= 0\n\t tmask = np.convolve(\n\t tmask.astype(float),\n\t np.ones(self.header['tdurcad'] * 2),\n\t mode='same'\n\t )\n\t tmask = tmask.astype(bool)\n\t fmcut.mask = fmcut.mask | tmask\n\t grid = tfind.Grid(self.t,fmcut)\n\n\n\t pgram_params = [\n\t dict(Pcad1=self.Pcad - 1, Pcad2=self.Pcad + 1, twdG = [self.header['tdurcad']])\n\t ]\n\t pgram = grid.periodogram(pgram_params,mode='max')\n\t idxmax = pgram.s2n.idxmax()\n\n\t dkeys = 's2ncut s2ncut_t0 s2ncut_mean'.split()\n\t pkeys = 's2n t0 mean'.split()\n\n\t for dkey,pkey in zip(dkeys,pkeys):\n\t self.add_attr(dkey,pgram.ix[idxmax,pkey])","def housing_labels_(strat_train_set):\n logging.info(\"copy of dataset\")\n housing_labels = strat_train_set[\"median_house_value\"].copy()\n return housing_labels","def addLabels(t):\n if not t.label:\n t.label = \"\".join([choice(\"abcdefghijklmnopqrstuvwxyz\") for i in range(4)])\n for r,w in t.children:\n addLabels(r)","def draw_heading(self, heading): \n\n heading_label = ttk.Label(self.frame, text=heading, background=\"blue\",\n foreground=\"white\", anchor=CENTER)\n \n heading_label.configure(font=('Times', 15, \"bold\"))\n heading_label.configure(wraplength=self.width) \n heading_label.pack(side=TOP, fill=X, ipady=10)","def h_t(self, x, t):\n ret = 0\n strong_classifier = self.classifiers[0:t+1]\n for wc in strong_classifier:\n ret += wc.classify(x)\n return ret","def h_t(self, x, t):\n ret = 0\n strong_classifier = self.classifiers[0:t+1]\n for wc in strong_classifier:\n ret += wc.classify(x)\n return ret","def encodeToLabels(self, gt_instances):\n raw_boxes_xyzwhd = np.zeros((self.config_data[\"max_boxes_per_frame\"], 7))\n ### initialize gronud truth labels as np.zeors ###\n gt_labels = np.zeros(list(self.headoutput_shape[1:4]) + \\\n [len(self.anchor_boxes)] + \\\n [len(self.config_data[\"all_classes\"]) + 7])\n\n ### start transferring box to ground turth label format ###\n for i in range(len(gt_instances[\"classes\"])):\n if i > self.config_data[\"max_boxes_per_frame\"]:\n continue\n class_name = gt_instances[\"classes\"][i]\n box_xyzwhd = gt_instances[\"boxes\"][i]\n class_id = self.config_data[\"all_classes\"].index(class_name)\n if i < self.config_data[\"max_boxes_per_frame\"]:\n raw_boxes_xyzwhd[i, :6] = box_xyzwhd\n raw_boxes_xyzwhd[i, 6] = class_id\n class_onehot = helper.smoothOnehot(class_id, len(self.config_data[\"all_classes\"]))\n \n exist_positive = False\n\n grid_strid = self.grid_strides\n anchor_stage = self.anchor_boxes\n box_xyzwhd_scaled = box_xyzwhd[np.newaxis, :].astype(np.float32)\n box_xyzwhd_scaled[:, :3] /= grid_strid\n anchorstage_xyzwhd = np.zeros([len(anchor_stage), 6])\n anchorstage_xyzwhd[:, :3] = np.floor(box_xyzwhd_scaled[:, :3]) + 0.5\n anchorstage_xyzwhd[:, 3:] = anchor_stage.astype(np.float32)\n\n iou_scaled = helper.iou3d(box_xyzwhd_scaled, anchorstage_xyzwhd, \\\n self.input_size)\n ### NOTE: 0.3 is from YOLOv4, maybe this should be different here ###\n ### it means, as long as iou is over 0.3 with an anchor, the anchor\n ### should be taken into consideration as a ground truth label\n iou_mask = iou_scaled > 0.3\n\n if np.any(iou_mask):\n xind, yind, zind = np.floor(np.squeeze(box_xyzwhd_scaled)[:3]).\\\n astype(np.int32)\n ### TODO: consider changing the box to raw yolohead output format ###\n gt_labels[xind, yind, zind, iou_mask, 0:6] = box_xyzwhd\n gt_labels[xind, yind, zind, iou_mask, 6:7] = 1.\n gt_labels[xind, yind, zind, iou_mask, 7:] = class_onehot\n exist_positive = True\n\n if not exist_positive:\n ### NOTE: this is the normal one ###\n ### it means take the anchor box with maximum iou to the raw\n ### box as the ground truth label\n anchor_ind = np.argmax(iou_scaled)\n xind, yind, zind = np.floor(np.squeeze(box_xyzwhd_scaled)[:3]).\\\n astype(np.int32)\n gt_labels[xind, yind, zind, anchor_ind, 0:6] = box_xyzwhd\n gt_labels[xind, yind, zind, anchor_ind, 6:7] = 1.\n gt_labels[xind, yind, zind, anchor_ind, 7:] = class_onehot\n\n has_label = False\n for label_stage in gt_labels:\n if label_stage.max() != 0:\n has_label = True\n gt_labels = [np.where(gt_i == 0, 1e-16, gt_i) for gt_i in gt_labels]\n return gt_labels, has_label, raw_boxes_xyzwhd","def __init__(self, iht_size=4096, num_tilings=8, num_tiles=8):\n self.iht = tc.IHT(iht_size)\n self.num_tilings = num_tilings\n self.num_tiles = num_tiles","def horde_step(self, observation):","def _make_vbenf_label(chain_parts):\n\n # toy label for development: run simple and dijet independently.\n # simple makes Et cuts on two jets. Independently (sharing possible)\n # of jets choosean by simple, the dijet\n # scenario requires a dijet of mass > 900, and opening angle in phi > 2.6\n\n assert len(chain_parts) == 1\n scenario = chain_parts[0]['hypoScenario']\n assert scenario.startswith('vbenf')\n args = _args_from_scenario(scenario)\n if not args:\n return 'and([]simple([(50et)(70et)])combgen([(2)] dijet([(900djmass, 26djdphi)])))' \n arg_res = [\n re.compile(r'(?P<lo>\\d*)(?P<key>fbet)(?P<hi>\\d*)'),\n re.compile(r'(?P<lo>\\d*)(?P<key>mass)(?P<hi>\\d*)'),\n re.compile(r'(?P<lo>\\d*)(?P<key>et)(?P<hi>\\d*)'),\n ]\n\n defaults = {\n 'et': ('101', 'inf'),\n 'mass': ('800', 'inf'),\n 'fbet': ('501', 'inf'),\n }\n\n argvals = {}\n while args:\n assert len(args) == len(arg_res)\n arg = args.pop()\n for r in arg_res:\n m = r.match(arg)\n if m is not None:\n arg_res.remove(r)\n gd = m.groupdict()\n key = gd['key']\n try:\n lo = float(gd['lo'])\n except ValueError:\n lo = defaults[key][0]\n argvals[key+'lo'] = lo \n try:\n hi = float(gd['hi'])\n except ValueError:\n hi = defaults[key][1]\n argvals[key+'hi'] = hi\n\n assert len(args) == len(arg_res)\n assert len(args) == 0\n\n return \"\"\"\n and\n (\n []\n simple\n (\n [(%(etlo).0fet, 500neta)(%(etlo).0fet, peta500)]\n )\n combgen\n (\n [(10et, 0eta320)]\n dijet\n (\n [(%(masslo).0fdjmass, 26djdphi)]\n ) \n simple\n (\n [(10et, 0eta320)(20et, 0eta320)]\n )\n )\n )\"\"\" % argvals","def removeLabel(edge):\n return edge[:-2]","def removeLabel(edge):\n return edge[:-2]","def cutPaper(self, cut='partial', feed=True):\n if cut not in ['partial', 'full']:\n raise ValueError('cut must be \\'partial\\' or \\'full\\'')\n elif type(feed) is not bool:\n raise ValueError('feed must be True or False')\n else:\n value = 0 if cut == 'full' else 1\n value += 65 if feed else 0\n self._write(self.__class__.__GS + 'V' + chr(value))","def resize_label(label):\n # If current ratio greater than given ratio\n if label[HEIGHT_INDEX] / label[WIDTH_INDEX] > 1.5:\n previous = label[WIDTH_INDEX]\n label[WIDTH_INDEX] = label[HEIGHT_INDEX] / 1.5\n label[J_INDEX] -= (label[WIDTH_INDEX] - previous) / 2\n # If current ratio smaller than given ratio\n else:\n previous = label[HEIGHT_INDEX]\n label[HEIGHT_INDEX] = label[WIDTH_INDEX] * 1.5\n label[I_INDEX] -= (label[HEIGHT_INDEX] - previous) / 2\n return label","def label(gt_dataset, volume_dim, voxel_dim, labeling_params):\n labeled_volumes = dict()\n labeled_cells = dict()\n #Use global density and reduce the size of gt_dataset here\n global_density = labeling_params[\"global_density\"]\n gt_dataset = {k: v for k,v in gt_dataset.items() if random_sample() < global_density}\n #Label in the order specified in the configuration\n layers = sorted(labeling_params.keys())\n #Remove global_density\n layers.remove(\"global_density\")\n for layer in layers:\n print \"Labeling {}\".format(layer)\n fluorophore = labeling_params[layer]['fluorophore']\n volume, cells = brainbow(gt_dataset, volume_dim, voxel_dim, **labeling_params[layer])\n if fluorophore in labeled_volumes:\n labeled_volumes[fluorophore] += volume\n labeled_cells[fluorophore] |= cells\n else:\n labeled_volumes[fluorophore] = volume\n labeled_cells[fluorophore] = cells\n return labeled_volumes, labeled_cells","def analyze(self, event):\n jets = Collection(event, \"Jet\")\n\n BTagWeightN = 1.0\n BTagWeightN_up = 1.0\n BTagWeightN_down = 1.0\n BTagWeightN_FS = 1.0\n BTagWeightN_up_FS = 1.0\n BTagWeightN_down_FS = 1.0\n BTagWeightD = 1.0\n BTagWeightNHeavy = 1.0\n BTagWeightNHeavy_up = 1.0\n BTagWeightNHeavy_down = 1.0\n BTagWeightNHeavy_FS = 1.0\n BTagWeightNHeavy_up_FS = 1.0\n BTagWeightNHeavy_down_FS = 1.0\n BTagWeightDHeavy = 1.0\n BTagWeightNLight = 1.0\n BTagWeightNLight_FS = 1.0\n BTagWeightNLight_up = 1.0\n BTagWeightNLight_up_FS= 1.0\n BTagWeightNLight_down = 1.0\n BTagWeightNLight_down_FS = 1.0\n BTagWeightDLight = 1.0\n\n for jet in jets:\n pt = jet.pt\n eta = abs(jet.eta)\n flavor = jet.hadronFlavour\n\n if not ( pt > self.jetPtMin and eta < self.jetEtaMax): continue\n\n if flavor == 5:\n pt_bin = self.h_eff_b.GetXaxis().FindBin(pt); \n if pt_bin > self.h_eff_b.GetXaxis().GetNbins():\n pt_bin = self.h_eff_b.GetXaxis().GetNbins(); \n eta_bin = self.h_eff_b.GetYaxis().FindBin(eta); \n if eta_bin > self.h_eff_b.GetYaxis().GetNbins():\n eta_bin = self.h_eff_b.GetYaxis().GetNbins();\n\n eff = self.h_eff_b.GetBinContent(pt_bin, eta_bin);\n\n elif flavor == 4:\n pt_bin = self.h_eff_c.GetXaxis().FindBin(pt); \n if pt_bin > self.h_eff_c.GetXaxis().GetNbins():\n pt_bin = self.h_eff_c.GetXaxis().GetNbins(); \n eta_bin = self.h_eff_c.GetYaxis().FindBin(eta); \n if eta_bin > self.h_eff_c.GetYaxis().GetNbins():\n eta_bin = self.h_eff_c.GetYaxis().GetNbins();\n\n eff = self.h_eff_c.GetBinContent(pt_bin, eta_bin);\n\n else:\n pt_bin = self.h_eff_udsg.GetXaxis().FindBin(pt); \n if pt_bin > self.h_eff_udsg.GetXaxis().GetNbins():\n pt_bin = self.h_eff_udsg.GetXaxis().GetNbins(); \n eta_bin = self.h_eff_udsg.GetYaxis().FindBin(eta); \n if eta_bin > self.h_eff_udsg.GetYaxis().GetNbins():\n eta_bin = self.h_eff_udsg.GetYaxis().GetNbins();\n\n eff = self.h_eff_udsg.GetBinContent(pt_bin, eta_bin);\n \n if self.FastSim:\n btagSF = jet.btagSF\n btagSF_FS=jet.btagSF_FS\n btagSF_up_FS = jet.btagSF_FS_up\n btagSF_down_FS = jet.btagSF_FS_down\n btagSF_down = jet.btagSF_down\n btagSF_up = jet.btagSF_up\n else:\n btagSF = jet.btagSF\n btagSF_FS= 1.0\n btagSF_up = jet.btagSF_up\n btagSF_down = jet.btagSF_down\n btagSF_up_FS = 1.0\n btagSF_down_FS = 1.0\n \n if jet.btagDeepB > self.bDiscCut:\n #check if eff is zero\n if eff < 0.001:\n eff = 0.001\n \n BTagWeightN *= btagSF * eff\n BTagWeightN_FS *= btagSF_FS * eff\n BTagWeightN_up *= btagSF_up * eff\n BTagWeightN_down *= btagSF_down * eff\n BTagWeightN_up_FS *= btagSF_up_FS * eff\n BTagWeightN_down_FS *= btagSF_down_FS * eff\n\n if abs(flavor) == 5:\n BTagWeightNHeavy *= btagSF * eff\n BTagWeightNHeavy_FS *= btagSF_FS * eff\n BTagWeightNHeavy_up *= btagSF_up * eff\n BTagWeightNHeavy_down *= btagSF_down * eff\n BTagWeightNHeavy_up_FS *= btagSF_up_FS * eff\n BTagWeightNHeavy_down_FS *= btagSF_down_FS * eff\n BTagWeightDHeavy *= eff\n else:\n BTagWeightNLight *= btagSF * eff\n BTagWeightNLight_FS *= btagSF_FS * eff\n BTagWeightNLight_up *= btagSF_up * eff\n BTagWeightNLight_down *= btagSF_down * eff\n BTagWeightNLight_up_FS *= btagSF_up_FS * eff\n BTagWeightNLight_down_FS *= btagSF_down_FS * eff\n BTagWeightDLight *= eff\n\n BTagWeightD *= eff\n else:\n #check if eff is 1.0\n if eff > 0.999:\n eff = 0.999\n\n BTagWeightN *= 1 - btagSF * eff\n BTagWeightN_FS *= 1 - btagSF_FS * eff\n BTagWeightN_up *= 1 - btagSF_up * eff\n BTagWeightN_down *= 1 - btagSF_down * eff\n BTagWeightN_up_FS *= 1 - btagSF_up_FS * eff\n BTagWeightN_down_FS *= 1 - btagSF_down_FS * eff\n\n if abs(flavor) == 5:\n BTagWeightNHeavy *= 1 - btagSF * eff\n BTagWeightNHeavy_FS *= 1 - btagSF_FS * eff\n BTagWeightNHeavy_up *= 1 - btagSF_up * eff\n BTagWeightNHeavy_down *= 1 - btagSF_down * eff\n BTagWeightNHeavy_up_FS *= 1 - btagSF_up_FS * eff\n BTagWeightNHeavy_down_FS *= 1 - btagSF_down_FS * eff\n BTagWeightDHeavy *= 1 - eff\n else:\n BTagWeightNLight *= 1 - btagSF * eff\n BTagWeightNLight_FS *= 1 - btagSF_FS * eff\n BTagWeightNLight_up *= 1 - btagSF_up * eff\n BTagWeightNLight_up_FS *= 1 - btagSF_up_FS * eff\n BTagWeightNLight_down *= 1 - btagSF_down * eff\n BTagWeightNLight_down_FS *= 1 - btagSF_down_FS * eff\n BTagWeightDLight *= 1 - eff\n\n BTagWeightD *= 1 - eff\n \n if self.FastSim:\n self.out.fillBranch(\"BTagWeight_FS\", BTagWeightN_FS / BTagWeightD)\n self.out.fillBranch(\"BTagWeight_Up_FS\", BTagWeightN_up_FS / BTagWeightD)\n self.out.fillBranch(\"BTagWeight_Down_FS\", BTagWeightN_down_FS / BTagWeightD)\n self.out.fillBranch(\"BTagWeightHeavy_FS\", BTagWeightNHeavy_FS / BTagWeightDHeavy)\n self.out.fillBranch(\"BTagWeightHeavy_Up_FS\", BTagWeightNHeavy_up_FS / BTagWeightDHeavy)\n self.out.fillBranch(\"BTagWeightHeavy_Down_FS\", BTagWeightNHeavy_down_FS / BTagWeightDHeavy)\n self.out.fillBranch(\"BTagWeightLight_FS\", BTagWeightNLight_FS / BTagWeightDLight)\n self.out.fillBranch(\"BTagWeightLight_Up_FS\", BTagWeightNLight_up_FS / BTagWeightDLight)\n self.out.fillBranch(\"BTagWeightLight_Down_FS\", BTagWeightNLight_down_FS / BTagWeightDLight)\n self.out.fillBranch(\"BTagWeight\", BTagWeightN / BTagWeightD)\n self.out.fillBranch(\"BTagWeight_Up\", BTagWeightN_up / BTagWeightD)\n self.out.fillBranch(\"BTagWeight_Down\", BTagWeightN_down / BTagWeightD)\n self.out.fillBranch(\"BTagWeightHeavy\", BTagWeightNHeavy / BTagWeightDHeavy)\n self.out.fillBranch(\"BTagWeightHeavy_Up\", BTagWeightNHeavy_up / BTagWeightDHeavy)\n self.out.fillBranch(\"BTagWeightHeavy_Down\", BTagWeightNHeavy_down / BTagWeightDHeavy)\n self.out.fillBranch(\"BTagWeightLight\", BTagWeightNLight / BTagWeightDLight)\n self.out.fillBranch(\"BTagWeightLight_Up\", BTagWeightNLight_up / BTagWeightDLight)\n self.out.fillBranch(\"BTagWeightLight_Down\", BTagWeightNLight_down / BTagWeightDLight)\n return True","def torsion_helix_strain(x, dof):\n base = np.zeros([6, dof])\n base[0, 0] = 1 # torsion\n base[1, 1] = 1 # y-bending\n base[2, 2] = 1 # z-bending\n return base","def make_cutout_table(ra_in, dec_in, other=None, othername=None, table=(2,7), compare=False, scale_unit='pixscale', scale=0.25, layer='decals-dr7', layer2=None, savefile=None): \n de_img = []\n wi_img = []\n N = table[0]*table[1]\n \n for i in range(N):\n de_cutout_url = 'http://legacysurvey.org/viewer-dev/jpeg-cutout/?ra=%g&dec=%g&%s=%g&layer=%s&size=180' % (ra_in[i],dec_in[i], scale_unit, scale, layer)\n img = plt.imread(download_file(de_cutout_url,cache=True,show_progress=False,timeout=120))\n de_img.append(img)\n \n if compare:\n wi_cutout_url = 'http://legacysurvey.org/viewer-dev/jpeg-cutout/?ra=%g&dec=%g&%s=%g&layer=%s&size=180' % (ra_in[i],dec_in[i], scale_unit, scale, layer2)\n img = plt.imread(download_file(wi_cutout_url,cache=True,show_progress=False,timeout=120))\n wi_img.append(img)\n \n fig = plt.figure(figsize=(4*table[1],4*table[0]))\n\n for i in range(len(de_img)):\n ax = fig.add_subplot(table[0],table[1],i+1)\n ax.imshow(de_img[i])\n ax.xaxis.set_major_formatter(NullFormatter())\n ax.yaxis.set_major_formatter(NullFormatter())\n if other[i] != None:\n ax.text(0.1,0.9,'%s=%.1f'%(othername,other[i]),transform=ax.transAxes,fontsize=14,color='white')\n\n plt.subplots_adjust(wspace=0.07, hspace=0.07)\n \n if compare:\n fig = plt.figure(figsize=(4*table[1],4*table[0]))\n for i in range(len(wi_img)):\n ax = fig.add_subplot(table[0],table[1],i+1)\n ax.imshow(wi_img[i])\n ax.xaxis.set_major_formatter(NullFormatter())\n ax.yaxis.set_major_formatter(NullFormatter())\n ax.text(0.1,0.9,'r=%.1f'%(mag[i]),transform=ax.transAxes,fontsize=14,color='white')\n\n plt.subplots_adjust(wspace=0.07, hspace=0.07)\n \n if savefile != None:\n fig.savefig(savefile +'.png')\n fig.savefig(savefile +'.pdf')","def assignLabels(self):\n clusters = np.arange(0, len(self.V))[self.V < self.V1] #indexes self.V, volumes_sorted, and oldOrder\n self.clusterV = self.volumes_sorted[clusters]\n clusters = self.oldOrder[clusters] #indexes volumes\n self.clusters = self.nonBI[clusters] #indexes self.vor and self.data\n self.easyLabel = np.zeros(len(self.data))\n self.easyLabel[self.clusters] = 1\n print('Out of ' + str(len(self.data)) + ' particles, ' + str(len(self.clusters)) + ' (' + str(round(len(self.clusters)*100/len(self.data), 3)) +' %) are labelled as cluster particles.')","def __init__(self, smoothing=0.1):\n super(LabelSmoothingCrossEntropy, self).__init__()\n assert smoothing < 1.0\n self.smoothing = smoothing\n self.confidence = 1. - smoothing","def __init__(self):\r\n self.label = \"Longest Flow Path\"\r\n self.description = \"this is my Longest Flow Path python tool\"","def adjust_labels(data_y, label):\n\n if label == 'locomotion': # Labels for locomotion are adjusted\n data_y[data_y == 4] = 3\n data_y[data_y == 5] = 4\n elif label == 'gestures': # Labels for gestures are adjusted\n data_y[data_y == 406516] = 1\n data_y[data_y == 406517] = 2\n data_y[data_y == 404516] = 3\n data_y[data_y == 404517] = 4\n data_y[data_y == 406520] = 5\n data_y[data_y == 404520] = 6\n data_y[data_y == 406505] = 7\n data_y[data_y == 404505] = 8\n data_y[data_y == 406519] = 9\n data_y[data_y == 404519] = 10\n data_y[data_y == 406511] = 11\n data_y[data_y == 404511] = 12\n data_y[data_y == 406508] = 13\n data_y[data_y == 404508] = 14\n data_y[data_y == 408512] = 15\n data_y[data_y == 407521] = 16\n data_y[data_y == 405506] = 17\n return data_y","def cut_bkg(self):\n c = TCut(self.cut_both)\n c += TCut(self._return_if('_cut_bkg'))\n return c","def __init__(self):\n Algorithm.__init__(self)\n self.name = \"Otsus Threshold\"\n self.parent = \"Segmentation\"","def old_ideal_label(I):\n a, c, d = ideal_HNF(I)\n return \"%s.%s.%s\" % (a * d, c, d)","def calc_Hcp_ij(self):\n\t\n\thp0_delayed = self.hp_wavelet.get_Psi(self.xi[0] + self.Orbit.L/l.Clight)\n\thp0 = self.hp_wavelet.get_Psi(self.xi[0])\n\thc0_delayed = self.hc_wavelet.get_Psi(self.xi[0] + self.Orbit.L/l.Clight)\n\thc0 = self.hc_wavelet.get_Psi(self.xi[0])\n\t\n\thp1_delayed = self.hp_wavelet.get_Psi(self.xi[1] + self.Orbit.L/l.Clight)\n\thp1 = self.hp_wavelet.get_Psi(self.xi[1])\n\thc1_delayed = self.hc_wavelet.get_Psi(self.xi[1] + self.Orbit.L/l.Clight)\n\thc1 = self.hc_wavelet.get_Psi(self.xi[1])\n\t\n\thp2_delayed = self.hp_wavelet.get_Psi(self.xi[2] + self.Orbit.L/l.Clight)\n\thp2 = self.hp_wavelet.get_Psi(self.xi[2])\n\thc2_delayed = self.hc_wavelet.get_Psi(self.xi[2] + self.Orbit.L/l.Clight)\n\thc2 = self.hc_wavelet.get_Psi(self.xi[2])\n\t\n\tself.Hpij[0,1] = hp1_delayed - hp0\n\tself.Hpij[1,0] = hp0_delayed - hp1\n\n\tself.Hpij[0,2] = hp2_delayed - hp0\n\tself.Hpij[2,0] = hp0_delayed - hp2\n\n\tself.Hpij[1,2] = hp2_delayed - hp1\n\tself.Hpij[2,1] = hp1_delayed - hp2\n\t\n\t# cross-polarization\n\tself.Hcij[0,1] = hc1_delayed - hc0\n\tself.Hcij[1,0] = hc0_delayed - hc1\n\n\tself.Hcij[0,2] = hc2_delayed - hc0\n\tself.Hcij[2,0] = hc0_delayed - hc2\n\n\tself.Hcij[1,2] = hc2_delayed - hc1\n\tself.Hcij[2,1] = hc1_delayed - hc2\n\t\n\treturn","def __init__(self, training_data, smoothing_factor=1.0):\n\t\tsuper(HostnameFeature, self).__init__('Hostname', 4, smoothing_factor)\n\t\tself.category_bag_of_hostname = {}\n\t\tfor record in training_data:\n\t\t\tcategory = record[6]\n\t\t\tif self.category_bag_of_hostname.get(category) is None:\n\t\t\t\tself.category_bag_of_hostname[category] = {}\n\t\t\tpublishers = self.category_bag_of_hostname[category]\n\t\t\tpublisher_name = record[4].strip().lower()\n\t\t\tif publisher_name not in publishers:\n\t\t\t\tpublishers[publisher_name] = 0\n\t\t\tpublishers[publisher_name] += 1\n\t\t# for k, bw in self.category_bag_of_hostname.items():\n\t\t# \tprint 'category ', k, ' with number of different hostname', len(bw)","def instance_label(task, pred, k=15, n_iters=1, dist_thresh=5, watershed=False):\n mask = pred\n\n # noise removal\n if k > 1 and n_iters > 0:\n kernel = np.ones((k, k), np.uint8)\n mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel,\n iterations=n_iters)\n\n if watershed:\n from clab.live import filters\n mask = filters.watershed_filter(mask, dist_thresh=dist_thresh)\n\n mask = mask.astype(np.uint8)\n n_ccs, cc_labels = cv2.connectedComponents(mask, connectivity=4)\n return cc_labels","def fredkin(ha, hb, hc):\n\n return controlled_U(ha, swap(hb, hc))","def labels(self, threshold, segment=True, exclude_border=0):\n data = self.unmasked_data\n isfin = numpy.isfinite(data)\n data[~isfin] = numpy.amin(data[isfin])\n regions = (data > threshold)\n if segment:\n local_max = peak_local_max(data, indices=False,\n exclude_border=0,\n footprint=numpy.ones((3, 3)),\n labels=regions)\n markers = measurements.label(local_max)[0]\n labels = watershed(-data, markers, mask=regions)\n if exclude_border > 0:\n # Remove basins originating from edge peaks\n diff = numpy.zeros_like(local_max)\n for i in range(local_max.ndim):\n local_max = local_max.swapaxes(0, i)\n diff = diff.swapaxes(0, i)\n diff[:exclude_border] = local_max[:exclude_border]\n diff[-exclude_border:] = local_max[-exclude_border:]\n diff = diff.swapaxes(0, i)\n local_max = local_max.swapaxes(0, i)\n \n for l in numpy.sort(labels[diff])[::-1]:\n labels[labels == l] = 0\n labels[labels > l] -= 1\n ulabels = numpy.unique(labels)\n n = ulabels[ulabels != 0].size\n else:\n data_thres = numpy.zeros_like(data)\n data_thres[regions] = data[regions]\n labels, n = measurements.label(data_thres)\n return labels, n","def graphCut(img, center, radius, temp, edge, count, editPoints, padList, theta_width, phi_width):\r\n\r\n\r\n \"\"\"Important note. The labeled image is referred to as temp, or self.temp in the interface.\r\n This stands for template. The previously labled image is fed back into the graphcut\"\"\"\r\n \r\n \"\"\"create polar images and cost arrays\"\"\"\r\n \r\n print \"RUNNING GRAPHCUT!\"\r\n img= padImage(img, padList)\r\n temp= padImage(temp, padList)\r\n edge= padImage(edge, padList)\r\n center= padCenter(center, padList)\r\n \r\n polar_img= img2polar(img, center, radius, theta_width=theta_width, phi_width=phi_width)\r\n\r\n \r\n \r\n polar_grad, y, x = np.gradient(np.array(polar_img, dtype='float'))\r\n \"\"\"Lockett 100416 replacement line below to not use gradient when the image has a surface label\"\"\"\r\n \"\"\"polar_grad = -1 * np.array(polar_img, dtype='float')\"\"\"\r\n \r\n \r\n polar_cost = -1 * np.ones(polar_img.shape)\r\n for r in range(1,radius):\r\n polar_cost[r]= polar_grad[r]-polar_grad[r-1]\r\n\r\n \r\n \r\n \"\"\"\r\n flip the cost image upside down. This is so that the base set is at the bottom of the array\r\n since the graphcut cuts from top to bottom, this inversion is necessary.\r\n \"\"\"\r\n polar_cost_inv=polar_cost[::-1,:,:]\r\n\r\n print \"CONSTRUCTING GRAPH EDGES... \"\r\n \r\n \"\"\"construct the graph using PyMaxFlow\"\"\"\r\n g=maxflow.GraphFloat()\r\n nodeids=g.add_grid_nodes(polar_img.shape)\r\n structure=np.zeros((3,3,3))\r\n structure[2]= np.array([[0,10000,0],[10000, 10000, 10000],[0, 10000, 0]])\r\n g.add_grid_edges(nodeids, structure=structure, symmetric=False)\r\n\r\n \r\n \"\"\"convert the previously labeled image (temp) into a polar transform image. Take the labels and\r\n give them high cost edge weights so the segmentation avoids previously labeled objects\"\"\"\r\n polar_lbl_img= img2polar(temp, center, radius, theta_width=theta_width, phi_width=phi_width)\r\n polar_lbl_img_inv= polar_lbl_img[::-1,:]\r\n \r\n lbl_caps= polar_lbl_img_inv>0\r\n self_caps= (polar_lbl_img_inv==count)\r\n lbl_caps-=self_caps\r\n lbl_source_caps= np.zeros(lbl_caps.shape)\r\n lbl_sink_caps= lbl_caps*10000\r\n g.add_grid_tedges(nodeids, lbl_source_caps, lbl_sink_caps)\r\n \r\n structure2= 10000*np.array([[0,0,0],[0,0,1],[0,1,0]])\r\n g.add_grid_edges(nodeids[radius-1], structure=structure2, symmetric=True)\r\n\r\n \"\"\"add terminal edges using two arrays whose elemnts are the costs of the edges from the source and to the\r\n sink\"\"\"\r\n print \"CONSTRUCTING GRAPH TEDGES...\"\r\n sinkcaps= polar_cost_inv * (polar_cost_inv>=0)\r\n sourcecaps = -1 * polar_cost_inv * (polar_cost_inv<0)\r\n g.add_grid_tedges(nodeids, sourcecaps, sinkcaps)\r\n\r\n \r\n\r\n \r\n \"\"\"accounts for edit points. Takes every point in the edit point list, converts it to its spherical coordinate, and adds high cost\r\n edges in the column of that edit point inverts the x and y coordinates of the center\"\"\"\r\n center= np.array((center[0], center[2], center[1]))\r\n if len(editPoints)!=0:\r\n for coords in editPoints:\r\n\r\n \r\n rad= math.sqrt((center[0]-coords[0])**2+ (center[1]-coords[2])**2 + (center[2]-coords[1])**2) \r\n theta= math.atan2(center[2]-coords[1], coords[2]-center[1])\r\n print str((coords[0]-center[0])/(rad+1))\r\n phi=math.acos(float(coords[0]-center[0])/(rad+1))\r\n if theta<0:\r\n theta=2*math.pi+ theta\r\n theta= theta_width- theta_width*theta/(2*math.pi)-1\r\n phi= phi_width*phi/(math.pi)-1\r\n rad= radius- rad\r\n print \"POLAR COORDS: \" + str((rad, theta, phi))\r\n\r\n for r in range(0, radius):\r\n if r<=rad:\r\n g.add_tedge(nodeids[r, theta, phi], 0, 10000)\r\n \r\n else:\r\n g.add_tedge(nodeids[r, theta, phi], 10000, 0) \r\n\r\n\r\n\r\n\r\n print \"CUTTING GRAPH...\"\r\n g.maxflow()\r\n\r\n \"\"\"s-t mincut of graph. This is converted to cartesian coordinates with the function img2cart. The\r\n images are also closed to eliminate spotty areas\"\"\"\r\n \r\n print \"STARTING CARTESIAN TRANSFORM...\"\r\n polar_img_seg= np.invert(g.get_grid_segments(nodeids)[::-1,:,:])\r\n\r\n \r\n edge_img= np.zeros(img.shape)\r\n seg_img= ndimage.binary_closing(img2cart(img, polar_img_seg, center, radius, theta_width, phi_width))\r\n \r\n \r\n \"\"\"create an edge image of the segmented object\"\"\"\r\n strel=np.ones((3,3,3))\r\n erode_img=ndimage.binary_erosion(seg_img, strel)\r\n edge_img=np.logical_xor(seg_img, erode_img)\r\n \r\n\r\n \"\"\"shears the segmentation image and edge if padding was applied\"\"\"\r\n \r\n\r\n \"\"\"add the object back on to the template image (and the edge image back on the template edge)\r\n If there was an editpoint involved, remove the previous segmentation of that object and add back\r\n on the edited object\"\"\"\r\n if len(editPoints)!=0:\r\n del_img= (temp==count)*count\r\n temp-=del_img\r\n\r\n del_edge_img= (edge==count)*count\r\n edge-= del_edge_img\r\n\r\n\r\n temp+=seg_img*count\r\n edge+=edge_img*count\r\n\r\n temp= shearImage(temp, padList)\r\n edge= shearImage(edge, padList)\r\n \r\n \r\n\r\n print \"FINISHED!\"\r\n \r\n return temp, edge","def __init__(self, *args):\n _BRepAlgo.BRepAlgo_Cut_swiginit(self,_BRepAlgo.new_BRepAlgo_Cut(*args))","def labeling(self, tab, i, j, element):\n label = element\n label.grid(row=i, column=j) # this specifies where in the grid\n tab.grid_columnconfigure(j, weight=1) \n # this last line makes the width of the column responsive to change in width of the window","def label(self, cfg):\n rep = \"\"\n nl = \"\"\n for node in cfg.nodes:\n rep += nl + \"{}\\tgen={}\\tkill={}\\tout={}\".format(\n node, \n set(self.gen.get(node)),\n set(self.kill.get(node)),\n set(self.out.get(node)))\n nl = \"\\n\"\n return rep","def _make_dijet_label(chain_parts):\n\n assert len(chain_parts) == 1\n scenario = chain_parts[0]['hypoScenario']\n \n assert scenario.startswith('dijet')\n\n arg_res = [\n re.compile(r'^(?P<lo>\\d*)(?P<key>djmass)(?P<hi>\\d*)$'),\n re.compile(r'^(?P<lo>\\d*)(?P<key>j1et)(?P<hi>\\d*)$'),\n re.compile(r'^(?P<lo>\\d*)(?P<key>j1eta)(?P<hi>\\d*)$'),\n re.compile(r'^(?P<lo>\\d*)(?P<key>j2et)(?P<hi>\\d*)$'),\n re.compile(r'^(?P<lo>\\d*)(?P<key>j2eta)(?P<hi>\\d*)$'),\n ]\n\n defaults = {\n 'j1et': ('100', 'inf'),\n 'j2et': ('100', 'inf'),\n 'j1eta': ('0', '320'),\n 'j2eta': ('0', '320'),\n 'djmass': ('1000', 'inf'),\n }\n\n\n args = _args_from_scenario(scenario)\n argvals = {}\n while args:\n assert len(args) == len(arg_res)\n arg = args.pop()\n for r in arg_res:\n m = r.match(arg)\n if m is not None:\n arg_res.remove(r)\n gd = m.groupdict()\n key = gd['key']\n\n try:\n lo = float(gd['lo'])\n except ValueError:\n lo = defaults[key][0]\n argvals[key+'lo'] = lo \n try:\n hi = float(gd['hi'])\n except ValueError:\n hi = defaults[key][1]\n argvals[key+'hi'] = hi\n\n assert len(args) == len(arg_res)\n assert len(args) == 0\n\n return \"\"\"\n combgen(\n [(2)(%(j1etlo).0fet, %(j1etalo).0feta%(j1etahi).0f)\n (%(j1etlo).0fet, %(j1etalo).0feta%(j1etahi).0f)\n ]\n \n dijet(\n [(%(djmasslo).0fdjmass)])\n simple([(%(j1etlo).0fet, %(j1etalo).0feta%(j1etahi).0f)\n (%(j2etlo).0fet, %(j2etalo).0feta%(j2etahi).0f)])\n )\"\"\" % argvals","def hilfe(self):\n sZweieck_hilfe(3)","def gen_hts_lab_full(self):\n self.gen_hts_lab_mono()\n\n hts_lab_time_prn = tuple(' '.join(l[0:2]) for l in self._hts_lab_mono_ttpl)\n\n self.hts_lab_full_prn = tuple(' '.join((l_time, l_gen)) for (l_time, l_gen)\n in zip(hts_lab_time_prn, self.hts_lab_gen_prn))","def x_group_label(\n x_gr: int, cut: int = 20, name_dict: Dict[AnyStr, AnyStr] = names_dict\n) -> AnyStr:\n name = name_dict[str(x_gr)]\n if len(name) > cut:\n return f\"{name[:cut-3]}...\"\n else:\n return name","def _labels_of_sentence(self, sentence, split):\n labels = torch.ones(1)\n labels[0] = self.category_int_of_label_string(sentence[0][self.name_to_index_dict['label']]) #\n return labels","def vertical_core(block,cut,laser):\r\n\r\n\tlayers = int(block[\"thickness\"]/laser[\"z_spacing\"])\r\n\tangle = math.radians(laser[\"kerf_angle\"]/2)\r\n\ttaper = math.tan(angle) * laser[\"z_spacing\"]\r\n\r\n\tu = math.tan(2 * angle) * (block[\"thickness\"] + laser[\"z_final_overshoot\"])\r\n\tz_0 = block[\"thickness\"]*math.cos(angle) + math.sin(angle)*((cut[\"final_dimension_y\"])/2 - block[\"origin_y\"] + u)\r\n\tz_1 = block[\"thickness\"]*math.cos(angle) + math.sin(angle)*((cut[\"final_dimension_x\"])/2 + block[\"origin_x\"] + u)\r\n\tz_2 = block[\"thickness\"]*math.cos(angle) + math.sin(angle)*((cut[\"final_dimension_y\"])/2 + block[\"origin_y\"] + u)\r\n\tz_3 = block[\"thickness\"]*math.cos(angle) + math.sin(angle)*((cut[\"final_dimension_x\"])/2 - block[\"origin_x\"] + u)\r\n\t\r\n\tcutlist = []\r\n\tcutlist.append([\"a_abs\", f\"{math.degrees(angle):.6f}\"])\r\n\tcutlist.append([\"c_abs\", str(block[\"physical_rotation\"])])\r\n\tcutlist.append([\"z_abs\", f\"{z_0:.6f}\"])\r\n\r\n\ty_start_wide = ((u + cut[\"final_dimension_x\"]/2)* math.cos(angle) \r\n\t\t\t\t - block[\"thickness\"]*math.sin(angle) \r\n\t\t\t\t - u/math.cos(angle))\r\n\ty_start_length = ((u + cut[\"final_dimension_y\"]/2)* math.cos(angle) \r\n\t\t\t\t - block[\"thickness\"]*math.sin(angle) \r\n\t\t\t\t - u/math.cos(angle))\r\n\r\n\tdepth_cut = (block[\"thickness\"] + laser[\"z_final_overshoot\"]) * math.cos(angle)/math.cos(2*angle)\r\n\r\n\tcut1 = json.loads(line(block[\"width\"]/2 - block[\"origin_x\"],y_start_length - block[\"origin_y\"],-block[\"width\"]/2 - block[\"origin_x\"],y_start_length - block[\"origin_y\"],depth_cut,laser))\r\n\r\n\tcut2 = json.loads(line(block[\"length\"]/2 + block[\"origin_y\"],y_start_wide - block[\"origin_x\"],-block[\"length\"]/2 + block[\"origin_y\"],y_start_wide - block[\"origin_x\"],depth_cut,laser))\r\n\r\n\tcut3 = json.loads(line(block[\"width\"]/2 + block[\"origin_x\"],y_start_length + block[\"origin_y\"],-block[\"width\"]/2 + block[\"origin_x\"],y_start_length + block[\"origin_y\"],depth_cut,laser))\r\n\r\n\tcut4 = json.loads(line(block[\"length\"]/2 - block[\"origin_y\"],y_start_wide + block[\"origin_x\"],-block[\"length\"]/2 - block[\"origin_y\"],y_start_wide + block[\"origin_x\"],depth_cut,laser))\r\n\r\n\t#cut1 = json.loads(line(block[\"width\"]/2,y_start_length,-block[\"width\"]/2,y_start_length,depth_cut,laser))\r\n\r\n\t#cut2 = json.loads(line(block[\"length\"]/2,y_start_wide,-cut[\"final_dimension_y\"]/2,y_start_wide,depth_cut,laser))\r\n\r\n\t#cut3 = json.loads(line(block[\"width\"]/2,y_start_length,-cut[\"final_dimension_x\"]/2,y_start_length,depth_cut,laser))\r\n\r\n\t#cut4 = json.loads(line(cut[\"final_dimension_y\"]/2,y_start_wide,-cut[\"final_dimension_y\"]/2,y_start_wide,depth_cut,laser))\r\n\r\n\tcutlist = (cutlist + cut1\r\n\t + [[\"c_rel\", \"90\"],[\"z_abs\", f\"{z_1:.6f}\"],] \r\n\t + cut2\r\n\t + [[\"c_rel\", \"90\"],[\"z_abs\", f\"{z_2:.6f}\"]] \r\n\t\t\t\t\t + cut3 \r\n\t\t\t\t\t + [[\"z_abs\", f\"{z_3:.6f}\"],[\"c_rel\", \"90\"]] \r\n\t\t\t\t\t + cut4)\r\n\r\n\tcutlist.insert(0, [\"set_trigger4\", \"1\", \"0\", \"7\", \"8\", \"45\"])\r\n\tcutlist.append([\"stop_trigger\"])\r\n\r\n\treturn json.dumps(cutlist)","def SCEC_LOH_1():\n\n #Initialize CrustModel\n model = CrustModel(2)\n\n #Slow layer\n vp=4.000\n vs=2.000\n rho=2.600\n Qa=10000.\n Qb=10000.\n thickness = 1.0\n\n model.add_layer(thickness, vp, vs, rho, Qa, Qb)\n\n #Halfspace\n vp=6.000\n vs=3.464\n rho=2.700\n Qa=10000.\n Qb=10000.\n thickness = 0 #Infinite thickness!\n model.add_layer(thickness, vp, vs, rho, Qa, Qb)\n\n return model","def sils_cut(T,f,c,d,h, conshdlr):\n Ts = range(1,T+1)\n\n model = sils(T,f,c,d,h)\n y,x,I = model.data\n\n # relax integer variables\n for t in Ts:\n model.chgVarType(y[t], \"C\")\n model.addVar(vtype=\"B\", name=\"fake\") # for making the problem MIP\n\n # compute D[i,j] = sum_{t=i}^j d[t]\n D = {}\n for t in Ts:\n s = 0\n for j in range(t,T+1):\n s += d[j]\n D[t,j] = s\n\n #include the lot sizing constraint handler\n model.includeConshdlr(conshdlr, \"SILS\", \"Constraint handler for single item lot sizing\",\n sepapriority = 0, enfopriority = -1, chckpriority = -1, sepafreq = -1, propfreq = -1,\n eagerfreq = -1, maxprerounds = 0, delaysepa = False, delayprop = False, needscons = False,\n presoltiming = SCIP_PRESOLTIMING.FAST, proptiming = SCIP_PROPTIMING.BEFORELP)\n conshdlr.data = D,Ts\n\n model.data = y,x,I\n return model","def _subconstituent_name(h):\n if h == 1:\n o = \"1st\"\n elif h == 2:\n o = \"2nd\"\n elif h == 3:\n o = \"3rd\"\n else:\n o = \"%dth\" % h\n return \"%s subconstituent\" % o","def display_and_label_hulls(self, hulls, src):\n \n labels = []\n\n for hull in hulls:\n\n angle = 0\n MA = 1\n ma = 1\n try:\n _,(MA,ma),angle = cv.fitEllipse(hull)\n except:\n pass\n cosAngle = np.abs(np.cos(angle*np.pi/180))\n\n # Only human-classify hulls if it is reasonably a vertically oriented rectangle\n # This is a hueristic to not have to waste time clasifying hulls clearly not poles\n if (cosAngle < 1.75) and (cosAngle > 0.85) and (MA/ma < 0.28):\n cpy = src.copy()\n hull_img = cv.polylines(cpy, [hull], True, (0,0,255), 3)\n cv.imshow(\"Hull\", hull_img)\n keycode = cv.waitKey(0)\n if keycode == 49:\n labels.append((hull, 0))\n print(\"Not a Pole\")\n elif keycode == 50:\n labels.append((hull, 1))\n print(\"A Pole!\")\n else:\n raise Exception(\"Unexpected Key Pressed\")\n else:\n labels.append((hull, 0))\n cv.destroyAllWindows()\n return labels","def __init__(self, word_embed_size, vocab):\n super(ModelEmbeddings, self).__init__()\n\n ### YOUR CODE HERE for part 1h\n dropout_rate = 0.3\n n_chars = len(vocab.char2id)\n self.char_embed_size = 50\n self.word_embed_size = word_embed_size\n self.vocab = vocab\n self.char_embed = nn.Embedding(n_chars, self.char_embed_size)\n self.conv = CNN(self.char_embed_size, word_embed_size)\n self.highway = Highway(word_embed_size)\n self.dropout = nn.Dropout(dropout_rate)\n ### END YOUR CODE","def plot_mass_flow(self,\n watershed, \n output, \n title = 'Subbasin Reach Mass Flow Diagram',\n fontsize = 6, \n theight = 0.2, \n l = 8.5, \n w = 11, \n verbose = True, \n overwrite = True,\n ):\n\n if os.path.exists(output) and not overwrite:\n if verbose: print('file %s exists' % output)\n return\n elif verbose: print('generating a mass linkage plot\\n')\n\n fontheight = fontsize / 72.\n rheight = 3 * fontheight\n rwidth = 12 * fontheight\n xgap = fontheight\n ygap = rheight\n awidth = rheight / 4\n aheight = rheight / 3\n\n # set up a sheet to write the image\n\n fig = pyplot.figure(figsize = (w, l))\n\n ax = fig.add_subplot(111, aspect = 'equal')\n ax.get_xaxis().set_visible(False)\n ax.get_yaxis().set_visible(False)\n t = ax.set_title(title)\n\n # divide the subbasins into rows and put them on the chart\n # start at the bottom to organize the linkages better\n\n rows = [watershed.outlets, ['outlet']]\n\n top = False\n while not top:\n row = []\n for next in rows[0]:\n for subbasin in watershed.updown:\n if watershed.updown[subbasin] == next: row.append(subbasin)\n if len(row) > 0: \n rows.insert(0, row)\n else: \n top = True\n\n # add an inlet box in the row above each inlet\n\n for inlet in watershed.inlets: \n\n i = 0\n while i < len(rows) - 1:\n\n for subbasin in rows[i]:\n\n if subbasin == inlet:\n \n # find the position of the subbasin in the chart\n\n j = rows[i].index(inlet)\n\n if i > 0:\n\n # figure out where the subbasins point\n \n updowns = [watershed.updown[s] for s in rows[i-1]]\n \n # if first or last, add it there in the row above\n\n if j == 0: \n rows[i-1].insert(0, 'inlet')\n elif j == len(rows[i]) - 1: \n rows[i-1].append('inlet')\n else:\n\n # find the place to add in the preceeding row \n\n n = updowns.index(rows[i][j-1]) + 1\n rows[i-1].insert(n, 'inlet')\n\n i += 1\n\n # write the subbasin boxes to the chart\n\n middle = math.ceil(w // (rwidth + xgap)) // 2\n last = 0\n\n # keep track of the bounding box of the plot\n\n xmin, ymin, xmax, ymax = middle, 0, middle, 0\n\n for i in range(len(rows)):\n\n row = rows[i]\n \n y = (ygap + rheight) * i + theight\n\n # figure out which cell to put in the main column\n\n if i == 0:\n main = row[(len(row) - 1) // 2]\n elif i < len(rows) - 1:\n main = watershed.updown[rows[i-1][last]]\n else: main = 'outlet'\n\n start = middle - row.index(main)\n\n if i < len(rows) - 1: next_row = rows[i + 1]\n\n for subbasin in row:\n x = (rwidth + xgap) * (start + row.index(subbasin))\n r = patches.Rectangle((x, y), rwidth, rheight, fill = False)\n\n # adjust the bounding box\n\n if x < xmin: xmin = x\n if x + rwidth > xmax: xmax = x + rwidth\n if y < ymin: ymin = y\n if y + rheight > ymax: ymax = y + rheight\n\n if subbasin != 'outlet': ax.add_patch(r)\n\n b = ax.text(x + rwidth / 2, y + rheight / 2, subbasin,\n horizontalalignment = 'center',\n verticalalignment = 'center')\n\n # draw the arrow\n\n if i < len(rows) - 1:\n\n x1 = x + rwidth / 2\n\n if i < len(rows) - 2 and subbasin != 'inlet':\n next = watershed.updown[subbasin]\n next_start = (middle - \n next_row.index(watershed.updown[main]))\n x2 = ((rwidth + xgap) * \n (next_start + next_row.index(next))\n + rwidth / 2)\n\n elif subbasin == 'inlet':\n next = watershed.inlets[0]\n next_start = (middle - \n next_row.index(watershed.updown[main]))\n\n x2 = ((rwidth + xgap) * \n (next_start + next_row.index(next))\n + rwidth / 2)\n\n else:\n next_start = middle\n x2 = ((rwidth + xgap) * (middle) + rwidth / 2)\n\n a = pyplot.arrow(x1, y + rheight, x2 - x1, ygap, \n head_width = awidth, head_length = aheight,\n fc = 'k', ec = 'k', \n length_includes_head = True)\n ax.add_patch(a)\n\n last = row.index(main)\n i += 1\n \n pad = 0.02\n\n xmin = xmin - (xmax - xmin) * pad\n xmax = xmax + (xmax - xmin) * pad\n ymin = ymin - (ymax - ymin) * pad\n ymax = ymax + (ymax - ymin) * pad\n\n ax.set_xlim(xmin, xmax)\n ax.set_ylim(ymax, ymin)\n pyplot.axis('off')\n pyplot.savefig(output, dpi = 200)\n\n pyplot.clf()\n pyplot.close()","def _get_labels(self, ind):\n pass","def plot_labels_bundle_pth(device, model, dataset, dataloader):\n ## Get labels and preds\n labels, preds = get_labels_and_preds(device, model, dataloader)\n \n ## Plot the figure\n plot_labels(labels, preds, dataset.id_to_class_dict)","def write_label(self, contig_name, width, height, font, title_width, upper_left, vertical_label,\n strand, canvas, horizontal_centering=False, center_vertical=False, chop_text=True,\n label_color=(50, 50, 50, 255)):\n upper_left = list(upper_left) # to make it mutable\n shortened = contig_name[-title_width:] # max length 18. Last characters are most unique\n txt = Image.new('RGBA', (width, height))#, color=(0,0,0,50))\n txt_canvas = ImageDraw.Draw(txt)\n text_width = txt_canvas.textsize(shortened, font)[0]\n if not chop_text and text_width > width:\n txt = Image.new('RGBA', (text_width, height)) # TODO performance around txt_canvas\n txt_canvas = ImageDraw.Draw(txt)\n if center_vertical or vertical_label: # Large labels are centered in the column to look nice,\n # rotation indicates strand in big text\n vertically_centered = (height // 2) - multi_line_height(font, shortened, txt)//2\n else: # Place label at the beginning of gene based on strand\n vertically_centered = height - multi_line_height(font, shortened, txt) # bottom\n if strand == \"+\":\n vertically_centered = 0 # top of the box\n txt_canvas.multiline_text((0, max(0, vertically_centered)), shortened, font=font,\n fill=label_color)\n if vertical_label:\n rotation_direction = 90 if strand == '-' else -90\n txt = txt.rotate(rotation_direction, expand=True)\n upper_left[1] += -4 if strand == '-' else 4\n if horizontal_centering:\n margin = width - text_width\n upper_left[0] += margin // 2\n canvas.paste(txt, (upper_left[0], upper_left[1]), txt)","def hbnb():\n return 'HBNB'","def TH(self, full=False):\n\t\treturn (arange(self.thbins + 3*self.thbins*(full==True)) + 0.5) * (pi / 2) / self.thbins","def displayNeedle(self,i):\n #obsolete\n profbox()\n modelNodes = slicer.util.getNodes('vtkMRMLModelNode*')\n for modelNode in modelNodes.values():\n if modelNode.GetAttribute(\"nth\")==str(i) and modelNode.GetAttribute(\"segmented\")=='1' :\n displayNode = modelNode.GetModelDisplayNode()\n nVisibility = displayNode.GetVisibility()\n \n if nVisibility:\n displayNode.SliceIntersectionVisibilityOff()\n displayNode.SetVisibility(0)\n else:\n displayNode.SliceIntersectionVisibilityOn()\n displayNode.SetVisibility(1)","def label_joints():\n side_dict = {'C': 0,\n 'L': 1,\n 'R': 2}\n for jnt in mc.ls(type='joint'):\n mc.setAttr('{}.side'.format(jnt), side_dict[jnt.split('_')[0]])\n mc.setAttr('{}.type'.format(jnt), 18)\n mc.setAttr('{}.otherType'.format(jnt), jnt.split('_')[1], type=\"string\")","def __init__(self, h, d_model, dropout=0.1):\n super(MultiHeadedAttention, self).__init__()\n assert d_model % h == 0\n # We assume d_v always equals d_k\n self.d_k = d_model // h\n self.h = h\n self.linears = clones(nn.Linear(d_model, d_model), 4)\n self.attn = None\n self.dropout = nn.Dropout(p=dropout)","def selection_correction_method1(tree, scale, h_in, h_out):\n #h_in = ROOT.TH1D(\"h_in\", \"neutron spectrum with all cuts: inside onset window; Energy [keV]; counts\", 50, 0, 25)\n #h_out = ROOT.TH1D(\"h_out\", \"neutron spectrum with all cuts: outside onset window; Energy [keV]; counts\", 50, 0, 25)\n for event in tree:\n cut = [0, 0]\n S15_ch = i_channel(0, event)\n bpm_ch = i_channel(4, event)\n RT = event.DD_Rise[S15_ch]\n S15_w2 = event.DD_AmplADU[S15_ch]\n onset = event.DD_Rise10pct[S15_ch]\n if cut[0]==0:\n # first cut: for inside onset window\n # if event passes the first cuts\n if S15_w2>1000 and RT>1.1 and RT<1.51 and onset>39 and onset<47:\n # loop over the pmt channel numbers to calculate the time of flight: time bd - time bpm\n for n_channel in range(5, 16):\n pmt_i = i_channel(n_channel, event)\n cfd_pmt = event.cfdPulse_CFDNS[pmt_i]\n cfd_bpm = event.cfdPulse_CFDNS[bpm_ch]\n # calculation of the time of flight\n tof = (cfd_pmt-cfd_bpm)%400\n #cut on tof: time of flight of the neutron\n if tof<335 and tof>295:\n energy2 = S15_w2*scale\n # fill histogram inside onset window\n h_in.Fill(energy2)\n cut[0]=1\n break\n if cut[1]==0:\n if S15_w2>1000 and RT<1.51 and RT>1.1 and ((onset<36 and onset>15) or (onset>50 and onset<=110)):\n for n_channel in range(5, 16):\n pmt_i = i_channel(n_channel, event)\n cfd_pmt = event.cfdPulse_CFDNS[pmt_i]\n cfd_bpm = event.cfdPulse_CFDNS[bpm_ch]\n tof = (cfd_pmt-cfd_bpm)%400\n if tof<335 and tof>295:\n energy2 = S15_w2*scale\n h_out.Fill(energy2)\n cut[1]=1\n break\n return h_in, h_out","def split(self, frame, y):\n return super(H2OStratifiedKFold, self).split(frame, y)","def hbnb():\n return \"HBNB\"","def hbnb():\n return \"HBNB\"","def label(self):\r\n raise NotImplementedError","def width_h_invis(self):\n if m_higgs > 2.0 * self.mx:\n coupling = self.gsxx * self.stheta / np.sqrt(1 - self.stheta**2)\n\n val = (\n (coupling**2 * (m_higgs**2 - 4 * self.mx**2) ** 1.5)\n / (8.0 * m_higgs**2 * np.pi)\n ).real\n\n assert val >= 0\n\n return val\n else:\n return 0.0","def J_J(h):\n\n h = MTS(h)\n hdot = h.dot\n J_𝒥 = 0.5j * 𝔇inverseLaplacianinverse(\n 0.125 * (3 * h * hdot.bar.ethbar - 3 * hdot * h.bar.ethbar + hdot.bar * h.ethbar - h.bar * hdot.ethbar).eth.im\n ).ethbar.ethbar\n\n return J_𝒥","def _extract_vanHove(g,j,count_cut,wind):\n count = g[fd('step',j)]['y']['disp_count'][:]\n # get better statistics\n count += g[fd('step',j)]['x']['disp_count'][:]\n # count += count[::-1]\n\n edges = g[fd('step',j)]['y']['disp_edges'][:]\n \n edges = np.array([np.mean(edges[j:j+wind]) for j in range(0,len(count)-wind,wind)])\n count = np.array([np.sum(count[j:j+wind]) for j in range(0,len(count)-wind,wind)])\n\n x_lim = (np.min(edges),np.max(edges))\n\n edges = edges[count>count_cut]\n count = count[count>count_cut]\n\n return edges,count,x_lim"],"string":"[\n \"def label_thin(self, orig_label):\\n pil_thin = thin(orig_label)\\n # Keep the original label and set non-thinning label as 0\\n orig_label[~pil_thin] = 0\\n\\n return orig_label\",\n \"def kohonen():\\n# plb.close('all')\\n \\n dim = 28*28\\n data_range = 255.0\\n \\n # load in data and labels \\n data = np.array(np.loadtxt('data.txt'))\\n labels = np.loadtxt('labels.txt')\\n\\n # select 4 digits \\n name = \\\"Stettler\\\"\\n targetdigits = name2digits(name) # assign the four digits that should be used\\n print(targetdigits) # output the digits that were selected\\n\\n # this selects all data vectors that corresponds to one of the four digits\\n data = data[np.logical_or.reduce([labels==x for x in targetdigits]),:]\\n \\n dy, dx = data.shape\\n \\n #set the size of the Kohonen map. In this case it will be 6 X 6\\n size_k = 6\\n \\n #set the width of the neighborhood via the width of the gaussian that\\n #describes it\\n sigma = 2.0\\n \\n #initialise the centers randomly\\n centers = np.random.rand(size_k**2, dim) * data_range\\n \\n #build a neighborhood matrix\\n neighbor = np.arange(size_k**2).reshape((size_k, size_k))\\n\\n #set the learning rate\\n eta = 0.9 # HERE YOU HAVE TO SET YOUR OWN LEARNING RATE\\n \\n #set the maximal iteration count\\n tmax = 5000 # this might or might not work; use your own convergence criterion\\n \\n #set the random order in which the datapoints should be presented\\n i_random = np.arange(tmax) % dy\\n np.random.shuffle(i_random)\\n \\n for t, i in enumerate(i_random):\\n som_step(centers, data[i,:],neighbor,eta,sigma)\\n\\n # for visualization, you can use this:\\n for i in range(size_k**2):\\n plb.subplot(size_k,size_k,i)\\n \\n plb.imshow(np.reshape(centers[i,:], [28, 28]),interpolation='bilinear')\\n plb.axis('off')\\n \\n # leave the window open at the end of the loop\\n plb.show()\\n plb.draw()\",\n \"def onCut(self):\\n pass\",\n \"def odemis_to_hyperspy(filename='sampledata/cltest.h5',specbin=1) :\\r\\n\\r\\n f=h5.File(filename,'r')\\r\\n shome = 'Acquisition2//ImageData/'\\r\\n x = f[shome + 'Image']\\r\\n cdesc =f['Acquisition2/PhysicalData/ChannelDescription'].value[0].decode('utf-8')\\r\\n #print(cdesc)\\r\\n\\r\\n cltype = None\\r\\n if 'Spectrum' in cdesc :\\r\\n cltype = 'spectrum'\\r\\n elif 'CL intensity' in cdesc:\\r\\n cltype = 'panchrom'\\r\\n\\r\\n print('<' + filename + '> original shape :' ,x.shape, cltype)\\r\\n\\r\\n # strip unused dimensions and transpose/ reverse index order\\r\\n if cltype == 'panchrom' :\\r\\n xx=x[0,0,0,:,:].transpose((1,0))\\r\\n # just an image..\\r\\n else :\\r\\n xx=x[:,0,0,:,:].transpose((2,1,0))\\r\\n\\r\\n if cltype == 'spectrum' :\\r\\n #interpolate data to linearize the wavelength scale\\r\\n w = f[shome + 'DimensionScaleC'].value *1e9\\r\\n wx = np.linspace(w.min(),w.max(),w.size)\\r\\n for i in np.arange(xx.shape[0]) :\\r\\n for k in np.arange(xx.shape[1]) :\\r\\n xx[i,k,:] = np.interp(wx,w,xx[i,k,:])\\r\\n\\r\\n wslope = wx[1]-wx[0]\\r\\n woffset = wx.min()\\r\\n #wx = np.arange(w.size)\\r\\n #wslope,woffset=np.polyfit(wx,w,1)\\r\\n s = hs.signals.Signal1D(xx)\\r\\n\\r\\n elif cltype == 'panchrom' :\\r\\n s = hs.signals.Signal2D(xx)\\r\\n else :\\r\\n print('unknown type')\\r\\n\\r\\n print('hyperspy shape :' ,s.data.shape)\\r\\n\\r\\n\\r\\n s.metadata.General.title = 'Odemis: ' + cdesc\\r\\n s.metadata.General.original_filename = filename\\r\\n s.metadata.General.notes = cltype\\r\\n s.axes_manager[0].name = 'pos x'\\r\\n s.axes_manager[0].scale = f[shome + 'DimensionScaleX'].value * 1e6\\r\\n s.axes_manager[0].offset = f[shome + 'XOffset'].value * 1e6\\r\\n s.axes_manager[0].units = 'um'\\r\\n\\r\\n\\r\\n s.axes_manager[1].name = 'pos y'\\r\\n s.axes_manager[1].scale = f[shome + 'DimensionScaleX'].value * 1e6\\r\\n s.axes_manager[1].offset = f[shome + 'YOffset'].value * 1e6\\r\\n s.axes_manager[1].units = 'um'\\r\\n\\r\\n if cltype == 'spectrum' :\\r\\n s.axes_manager[2].name = 'wavelength'\\r\\n s.axes_manager[2].units = 'nm'\\r\\n s.axes_manager[2].offset = woffset\\r\\n s.axes_manager[2].scale = wslope\\r\\n s.metadata.signal_type = 'CL'\\r\\n\\r\\n f.close()\\r\\n if (specbin > 1) and (cltype == 'spectrum'):\\r\\n return( s.rebin(scale=[1,1,specbin]) )\\r\\n else :\\r\\n return( s )\\r\\n #end odemis_to_hyperspy\\r\\n #######################\\r\",\n \"def cut(S, T, graph):\\n ###TODO\\n pass\",\n \"def __init__(self, label=None):\\n super().__init__(\\\"h\\\", 1, [], label=label)\",\n \"def extract_info(config, cut, label):\\n cfg = filter(lambda c: c['name'] == cut, config['physics']['cuts'])[0]\\n text = \\\"\\\"\\n if 'max' not in cfg:\\n text += \\\"#geq \\\"\\n text += str(cfg['min'])\\n if 'max' in cfg and cfg['max'] != cfg['min']:\\n text += '-' + str(cfg['max']) + ' ' + label + 's'\\n elif cfg['min'] != 1:\\n text += ' ' + label + 's'\\n else:\\n text += ' ' + label\\n return text\",\n \"def ch(h1):\\n return -(pic_height / float(h)) * h1\",\n \"def drawlabels(t, t1):\\r\\n t.fd(250)\\r\\n t.pd()\\r\\n t.write(\\\"Life\\\", font=(\\\"Arial\\\", 10, \\\"bold\\\"))\\r\\n t.pu()\\r\\n t.back(12)\\r\\n t.pd()\\r\\n t.write(\\\"Exp.\\\", font=(\\\"Arial\\\", 10, \\\"bold\\\"))\\r\\n t.pu()\\r\\n t.back(238)\\r\\n t.right(90)\\r\\n t.fd(80)\\r\\n t1.pu()\\r\\n t1.back(50)\\r\\n t1.rt(90)\\r\\n t1.fd(250)\\r\\n t1.pd()\\r\\n t1.write(\\\"Year\\\", font=(\\\"Arial\\\", 10, \\\"bold\\\"))\\r\\n t1.pu()\\r\\n t1.back(250)\\r\\n t1.left(90)\\r\\n t1.fd(50)\",\n \"def hxlcut():\\n run_script(hxlcut_main)\",\n \"def write_label_ps(header_lines, base_lines, tail_lines, shape_list, title, outFn, cutofflist=[0.3,0.5,0.7], mode='fill'):\\n OUT = open(outFn, \\\"w\\\")\\n for header_line in header_lines:\\n if r'{title}' in header_line:\\n header_line = header_line.format(title=title)\\n OUT.writelines(header_line)\\n #print(len(shape_list), len())\\n for shape,base_line in zip(shape_list,base_lines):\\n if mode=='label':\\n OUT.writelines( _color_command_segmented(shape, cutofflist)+\\\"\\\\n\\\" )\\n elif mode=='heatmap':\\n OUT.writelines( _color_command_heatmap(shape, Gradient_Colors, 0, 1)+\\\"\\\\n\\\" )\\n else:\\n raise RuntimeError(\\\"Sorry: mode='fill' Not applicant now\\\")\\n OUT.writelines(base_line)\\n for tail_line in tail_lines:\\n OUT.writelines(tail_line)\\n OUT.close()\",\n \"def __get_ohe_label__(self, label_idx) -> List[int]:\\n\\n label = [0] * self.n_classes\\n label[label_idx] = 1\\n\\n return label\",\n \"def agglo_from_labelmask(\\n h5path_in,\\n h5path_lv='',\\n ratio_threshold=0,\\n h5path_out='',\\n save_steps=False,\\n protective=False,\\n ):\\n\\n # check output paths\\n outpaths = {'out': h5path_out}\\n status = utils.output_check(outpaths, save_steps, protective)\\n if status == \\\"CANCELLED\\\":\\n return\\n\\n # open data for reading\\n h5file_in, ds_in, elsize, axlab = utils.h5_load(h5path_in)\\n h5file_lv, ds_lv, _, _ = utils.h5_load(h5path_lv)\\n\\n # open data for writing\\n h5file_out, ds_out = utils.h5_write(None, ds_in.shape, ds_in.dtype,\\n h5path_out,\\n element_size_um=elsize,\\n axislabels=axlab)\\n\\n ulabels = np.unique(ds_in)\\n maxlabel = np.amax(ulabels)\\n print(\\\"number of labels in watershed: {:d}\\\".format(maxlabel))\\n\\n fwmap = np.zeros(maxlabel + 1, dtype='i')\\n\\n areas_ws = np.bincount(ds_in.ravel())\\n\\n labelsets = {}\\n rp_lw = regionprops(ds_lv, ds_in)\\n for prop in rp_lw:\\n\\n maskedregion = prop.intensity_image[prop.image]\\n counts = np.bincount(maskedregion)\\n svoxs_in_label = [l for sl in np.argwhere(counts) for l in sl]\\n\\n ratios_svox_in_label = [float(counts[svox]) / float(areas_ws[svox])\\n for svox in svoxs_in_label]\\n fwmask = np.greater(ratios_svox_in_label, ratio_threshold)\\n labelset = np.array(svoxs_in_label)[fwmask]\\n labelsets[prop.label] = set(labelset) - set([0])\\n\\n basepath = h5path_in.split('.h5/')[0]\\n utils.write_labelsets(labelsets, basepath + \\\"_svoxsets\\\",\\n filetypes=['pickle'])\\n\\n ds_out[:] = utils.forward_map(np.array(fwmap), ds_in, labelsets)\\n\\n # close and return\\n h5file_in.close()\\n h5file_lv.close()\\n try:\\n h5file_out.close()\\n except (ValueError, AttributeError):\\n return ds_out\",\n \"def cut(self,cell):\\r\\n self.grid[cell[0]][cell[1]] = 1\",\n \"def o_wo_per_head(self):\\n assert self.ff % self.heads == 0\\n # fuse ff->e and projection layer of self-attention\\n return (self.ff // (self.heads-self.padded_heads)) + self.qkv\",\n \"def ksh(i,t,htanses):\\n for (zs,ys,zx,yx) in htanses[i]:\\n alex.penup()\\n alex.goto((zs%m)*20-10*m,(zs//m)*20-10*n)\\n alex.pendown()\\n alex.goto((ys%m+1)*20-10*m,(ys//m)*20-10*n)\\n alex.goto((yx%m+1)*20-10*m,(yx//m+1)*20-10*n)\\n alex.goto((zx%m)*20-10*m,(zx//m+1)*20-10*n)\\n alex.goto((zs%m)*20-10*m,(zs//m)*20-10*n)\\n alex.hideturtle()\",\n \"def create_teacher(self):\\n\\n #words = [\\\"one\\\", \\\"two\\\", \\\"three\\\", \\\"four\\\", \\\"five\\\", \\\"six\\\", \\\"seven\\\", \\\"eight\\\", \\\"nine\\\"]\\n\\n #print(\\\"self.length: \\\", self.length)\\n for i, image in enumerate(self.images):\\n if False:#i % 2 == 0:\\n img = list(chunks(image, 10))\\n plt.imshow(img, interpolation=\\\"nearest\\\", origin=\\\"upper\\\")\\n plt.colorbar()\\n plt.title(self.labels[i])\\n plt.show()\\n label = np.argmax(self.labels[i]) + 1\\n label_vector = self.labels[i]\\n timesteps = label + 1\\n\\n for chain in list(self.traces[i]):\\n count_tensor = list()\\n input_tensor = list()\\n target_tensor = list()\\n \\n #count_tensor.append([0] * z_size)\\n #input_tensor.append(image)\\n #target_tensor.append([None, None])\\n\\n #count_padding = [0 for x in range(z_size)]\\n \\n for count, link in enumerate(chain):\\n count_vector = [0 if x is not count else 1 for x in range(z_size)]\\n count_tensor.append(count_vector)\\n x, y = link\\n image[y*200+x] = 255\\n input_tensor.append(image)\\n target_tensor.append(list(link))\\n\\n # Fill in the rest of the list with the same (current one doe\\n #for cont in range(count + 1, z_size):\\n for cont in range(count + 1, z_size + 1):\\n #count_tensor.append(count_padding)\\n count_tensor.append(count_vector)\\n input_tensor.append(image)\\n target_tensor.append(list(link))\\n\\n \\n\\n self.explode_lbls.append(label)\\n self.explode_labels.append(label_vector)\\n self.explode_counts.append(count_tensor)\\n self.explode_images.append(input_tensor)\\n self.explode_traces.append(target_tensor)\\n #print(target_tensor)\\n\\n \\n \\n self.explode_length = len(self.explode_images)\",\n \"def get_hbls_hbbl(self):\\n [Ly,N] = self.b.shape\\n z_u_w = self.grid_dict['z_u_w']\\n z_u_r = self.grid_dict['z_u_r']\\n u = self.u\\n v = self.v\\n \\n v_upts = TTTW_func.v2u(v)\\n Hz = z_u_w[:,1:] - z_u_w[:,:-1]\\n\\n\\n\\n # CALCULATE swr_frac\\n self.swr_frac = TTTW_func.lmd_swr_frac(self.grid_dict)\\n\\n\\n # WHOLE THING HAPPENS IN j loop through y-indices\\n \\n # INITIALIZE ARRAYS\\n self.kmo = np.zeros([Ly])\\n self.Cr = np.zeros([Ly])\\n self.kbl = np.empty([Ly],dtype='int')\\n self.C_h_MO = np.zeros([Ly])\\n self.Cr = np.zeros([Ly,N+1]) # sum term\\n self.FC = np.zeros([Ly,N+1])\\n self.swdk_r = np.zeros([Ly,N+1])\\n \\n self.zscale = np.zeros([Ly,N])\\n self.Kern = np.zeros([Ly,N])\\n\\n \\n # --> LOOP THROUGH Y-INDICES\\n for j in range(Ly):\\n if self.LIMIT_MO_DEPTH:\\n self.kmo[j] = 0\\n self.C_h_MO[j] = self.C_MO *self.ustar[j]**3/self.vonKar\\n \\n self.kbl[j] = 0\\n self.Cr[j,-1] = 0 # set top Cr\\n self.Cr[j,0] = 0 # set bottom Cr\\n \\n # SEARCH FOR MIXED LAYER DEPTH\\n self.FC[j,-1] = 0.\\n\\n\\n # ---> LOOP TOP TO BOTTOM (FORTRAN ==> k=N-1,1,-1)\\n for k in range(N-1,0,-1):\\n # INDEX MAP\\n k_r = k-1\\n k_w = k\\n\\n \\n zscale = z_u_w[j,N] - z_u_r[j,k_r]\\n self.zscale[j,k_w] = zscale\\n if self.LMD_KPP:\\n if self.LMD_BKPP:\\n zscaleb = z_u_r[j,k_r] - z_u_w[j,0]\\n Kern = zscale * zscaleb**2 / ( (zscale + self.epssfcs*self.hbls_old[j]) * (zscaleb**2+(self.epssfcb**2*self.hbbl_old[j]**2)))\\n else:\\n Kern = zscale / (zscale + (self.epssfcs*self.hbls_old[j]))\\n else:\\n Kern = 1.\\n \\n\\n\\n self.Kern[j,k_w] = Kern\\n self.FC[j,k_w] = self.FC[j,k_w+1] + Kern * (\\\\\\n ( ( u[j,k_r+1] - u[j,k_r] )**2 + ( v_upts[j,k_r+1] - v_upts[j,k_r])**2 ) \\\\\\n / (Hz[j,k_r] + Hz[j,k_r+1]) \\\\\\n - 0.5 * ( Hz[j,k_r] + Hz[j,k_r+1]) * (self.Ri_inv * self.bvf[j,k_w] + self.C_Ek*self.f[j]*self.f[j]))\\n\\n\\n #\\t\\tLOOP THAT FINDS BL DEPTH ##\\n #----> LOOP TOP TO BOTTOM (start at free surface, w-level surface) \\n \\n if self.LMD_KPP:\\n #swdk_r only used in this function so don't need to be class attribute\\n # but for testing make it an attribute to see what it is\\n \\n # fortran equivlanet ===> k=N,1,-1 \\n for k in range(N,0,-1):\\n # INDEX MAP\\n k_r = k-1\\n k_w = k\\n\\n ###################################################################### \\n self.swdk_r[j,k_w] = np.sqrt( self.swr_frac[j,k_w] * self.swr_frac[j,k_w-1])\\n zscale = z_u_w[j,N] - z_u_r[j,k_r]\\n Bfsfc = self.Bo[j] + self.Bosol[j] * (1-self.swdk_r[j,k_w])\\n \\n self.bvf_max = np.sqrt(np.max([0,self.bvf[j,k_w-1]]))\\n \\n # CALCULATE TURBULENT VELOCITY SCALE FOR TRACERS\\n \\t\\t\\t self.ws = self.lmd_wscale_ws_only(Bfsfc, zscale,self.hbls_old[j],self.ustar[j])\\n \\n self.Vtsq = self.Vtc * self.ws* self.bvf_max + self.V0\\n \\n\\n self.Cr[j,k_w] = self.FC[j,k_w] + self.Vtsq\\n \\n\\n #######################################################################\\n \\n # SEARCH FOR hbls vertical level #\\n '''\\n kbl is specified at vertical w-level (via Cr which is at\\n vertical w-levels)\\n '''\\n if self.kbl[j] == 0 and self.Cr[j,k_w] < 0:\\n self.kbl[j] = k_w\\n if self.LIMIT_MO_DEPTH:\\n if self.kmo[j] == 0 and Bfsfc*(z_u_w[j,N] - z_u_r[j,k_r]) > self.C_h_MO[j]:\\n self.kmo[j] = k_w\\n\\n \\n #--> still in j-loop\\n #######################################################\\n \\n # \\t\\tGET SURFACE BOUNDARY LAYER DEPTH # \\n self.hbls[j] = z_u_w[j,N] - z_u_w[j,0] + self.eps # set hbls as depth of entire water column\\n if self.kbl[j] > 0:\\n k_w = self.kbl[j]\\n k_r = k_w - 1 \\n if k_w == N: # set hbls at the surface btwn w- and rho-levels at surface\\n self.hbls[j] = z_u_w[j,N] - z_u_r[j,N-1]\\n \\n else:\\n self.hbls[j] = z_u_w[j,N] - ( z_u_r[j,k_r] * self.Cr[j,k_w+1] - z_u_r[j,k_r+1] * self.Cr[j,k_w]) / \\\\\\n (self.Cr[j,k_w+1] - self.Cr[j,k_w])\\n \\n if self.LIMIT_MO_DEPTH:\\n if self.kmo[j] > 0:\\n k_w = self.kmo[j]\\n k_r = k_w-1\\n if k_w == N:\\n z_up = z_u_w[j,N]\\n cff_up = np.max([0,Bo[j]])\\n else:\\n z_up = z_r[j,k_w+1]\\n cff_up = np.max([0, Bo[j] + self.Bosol[j]*(1-self.swdk_r[j,(k_w-1)+1])])\\n \\n cff_dn = np.max([0,Bo[j] + self.Bosol[j] * (1-self.swdk_r[j,k_w])]) \\n h_MO = z_u_w[j,N] + self.C_h_MO[j] * ( cff_up*z_up - cff_dn * z_u_r[j,k_r] ) \\\\\\n / ( cff_up * cff_dn * (z_up - z_u_r[j,k_r]) ) \\\\\\n + self.C_h_MO[j] * (cff_dn - cff_up)\\n\\n self.hbls[j] = np.min([self.hbls[j],np.max([h_MO,0])])\\n\\n\\n\\n #### GET BOTTOM BOUNDARY LAYER DEPTH #######\\n if self.LMD_BKPP:\\n self.kbl[j] = 0 # reset Cr at bottom and kbl for BKPP\\n self.Cr[j,0] = 0.\\n self.FC[j,0] = 1.5 * self.FC[j,1] - 0.5 * self.FC[j,2] # linear extrapolation\\n \\n #---> LOOP BOTTOM TO TOP\\n # FIND kbl for BBL\\n for k in range(1,N+1):\\n k_r = k-1\\n k_w = k \\n self.Cr[j,k_w] = self.FC[j,k_w] - self.FC[j,0]\\n \\n # LOOK FOR FIRST ZERO CROSSING FROM BOTTOM UP\\n if self.kbl[j] == 0 and self.Cr[j,k_w] > 0:\\n self.kbl[j] = k_w \\n \\n\\n self.hbbl[j] = z_u_w[j,N] - z_u_w[j,0] # total depth\\n if self.kbl[j] > 0 :\\n k_w = self.kbl[j] \\n k_r = k_w -1\\n if k_w == 1: # NO BBL CASE\\n self.hbbl[j] = z_u_r[j,0] - z_u_w[j,0] #in between bottom rho and w-level\\n else:\\n self.hbbl[j] = ( z_u_r[j,k_r-1] * self.Cr[j,k_w] - z_u_r[j,k_r] * self.Cr[j,k_w-1]) / \\\\\\n (self.Cr[j,k_w] - self.Cr[j,k_w-1]) - z_u_w[j,0]\",\n \"def process_labels(ctx, tex, chapter):\\n headings = ['chapter'] + ['sub'*i + 'section' for i in range(4)]\\n reh = r'(' + '|'.join(headings) + r'){(.+?)}'\\n environments = ['thm', 'lem', 'exc', 'figure', 'equation']\\n ree = r'begin{(' + '|'.join(environments) + r')}'\\n rel = r'(\\\\w+)label{(.+?)}'\\n rel2 = r'label{(.+?)}'\\n bigone = r'\\\\\\\\({})|\\\\\\\\({})|\\\\\\\\({})|\\\\\\\\(caption)|\\\\\\\\({})'.format(reh, ree, rel, rel2)\\n rx = re.compile(bigone)\\n\\n sec_ctr = [chapter] + [0]*(len(headings))\\n env_ctr = [0]*len(environments)\\n blocks = catlist()\\n lastlabel = None\\n lastidx = 0\\n m = rx.search(tex, lastidx)\\n while m:\\n blocks.append(tex[lastidx:m.start()])\\n lastidx = m.start()\\n cmd = next_command(tex, lastidx)\\n lastidx = cmd.end\\n if m.group(2):\\n # This is a sectioning command (chapter, subsection,...)\\n name = m.group(2)\\n i = headings.index(name)\\n if i == 0:\\n env_ctr = [0]*len(env_ctr)\\n sec_ctr[i:] = [sec_ctr[i]+1]+[0]*(len(headings)-i-1)\\n number = \\\".\\\".join([str(x) for x in sec_ctr[:i+1]])\\n idd = \\\"{}:{}\\\".format(name, number)\\n lastlabel = idd\\n blocks.append(\\\"<a id='{}'></a>\\\".format(idd))\\n\\n title = '{} {}'.format(number, cmd.args[0])\\n blocks.append(r'\\\\{}{{{}}}'.format(name, title))\\n\\n elif m.group(5):\\n # This is an environment (thm, lem, ...)\\n name = m.group(5)\\n lastenv = name # save this for a caption command coming later...\\n i = environments.index(name)\\n env_ctr[i] += 1\\n number = \\\"{}.{}\\\".format(sec_ctr[0], env_ctr[i])\\n idd = \\\"{}:{}\\\".format(name, number)\\n lastlabel = idd\\n blocks.append(\\\"<a id='{}'></a>\\\".format(idd))\\n\\n if name in ctx.theoremlike_environments:\\n nicename = ctx.named_entities[name]\\n title = '{} {}'.format(nicename, number)\\n blocks.append(r'\\\\begin{{{}}}[{}]'.format(name, title))\\n else:\\n blocks.append(r'\\\\begin{{{}}}'.format(name))\\n\\n elif m.group(6):\\n # This is a labelling command (\\\\thmlabel, \\\\seclabel,...)\\n label = \\\"{}:{}\\\".format(m.group(7), m.group(8))\\n ctx.label_map[label] = (ctx.outputfile, lastlabel)\\n\\n elif m.group(9):\\n # This is a caption command\\n name = lastenv\\n i = environments.index(name)\\n number = \\\"{}.{}\\\".format(sec_ctr[0], env_ctr[i])\\n idd = \\\"{}:{}\\\".format(name, number)\\n lastlabel = idd\\n nicename = ctx.named_entities[name]\\n title = '<span class=\\\"title\\\">{} {}</span>'.format(nicename, number)\\n text = '{} {}'.format(title, cmd.args[0])\\n blocks.append(r'\\\\caption{{{}}}'.format(text))\\n\\n elif m.group(10):\\n # This is a \\\\label command, probably the target of a pageref\\n idd = gen_unique_id()\\n blocks.append(\\\"<a id={}></a>\\\".format(idd))\\n ctx.label_map[m.group(11)] = (ctx.outputfile, idd)\\n\\n m = rx.search(tex, lastidx)\\n blocks.append(tex[lastidx:])\\n return \\\"\\\".join(blocks)\",\n \"def simple_core(block,cut,laser):\\r\\n\\r\\n\\tlayers = int(block[\\\"thickness\\\"]/laser[\\\"z_spacing\\\"])\\r\\n\\r\\n\\t#Since all cuts are square, the offsets are more obvious than in the general linear case.\\r\\n\\ttaper = math.tan(math.radians(laser[\\\"kerf_angle\\\"]/2)) * laser[\\\"z_spacing\\\"]\\r\\n\\tmax_delta = math.tan(math.radians(laser[\\\"kerf_angle\\\"]/2)) * (block[\\\"thickness\\\"] + laser[\\\"z_final_overshoot\\\"]) * 2\\r\\n\\t\\r\\n\\tcutlist = []\\r\\n\\tcutlist.append([\\\"a_abs\\\", \\\"0\\\"])\\r\\n\\tcutlist.append([\\\"c_abs\\\", str(block[\\\"physical_rotation\\\"])])\\r\\n\\tcutlist.append([\\\"z_abs\\\", str(block[\\\"thickness\\\"])])\\r\\n\\r\\n\\tfor a in range(layers):\\r\\n\\t\\tx1, y1 = cut[\\\"final_dimension_x\\\"]/2 + a*taper, cut[\\\"final_dimension_y\\\"]/2 + a*taper\\r\\n\\t\\twhile abs(x1-cut[\\\"final_dimension_x\\\"]/2) < abs(max_delta):\\r\\n\\t\\t\\tcutlist.append([\\\"jump\\\", str(x1 + block[\\\"origin_x\\\"]), str(y1 + block[\\\"origin_y\\\"])])\\r\\n\\t\\t\\tcutlist.append([\\\"mark\\\", str(x1 + block[\\\"origin_x\\\"]), str(-y1 + block[\\\"origin_y\\\"])])\\r\\n\\t\\t\\tcutlist.append([\\\"mark\\\", str(-x1 + block[\\\"origin_x\\\"]), str(-y1 + block[\\\"origin_y\\\"])])\\r\\n\\t\\t\\tcutlist.append([\\\"mark\\\", str(-x1 + block[\\\"origin_x\\\"]), str(y1 + block[\\\"origin_y\\\"])])\\r\\n\\t\\t\\tcutlist.append([\\\"mark\\\", str(x1 + block[\\\"origin_x\\\"]), str(y1 + block[\\\"origin_y\\\"])])\\r\\n\\t\\t\\tx1, y1 = x1 + laser[\\\"xy_spacing\\\"], y1 + laser[\\\"xy_spacing\\\"]\\r\\n\\t\\tcutlist.append([\\\"z_step\\\", str(-laser[\\\"z_spacing\\\"])])\\r\\n\\t\\tmax_delta = max_delta - taper \\r\\n\\treturn json.dumps(cutlist)\",\n \"def LabelDisks(self):\\n pass\",\n \"def split2(self, eccMap, patchName='patch00', cutStep=1, borderWidth=2, isplot=False):\\r\\n minMarker = localMin(eccMap, cutStep)\\r\\n\\r\\n connectivity = np.array([[1, 1, 1], [1, 1, 1], [1, 1, 1]])\\r\\n\\r\\n newLabel = sm.watershed(eccMap, minMarker, connectivity=connectivity, mask=self.array)\\r\\n\\r\\n border = ni.binary_dilation(self.array).astype(np.int8) - self.array\\r\\n\\r\\n for i in range(1, np.amax(newLabel) + 1):\\r\\n currArray = np.zeros(self.array.shape, dtype=np.int8)\\r\\n currArray[newLabel == i] = 1\\r\\n currBorder = ni.binary_dilation(currArray).astype(np.int8) - currArray\\r\\n border = border + currBorder\\r\\n\\r\\n border[border > 1] = 1\\r\\n border = sm.skeletonize(border)\\r\\n\\r\\n if borderWidth > 1:\\r\\n border = ni.binary_dilation(border, iterations=borderWidth - 1).astype(np.int8)\\r\\n\\r\\n newPatchMap = ni.binary_dilation(self.array).astype(np.int8) * (-1 * (border - 1))\\r\\n\\r\\n labeledNewPatchMap, patchNum = ni.label(newPatchMap)\\r\\n\\r\\n # if patchNum != np.amax(newLabel):\\r\\n # print 'number of patches: ', patchNum, '; number of local minimum:', np.amax(newLabel)\\r\\n # raise ValueError, \\\"Number of patches after splitting does not equal to number of local minimum!\\\"\\r\\n\\r\\n newPatchDict = {}\\r\\n\\r\\n for j in range(1, patchNum + 1):\\r\\n\\r\\n currPatchName = patchName + '.' + str(j)\\r\\n currArray = np.zeros(self.array.shape, dtype=np.int8)\\r\\n currArray[labeledNewPatchMap == j] = 1\\r\\n currArray = currArray * self.array\\r\\n\\r\\n if np.sum(currArray[:]) > 0:\\r\\n newPatchDict.update({currPatchName: Patch(currArray, self.sign)})\\r\\n\\r\\n if isplot:\\r\\n plt.figure()\\r\\n plt.subplot(121)\\r\\n plt.imshow(self.array, interpolation='nearest')\\r\\n plt.title(patchName + ': before split')\\r\\n plt.subplot(122)\\r\\n plt.imshow(labeledNewPatchMap, interpolation='nearest')\\r\\n plt.title(patchName + ': after split')\\r\\n\\r\\n return newPatchDict\",\n \"def __init__(self, smoothing=0.1):\\n super(LabelSmoothing, self).__init__()\\n self.confidence = 1.0 - smoothing\\n self.smoothing = smoothing\",\n \"def hilfe(self):\\n toto_hilfe(3)\",\n \"def identify_leaflets(u, time_ts):\\n z = u.select_atoms(\\\"all\\\").center_of_geometry()[2]\\n COM_z= np.array([0,0,z]) #defines the global midplane position along z\\n x, y, z = u.trajectory.ts.triclinic_dimensions[0][0], u.trajectory.ts.triclinic_dimensions[1][1], u.trajectory.ts.triclinic_dimensions[2][2]\\n box = np.array([x, y, z, 90, 90, 90]) \\n ### Determining side of the bilayer CHOL belongs to in this frame\\n lipid1 = 'CHL'\\n lipid2 = 'DLIP'\\n lipid3 = 'SSM'\\n lipid4 = 'DSPC'\\n \\n lpd1_atoms = u.select_atoms('resname %s and name O2'%lipid1) \\n lpd2_atoms = u.select_atoms('resname %s and name P '%lipid2) \\n lpd3_atoms = u.select_atoms('resname %s and name P '%lipid3) \\n lpd4_atoms = u.select_atoms('resname %s and name P '%lipid4)\\n \\n num_lpd2 = lpd2_atoms.n_atoms\\n num_lpd3 = lpd3_atoms.n_atoms\\n num_lpd4 = lpd4_atoms.n_atoms \\n # atoms in the upper leaflet as defined by insane.py or the CHARMM-GUI membrane builders\\n # select cholesterol headgroups within 1.5 nm of lipid headgroups in the selected leaflet\\n # this must be done because CHOL rapidly flip-flops between leaflets\\n # so we must assign CHOL to each leaflet at every time step, and in large systems\\n # with substantial membrane undulations, a simple cut-off in the z-axis just will not cut it\\n if side == 'up':\\n lpd2i = lpd2_atoms[:int((num_lpd2)/2)]\\n lpd3i = lpd3_atoms[:int((num_lpd3)/2)]\\n lpd4i = lpd4_atoms[:int((num_lpd4)/2)]\\n \\n\\n lipids = lpd2i + lpd3i + lpd4i \\n\\n ns_lipids = NS.AtomNeighborSearch(lpd1_atoms, box=box) \\n lpd1i = ns_lipids.search(lipids,15.0) #1.5 nm\\n leaflet = lpd1i + lpd2i + lpd3i + lpd4i \\n\\n elif side == 'down':\\n lpd2i = lpd2_atoms[int((num_lpd2)/2):]\\n lpd3i = lpd3_atoms[int((num_lpd3)/2):]\\n lpd4i = lpd4_atoms[int((num_lpd4)/2):]\\n\\n lipids = lpd2i + lpd3i + lpd4i #+ lpd3i\\n \\n ns_lipids = NS.AtomNeighborSearch(lpd1_atoms, box=box)\\n lpd1i = ns_lipids.search(lipids,15.0) # 1.5nm\\n leaflet = lpd1i + lpd2i + lpd3i+ lpd4i \\n return lpd1i, lpd2i, lpd3i, lpd4i, COM_z, box, leaflet\",\n \"def cmd_label_merged_boundaries(self,sun_dir,output_dir=None):\\n sun=sunreader.SunReader(sun_dir)\\n if output_dir is None:\\n # defaults location of dense output\\n output_dir=os.path.join(sun.datadir,'dwaq',\\\"global-dense\\\")\\n \\n hyd_fn=glob.glob(os.path.join(output_dir,'*.hyd'))[0]\\n \\n hydro=SunHydro(sun=sun,hyd_path=hyd_fn,flow_shps=[self.flows_shp])\\n\\n class SpliceScenario(waq_scenario.Scenario):\\n base_path=output_dir\\n name=\\\"spliced\\\"\\n\\n scen=SpliceScenario(hydro=hydro)\\n\\n self.log.info(\\\"Writing labels\\\")\\n scen.hydro.write_boundary_links()\",\n \"def __init__(self, smoothing=0.0):\\n super(LabelSmoothing, self).__init__()\\n self.confidence = 1.0 - smoothing\\n self.smoothing = smoothing\",\n \"def __init__(self, smoothing=0.0):\\n super(LabelSmoothing, self).__init__()\\n self.confidence = 1.0 - smoothing\\n self.smoothing = smoothing\",\n \"def make_stehle(self):\\n\\n temp_k = self.temp * e / k # temperature in K\\n dens_cm = self.e_dens * 1.e-6 # electronic density in cm-3\\n prefix = 'n_' + str(self.n_upper) + '_' + str(self.n_lower) + '_'\\n\\n # extract raw tabulated tabulated_data\\n tab_temp_k = np.array(pystark.nc.variables[prefix + 'tempe'].data) # tabulated electron temperatures (K)\\n olam0 = pystark.nc.variables[prefix + 'olam0'].data # line centre wavelength (A)\\n num_tab_dens = pystark.nc.variables[prefix + 'id_max'].data\\n fainom = pystark.nc.variables[prefix + 'fainom'].data\\n tab_dens_cm = np.array(pystark.nc.variables[prefix + 'dense'].data) # tabulated electron densities (cm ** -3)\\n f00 = np.array(pystark.nc.variables[prefix + 'f00'].data) # normal Holtsmark field strength (30 kV / m)\\n dl12 = np.array(pystark.nc.variables[prefix + 'dl12'].data)\\n dl12s = np.array(pystark.nc.variables[prefix + 'dl12s'].data)\\n fainu = pystark.nc.variables[\\n prefix + 'fainu'].data # Asymptotic value of iStark * (alpha ** 2.5) (\\\"wings factor in alfa units\\\")\\n pr0 = np.array(pystark.nc.variables[\\n prefix + 'pr0'].data) # Ratio of the mean interelectronic distance to the electronic Debye length\\n jtot = np.array(pystark.nc.variables[prefix + 'jtot'].data,\\n dtype=np.int) # \\\"number of wave lengths for the couple (T,Ne)\\\"\\n dom = np.array(pystark.nc.variables[prefix + 'dom'].data) # frequency detunings in units (rad / (s*ues)\\n d1om = np.array(pystark.nc.variables[prefix + 'd1om'].data)\\n o1line = np.array(pystark.nc.variables[prefix + 'o1line'].data)\\n o1lines = np.array(pystark.nc.variables[prefix + 'o1lines'].data)\\n\\n # ensure given temperature + density falls within tabulated values\\n # change sligtly the value of the input density\\n # dens_cm in order to remain , as far as possible, inside the tabulation\\n # JSA: this first step seems bogus!\\n\\n if np.abs(dens_cm - tab_dens_cm[0]) / dens_cm <= 1.0E-3:\\n dens_cm = tab_dens_cm[0] * 1.001\\n\\n for id in np.arange(1, num_tab_dens + 1):\\n if np.abs(dens_cm - tab_dens_cm[id]) / dens_cm <= 1.0E-3:\\n dens_cm = tab_dens_cm[id] * 0.999\\n\\n if dens_cm >= 2.0 * tab_dens_cm[num_tab_dens]:\\n raise Exception(\\n 'Your input density is higher than the largest tabulated value %f' % tab_dens_cm[num_tab_dens])\\n\\n if dens_cm <= tab_dens_cm[0]:\\n raise Exception('Your input density is smaller than the smallest tabulated value %f' % tab_dens_cm[0])\\n\\n if temp_k >= tab_temp_k[9]:\\n raise Exception('Your input temperature is higher than the largest tabulated value %f' % tab_temp_k[9])\\n\\n if temp_k <= tab_temp_k[0]:\\n raise Exception('Your input temperature is lower than the smallest tabulated value %f' % tab_temp_k[0])\\n\\n normal_holtsmark_field = 1.25e-9 * (dens_cm ** (2. / 3.)) # normal field value in ues\\n\\n # calculate line centre wavelength and frequency using Rydberg formula\\n # JSA: I have made this step clearer and corrected for deuteron mass in the Rydberg constant (though the effect is small)\\n # TODO make sure this matches olam0 parameter above -- why were there two variables in the first place?!\\n # rydberg_m = Rydberg / (1. + (electron_mass / physical_constants['deuteron mass'][0]))\\n # wl_0_angst = 1e10 * (rydberg_m * (1 / n_lower ** 2 - 1 / n_upper ** 2)) ** -1\\n\\n wl_centre_angst = self.wl_centre * 1e10\\n\\n c_angst = c * 1e10 # velocity of light in Ansgtroms / s\\n angular_freq_0 = 2 * np.pi * c_angst / wl_centre_angst # rad / s\\n\\n otrans = -2 * np.pi * c_angst / wl_centre_angst ** 2\\n\\n olines = o1lines / np.abs(otrans)\\n oline = o1line / np.abs(otrans)\\n\\n # Limit analysis_tools to uncorrelated plasmas.\\n # check that mean interelectronic distance is smaller than the electronic Debye length (equ. 10)\\n PR0_exp = 0.0898 * (dens_cm ** (1. / 6.)) / np.sqrt(temp_k) # = (r0 / debye)\\n if PR0_exp > 1.:\\n raise Exception('The plasma is too strongly correlated\\\\ni.e. r0/debye=0.1\\\\nthe line cannot be computed.')\\n\\n # fainom_exp=fainom*(F00_exp**1.5)\\n # fainum_exp=fainom_exp/( (OPI*2.)**1.5)\\n\\n # ========================\\n # TABULATION Format CDS\\n # si on veut ecrire\\n # n -np lambda0 kalpha Ne E0 T R0/Debye Dalpha iDoppler iStark\\n\\n # IN_cds= N+0.01\\n # INP_cds = NP+0.01\\n\\n # ***********************************************************\\n # Don't edit the CDS format...\\n # ***********************************************************\\n\\n # Skipped the code in the IF statement starting at line 470, since it\\n # isn't used, if (.FALSE.) ...\\n\\n # ==============================================\\n # define an unique detunings grid - domm - for the tabulated\\n # profiles ( various temperatures , densities)\\n # calculate all the line shapes for this common grid\\n # units used at this points are Domega_new= Delta(omega)/F00\\n # in rd/(s-1 ues)\\n\\n max_num_dens = 30 # Maximum number of densities\\n max_num_tab_temp = 10\\n max_num_detunings = 60 # Maximum number of detunings\\n jtot = jtot.astype(np.int)\\n domm = np.zeros(100000)\\n dom0 = np.zeros(10000)\\n tprof = np.zeros([max_num_dens, max_num_tab_temp, 10000])\\n tprofs = np.zeros([max_num_dens, max_num_tab_temp, 10000])\\n uprof = np.zeros([max_num_dens, 10000])\\n uprofs = np.zeros([max_num_dens, 10000])\\n\\n inc = 0\\n domm[inc] = 0.0\\n # ---- Look to replace this loop\\n for id in np.arange(num_tab_dens + 1): # loop over tab densities\\n for j in np.arange(max_num_tab_temp): # loop over tab temperatures (?)\\n for i in np.arange(1, jtot[id, j]):\\n inc += 1\\n dom0[inc] = dom[id, j, i]\\n\\n inc = np.count_nonzero(dom)\\n npik = inc + 1\\n # nut=10000\\n\\n # Calling numpy sort instead of piksrt\\n tmp = np.sort(dom0[0:npik])\\n dom0[0:npik] = tmp[0:npik]\\n # dom0 seems to agree with the FORTRAN version\\n\\n inc = 0\\n domm[0] = 0.0\\n # print 'npik',npik\\n # ---- Look to replace this loop\\n for i in np.arange(1, npik):\\n dif = (dom0[i] - dom0[i - 1])\\n if dif <= 1.0E-6:\\n continue\\n if dif / np.abs(dom0[i]) <= 0.1:\\n continue\\n inc = inc + 1\\n domm[inc] = dom0[i]\\n\\n jdom = inc + 1 # One line after marker 35\\n\\n for id in np.arange(num_tab_dens):\\n for j in np.arange(10):\\n if pr0[id, j] > 1.0:\\n continue\\n\\n tprof[id, j, 0] = oline[id, j, 0]\\n tprofs[id, j, 0] = olines[id, j, 0]\\n\\n if jtot[id, j] == 0:\\n continue\\n\\n for i in np.arange(1, jdom + 1):\\n skip1 = False\\n skip2 = False\\n # print 'i',i\\n domeg = domm[i]\\n ij_max = jtot[id, j]\\n # print 'domeg,ij_max',domeg,ij_max\\n for ij in np.arange(1, ij_max - 1):\\n # print 'ij',ij\\n test = (domeg - dom[id, j, ij]) * (domeg - dom[id, j, ij - 1])\\n # print 'test1:',test\\n if test <= 0.0:\\n # print 'triggered test1'\\n x1 = dom[id, j, ij - 1]\\n x2 = dom[id, j, ij]\\n x3 = dom[id, j, ij + 1]\\n y1 = oline[id, j, ij - 1]\\n y2 = oline[id, j, ij]\\n y3 = oline[id, j, ij + 1]\\n # print 'x1,x2,x3',x1,x2,x3\\n # print 'y1,y2,y3',y1,y2,y3\\n tprof[id, j, i] = pystark.FINTRP(x1, x2, x3, y1, y2, y3, domeg)\\n y1 = olines[id, j, ij - 1]\\n y2 = olines[id, j, ij]\\n y3 = olines[id, j, ij + 1]\\n tprofs[id, j, i] = pystark.FINTRP(x1, x2, x3, y1, y2, y3, domeg)\\n # print 'tprof[id,j,i]',tprof[id,j,i]\\n # print 'tprofs[id,j,i]',tprofs[id,j,i]\\n skip1 = True\\n skip2 = True\\n break\\n\\n if skip1 is False:\\n test = (domeg - dom[id, j, ij_max - 2]) * (domeg - dom[id, j, ij_max - 1])\\n # print 'test2:',test\\n # print 'domeg',domeg\\n # print 'dom[id,j,ij_max-1]',dom[id,j,ij_max-2]\\n # print 'dom[id,j,ij_max]',dom[id,j,ij_max-1]\\n if test <= 0.0:\\n # print 'triggered test2'\\n x1 = dom[id, j, ij_max - 3]\\n x2 = dom[id, j, ij_max - 2]\\n x3 = dom[id, j, ij_max - 1]\\n y1 = oline[id, j, ij_max - 3]\\n y2 = oline[id, j, ij_max - 2]\\n y3 = oline[id, j, ij_max - 1]\\n tprof[id, j, i] = pystark.FINTRP(x1, x2, x3, y1, y2, y3, domeg)\\n y1 = olines[id, j, ij_max - 3]\\n y2 = olines[id, j, ij_max - 2]\\n y3 = olines[id, j, ij_max - 1]\\n tprofs[id, j, i] = pystark.FINTRP(x1, x2, x3, y1, y2, y3, domeg)\\n skip2 = True\\n # print 'x1,x2,x3',x1,x2,x3\\n # print 'y1,y2,y3',y1,y2,y3\\n # print 'tprof[id,j,i]',tprof[id,j,i]\\n # print 'tprofs[id,j,i]',tprofs[id,j,i]\\n continue\\n\\n if skip2 is False:\\n if domeg > dom[id, j, ij_max]:\\n # print 'triggered test3'\\n tprof[id, j, i] = fainom / (domeg ** 2.5)\\n tprofs[id, j, i] = tprof[id, j, i]\\n continue\\n\\n # We can skip writing the intermediate file\\n\\n\\n for id in np.arange(num_tab_dens):\\n otest_dens = (dens_cm - tab_dens_cm[id]) * (dens_cm - tab_dens_cm[id + 1])\\n if otest_dens <= 0.0:\\n dense1 = tab_dens_cm[id]\\n dense2 = tab_dens_cm[id + 1]\\n id1 = id\\n id2 = id + 1\\n break\\n\\n if dens_cm >= tab_dens_cm[num_tab_dens]:\\n dense1 = tab_dens_cm[num_tab_dens - 1]\\n dense2 = tab_dens_cm[num_tab_dens]\\n id1 = num_tab_dens - 1\\n id2 = num_tab_dens\\n\\n for it in np.arange(10):\\n otest = (temp_k - tab_temp_k[it]) * (temp_k - tab_temp_k[it + 1])\\n if otest <= 0.0:\\n it1 = it\\n it2 = it + 1\\n # pr01 = pr0[id2,it1] # max value of pr0 for T1,T2,dense1,dense2\\n tempe1 = tab_temp_k[it]\\n tempe2 = tab_temp_k[it + 1]\\n break\\n\\n # interpolation in temperature\\n for id in np.arange(id1, id2 + 1):\\n for i in np.arange(jdom):\\n uprof[id, i] = tprof[id, it1, i] + (temp_k - tempe1) * (tprof[id, it2, i] - tprof[id, it1, i]) / (\\n tempe2 - tempe1)\\n uprofs[id, i] = tprofs[id, it1, i] + (temp_k - tempe1) * (tprofs[id, it2, i] - tprofs[id, it1, i]) / (\\n tempe2 - tempe1)\\n\\n delta_lambda = np.zeros(jdom)\\n delta_nu = np.zeros(jdom)\\n wprof_nu = np.zeros(jdom)\\n wprofs_nu = np.zeros(jdom)\\n\\n for i in np.arange(jdom):\\n wprof = uprof[id1, i] + (dens_cm - dense1) * (uprof[id2, i] - uprof[id1, i]) / (dense2 - dense1)\\n wprofs = uprofs[id1, i] + (dens_cm - dense1) * (uprofs[id2, i] - uprofs[id1, i]) / (dense2 - dense1)\\n delta_omega = domm[i] * normal_holtsmark_field\\n delta_nu[i] = delta_omega / (2 * np.pi)\\n delta_lambda[i] = wl_centre_angst * delta_omega / (angular_freq_0 + delta_omega)\\n # print(delta_lambda[i])\\n wprof_nu[i] = (wprof / normal_holtsmark_field) * (2. * np.pi)\\n wprofs_nu[i] = (wprofs / normal_holtsmark_field) * (2. * np.pi)\\n # print '%e %e %e %e' %(delta_lambda[i],delta_nu[i],wprof_nu[i],wprofs_nu[i])\\n\\n delta_lambda2 = np.concatenate((-delta_lambda[::-1], delta_lambda)) + wl_centre_angst # + olam0\\n delta_nu2 = np.concatenate((-delta_nu[::-1], delta_nu))\\n wprof_nu2 = np.concatenate((wprof_nu[::-1], wprof_nu))\\n wprofs_nu2 = np.concatenate((wprofs_nu[::-1], wprofs_nu))\\n\\n # for some reason, i only get a good agreement with the other models if i take the pure Stark broadened Stehle\\n # output and manually convolve it with the Doppler profile -- not sure why...\\n ls_sd = wprofs_nu2\\n\\n # interpolate onto frequency axis\\n ls_sd = np.interp(self.freq_axis, delta_nu2 + self.freq_centre, ls_sd)\\n\\n return ls_sd\",\n \"def _add_labels(self):\\n coords = self['pore.coords']\\n self['pore.front'] = coords[:,0]<(0.1*self._Lx)\\n self['pore.back'] = coords[:,0]>(0.9*self._Lx)\\n self['pore.left'] = coords[:,1]<(0.1*self._Ly)\\n self['pore.right'] = coords[:,1]>(0.9*self._Ly)\\n self['pore.bottom'] = coords[:,2]<(0.1*self._Lz)\\n self['pore.top'] = coords[:,2]>(0.9*self._Lz)\\n bnds = self.pores(labels=['front','back','left','right','bottom','top'])\\n self['pore.boundary'] = False\\n self['pore.boundary'] = bnds\",\n \"def __call__(self, src, label):\\n\\n h, w, _ = src.shape\\n # interp = np.random.randint(0, 5)\\n img = timage.resize_short_within(src, self._short, self._max_size, interp=1)\\n img, flips = timage.random_flip(img, px=0.5)\\n img = img.astype(np.float32)\\n target_list_1 = []\\n target_list_2 = []\\n\\n for k in range(self.teacher_num):\\n if self.teacher_aug:\\n target_image_1 = self.random_color_aug(img)\\n else:\\n target_image_1 = img\\n\\n target_image_2 = self.random_color_aug(img)\\n\\n target_image_1 = mx.nd.image.to_tensor(target_image_1)\\n target_image_1 = mx.nd.image.normalize(target_image_1, mean=self._mean, std=self._std)\\n\\n target_image_2 = mx.nd.image.to_tensor(target_image_2)\\n target_image_2 = mx.nd.image.normalize(target_image_2, mean=self._mean, std=self._std)\\n target_list_1.append(target_image_1)\\n target_list_2.append(target_image_2)\\n target_list_1 = mx.nd.concat(*target_list_1, dim=0)\\n target_list_2 = mx.nd.concat(*target_list_2, dim=0)\\n return target_list_1, target_list_2\",\n \"def _build_ham(self):\\n path = self._solverpath.long_tail()\\n print(path)\\n current, k = self.snake.head(), 0\\n for direc in path:\\n self.information[current.x][current.y].idx = k\\n self.information[current.x][current.y].direc = direc\\n current = current.adj(direc)\\n k += 1\\n # Process snake bodies\\n current = self.snake.tail()\\n for _ in range(self.snake.len() - 1):\\n self.information[current.x][current.y].idx = k\\n self.information[current.x][current.y].direc = self.snake.direc\\n current = current.adj(self.snake.direc)\\n k += 1\",\n \"def tagview(tab,label,x,y):\\r\\n font = cv2.FONT_HERSHEY_SIMPLEX\\r\\n col=classifc[label]\\r\\n labnow=classif[label]\\r\\n# print (labnow, text)\\r\\n if label == 'back_ground':\\r\\n deltay=30\\r\\n else:\\r\\n# deltay=25*((labnow-1)%5)\\r\\n deltay=40+10*(labnow-1)\\r\\n\\r\\n viseg=cv2.putText(tab,label,(x, y+deltay), font,0.3,col,1)\\r\\n return viseg\",\n \"def split(self, eccMap, patchName='patch00', cutStep=1, borderWidth=2, isplot=False):\\r\\n minMarker = localMin(eccMap, cutStep)\\r\\n\\r\\n plt.figure()\\r\\n plt.imshow(minMarker, vmin=0, interpolation='nearest')\\r\\n plt.colorbar()\\r\\n plt.title('markers 1')\\r\\n plt.show()\\r\\n\\r\\n minMarker = minMarker.astype(np.int32)\\r\\n selfArray = self.array.astype(np.int32)\\r\\n minMarker = minMarker + 1\\r\\n minMarker[minMarker == 1] = 0\\r\\n minMarker = minMarker + (-1 * (selfArray - 1))\\r\\n # minMarker: marker type for opencv watershed,\\r\\n # sure background = 1\\r\\n # unknow = 0\\r\\n # sure forgrand = 2,3,4... etc\\r\\n\\r\\n plt.figure()\\r\\n plt.imshow(minMarker, vmin=0, interpolation='nearest')\\r\\n plt.colorbar()\\r\\n plt.title('markers 2')\\r\\n plt.show()\\r\\n\\r\\n eccMapNor = (np.round(ia.array_nor(eccMap) * 255)).astype(np.uint8)\\r\\n eccMapRGB = cv2.cvtColor(eccMapNor, cv2.COLOR_GRAY2RGB)\\r\\n # eccMapRGB: image type for opencv watershed, RGB, [uint8, uint8, uint8]\\r\\n\\r\\n newLabel = cv2.watershed(eccMapRGB, minMarker)\\r\\n\\r\\n plt.figure()\\r\\n plt.imshow(newLabel, vmin=0, interpolation='nearest')\\r\\n plt.colorbar()\\r\\n plt.title('markers 3')\\r\\n plt.show()\\r\\n\\r\\n newBorder = np.zeros(newLabel.shape).astype(np.int)\\r\\n\\r\\n newBorder[newLabel == -1] = 1\\r\\n\\r\\n border = ni.binary_dilation(self.array).astype(np.int) - self.array\\r\\n\\r\\n border = newBorder + border\\r\\n\\r\\n border[border > 1] = 1\\r\\n\\r\\n border = sm.skeletonize(border)\\r\\n\\r\\n if borderWidth > 1:\\r\\n border = ni.binary_dilation(border, iterations=borderWidth - 1).astype(np.int8)\\r\\n\\r\\n newPatchMap = ni.binary_dilation(self.array).astype(np.int8) * (-1 * (border - 1))\\r\\n\\r\\n labeledNewPatchMap, patchNum = ni.label(newPatchMap)\\r\\n\\r\\n # if patchNum != np.amax(newLabel):\\r\\n # print 'number of patches: ', patchNum, '; number of local minimum:', np.amax(newLabel)\\r\\n # raise ValueError, \\\"Number of patches after splitting does not equal to number of local minimum!\\\"\\r\\n\\r\\n newPatchDict = {}\\r\\n\\r\\n for j in range(1, patchNum + 1):\\r\\n\\r\\n currPatchName = patchName + '.' + str(j)\\r\\n currArray = np.zeros(self.array.shape, dtype=np.int8)\\r\\n currArray[labeledNewPatchMap == j] = 1\\r\\n currArray = currArray * self.array\\r\\n\\r\\n if np.sum(currArray[:]) > 0:\\r\\n newPatchDict.update({currPatchName: Patch(currArray, self.sign)})\\r\\n\\r\\n if isplot:\\r\\n plt.figure()\\r\\n plt.subplot(121)\\r\\n plt.imshow(self.array, interpolation='nearest')\\r\\n plt.title(patchName + ': before split')\\r\\n plt.subplot(122)\\r\\n plt.imshow(labeledNewPatchMap, interpolation='nearest')\\r\\n plt.title(patchName + ': after split')\\r\\n\\r\\n return newPatchDict\",\n \"def do_htt_plots(tree, output_dir, cut=''):\\n for logz in [True, False]:\\n make_2d_plot(tree, 'httRef', HTT_REF_STR, NB_HTT, HTT_MIN, HTT_MAX, 'httL1', HTT_L1_STR, NB_HTT, HTT_MIN, HTT_MAX,\\n os.path.join(output_dir, 'httRef_httL1.pdf'), logz=logz, normx=False,\\n cut=cut, title=TITLE, diagonal_line=True)\\n for normx in [True, False]:\\n make_2d_plot(tree, 'httL1', HTT_L1_STR, NB_HTT, HTT_MIN, HTT_MAX, 'httL1/httRef', HTT_RATIO_STR, NB_HTT_RATIO, HTT_RATIO_MIN, HTT_RATIO_MAX,\\n os.path.join(output_dir, 'httRatio_httL1.pdf'), logz=logz, normx=normx,\\n cut=cut, title=TITLE, horizontal_line=True)\\n make_2d_plot(tree, 'httRef', HTT_REF_STR, NB_HTT, HTT_MIN, HTT_MAX, 'httL1/httRef', HTT_RATIO_STR, NB_HTT_RATIO, HTT_RATIO_MIN, HTT_RATIO_MAX,\\n os.path.join(output_dir, 'httRatio_httRef.pdf'), logz=logz, normx=normx,\\n cut=cut, title=TITLE, horizontal_line=True)\\n\\n make_2d_plot(tree, 'httL1', HTT_L1_STR, NB_HTT, HTT_MIN, HTT_MAX, 'httL1-httRef', HTT_DIFF_STR, NB_HTT_DIFF, HTT_DIFF_MIN, HTT_DIFF_MAX,\\n os.path.join(output_dir, 'httDiff_httL1.pdf'), logz=logz, normx=normx,\\n cut=cut, title=TITLE, horizontal_line=True)\\n make_2d_plot(tree, 'httRef', HTT_REF_STR, NB_HTT, HTT_MIN, HTT_MAX, 'httL1-httRef', HTT_DIFF_STR, NB_HTT_DIFF, HTT_DIFF_MIN, HTT_DIFF_MAX,\\n os.path.join(output_dir, 'httDiff_httRef.pdf'), logz=logz, normx=normx,\\n cut=cut, title=TITLE, horizontal_line=True)\\n make_2d_plot(tree, 'httL1/httRef', HTT_RATIO_STR, NB_HTT_RATIO, HTT_RATIO_MIN, HTT_RATIO_MAX,\\n 'httL1-httRef', HTT_DIFF_STR, NB_HTT_DIFF, HTT_DIFF_MIN, HTT_DIFF_MAX,\\n os.path.join(output_dir, 'httDiff_httRatio.pdf'), logz=logz, normx=normx,\\n cut=cut, title=TITLE, horizontal_line=True)\",\n \"def __init__(self, trg_vocab_size, label_smoothing=0.1, reduction='mean', with_logits=True, ignore_index=0):\\n super(LabelSmoothingLoss, self).__init__()\\n self.with_logits = with_logits\\n self.ignore_index = ignore_index\\n self.kl_divergence = nn.KLDivLoss(reduction=reduction)\\n\\n self._create_one_hot(label_smoothing, trg_vocab_size)\\n self.confidence = 1.0 - label_smoothing\",\n \"def nodules_connection(label_data, label_header):\\n\\n\\n las_labels = measure.label(label_data,\\n neighbors=8,\\n background=0,\\n return_num=True)\\n\\n las_labels_nzero = np.nonzero(las_labels[0])\\n [xdif, ydif, zdif] = [np.amax(las_labels_nzero[0])-np.amin(las_labels_nzero[0]),\\n np.amax(las_labels_nzero[1])-np.amin(las_labels_nzero[1]),\\n np.amax(las_labels_nzero[2])-np.amin(las_labels_nzero[2])]\\n\\n # conversion pixels to mm\\n dims = label_header['pixdim']\\n if label_header['xyzt_units'] == 10:\\n #dimensions in mm\\n print('xyzt_units=10')\\n xdif=dims[1]*xdif\\n ydif=dims[2]*ydif\\n zdif=dims[3]*zdif\\n\\n\\n return las_labels,[xdif,ydif,zdif]\",\n \"def at_s2ncut(self):\\n\\n\\t # Notch out the transit and recompute\\n\\t fmcut = self.fm.copy()\\n\\t fmcut.fill_value=0\\n\\t # Widen by twice the transit duration\\n\\t tmask = self.rLbl['tRegLbl'] >= 0\\n\\t tmask = np.convolve(\\n\\t tmask.astype(float),\\n\\t np.ones(self.header['tdurcad'] * 2),\\n\\t mode='same'\\n\\t )\\n\\t tmask = tmask.astype(bool)\\n\\t fmcut.mask = fmcut.mask | tmask\\n\\t grid = tfind.Grid(self.t,fmcut)\\n\\n\\n\\t pgram_params = [\\n\\t dict(Pcad1=self.Pcad - 1, Pcad2=self.Pcad + 1, twdG = [self.header['tdurcad']])\\n\\t ]\\n\\t pgram = grid.periodogram(pgram_params,mode='max')\\n\\t idxmax = pgram.s2n.idxmax()\\n\\n\\t dkeys = 's2ncut s2ncut_t0 s2ncut_mean'.split()\\n\\t pkeys = 's2n t0 mean'.split()\\n\\n\\t for dkey,pkey in zip(dkeys,pkeys):\\n\\t self.add_attr(dkey,pgram.ix[idxmax,pkey])\",\n \"def at_s2ncut(self):\\n\\n\\t # Notch out the transit and recompute\\n\\t fmcut = self.fm.copy()\\n\\t fmcut.fill_value=0\\n\\t # Widen by twice the transit duration\\n\\t tmask = self.rLbl['tRegLbl'] >= 0\\n\\t tmask = np.convolve(\\n\\t tmask.astype(float),\\n\\t np.ones(self.header['tdurcad'] * 2),\\n\\t mode='same'\\n\\t )\\n\\t tmask = tmask.astype(bool)\\n\\t fmcut.mask = fmcut.mask | tmask\\n\\t grid = tfind.Grid(self.t,fmcut)\\n\\n\\n\\t pgram_params = [\\n\\t dict(Pcad1=self.Pcad - 1, Pcad2=self.Pcad + 1, twdG = [self.header['tdurcad']])\\n\\t ]\\n\\t pgram = grid.periodogram(pgram_params,mode='max')\\n\\t idxmax = pgram.s2n.idxmax()\\n\\n\\t dkeys = 's2ncut s2ncut_t0 s2ncut_mean'.split()\\n\\t pkeys = 's2n t0 mean'.split()\\n\\n\\t for dkey,pkey in zip(dkeys,pkeys):\\n\\t self.add_attr(dkey,pgram.ix[idxmax,pkey])\",\n \"def housing_labels_(strat_train_set):\\n logging.info(\\\"copy of dataset\\\")\\n housing_labels = strat_train_set[\\\"median_house_value\\\"].copy()\\n return housing_labels\",\n \"def addLabels(t):\\n if not t.label:\\n t.label = \\\"\\\".join([choice(\\\"abcdefghijklmnopqrstuvwxyz\\\") for i in range(4)])\\n for r,w in t.children:\\n addLabels(r)\",\n \"def draw_heading(self, heading): \\n\\n heading_label = ttk.Label(self.frame, text=heading, background=\\\"blue\\\",\\n foreground=\\\"white\\\", anchor=CENTER)\\n \\n heading_label.configure(font=('Times', 15, \\\"bold\\\"))\\n heading_label.configure(wraplength=self.width) \\n heading_label.pack(side=TOP, fill=X, ipady=10)\",\n \"def h_t(self, x, t):\\n ret = 0\\n strong_classifier = self.classifiers[0:t+1]\\n for wc in strong_classifier:\\n ret += wc.classify(x)\\n return ret\",\n \"def h_t(self, x, t):\\n ret = 0\\n strong_classifier = self.classifiers[0:t+1]\\n for wc in strong_classifier:\\n ret += wc.classify(x)\\n return ret\",\n \"def encodeToLabels(self, gt_instances):\\n raw_boxes_xyzwhd = np.zeros((self.config_data[\\\"max_boxes_per_frame\\\"], 7))\\n ### initialize gronud truth labels as np.zeors ###\\n gt_labels = np.zeros(list(self.headoutput_shape[1:4]) + \\\\\\n [len(self.anchor_boxes)] + \\\\\\n [len(self.config_data[\\\"all_classes\\\"]) + 7])\\n\\n ### start transferring box to ground turth label format ###\\n for i in range(len(gt_instances[\\\"classes\\\"])):\\n if i > self.config_data[\\\"max_boxes_per_frame\\\"]:\\n continue\\n class_name = gt_instances[\\\"classes\\\"][i]\\n box_xyzwhd = gt_instances[\\\"boxes\\\"][i]\\n class_id = self.config_data[\\\"all_classes\\\"].index(class_name)\\n if i < self.config_data[\\\"max_boxes_per_frame\\\"]:\\n raw_boxes_xyzwhd[i, :6] = box_xyzwhd\\n raw_boxes_xyzwhd[i, 6] = class_id\\n class_onehot = helper.smoothOnehot(class_id, len(self.config_data[\\\"all_classes\\\"]))\\n \\n exist_positive = False\\n\\n grid_strid = self.grid_strides\\n anchor_stage = self.anchor_boxes\\n box_xyzwhd_scaled = box_xyzwhd[np.newaxis, :].astype(np.float32)\\n box_xyzwhd_scaled[:, :3] /= grid_strid\\n anchorstage_xyzwhd = np.zeros([len(anchor_stage), 6])\\n anchorstage_xyzwhd[:, :3] = np.floor(box_xyzwhd_scaled[:, :3]) + 0.5\\n anchorstage_xyzwhd[:, 3:] = anchor_stage.astype(np.float32)\\n\\n iou_scaled = helper.iou3d(box_xyzwhd_scaled, anchorstage_xyzwhd, \\\\\\n self.input_size)\\n ### NOTE: 0.3 is from YOLOv4, maybe this should be different here ###\\n ### it means, as long as iou is over 0.3 with an anchor, the anchor\\n ### should be taken into consideration as a ground truth label\\n iou_mask = iou_scaled > 0.3\\n\\n if np.any(iou_mask):\\n xind, yind, zind = np.floor(np.squeeze(box_xyzwhd_scaled)[:3]).\\\\\\n astype(np.int32)\\n ### TODO: consider changing the box to raw yolohead output format ###\\n gt_labels[xind, yind, zind, iou_mask, 0:6] = box_xyzwhd\\n gt_labels[xind, yind, zind, iou_mask, 6:7] = 1.\\n gt_labels[xind, yind, zind, iou_mask, 7:] = class_onehot\\n exist_positive = True\\n\\n if not exist_positive:\\n ### NOTE: this is the normal one ###\\n ### it means take the anchor box with maximum iou to the raw\\n ### box as the ground truth label\\n anchor_ind = np.argmax(iou_scaled)\\n xind, yind, zind = np.floor(np.squeeze(box_xyzwhd_scaled)[:3]).\\\\\\n astype(np.int32)\\n gt_labels[xind, yind, zind, anchor_ind, 0:6] = box_xyzwhd\\n gt_labels[xind, yind, zind, anchor_ind, 6:7] = 1.\\n gt_labels[xind, yind, zind, anchor_ind, 7:] = class_onehot\\n\\n has_label = False\\n for label_stage in gt_labels:\\n if label_stage.max() != 0:\\n has_label = True\\n gt_labels = [np.where(gt_i == 0, 1e-16, gt_i) for gt_i in gt_labels]\\n return gt_labels, has_label, raw_boxes_xyzwhd\",\n \"def __init__(self, iht_size=4096, num_tilings=8, num_tiles=8):\\n self.iht = tc.IHT(iht_size)\\n self.num_tilings = num_tilings\\n self.num_tiles = num_tiles\",\n \"def horde_step(self, observation):\",\n \"def _make_vbenf_label(chain_parts):\\n\\n # toy label for development: run simple and dijet independently.\\n # simple makes Et cuts on two jets. Independently (sharing possible)\\n # of jets choosean by simple, the dijet\\n # scenario requires a dijet of mass > 900, and opening angle in phi > 2.6\\n\\n assert len(chain_parts) == 1\\n scenario = chain_parts[0]['hypoScenario']\\n assert scenario.startswith('vbenf')\\n args = _args_from_scenario(scenario)\\n if not args:\\n return 'and([]simple([(50et)(70et)])combgen([(2)] dijet([(900djmass, 26djdphi)])))' \\n arg_res = [\\n re.compile(r'(?P<lo>\\\\d*)(?P<key>fbet)(?P<hi>\\\\d*)'),\\n re.compile(r'(?P<lo>\\\\d*)(?P<key>mass)(?P<hi>\\\\d*)'),\\n re.compile(r'(?P<lo>\\\\d*)(?P<key>et)(?P<hi>\\\\d*)'),\\n ]\\n\\n defaults = {\\n 'et': ('101', 'inf'),\\n 'mass': ('800', 'inf'),\\n 'fbet': ('501', 'inf'),\\n }\\n\\n argvals = {}\\n while args:\\n assert len(args) == len(arg_res)\\n arg = args.pop()\\n for r in arg_res:\\n m = r.match(arg)\\n if m is not None:\\n arg_res.remove(r)\\n gd = m.groupdict()\\n key = gd['key']\\n try:\\n lo = float(gd['lo'])\\n except ValueError:\\n lo = defaults[key][0]\\n argvals[key+'lo'] = lo \\n try:\\n hi = float(gd['hi'])\\n except ValueError:\\n hi = defaults[key][1]\\n argvals[key+'hi'] = hi\\n\\n assert len(args) == len(arg_res)\\n assert len(args) == 0\\n\\n return \\\"\\\"\\\"\\n and\\n (\\n []\\n simple\\n (\\n [(%(etlo).0fet, 500neta)(%(etlo).0fet, peta500)]\\n )\\n combgen\\n (\\n [(10et, 0eta320)]\\n dijet\\n (\\n [(%(masslo).0fdjmass, 26djdphi)]\\n ) \\n simple\\n (\\n [(10et, 0eta320)(20et, 0eta320)]\\n )\\n )\\n )\\\"\\\"\\\" % argvals\",\n \"def removeLabel(edge):\\n return edge[:-2]\",\n \"def removeLabel(edge):\\n return edge[:-2]\",\n \"def cutPaper(self, cut='partial', feed=True):\\n if cut not in ['partial', 'full']:\\n raise ValueError('cut must be \\\\'partial\\\\' or \\\\'full\\\\'')\\n elif type(feed) is not bool:\\n raise ValueError('feed must be True or False')\\n else:\\n value = 0 if cut == 'full' else 1\\n value += 65 if feed else 0\\n self._write(self.__class__.__GS + 'V' + chr(value))\",\n \"def resize_label(label):\\n # If current ratio greater than given ratio\\n if label[HEIGHT_INDEX] / label[WIDTH_INDEX] > 1.5:\\n previous = label[WIDTH_INDEX]\\n label[WIDTH_INDEX] = label[HEIGHT_INDEX] / 1.5\\n label[J_INDEX] -= (label[WIDTH_INDEX] - previous) / 2\\n # If current ratio smaller than given ratio\\n else:\\n previous = label[HEIGHT_INDEX]\\n label[HEIGHT_INDEX] = label[WIDTH_INDEX] * 1.5\\n label[I_INDEX] -= (label[HEIGHT_INDEX] - previous) / 2\\n return label\",\n \"def label(gt_dataset, volume_dim, voxel_dim, labeling_params):\\n labeled_volumes = dict()\\n labeled_cells = dict()\\n #Use global density and reduce the size of gt_dataset here\\n global_density = labeling_params[\\\"global_density\\\"]\\n gt_dataset = {k: v for k,v in gt_dataset.items() if random_sample() < global_density}\\n #Label in the order specified in the configuration\\n layers = sorted(labeling_params.keys())\\n #Remove global_density\\n layers.remove(\\\"global_density\\\")\\n for layer in layers:\\n print \\\"Labeling {}\\\".format(layer)\\n fluorophore = labeling_params[layer]['fluorophore']\\n volume, cells = brainbow(gt_dataset, volume_dim, voxel_dim, **labeling_params[layer])\\n if fluorophore in labeled_volumes:\\n labeled_volumes[fluorophore] += volume\\n labeled_cells[fluorophore] |= cells\\n else:\\n labeled_volumes[fluorophore] = volume\\n labeled_cells[fluorophore] = cells\\n return labeled_volumes, labeled_cells\",\n \"def analyze(self, event):\\n jets = Collection(event, \\\"Jet\\\")\\n\\n BTagWeightN = 1.0\\n BTagWeightN_up = 1.0\\n BTagWeightN_down = 1.0\\n BTagWeightN_FS = 1.0\\n BTagWeightN_up_FS = 1.0\\n BTagWeightN_down_FS = 1.0\\n BTagWeightD = 1.0\\n BTagWeightNHeavy = 1.0\\n BTagWeightNHeavy_up = 1.0\\n BTagWeightNHeavy_down = 1.0\\n BTagWeightNHeavy_FS = 1.0\\n BTagWeightNHeavy_up_FS = 1.0\\n BTagWeightNHeavy_down_FS = 1.0\\n BTagWeightDHeavy = 1.0\\n BTagWeightNLight = 1.0\\n BTagWeightNLight_FS = 1.0\\n BTagWeightNLight_up = 1.0\\n BTagWeightNLight_up_FS= 1.0\\n BTagWeightNLight_down = 1.0\\n BTagWeightNLight_down_FS = 1.0\\n BTagWeightDLight = 1.0\\n\\n for jet in jets:\\n pt = jet.pt\\n eta = abs(jet.eta)\\n flavor = jet.hadronFlavour\\n\\n if not ( pt > self.jetPtMin and eta < self.jetEtaMax): continue\\n\\n if flavor == 5:\\n pt_bin = self.h_eff_b.GetXaxis().FindBin(pt); \\n if pt_bin > self.h_eff_b.GetXaxis().GetNbins():\\n pt_bin = self.h_eff_b.GetXaxis().GetNbins(); \\n eta_bin = self.h_eff_b.GetYaxis().FindBin(eta); \\n if eta_bin > self.h_eff_b.GetYaxis().GetNbins():\\n eta_bin = self.h_eff_b.GetYaxis().GetNbins();\\n\\n eff = self.h_eff_b.GetBinContent(pt_bin, eta_bin);\\n\\n elif flavor == 4:\\n pt_bin = self.h_eff_c.GetXaxis().FindBin(pt); \\n if pt_bin > self.h_eff_c.GetXaxis().GetNbins():\\n pt_bin = self.h_eff_c.GetXaxis().GetNbins(); \\n eta_bin = self.h_eff_c.GetYaxis().FindBin(eta); \\n if eta_bin > self.h_eff_c.GetYaxis().GetNbins():\\n eta_bin = self.h_eff_c.GetYaxis().GetNbins();\\n\\n eff = self.h_eff_c.GetBinContent(pt_bin, eta_bin);\\n\\n else:\\n pt_bin = self.h_eff_udsg.GetXaxis().FindBin(pt); \\n if pt_bin > self.h_eff_udsg.GetXaxis().GetNbins():\\n pt_bin = self.h_eff_udsg.GetXaxis().GetNbins(); \\n eta_bin = self.h_eff_udsg.GetYaxis().FindBin(eta); \\n if eta_bin > self.h_eff_udsg.GetYaxis().GetNbins():\\n eta_bin = self.h_eff_udsg.GetYaxis().GetNbins();\\n\\n eff = self.h_eff_udsg.GetBinContent(pt_bin, eta_bin);\\n \\n if self.FastSim:\\n btagSF = jet.btagSF\\n btagSF_FS=jet.btagSF_FS\\n btagSF_up_FS = jet.btagSF_FS_up\\n btagSF_down_FS = jet.btagSF_FS_down\\n btagSF_down = jet.btagSF_down\\n btagSF_up = jet.btagSF_up\\n else:\\n btagSF = jet.btagSF\\n btagSF_FS= 1.0\\n btagSF_up = jet.btagSF_up\\n btagSF_down = jet.btagSF_down\\n btagSF_up_FS = 1.0\\n btagSF_down_FS = 1.0\\n \\n if jet.btagDeepB > self.bDiscCut:\\n #check if eff is zero\\n if eff < 0.001:\\n eff = 0.001\\n \\n BTagWeightN *= btagSF * eff\\n BTagWeightN_FS *= btagSF_FS * eff\\n BTagWeightN_up *= btagSF_up * eff\\n BTagWeightN_down *= btagSF_down * eff\\n BTagWeightN_up_FS *= btagSF_up_FS * eff\\n BTagWeightN_down_FS *= btagSF_down_FS * eff\\n\\n if abs(flavor) == 5:\\n BTagWeightNHeavy *= btagSF * eff\\n BTagWeightNHeavy_FS *= btagSF_FS * eff\\n BTagWeightNHeavy_up *= btagSF_up * eff\\n BTagWeightNHeavy_down *= btagSF_down * eff\\n BTagWeightNHeavy_up_FS *= btagSF_up_FS * eff\\n BTagWeightNHeavy_down_FS *= btagSF_down_FS * eff\\n BTagWeightDHeavy *= eff\\n else:\\n BTagWeightNLight *= btagSF * eff\\n BTagWeightNLight_FS *= btagSF_FS * eff\\n BTagWeightNLight_up *= btagSF_up * eff\\n BTagWeightNLight_down *= btagSF_down * eff\\n BTagWeightNLight_up_FS *= btagSF_up_FS * eff\\n BTagWeightNLight_down_FS *= btagSF_down_FS * eff\\n BTagWeightDLight *= eff\\n\\n BTagWeightD *= eff\\n else:\\n #check if eff is 1.0\\n if eff > 0.999:\\n eff = 0.999\\n\\n BTagWeightN *= 1 - btagSF * eff\\n BTagWeightN_FS *= 1 - btagSF_FS * eff\\n BTagWeightN_up *= 1 - btagSF_up * eff\\n BTagWeightN_down *= 1 - btagSF_down * eff\\n BTagWeightN_up_FS *= 1 - btagSF_up_FS * eff\\n BTagWeightN_down_FS *= 1 - btagSF_down_FS * eff\\n\\n if abs(flavor) == 5:\\n BTagWeightNHeavy *= 1 - btagSF * eff\\n BTagWeightNHeavy_FS *= 1 - btagSF_FS * eff\\n BTagWeightNHeavy_up *= 1 - btagSF_up * eff\\n BTagWeightNHeavy_down *= 1 - btagSF_down * eff\\n BTagWeightNHeavy_up_FS *= 1 - btagSF_up_FS * eff\\n BTagWeightNHeavy_down_FS *= 1 - btagSF_down_FS * eff\\n BTagWeightDHeavy *= 1 - eff\\n else:\\n BTagWeightNLight *= 1 - btagSF * eff\\n BTagWeightNLight_FS *= 1 - btagSF_FS * eff\\n BTagWeightNLight_up *= 1 - btagSF_up * eff\\n BTagWeightNLight_up_FS *= 1 - btagSF_up_FS * eff\\n BTagWeightNLight_down *= 1 - btagSF_down * eff\\n BTagWeightNLight_down_FS *= 1 - btagSF_down_FS * eff\\n BTagWeightDLight *= 1 - eff\\n\\n BTagWeightD *= 1 - eff\\n \\n if self.FastSim:\\n self.out.fillBranch(\\\"BTagWeight_FS\\\", BTagWeightN_FS / BTagWeightD)\\n self.out.fillBranch(\\\"BTagWeight_Up_FS\\\", BTagWeightN_up_FS / BTagWeightD)\\n self.out.fillBranch(\\\"BTagWeight_Down_FS\\\", BTagWeightN_down_FS / BTagWeightD)\\n self.out.fillBranch(\\\"BTagWeightHeavy_FS\\\", BTagWeightNHeavy_FS / BTagWeightDHeavy)\\n self.out.fillBranch(\\\"BTagWeightHeavy_Up_FS\\\", BTagWeightNHeavy_up_FS / BTagWeightDHeavy)\\n self.out.fillBranch(\\\"BTagWeightHeavy_Down_FS\\\", BTagWeightNHeavy_down_FS / BTagWeightDHeavy)\\n self.out.fillBranch(\\\"BTagWeightLight_FS\\\", BTagWeightNLight_FS / BTagWeightDLight)\\n self.out.fillBranch(\\\"BTagWeightLight_Up_FS\\\", BTagWeightNLight_up_FS / BTagWeightDLight)\\n self.out.fillBranch(\\\"BTagWeightLight_Down_FS\\\", BTagWeightNLight_down_FS / BTagWeightDLight)\\n self.out.fillBranch(\\\"BTagWeight\\\", BTagWeightN / BTagWeightD)\\n self.out.fillBranch(\\\"BTagWeight_Up\\\", BTagWeightN_up / BTagWeightD)\\n self.out.fillBranch(\\\"BTagWeight_Down\\\", BTagWeightN_down / BTagWeightD)\\n self.out.fillBranch(\\\"BTagWeightHeavy\\\", BTagWeightNHeavy / BTagWeightDHeavy)\\n self.out.fillBranch(\\\"BTagWeightHeavy_Up\\\", BTagWeightNHeavy_up / BTagWeightDHeavy)\\n self.out.fillBranch(\\\"BTagWeightHeavy_Down\\\", BTagWeightNHeavy_down / BTagWeightDHeavy)\\n self.out.fillBranch(\\\"BTagWeightLight\\\", BTagWeightNLight / BTagWeightDLight)\\n self.out.fillBranch(\\\"BTagWeightLight_Up\\\", BTagWeightNLight_up / BTagWeightDLight)\\n self.out.fillBranch(\\\"BTagWeightLight_Down\\\", BTagWeightNLight_down / BTagWeightDLight)\\n return True\",\n \"def torsion_helix_strain(x, dof):\\n base = np.zeros([6, dof])\\n base[0, 0] = 1 # torsion\\n base[1, 1] = 1 # y-bending\\n base[2, 2] = 1 # z-bending\\n return base\",\n \"def make_cutout_table(ra_in, dec_in, other=None, othername=None, table=(2,7), compare=False, scale_unit='pixscale', scale=0.25, layer='decals-dr7', layer2=None, savefile=None): \\n de_img = []\\n wi_img = []\\n N = table[0]*table[1]\\n \\n for i in range(N):\\n de_cutout_url = 'http://legacysurvey.org/viewer-dev/jpeg-cutout/?ra=%g&dec=%g&%s=%g&layer=%s&size=180' % (ra_in[i],dec_in[i], scale_unit, scale, layer)\\n img = plt.imread(download_file(de_cutout_url,cache=True,show_progress=False,timeout=120))\\n de_img.append(img)\\n \\n if compare:\\n wi_cutout_url = 'http://legacysurvey.org/viewer-dev/jpeg-cutout/?ra=%g&dec=%g&%s=%g&layer=%s&size=180' % (ra_in[i],dec_in[i], scale_unit, scale, layer2)\\n img = plt.imread(download_file(wi_cutout_url,cache=True,show_progress=False,timeout=120))\\n wi_img.append(img)\\n \\n fig = plt.figure(figsize=(4*table[1],4*table[0]))\\n\\n for i in range(len(de_img)):\\n ax = fig.add_subplot(table[0],table[1],i+1)\\n ax.imshow(de_img[i])\\n ax.xaxis.set_major_formatter(NullFormatter())\\n ax.yaxis.set_major_formatter(NullFormatter())\\n if other[i] != None:\\n ax.text(0.1,0.9,'%s=%.1f'%(othername,other[i]),transform=ax.transAxes,fontsize=14,color='white')\\n\\n plt.subplots_adjust(wspace=0.07, hspace=0.07)\\n \\n if compare:\\n fig = plt.figure(figsize=(4*table[1],4*table[0]))\\n for i in range(len(wi_img)):\\n ax = fig.add_subplot(table[0],table[1],i+1)\\n ax.imshow(wi_img[i])\\n ax.xaxis.set_major_formatter(NullFormatter())\\n ax.yaxis.set_major_formatter(NullFormatter())\\n ax.text(0.1,0.9,'r=%.1f'%(mag[i]),transform=ax.transAxes,fontsize=14,color='white')\\n\\n plt.subplots_adjust(wspace=0.07, hspace=0.07)\\n \\n if savefile != None:\\n fig.savefig(savefile +'.png')\\n fig.savefig(savefile +'.pdf')\",\n \"def assignLabels(self):\\n clusters = np.arange(0, len(self.V))[self.V < self.V1] #indexes self.V, volumes_sorted, and oldOrder\\n self.clusterV = self.volumes_sorted[clusters]\\n clusters = self.oldOrder[clusters] #indexes volumes\\n self.clusters = self.nonBI[clusters] #indexes self.vor and self.data\\n self.easyLabel = np.zeros(len(self.data))\\n self.easyLabel[self.clusters] = 1\\n print('Out of ' + str(len(self.data)) + ' particles, ' + str(len(self.clusters)) + ' (' + str(round(len(self.clusters)*100/len(self.data), 3)) +' %) are labelled as cluster particles.')\",\n \"def __init__(self, smoothing=0.1):\\n super(LabelSmoothingCrossEntropy, self).__init__()\\n assert smoothing < 1.0\\n self.smoothing = smoothing\\n self.confidence = 1. - smoothing\",\n \"def __init__(self):\\r\\n self.label = \\\"Longest Flow Path\\\"\\r\\n self.description = \\\"this is my Longest Flow Path python tool\\\"\",\n \"def adjust_labels(data_y, label):\\n\\n if label == 'locomotion': # Labels for locomotion are adjusted\\n data_y[data_y == 4] = 3\\n data_y[data_y == 5] = 4\\n elif label == 'gestures': # Labels for gestures are adjusted\\n data_y[data_y == 406516] = 1\\n data_y[data_y == 406517] = 2\\n data_y[data_y == 404516] = 3\\n data_y[data_y == 404517] = 4\\n data_y[data_y == 406520] = 5\\n data_y[data_y == 404520] = 6\\n data_y[data_y == 406505] = 7\\n data_y[data_y == 404505] = 8\\n data_y[data_y == 406519] = 9\\n data_y[data_y == 404519] = 10\\n data_y[data_y == 406511] = 11\\n data_y[data_y == 404511] = 12\\n data_y[data_y == 406508] = 13\\n data_y[data_y == 404508] = 14\\n data_y[data_y == 408512] = 15\\n data_y[data_y == 407521] = 16\\n data_y[data_y == 405506] = 17\\n return data_y\",\n \"def cut_bkg(self):\\n c = TCut(self.cut_both)\\n c += TCut(self._return_if('_cut_bkg'))\\n return c\",\n \"def __init__(self):\\n Algorithm.__init__(self)\\n self.name = \\\"Otsus Threshold\\\"\\n self.parent = \\\"Segmentation\\\"\",\n \"def old_ideal_label(I):\\n a, c, d = ideal_HNF(I)\\n return \\\"%s.%s.%s\\\" % (a * d, c, d)\",\n \"def calc_Hcp_ij(self):\\n\\t\\n\\thp0_delayed = self.hp_wavelet.get_Psi(self.xi[0] + self.Orbit.L/l.Clight)\\n\\thp0 = self.hp_wavelet.get_Psi(self.xi[0])\\n\\thc0_delayed = self.hc_wavelet.get_Psi(self.xi[0] + self.Orbit.L/l.Clight)\\n\\thc0 = self.hc_wavelet.get_Psi(self.xi[0])\\n\\t\\n\\thp1_delayed = self.hp_wavelet.get_Psi(self.xi[1] + self.Orbit.L/l.Clight)\\n\\thp1 = self.hp_wavelet.get_Psi(self.xi[1])\\n\\thc1_delayed = self.hc_wavelet.get_Psi(self.xi[1] + self.Orbit.L/l.Clight)\\n\\thc1 = self.hc_wavelet.get_Psi(self.xi[1])\\n\\t\\n\\thp2_delayed = self.hp_wavelet.get_Psi(self.xi[2] + self.Orbit.L/l.Clight)\\n\\thp2 = self.hp_wavelet.get_Psi(self.xi[2])\\n\\thc2_delayed = self.hc_wavelet.get_Psi(self.xi[2] + self.Orbit.L/l.Clight)\\n\\thc2 = self.hc_wavelet.get_Psi(self.xi[2])\\n\\t\\n\\tself.Hpij[0,1] = hp1_delayed - hp0\\n\\tself.Hpij[1,0] = hp0_delayed - hp1\\n\\n\\tself.Hpij[0,2] = hp2_delayed - hp0\\n\\tself.Hpij[2,0] = hp0_delayed - hp2\\n\\n\\tself.Hpij[1,2] = hp2_delayed - hp1\\n\\tself.Hpij[2,1] = hp1_delayed - hp2\\n\\t\\n\\t# cross-polarization\\n\\tself.Hcij[0,1] = hc1_delayed - hc0\\n\\tself.Hcij[1,0] = hc0_delayed - hc1\\n\\n\\tself.Hcij[0,2] = hc2_delayed - hc0\\n\\tself.Hcij[2,0] = hc0_delayed - hc2\\n\\n\\tself.Hcij[1,2] = hc2_delayed - hc1\\n\\tself.Hcij[2,1] = hc1_delayed - hc2\\n\\t\\n\\treturn\",\n \"def __init__(self, training_data, smoothing_factor=1.0):\\n\\t\\tsuper(HostnameFeature, self).__init__('Hostname', 4, smoothing_factor)\\n\\t\\tself.category_bag_of_hostname = {}\\n\\t\\tfor record in training_data:\\n\\t\\t\\tcategory = record[6]\\n\\t\\t\\tif self.category_bag_of_hostname.get(category) is None:\\n\\t\\t\\t\\tself.category_bag_of_hostname[category] = {}\\n\\t\\t\\tpublishers = self.category_bag_of_hostname[category]\\n\\t\\t\\tpublisher_name = record[4].strip().lower()\\n\\t\\t\\tif publisher_name not in publishers:\\n\\t\\t\\t\\tpublishers[publisher_name] = 0\\n\\t\\t\\tpublishers[publisher_name] += 1\\n\\t\\t# for k, bw in self.category_bag_of_hostname.items():\\n\\t\\t# \\tprint 'category ', k, ' with number of different hostname', len(bw)\",\n \"def instance_label(task, pred, k=15, n_iters=1, dist_thresh=5, watershed=False):\\n mask = pred\\n\\n # noise removal\\n if k > 1 and n_iters > 0:\\n kernel = np.ones((k, k), np.uint8)\\n mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel,\\n iterations=n_iters)\\n\\n if watershed:\\n from clab.live import filters\\n mask = filters.watershed_filter(mask, dist_thresh=dist_thresh)\\n\\n mask = mask.astype(np.uint8)\\n n_ccs, cc_labels = cv2.connectedComponents(mask, connectivity=4)\\n return cc_labels\",\n \"def fredkin(ha, hb, hc):\\n\\n return controlled_U(ha, swap(hb, hc))\",\n \"def labels(self, threshold, segment=True, exclude_border=0):\\n data = self.unmasked_data\\n isfin = numpy.isfinite(data)\\n data[~isfin] = numpy.amin(data[isfin])\\n regions = (data > threshold)\\n if segment:\\n local_max = peak_local_max(data, indices=False,\\n exclude_border=0,\\n footprint=numpy.ones((3, 3)),\\n labels=regions)\\n markers = measurements.label(local_max)[0]\\n labels = watershed(-data, markers, mask=regions)\\n if exclude_border > 0:\\n # Remove basins originating from edge peaks\\n diff = numpy.zeros_like(local_max)\\n for i in range(local_max.ndim):\\n local_max = local_max.swapaxes(0, i)\\n diff = diff.swapaxes(0, i)\\n diff[:exclude_border] = local_max[:exclude_border]\\n diff[-exclude_border:] = local_max[-exclude_border:]\\n diff = diff.swapaxes(0, i)\\n local_max = local_max.swapaxes(0, i)\\n \\n for l in numpy.sort(labels[diff])[::-1]:\\n labels[labels == l] = 0\\n labels[labels > l] -= 1\\n ulabels = numpy.unique(labels)\\n n = ulabels[ulabels != 0].size\\n else:\\n data_thres = numpy.zeros_like(data)\\n data_thres[regions] = data[regions]\\n labels, n = measurements.label(data_thres)\\n return labels, n\",\n \"def graphCut(img, center, radius, temp, edge, count, editPoints, padList, theta_width, phi_width):\\r\\n\\r\\n\\r\\n \\\"\\\"\\\"Important note. The labeled image is referred to as temp, or self.temp in the interface.\\r\\n This stands for template. The previously labled image is fed back into the graphcut\\\"\\\"\\\"\\r\\n \\r\\n \\\"\\\"\\\"create polar images and cost arrays\\\"\\\"\\\"\\r\\n \\r\\n print \\\"RUNNING GRAPHCUT!\\\"\\r\\n img= padImage(img, padList)\\r\\n temp= padImage(temp, padList)\\r\\n edge= padImage(edge, padList)\\r\\n center= padCenter(center, padList)\\r\\n \\r\\n polar_img= img2polar(img, center, radius, theta_width=theta_width, phi_width=phi_width)\\r\\n\\r\\n \\r\\n \\r\\n polar_grad, y, x = np.gradient(np.array(polar_img, dtype='float'))\\r\\n \\\"\\\"\\\"Lockett 100416 replacement line below to not use gradient when the image has a surface label\\\"\\\"\\\"\\r\\n \\\"\\\"\\\"polar_grad = -1 * np.array(polar_img, dtype='float')\\\"\\\"\\\"\\r\\n \\r\\n \\r\\n polar_cost = -1 * np.ones(polar_img.shape)\\r\\n for r in range(1,radius):\\r\\n polar_cost[r]= polar_grad[r]-polar_grad[r-1]\\r\\n\\r\\n \\r\\n \\r\\n \\\"\\\"\\\"\\r\\n flip the cost image upside down. This is so that the base set is at the bottom of the array\\r\\n since the graphcut cuts from top to bottom, this inversion is necessary.\\r\\n \\\"\\\"\\\"\\r\\n polar_cost_inv=polar_cost[::-1,:,:]\\r\\n\\r\\n print \\\"CONSTRUCTING GRAPH EDGES... \\\"\\r\\n \\r\\n \\\"\\\"\\\"construct the graph using PyMaxFlow\\\"\\\"\\\"\\r\\n g=maxflow.GraphFloat()\\r\\n nodeids=g.add_grid_nodes(polar_img.shape)\\r\\n structure=np.zeros((3,3,3))\\r\\n structure[2]= np.array([[0,10000,0],[10000, 10000, 10000],[0, 10000, 0]])\\r\\n g.add_grid_edges(nodeids, structure=structure, symmetric=False)\\r\\n\\r\\n \\r\\n \\\"\\\"\\\"convert the previously labeled image (temp) into a polar transform image. Take the labels and\\r\\n give them high cost edge weights so the segmentation avoids previously labeled objects\\\"\\\"\\\"\\r\\n polar_lbl_img= img2polar(temp, center, radius, theta_width=theta_width, phi_width=phi_width)\\r\\n polar_lbl_img_inv= polar_lbl_img[::-1,:]\\r\\n \\r\\n lbl_caps= polar_lbl_img_inv>0\\r\\n self_caps= (polar_lbl_img_inv==count)\\r\\n lbl_caps-=self_caps\\r\\n lbl_source_caps= np.zeros(lbl_caps.shape)\\r\\n lbl_sink_caps= lbl_caps*10000\\r\\n g.add_grid_tedges(nodeids, lbl_source_caps, lbl_sink_caps)\\r\\n \\r\\n structure2= 10000*np.array([[0,0,0],[0,0,1],[0,1,0]])\\r\\n g.add_grid_edges(nodeids[radius-1], structure=structure2, symmetric=True)\\r\\n\\r\\n \\\"\\\"\\\"add terminal edges using two arrays whose elemnts are the costs of the edges from the source and to the\\r\\n sink\\\"\\\"\\\"\\r\\n print \\\"CONSTRUCTING GRAPH TEDGES...\\\"\\r\\n sinkcaps= polar_cost_inv * (polar_cost_inv>=0)\\r\\n sourcecaps = -1 * polar_cost_inv * (polar_cost_inv<0)\\r\\n g.add_grid_tedges(nodeids, sourcecaps, sinkcaps)\\r\\n\\r\\n \\r\\n\\r\\n \\r\\n \\\"\\\"\\\"accounts for edit points. Takes every point in the edit point list, converts it to its spherical coordinate, and adds high cost\\r\\n edges in the column of that edit point inverts the x and y coordinates of the center\\\"\\\"\\\"\\r\\n center= np.array((center[0], center[2], center[1]))\\r\\n if len(editPoints)!=0:\\r\\n for coords in editPoints:\\r\\n\\r\\n \\r\\n rad= math.sqrt((center[0]-coords[0])**2+ (center[1]-coords[2])**2 + (center[2]-coords[1])**2) \\r\\n theta= math.atan2(center[2]-coords[1], coords[2]-center[1])\\r\\n print str((coords[0]-center[0])/(rad+1))\\r\\n phi=math.acos(float(coords[0]-center[0])/(rad+1))\\r\\n if theta<0:\\r\\n theta=2*math.pi+ theta\\r\\n theta= theta_width- theta_width*theta/(2*math.pi)-1\\r\\n phi= phi_width*phi/(math.pi)-1\\r\\n rad= radius- rad\\r\\n print \\\"POLAR COORDS: \\\" + str((rad, theta, phi))\\r\\n\\r\\n for r in range(0, radius):\\r\\n if r<=rad:\\r\\n g.add_tedge(nodeids[r, theta, phi], 0, 10000)\\r\\n \\r\\n else:\\r\\n g.add_tedge(nodeids[r, theta, phi], 10000, 0) \\r\\n\\r\\n\\r\\n\\r\\n\\r\\n print \\\"CUTTING GRAPH...\\\"\\r\\n g.maxflow()\\r\\n\\r\\n \\\"\\\"\\\"s-t mincut of graph. This is converted to cartesian coordinates with the function img2cart. The\\r\\n images are also closed to eliminate spotty areas\\\"\\\"\\\"\\r\\n \\r\\n print \\\"STARTING CARTESIAN TRANSFORM...\\\"\\r\\n polar_img_seg= np.invert(g.get_grid_segments(nodeids)[::-1,:,:])\\r\\n\\r\\n \\r\\n edge_img= np.zeros(img.shape)\\r\\n seg_img= ndimage.binary_closing(img2cart(img, polar_img_seg, center, radius, theta_width, phi_width))\\r\\n \\r\\n \\r\\n \\\"\\\"\\\"create an edge image of the segmented object\\\"\\\"\\\"\\r\\n strel=np.ones((3,3,3))\\r\\n erode_img=ndimage.binary_erosion(seg_img, strel)\\r\\n edge_img=np.logical_xor(seg_img, erode_img)\\r\\n \\r\\n\\r\\n \\\"\\\"\\\"shears the segmentation image and edge if padding was applied\\\"\\\"\\\"\\r\\n \\r\\n\\r\\n \\\"\\\"\\\"add the object back on to the template image (and the edge image back on the template edge)\\r\\n If there was an editpoint involved, remove the previous segmentation of that object and add back\\r\\n on the edited object\\\"\\\"\\\"\\r\\n if len(editPoints)!=0:\\r\\n del_img= (temp==count)*count\\r\\n temp-=del_img\\r\\n\\r\\n del_edge_img= (edge==count)*count\\r\\n edge-= del_edge_img\\r\\n\\r\\n\\r\\n temp+=seg_img*count\\r\\n edge+=edge_img*count\\r\\n\\r\\n temp= shearImage(temp, padList)\\r\\n edge= shearImage(edge, padList)\\r\\n \\r\\n \\r\\n\\r\\n print \\\"FINISHED!\\\"\\r\\n \\r\\n return temp, edge\",\n \"def __init__(self, *args):\\n _BRepAlgo.BRepAlgo_Cut_swiginit(self,_BRepAlgo.new_BRepAlgo_Cut(*args))\",\n \"def labeling(self, tab, i, j, element):\\n label = element\\n label.grid(row=i, column=j) # this specifies where in the grid\\n tab.grid_columnconfigure(j, weight=1) \\n # this last line makes the width of the column responsive to change in width of the window\",\n \"def label(self, cfg):\\n rep = \\\"\\\"\\n nl = \\\"\\\"\\n for node in cfg.nodes:\\n rep += nl + \\\"{}\\\\tgen={}\\\\tkill={}\\\\tout={}\\\".format(\\n node, \\n set(self.gen.get(node)),\\n set(self.kill.get(node)),\\n set(self.out.get(node)))\\n nl = \\\"\\\\n\\\"\\n return rep\",\n \"def _make_dijet_label(chain_parts):\\n\\n assert len(chain_parts) == 1\\n scenario = chain_parts[0]['hypoScenario']\\n \\n assert scenario.startswith('dijet')\\n\\n arg_res = [\\n re.compile(r'^(?P<lo>\\\\d*)(?P<key>djmass)(?P<hi>\\\\d*)$'),\\n re.compile(r'^(?P<lo>\\\\d*)(?P<key>j1et)(?P<hi>\\\\d*)$'),\\n re.compile(r'^(?P<lo>\\\\d*)(?P<key>j1eta)(?P<hi>\\\\d*)$'),\\n re.compile(r'^(?P<lo>\\\\d*)(?P<key>j2et)(?P<hi>\\\\d*)$'),\\n re.compile(r'^(?P<lo>\\\\d*)(?P<key>j2eta)(?P<hi>\\\\d*)$'),\\n ]\\n\\n defaults = {\\n 'j1et': ('100', 'inf'),\\n 'j2et': ('100', 'inf'),\\n 'j1eta': ('0', '320'),\\n 'j2eta': ('0', '320'),\\n 'djmass': ('1000', 'inf'),\\n }\\n\\n\\n args = _args_from_scenario(scenario)\\n argvals = {}\\n while args:\\n assert len(args) == len(arg_res)\\n arg = args.pop()\\n for r in arg_res:\\n m = r.match(arg)\\n if m is not None:\\n arg_res.remove(r)\\n gd = m.groupdict()\\n key = gd['key']\\n\\n try:\\n lo = float(gd['lo'])\\n except ValueError:\\n lo = defaults[key][0]\\n argvals[key+'lo'] = lo \\n try:\\n hi = float(gd['hi'])\\n except ValueError:\\n hi = defaults[key][1]\\n argvals[key+'hi'] = hi\\n\\n assert len(args) == len(arg_res)\\n assert len(args) == 0\\n\\n return \\\"\\\"\\\"\\n combgen(\\n [(2)(%(j1etlo).0fet, %(j1etalo).0feta%(j1etahi).0f)\\n (%(j1etlo).0fet, %(j1etalo).0feta%(j1etahi).0f)\\n ]\\n \\n dijet(\\n [(%(djmasslo).0fdjmass)])\\n simple([(%(j1etlo).0fet, %(j1etalo).0feta%(j1etahi).0f)\\n (%(j2etlo).0fet, %(j2etalo).0feta%(j2etahi).0f)])\\n )\\\"\\\"\\\" % argvals\",\n \"def hilfe(self):\\n sZweieck_hilfe(3)\",\n \"def gen_hts_lab_full(self):\\n self.gen_hts_lab_mono()\\n\\n hts_lab_time_prn = tuple(' '.join(l[0:2]) for l in self._hts_lab_mono_ttpl)\\n\\n self.hts_lab_full_prn = tuple(' '.join((l_time, l_gen)) for (l_time, l_gen)\\n in zip(hts_lab_time_prn, self.hts_lab_gen_prn))\",\n \"def x_group_label(\\n x_gr: int, cut: int = 20, name_dict: Dict[AnyStr, AnyStr] = names_dict\\n) -> AnyStr:\\n name = name_dict[str(x_gr)]\\n if len(name) > cut:\\n return f\\\"{name[:cut-3]}...\\\"\\n else:\\n return name\",\n \"def _labels_of_sentence(self, sentence, split):\\n labels = torch.ones(1)\\n labels[0] = self.category_int_of_label_string(sentence[0][self.name_to_index_dict['label']]) #\\n return labels\",\n \"def vertical_core(block,cut,laser):\\r\\n\\r\\n\\tlayers = int(block[\\\"thickness\\\"]/laser[\\\"z_spacing\\\"])\\r\\n\\tangle = math.radians(laser[\\\"kerf_angle\\\"]/2)\\r\\n\\ttaper = math.tan(angle) * laser[\\\"z_spacing\\\"]\\r\\n\\r\\n\\tu = math.tan(2 * angle) * (block[\\\"thickness\\\"] + laser[\\\"z_final_overshoot\\\"])\\r\\n\\tz_0 = block[\\\"thickness\\\"]*math.cos(angle) + math.sin(angle)*((cut[\\\"final_dimension_y\\\"])/2 - block[\\\"origin_y\\\"] + u)\\r\\n\\tz_1 = block[\\\"thickness\\\"]*math.cos(angle) + math.sin(angle)*((cut[\\\"final_dimension_x\\\"])/2 + block[\\\"origin_x\\\"] + u)\\r\\n\\tz_2 = block[\\\"thickness\\\"]*math.cos(angle) + math.sin(angle)*((cut[\\\"final_dimension_y\\\"])/2 + block[\\\"origin_y\\\"] + u)\\r\\n\\tz_3 = block[\\\"thickness\\\"]*math.cos(angle) + math.sin(angle)*((cut[\\\"final_dimension_x\\\"])/2 - block[\\\"origin_x\\\"] + u)\\r\\n\\t\\r\\n\\tcutlist = []\\r\\n\\tcutlist.append([\\\"a_abs\\\", f\\\"{math.degrees(angle):.6f}\\\"])\\r\\n\\tcutlist.append([\\\"c_abs\\\", str(block[\\\"physical_rotation\\\"])])\\r\\n\\tcutlist.append([\\\"z_abs\\\", f\\\"{z_0:.6f}\\\"])\\r\\n\\r\\n\\ty_start_wide = ((u + cut[\\\"final_dimension_x\\\"]/2)* math.cos(angle) \\r\\n\\t\\t\\t\\t - block[\\\"thickness\\\"]*math.sin(angle) \\r\\n\\t\\t\\t\\t - u/math.cos(angle))\\r\\n\\ty_start_length = ((u + cut[\\\"final_dimension_y\\\"]/2)* math.cos(angle) \\r\\n\\t\\t\\t\\t - block[\\\"thickness\\\"]*math.sin(angle) \\r\\n\\t\\t\\t\\t - u/math.cos(angle))\\r\\n\\r\\n\\tdepth_cut = (block[\\\"thickness\\\"] + laser[\\\"z_final_overshoot\\\"]) * math.cos(angle)/math.cos(2*angle)\\r\\n\\r\\n\\tcut1 = json.loads(line(block[\\\"width\\\"]/2 - block[\\\"origin_x\\\"],y_start_length - block[\\\"origin_y\\\"],-block[\\\"width\\\"]/2 - block[\\\"origin_x\\\"],y_start_length - block[\\\"origin_y\\\"],depth_cut,laser))\\r\\n\\r\\n\\tcut2 = json.loads(line(block[\\\"length\\\"]/2 + block[\\\"origin_y\\\"],y_start_wide - block[\\\"origin_x\\\"],-block[\\\"length\\\"]/2 + block[\\\"origin_y\\\"],y_start_wide - block[\\\"origin_x\\\"],depth_cut,laser))\\r\\n\\r\\n\\tcut3 = json.loads(line(block[\\\"width\\\"]/2 + block[\\\"origin_x\\\"],y_start_length + block[\\\"origin_y\\\"],-block[\\\"width\\\"]/2 + block[\\\"origin_x\\\"],y_start_length + block[\\\"origin_y\\\"],depth_cut,laser))\\r\\n\\r\\n\\tcut4 = json.loads(line(block[\\\"length\\\"]/2 - block[\\\"origin_y\\\"],y_start_wide + block[\\\"origin_x\\\"],-block[\\\"length\\\"]/2 - block[\\\"origin_y\\\"],y_start_wide + block[\\\"origin_x\\\"],depth_cut,laser))\\r\\n\\r\\n\\t#cut1 = json.loads(line(block[\\\"width\\\"]/2,y_start_length,-block[\\\"width\\\"]/2,y_start_length,depth_cut,laser))\\r\\n\\r\\n\\t#cut2 = json.loads(line(block[\\\"length\\\"]/2,y_start_wide,-cut[\\\"final_dimension_y\\\"]/2,y_start_wide,depth_cut,laser))\\r\\n\\r\\n\\t#cut3 = json.loads(line(block[\\\"width\\\"]/2,y_start_length,-cut[\\\"final_dimension_x\\\"]/2,y_start_length,depth_cut,laser))\\r\\n\\r\\n\\t#cut4 = json.loads(line(cut[\\\"final_dimension_y\\\"]/2,y_start_wide,-cut[\\\"final_dimension_y\\\"]/2,y_start_wide,depth_cut,laser))\\r\\n\\r\\n\\tcutlist = (cutlist + cut1\\r\\n\\t + [[\\\"c_rel\\\", \\\"90\\\"],[\\\"z_abs\\\", f\\\"{z_1:.6f}\\\"],] \\r\\n\\t + cut2\\r\\n\\t + [[\\\"c_rel\\\", \\\"90\\\"],[\\\"z_abs\\\", f\\\"{z_2:.6f}\\\"]] \\r\\n\\t\\t\\t\\t\\t + cut3 \\r\\n\\t\\t\\t\\t\\t + [[\\\"z_abs\\\", f\\\"{z_3:.6f}\\\"],[\\\"c_rel\\\", \\\"90\\\"]] \\r\\n\\t\\t\\t\\t\\t + cut4)\\r\\n\\r\\n\\tcutlist.insert(0, [\\\"set_trigger4\\\", \\\"1\\\", \\\"0\\\", \\\"7\\\", \\\"8\\\", \\\"45\\\"])\\r\\n\\tcutlist.append([\\\"stop_trigger\\\"])\\r\\n\\r\\n\\treturn json.dumps(cutlist)\",\n \"def SCEC_LOH_1():\\n\\n #Initialize CrustModel\\n model = CrustModel(2)\\n\\n #Slow layer\\n vp=4.000\\n vs=2.000\\n rho=2.600\\n Qa=10000.\\n Qb=10000.\\n thickness = 1.0\\n\\n model.add_layer(thickness, vp, vs, rho, Qa, Qb)\\n\\n #Halfspace\\n vp=6.000\\n vs=3.464\\n rho=2.700\\n Qa=10000.\\n Qb=10000.\\n thickness = 0 #Infinite thickness!\\n model.add_layer(thickness, vp, vs, rho, Qa, Qb)\\n\\n return model\",\n \"def sils_cut(T,f,c,d,h, conshdlr):\\n Ts = range(1,T+1)\\n\\n model = sils(T,f,c,d,h)\\n y,x,I = model.data\\n\\n # relax integer variables\\n for t in Ts:\\n model.chgVarType(y[t], \\\"C\\\")\\n model.addVar(vtype=\\\"B\\\", name=\\\"fake\\\") # for making the problem MIP\\n\\n # compute D[i,j] = sum_{t=i}^j d[t]\\n D = {}\\n for t in Ts:\\n s = 0\\n for j in range(t,T+1):\\n s += d[j]\\n D[t,j] = s\\n\\n #include the lot sizing constraint handler\\n model.includeConshdlr(conshdlr, \\\"SILS\\\", \\\"Constraint handler for single item lot sizing\\\",\\n sepapriority = 0, enfopriority = -1, chckpriority = -1, sepafreq = -1, propfreq = -1,\\n eagerfreq = -1, maxprerounds = 0, delaysepa = False, delayprop = False, needscons = False,\\n presoltiming = SCIP_PRESOLTIMING.FAST, proptiming = SCIP_PROPTIMING.BEFORELP)\\n conshdlr.data = D,Ts\\n\\n model.data = y,x,I\\n return model\",\n \"def _subconstituent_name(h):\\n if h == 1:\\n o = \\\"1st\\\"\\n elif h == 2:\\n o = \\\"2nd\\\"\\n elif h == 3:\\n o = \\\"3rd\\\"\\n else:\\n o = \\\"%dth\\\" % h\\n return \\\"%s subconstituent\\\" % o\",\n \"def display_and_label_hulls(self, hulls, src):\\n \\n labels = []\\n\\n for hull in hulls:\\n\\n angle = 0\\n MA = 1\\n ma = 1\\n try:\\n _,(MA,ma),angle = cv.fitEllipse(hull)\\n except:\\n pass\\n cosAngle = np.abs(np.cos(angle*np.pi/180))\\n\\n # Only human-classify hulls if it is reasonably a vertically oriented rectangle\\n # This is a hueristic to not have to waste time clasifying hulls clearly not poles\\n if (cosAngle < 1.75) and (cosAngle > 0.85) and (MA/ma < 0.28):\\n cpy = src.copy()\\n hull_img = cv.polylines(cpy, [hull], True, (0,0,255), 3)\\n cv.imshow(\\\"Hull\\\", hull_img)\\n keycode = cv.waitKey(0)\\n if keycode == 49:\\n labels.append((hull, 0))\\n print(\\\"Not a Pole\\\")\\n elif keycode == 50:\\n labels.append((hull, 1))\\n print(\\\"A Pole!\\\")\\n else:\\n raise Exception(\\\"Unexpected Key Pressed\\\")\\n else:\\n labels.append((hull, 0))\\n cv.destroyAllWindows()\\n return labels\",\n \"def __init__(self, word_embed_size, vocab):\\n super(ModelEmbeddings, self).__init__()\\n\\n ### YOUR CODE HERE for part 1h\\n dropout_rate = 0.3\\n n_chars = len(vocab.char2id)\\n self.char_embed_size = 50\\n self.word_embed_size = word_embed_size\\n self.vocab = vocab\\n self.char_embed = nn.Embedding(n_chars, self.char_embed_size)\\n self.conv = CNN(self.char_embed_size, word_embed_size)\\n self.highway = Highway(word_embed_size)\\n self.dropout = nn.Dropout(dropout_rate)\\n ### END YOUR CODE\",\n \"def plot_mass_flow(self,\\n watershed, \\n output, \\n title = 'Subbasin Reach Mass Flow Diagram',\\n fontsize = 6, \\n theight = 0.2, \\n l = 8.5, \\n w = 11, \\n verbose = True, \\n overwrite = True,\\n ):\\n\\n if os.path.exists(output) and not overwrite:\\n if verbose: print('file %s exists' % output)\\n return\\n elif verbose: print('generating a mass linkage plot\\\\n')\\n\\n fontheight = fontsize / 72.\\n rheight = 3 * fontheight\\n rwidth = 12 * fontheight\\n xgap = fontheight\\n ygap = rheight\\n awidth = rheight / 4\\n aheight = rheight / 3\\n\\n # set up a sheet to write the image\\n\\n fig = pyplot.figure(figsize = (w, l))\\n\\n ax = fig.add_subplot(111, aspect = 'equal')\\n ax.get_xaxis().set_visible(False)\\n ax.get_yaxis().set_visible(False)\\n t = ax.set_title(title)\\n\\n # divide the subbasins into rows and put them on the chart\\n # start at the bottom to organize the linkages better\\n\\n rows = [watershed.outlets, ['outlet']]\\n\\n top = False\\n while not top:\\n row = []\\n for next in rows[0]:\\n for subbasin in watershed.updown:\\n if watershed.updown[subbasin] == next: row.append(subbasin)\\n if len(row) > 0: \\n rows.insert(0, row)\\n else: \\n top = True\\n\\n # add an inlet box in the row above each inlet\\n\\n for inlet in watershed.inlets: \\n\\n i = 0\\n while i < len(rows) - 1:\\n\\n for subbasin in rows[i]:\\n\\n if subbasin == inlet:\\n \\n # find the position of the subbasin in the chart\\n\\n j = rows[i].index(inlet)\\n\\n if i > 0:\\n\\n # figure out where the subbasins point\\n \\n updowns = [watershed.updown[s] for s in rows[i-1]]\\n \\n # if first or last, add it there in the row above\\n\\n if j == 0: \\n rows[i-1].insert(0, 'inlet')\\n elif j == len(rows[i]) - 1: \\n rows[i-1].append('inlet')\\n else:\\n\\n # find the place to add in the preceeding row \\n\\n n = updowns.index(rows[i][j-1]) + 1\\n rows[i-1].insert(n, 'inlet')\\n\\n i += 1\\n\\n # write the subbasin boxes to the chart\\n\\n middle = math.ceil(w // (rwidth + xgap)) // 2\\n last = 0\\n\\n # keep track of the bounding box of the plot\\n\\n xmin, ymin, xmax, ymax = middle, 0, middle, 0\\n\\n for i in range(len(rows)):\\n\\n row = rows[i]\\n \\n y = (ygap + rheight) * i + theight\\n\\n # figure out which cell to put in the main column\\n\\n if i == 0:\\n main = row[(len(row) - 1) // 2]\\n elif i < len(rows) - 1:\\n main = watershed.updown[rows[i-1][last]]\\n else: main = 'outlet'\\n\\n start = middle - row.index(main)\\n\\n if i < len(rows) - 1: next_row = rows[i + 1]\\n\\n for subbasin in row:\\n x = (rwidth + xgap) * (start + row.index(subbasin))\\n r = patches.Rectangle((x, y), rwidth, rheight, fill = False)\\n\\n # adjust the bounding box\\n\\n if x < xmin: xmin = x\\n if x + rwidth > xmax: xmax = x + rwidth\\n if y < ymin: ymin = y\\n if y + rheight > ymax: ymax = y + rheight\\n\\n if subbasin != 'outlet': ax.add_patch(r)\\n\\n b = ax.text(x + rwidth / 2, y + rheight / 2, subbasin,\\n horizontalalignment = 'center',\\n verticalalignment = 'center')\\n\\n # draw the arrow\\n\\n if i < len(rows) - 1:\\n\\n x1 = x + rwidth / 2\\n\\n if i < len(rows) - 2 and subbasin != 'inlet':\\n next = watershed.updown[subbasin]\\n next_start = (middle - \\n next_row.index(watershed.updown[main]))\\n x2 = ((rwidth + xgap) * \\n (next_start + next_row.index(next))\\n + rwidth / 2)\\n\\n elif subbasin == 'inlet':\\n next = watershed.inlets[0]\\n next_start = (middle - \\n next_row.index(watershed.updown[main]))\\n\\n x2 = ((rwidth + xgap) * \\n (next_start + next_row.index(next))\\n + rwidth / 2)\\n\\n else:\\n next_start = middle\\n x2 = ((rwidth + xgap) * (middle) + rwidth / 2)\\n\\n a = pyplot.arrow(x1, y + rheight, x2 - x1, ygap, \\n head_width = awidth, head_length = aheight,\\n fc = 'k', ec = 'k', \\n length_includes_head = True)\\n ax.add_patch(a)\\n\\n last = row.index(main)\\n i += 1\\n \\n pad = 0.02\\n\\n xmin = xmin - (xmax - xmin) * pad\\n xmax = xmax + (xmax - xmin) * pad\\n ymin = ymin - (ymax - ymin) * pad\\n ymax = ymax + (ymax - ymin) * pad\\n\\n ax.set_xlim(xmin, xmax)\\n ax.set_ylim(ymax, ymin)\\n pyplot.axis('off')\\n pyplot.savefig(output, dpi = 200)\\n\\n pyplot.clf()\\n pyplot.close()\",\n \"def _get_labels(self, ind):\\n pass\",\n \"def plot_labels_bundle_pth(device, model, dataset, dataloader):\\n ## Get labels and preds\\n labels, preds = get_labels_and_preds(device, model, dataloader)\\n \\n ## Plot the figure\\n plot_labels(labels, preds, dataset.id_to_class_dict)\",\n \"def write_label(self, contig_name, width, height, font, title_width, upper_left, vertical_label,\\n strand, canvas, horizontal_centering=False, center_vertical=False, chop_text=True,\\n label_color=(50, 50, 50, 255)):\\n upper_left = list(upper_left) # to make it mutable\\n shortened = contig_name[-title_width:] # max length 18. Last characters are most unique\\n txt = Image.new('RGBA', (width, height))#, color=(0,0,0,50))\\n txt_canvas = ImageDraw.Draw(txt)\\n text_width = txt_canvas.textsize(shortened, font)[0]\\n if not chop_text and text_width > width:\\n txt = Image.new('RGBA', (text_width, height)) # TODO performance around txt_canvas\\n txt_canvas = ImageDraw.Draw(txt)\\n if center_vertical or vertical_label: # Large labels are centered in the column to look nice,\\n # rotation indicates strand in big text\\n vertically_centered = (height // 2) - multi_line_height(font, shortened, txt)//2\\n else: # Place label at the beginning of gene based on strand\\n vertically_centered = height - multi_line_height(font, shortened, txt) # bottom\\n if strand == \\\"+\\\":\\n vertically_centered = 0 # top of the box\\n txt_canvas.multiline_text((0, max(0, vertically_centered)), shortened, font=font,\\n fill=label_color)\\n if vertical_label:\\n rotation_direction = 90 if strand == '-' else -90\\n txt = txt.rotate(rotation_direction, expand=True)\\n upper_left[1] += -4 if strand == '-' else 4\\n if horizontal_centering:\\n margin = width - text_width\\n upper_left[0] += margin // 2\\n canvas.paste(txt, (upper_left[0], upper_left[1]), txt)\",\n \"def hbnb():\\n return 'HBNB'\",\n \"def TH(self, full=False):\\n\\t\\treturn (arange(self.thbins + 3*self.thbins*(full==True)) + 0.5) * (pi / 2) / self.thbins\",\n \"def displayNeedle(self,i):\\n #obsolete\\n profbox()\\n modelNodes = slicer.util.getNodes('vtkMRMLModelNode*')\\n for modelNode in modelNodes.values():\\n if modelNode.GetAttribute(\\\"nth\\\")==str(i) and modelNode.GetAttribute(\\\"segmented\\\")=='1' :\\n displayNode = modelNode.GetModelDisplayNode()\\n nVisibility = displayNode.GetVisibility()\\n \\n if nVisibility:\\n displayNode.SliceIntersectionVisibilityOff()\\n displayNode.SetVisibility(0)\\n else:\\n displayNode.SliceIntersectionVisibilityOn()\\n displayNode.SetVisibility(1)\",\n \"def label_joints():\\n side_dict = {'C': 0,\\n 'L': 1,\\n 'R': 2}\\n for jnt in mc.ls(type='joint'):\\n mc.setAttr('{}.side'.format(jnt), side_dict[jnt.split('_')[0]])\\n mc.setAttr('{}.type'.format(jnt), 18)\\n mc.setAttr('{}.otherType'.format(jnt), jnt.split('_')[1], type=\\\"string\\\")\",\n \"def __init__(self, h, d_model, dropout=0.1):\\n super(MultiHeadedAttention, self).__init__()\\n assert d_model % h == 0\\n # We assume d_v always equals d_k\\n self.d_k = d_model // h\\n self.h = h\\n self.linears = clones(nn.Linear(d_model, d_model), 4)\\n self.attn = None\\n self.dropout = nn.Dropout(p=dropout)\",\n \"def selection_correction_method1(tree, scale, h_in, h_out):\\n #h_in = ROOT.TH1D(\\\"h_in\\\", \\\"neutron spectrum with all cuts: inside onset window; Energy [keV]; counts\\\", 50, 0, 25)\\n #h_out = ROOT.TH1D(\\\"h_out\\\", \\\"neutron spectrum with all cuts: outside onset window; Energy [keV]; counts\\\", 50, 0, 25)\\n for event in tree:\\n cut = [0, 0]\\n S15_ch = i_channel(0, event)\\n bpm_ch = i_channel(4, event)\\n RT = event.DD_Rise[S15_ch]\\n S15_w2 = event.DD_AmplADU[S15_ch]\\n onset = event.DD_Rise10pct[S15_ch]\\n if cut[0]==0:\\n # first cut: for inside onset window\\n # if event passes the first cuts\\n if S15_w2>1000 and RT>1.1 and RT<1.51 and onset>39 and onset<47:\\n # loop over the pmt channel numbers to calculate the time of flight: time bd - time bpm\\n for n_channel in range(5, 16):\\n pmt_i = i_channel(n_channel, event)\\n cfd_pmt = event.cfdPulse_CFDNS[pmt_i]\\n cfd_bpm = event.cfdPulse_CFDNS[bpm_ch]\\n # calculation of the time of flight\\n tof = (cfd_pmt-cfd_bpm)%400\\n #cut on tof: time of flight of the neutron\\n if tof<335 and tof>295:\\n energy2 = S15_w2*scale\\n # fill histogram inside onset window\\n h_in.Fill(energy2)\\n cut[0]=1\\n break\\n if cut[1]==0:\\n if S15_w2>1000 and RT<1.51 and RT>1.1 and ((onset<36 and onset>15) or (onset>50 and onset<=110)):\\n for n_channel in range(5, 16):\\n pmt_i = i_channel(n_channel, event)\\n cfd_pmt = event.cfdPulse_CFDNS[pmt_i]\\n cfd_bpm = event.cfdPulse_CFDNS[bpm_ch]\\n tof = (cfd_pmt-cfd_bpm)%400\\n if tof<335 and tof>295:\\n energy2 = S15_w2*scale\\n h_out.Fill(energy2)\\n cut[1]=1\\n break\\n return h_in, h_out\",\n \"def split(self, frame, y):\\n return super(H2OStratifiedKFold, self).split(frame, y)\",\n \"def hbnb():\\n return \\\"HBNB\\\"\",\n \"def hbnb():\\n return \\\"HBNB\\\"\",\n \"def label(self):\\r\\n raise NotImplementedError\",\n \"def width_h_invis(self):\\n if m_higgs > 2.0 * self.mx:\\n coupling = self.gsxx * self.stheta / np.sqrt(1 - self.stheta**2)\\n\\n val = (\\n (coupling**2 * (m_higgs**2 - 4 * self.mx**2) ** 1.5)\\n / (8.0 * m_higgs**2 * np.pi)\\n ).real\\n\\n assert val >= 0\\n\\n return val\\n else:\\n return 0.0\",\n \"def J_J(h):\\n\\n h = MTS(h)\\n hdot = h.dot\\n J_𝒥 = 0.5j * 𝔇inverseLaplacianinverse(\\n 0.125 * (3 * h * hdot.bar.ethbar - 3 * hdot * h.bar.ethbar + hdot.bar * h.ethbar - h.bar * hdot.ethbar).eth.im\\n ).ethbar.ethbar\\n\\n return J_𝒥\",\n \"def _extract_vanHove(g,j,count_cut,wind):\\n count = g[fd('step',j)]['y']['disp_count'][:]\\n # get better statistics\\n count += g[fd('step',j)]['x']['disp_count'][:]\\n # count += count[::-1]\\n\\n edges = g[fd('step',j)]['y']['disp_edges'][:]\\n \\n edges = np.array([np.mean(edges[j:j+wind]) for j in range(0,len(count)-wind,wind)])\\n count = np.array([np.sum(count[j:j+wind]) for j in range(0,len(count)-wind,wind)])\\n\\n x_lim = (np.min(edges),np.max(edges))\\n\\n edges = edges[count>count_cut]\\n count = count[count>count_cut]\\n\\n return edges,count,x_lim\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5253033","0.5244755","0.5173087","0.51096773","0.5103869","0.50852627","0.5053167","0.4967331","0.49329308","0.4927268","0.4886447","0.4883699","0.48704627","0.48665786","0.48657504","0.48568624","0.484965","0.48423848","0.48153552","0.4808797","0.47966635","0.47905484","0.47897264","0.4789602","0.47883236","0.4778537","0.47747788","0.47747788","0.47688013","0.47625986","0.47623906","0.47590986","0.47565174","0.47555858","0.47543168","0.47531363","0.47462907","0.47368893","0.47368893","0.4735266","0.47266668","0.47257203","0.47236973","0.47236973","0.4721428","0.47145838","0.47108462","0.46985096","0.46970034","0.46970034","0.46903425","0.4678745","0.46785632","0.46737352","0.46721482","0.46716332","0.4668553","0.46664682","0.46631366","0.4650076","0.4649602","0.46484134","0.46478298","0.46409085","0.46390003","0.4636259","0.46301612","0.46296418","0.46274868","0.46253723","0.46242732","0.4620448","0.4620207","0.46172926","0.4612796","0.46107337","0.46043545","0.45970452","0.45920217","0.45911533","0.45852852","0.45762974","0.45722124","0.45691916","0.4559683","0.4556273","0.455437","0.45497307","0.45415783","0.45405617","0.45398763","0.45394397","0.45376632","0.45373675","0.45241743","0.45241743","0.45232397","0.4519799","0.45189357","0.45187494"],"string":"[\n \"0.5253033\",\n \"0.5244755\",\n \"0.5173087\",\n \"0.51096773\",\n \"0.5103869\",\n \"0.50852627\",\n \"0.5053167\",\n \"0.4967331\",\n \"0.49329308\",\n \"0.4927268\",\n \"0.4886447\",\n \"0.4883699\",\n \"0.48704627\",\n \"0.48665786\",\n \"0.48657504\",\n \"0.48568624\",\n \"0.484965\",\n \"0.48423848\",\n \"0.48153552\",\n \"0.4808797\",\n \"0.47966635\",\n \"0.47905484\",\n \"0.47897264\",\n \"0.4789602\",\n \"0.47883236\",\n \"0.4778537\",\n \"0.47747788\",\n \"0.47747788\",\n \"0.47688013\",\n \"0.47625986\",\n \"0.47623906\",\n \"0.47590986\",\n \"0.47565174\",\n \"0.47555858\",\n \"0.47543168\",\n \"0.47531363\",\n \"0.47462907\",\n \"0.47368893\",\n \"0.47368893\",\n \"0.4735266\",\n \"0.47266668\",\n \"0.47257203\",\n \"0.47236973\",\n \"0.47236973\",\n \"0.4721428\",\n \"0.47145838\",\n \"0.47108462\",\n \"0.46985096\",\n \"0.46970034\",\n \"0.46970034\",\n \"0.46903425\",\n \"0.4678745\",\n \"0.46785632\",\n \"0.46737352\",\n \"0.46721482\",\n \"0.46716332\",\n \"0.4668553\",\n \"0.46664682\",\n \"0.46631366\",\n \"0.4650076\",\n \"0.4649602\",\n \"0.46484134\",\n \"0.46478298\",\n \"0.46409085\",\n \"0.46390003\",\n \"0.4636259\",\n \"0.46301612\",\n \"0.46296418\",\n \"0.46274868\",\n \"0.46253723\",\n \"0.46242732\",\n \"0.4620448\",\n \"0.4620207\",\n \"0.46172926\",\n \"0.4612796\",\n \"0.46107337\",\n \"0.46043545\",\n \"0.45970452\",\n \"0.45920217\",\n \"0.45911533\",\n \"0.45852852\",\n \"0.45762974\",\n \"0.45722124\",\n \"0.45691916\",\n \"0.4559683\",\n \"0.4556273\",\n \"0.455437\",\n \"0.45497307\",\n \"0.45415783\",\n \"0.45405617\",\n \"0.45398763\",\n \"0.45394397\",\n \"0.45376632\",\n \"0.45373675\",\n \"0.45241743\",\n \"0.45241743\",\n \"0.45232397\",\n \"0.4519799\",\n \"0.45189357\",\n \"0.45187494\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5767312"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":8790,"cells":{"query":{"kind":"string","value":"make test label for combinations helper with two simple children."},"document":{"kind":"string","value":"def _make_combinationsTest_label(chain_parts):\n\n assert len(chain_parts) == 1\n scenario = chain_parts[0]['hypoScenario']\n \n assert scenario == 'combinationsTest'\n\n \n\n return \"\"\"\n combgen(\n [(2)(20et, 0eta320)]\n \n simple([(40et, 0eta320) (50et, 0eta320)])\n simple([(35et, 0eta240) (55et, 0eta240)])\n )\"\"\""},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def test_sums():\n assert label_parent(1, 2) == 3\n assert label_parent (1, 4) == 8\n # Should ignore arg order\n assert label_parent(4, 1) == 8","def _make_partitionsTest_label(chain_parts):\n\n assert len(chain_parts) == 1\n scenario = chain_parts[0]['hypoScenario']\n \n assert scenario == 'partitionsTest'\n\n \n\n return \"\"\"\n partgen(\n [(20et, 0eta320)]\n \n simple([(40et, 0eta320) (50et, 0eta320)])\n simple([(35et, 0eta240) (55et, 0eta240)])\n )\"\"\"","def test_recipe_nutrition_label_widget(self):\n pass","def test_select_label(self):\n title = ('Transportation Challenges Limit Education Choices for '\n 'Denver Parents')\n summary = \"\"\"\n Many families in the Denver metro area use public\n transportation instead of a school bus because for them, a\n quality education is worth hours of daily commuting. Colorado's\n school choice program is meant to foster educational equity,\n but the families who benefit most are those who have time and\n money to travel. Low-income families are often left in a lurch.\n \"\"\"\n byline = \"Mile High Connects\"\n story = create_story(title=title, summary=summary, byline=byline)\n layout = SectionLayout.objects.get(sectionlayouttranslation__name=\"Side by Side\")\n section1 = create_section(title=\"Test Section 1\", story=story, layout=layout)\n section2 = create_section(title=\"Test Section 2\", story=story, layout=layout)\n form = SectionRelationAdminForm()\n choices_list = list(form.fields['parent'].widget.choices)\n self.assertIn(story.title, choices_list[1][1])\n self.assertIn(story.title, choices_list[2][1])","def setUp(self):\n\n singleLabels = linkoCreate.Linkograph(\n [({'A'}, set(), {1,2,3}),\n ({'D'}, {0}, {3,4}),\n ({'A'}, {0}, {4}),\n ({'C'}, {0,1}, {4}),\n ({'A'}, {1,2,3}, set())],\n ['A', 'B', 'C', 'D'])\n\n singleSubLinko0_2 = linkoCreate.Linkograph(\n [({'A'}, set(), {1,2}),\n ({'D'}, {0}, set()),\n ({'A'}, {0}, set())],\n ['A', 'B', 'C', 'D'])\n\n singleSubLinko0_1 = linkoCreate.Linkograph(\n [({'A'}, set(), {1}),\n ({'D'}, {0}, set())],\n ['A', 'B', 'C', 'D'])\n\n singleSubLinko0_0 = linkoCreate.Linkograph(\n [({'A'}, set(), set())],\n ['A', 'B', 'C', 'D'])\n\n singleSubLinko1_2 = linkoCreate.Linkograph(\n [({'D'}, set(), set()),\n ({'A'}, set(), set())],\n ['A', 'B', 'C', 'D'])\n\n singleSubLinko1_1 = linkoCreate.Linkograph(\n [({'D'}, set(), set())],\n ['A', 'B', 'C', 'D'])\n\n trivialLinkograph = linkoCreate.Linkograph(\n [], ['A', 'B', 'C', 'D'])\n\n\n singleSubLinko1_4 = linkoCreate.Linkograph(\n [({'D'}, set(), {2,3}),\n ({'A'}, set(), {3}),\n ({'C'}, {0}, {3}),\n ({'A'}, {0,1,2}, set())],\n ['A', 'B', 'C', 'D'])\n\n singleSubLinko2_4 = linkoCreate.Linkograph(\n [({'A'}, set(), {2}),\n ({'C'}, set(), {2}),\n ({'A'}, {0,1}, set())],\n ['A', 'B', 'C', 'D'])\n\n singleSubLinko3_4 = linkoCreate.Linkograph(\n [({'C'}, set(), {1}),\n ({'A'}, {0}, set())],\n ['A', 'B', 'C', 'D'])\n\n singleSubLinko4_4 = linkoCreate.Linkograph(\n [({'A'}, set(), set())],\n ['A', 'B', 'C', 'D'])\n\n simpleLinko = linkoCreate.Linkograph(\n [({'A', 'B', 'C'}, set(), {1,2,3}),\n ({'D'}, {0}, {3,4}),\n ({'A'}, {0}, {4}),\n ({'B', 'C'}, {0,1}, {4}),\n ({'A'}, {1,2,3}, set())],\n ['A', 'B', 'C', 'D'])\n\n if self.id().split('.')[-1] == 'test_createSubLinkographWithoutCommands':\n self.testParams = [\n {'linko': singleLabels,\n 'lowerBound': None,\n 'upperBound': None,\n 'ExpectedLinkograph': singleLabels},\n\n {'linko': singleLabels,\n 'lowerBound': 0,\n 'upperBound': 4,\n 'ExpectedLinkograph': singleLabels},\n\n {'linko': singleLabels,\n 'lowerBound': 0,\n 'upperBound': 5,\n 'ExpectedLinkograph': singleLabels},\n\n {'linko': singleLabels,\n 'lowerBound': 0,\n 'upperBound': 2,\n 'ExpectedLinkograph': singleSubLinko0_2},\n\n {'linko': singleLabels,\n 'lowerBound': -1,\n 'upperBound': 2,\n 'ExpectedLinkograph': singleSubLinko0_2},\n\n {'linko': singleLabels,\n 'lowerBound': None,\n 'upperBound': 2,\n 'ExpectedLinkograph': singleSubLinko0_2},\n\n {'linko': singleLabels,\n 'lowerBound': 0,\n 'upperBound': 1,\n 'ExpectedLinkograph': singleSubLinko0_1},\n\n {'linko': singleLabels,\n 'lowerBound': 0,\n 'upperBound': 0,\n 'ExpectedLinkograph': singleSubLinko0_0},\n\n {'linko': singleLabels,\n 'lowerBound': 0,\n 'upperBound': -1,\n 'ExpectedLinkograph': trivialLinkograph},\n\n {'linko': singleLabels,\n 'lowerBound': 1,\n 'upperBound': 2,\n 'ExpectedLinkograph': singleSubLinko1_2},\n\n {'linko': singleLabels,\n 'lowerBound': 1,\n 'upperBound': 1,\n 'ExpectedLinkograph': singleSubLinko1_1},\n\n {'linko': singleLabels,\n 'lowerBound': 1,\n 'upperBound': 0,\n 'ExpectedLinkograph': trivialLinkograph},\n\n {'linko': singleLabels,\n 'lowerBound': -1,\n 'upperBound': -1,\n 'ExpectedLinkograph': trivialLinkograph},\n\n {'linko': singleLabels,\n 'lowerBound': 1,\n 'upperBound': 4,\n 'ExpectedLinkograph': singleSubLinko1_4},\n\n {'linko': singleLabels,\n 'lowerBound': 2,\n 'upperBound': 4,\n 'ExpectedLinkograph': singleSubLinko2_4},\n\n {'linko': singleLabels,\n 'lowerBound': 3,\n 'upperBound': 4,\n 'ExpectedLinkograph': singleSubLinko3_4},\n\n {'linko': singleLabels,\n 'lowerBound': 4,\n 'upperBound': 4,\n 'ExpectedLinkograph': singleSubLinko4_4},\n\n ]","def test_labels(self):\n self.compliance_tester.test_labels(self.oi)","def test_parent_label(self):\n l = self.d.label(1)\n l2 = self.d.label(31405)\n\n self.assertTrue(l.parent_label is None)\n self.assertTrue(l2 in l.sublabels)\n self.assertEqual(l2.parent_label, l)","def test_simple(self):\n exp = [{'type': NewickEvents.OPEN_SUBTREE, 'comments': []},\n {'type': NewickEvents.OPEN_SUBTREE, 'comments': []},\n {'edge_info': None, 'type': NewickEvents.TIP, 'comments': [], 'label': 'h'},\n {'edge_info': None, 'type': NewickEvents.TIP, 'comments': [], 'label': 'p'},\n {'edge_info': '1', 'type': NewickEvents.CLOSE_SUBTREE,\n 'comments': [], 'label': 'hp'},\n {'edge_info': None, 'type': NewickEvents.TIP, 'comments': [], 'label': 'g'},\n {'edge_info': None, 'type': NewickEvents.CLOSE_SUBTREE,\n 'comments': [], 'label': 'hpg'}\n ]\n content = '((h,p)hp:1,g)hpg;'\n self._do_test(content, exp)\n content = '((h,[pretest]p[test][posttest])hp,g)hpg;'\n exp = [{'type': NewickEvents.OPEN_SUBTREE, 'comments': []},\n {'type': NewickEvents.OPEN_SUBTREE, 'comments': []},\n {'edge_info': None, 'type': NewickEvents.TIP, 'comments': [], 'label': 'h'},\n {'edge_info': None, 'type': NewickEvents.TIP,\n 'comments': ['pretest', 'test', 'posttest'], 'label': 'p'},\n {'edge_info': None, 'type': NewickEvents.CLOSE_SUBTREE,\n 'comments': [], 'label': 'hp'},\n {'edge_info': None, 'type': NewickEvents.TIP, 'comments': [], 'label': 'g'},\n {'edge_info': None, 'type': NewickEvents.CLOSE_SUBTREE,\n 'comments': [], 'label': 'hpg'}\n ]\n self._do_test(content, exp)","def test_label(self):\n xs = t.Label(t.Exactly(\"x\"), 'CustomLabel')\n self.assertEqual(writePython(xs),\n dd(\"\"\"\n def _G_label_1():\n _G_exactly_2, lastError = self.exactly('x')\n self.considerError(lastError, None)\n return (_G_exactly_2, self.currentError)\n _G_label_3, lastError = self.label(_G_label_1, \"CustomLabel\")\n self.considerError(lastError, None)\n _G_label_3\n \"\"\"))","def addLabels(t):\n if not t.label:\n t.label = \"\".join([choice(\"abcdefghijklmnopqrstuvwxyz\") for i in range(4)])\n for r,w in t.children:\n addLabels(r)","def test_general_subset_level():\n pass","def _make_simple_comb_label(chain_dict):\n\n cps = chain_dict['chainParts']\n if not (_select_simple_chainparts(cps)):\n raise NotImplementedError(\n 'chain fails substring selection: not \"simple\": %s' % (\n chain_dict['chainName']))\n \n simple_strs = []\n\n for cp in cps:\n print(cp)\n simple_strs.append(_make_simple_label([cp]))\n\n label = 'combgen([(%d)]' % len(cps)\n for s in simple_strs:\n label += ' %s ' % s\n label += ')'\n return label","def _generateLabelAndName(self, obj, **args):\n result = []\n label = self._generateLabel(obj, **args)\n name = self._generateName(obj, **args)\n result.extend(label)\n if not len(label):\n result.extend(name)\n elif len(name) and name[0].strip() != label[0].strip():\n result.extend(name)\n return result","def tests_ti_document_add_label(self):\n super().group_add_label()","def getLabel2(*args):","def getLabel2(*args):","def test_checkboxtextgroup(self):\r\n self.check_group('checkboxtextgroup', 'choice', 'checkbox')","def _generateTableCell2ChildLabel(self, obj, **args):\n result = []\n\n # If this table cell has 2 children and one of them has a\n # 'toggle' action and the other does not, then present this\n # as a checkbox where:\n # 1) we get the checked state from the cell with the 'toggle' action\n # 2) we get the label from the other cell.\n # See Orca bug #376015 for more details.\n #\n if obj.childCount == 2:\n cellOrder = []\n hasToggle = [False, False]\n for i, child in enumerate(obj):\n if self._script.utilities.hasMeaningfulToggleAction(child):\n hasToggle[i] = True\n break\n if hasToggle[0] and not hasToggle[1]:\n cellOrder = [ 1, 0 ]\n elif not hasToggle[0] and hasToggle[1]:\n cellOrder = [ 0, 1 ]\n if cellOrder:\n for i in cellOrder:\n if not hasToggle[i]:\n result.extend(self.generate(obj[i], **args))\n return result","def test_process_label_in_node(self):\n tree = Node(children=[\n Node(\"Defining secret phrase.\", label=['AB', 'a']),\n Node(\"Has secret phrase. Then some other content\", \n label=['AB', 'b'])\n ], label=['AB'])\n t = Terms(tree)\n t.scoped_terms = {\n ('AB',): [Ref(\"secret phrase\", \"AB-a\", (9,22))]\n }\n # Term is defined in the first child\n self.assertEqual([], t.process(tree.children[0]))\n self.assertEqual(1, len(t.process(tree.children[1])))","def get_extra_label(self, label_name: str, hierarchy: List[str]) -> Any:","def test_get_scenarios_expanded(self):\n pass","def test_nested():\n res = conf.status.conditions.choose(lambda c: (c.type, c.reason, c.root.metadata.choose(lambda m: (m[\"name\"], m.uid))))\n assert \"type\" in res # from conditions\n assert \"reason\" in res # from conditions\n assert \"name\" in res # from metadata\n assert \"uid\" in res # from metadata","def _make_simple_label(chain_parts):\n \n if not _select_simple_chainparts(chain_parts):\n msg = 'Jet Configuration error: '\\\n 'chain fails substring selection: not \"simple\" '\n\n raise NotImplementedError(msg)\n \n label = 'simple(['\n for cp in chain_parts:\n smcstr = str(cp['smc'])\n jvtstr = str(cp['jvt'])\n if smcstr == 'nosmc':\n smcstr = ''\n for i in range(int(cp['multiplicity'])):\n # condition_str = '(%set,%s,%s)' % (str(cp['threshold']),\n # str(cp['etaRange']),\n # smcstr,)\n condition_str = '(%set,%s' % (str(cp['threshold']),\n str(cp['etaRange']),)\n if smcstr: # Run 2 chains have \"INF\" in the SMC substring\n condition_str += ',%s)' % smcstr.replace('INF','')\n elif jvtstr:\n condition_str += ',%s)' % jvtstr\n else:\n condition_str += ')'\n label += condition_str\n label += '])'\n return label","def test_nested_sequence(self):\n\n self.taxon_tester('Apis mellifera')\n self.taxon_tester('Apis')\n self.taxon_tester('Apini')\n self.taxon_tester('Apinae')\n # Apidae at 5680 species is a struggle\n self.taxon_tester('Apidae')\n if False:\n # Apoidea: 19566 takes 223 seconds\n self.taxon_tester('Apoidea')\n # Aculeata fails after 339 seconds\n self.taxon_tester('Aculeata')\n self.taxon_tester('Apocrita')\n self.taxon_tester('Hymenoptera')\n self.taxon_tester('Endopterygota')\n self.taxon_tester('Neoptera')\n self.taxon_tester('Pterygota')\n self.taxon_tester('Dicondylia')\n self.taxon_tester('Insecta')\n self.taxon_tester('Hexapoda')\n self.taxon_tester('Pancrustacea')\n self.taxon_tester('Mandibulata')\n self.taxon_tester('Arthropoda')\n self.taxon_tester('Panarthropoda')\n self.taxon_tester('Ecdysozoa')\n self.taxon_tester('Protostomia')\n self.taxon_tester('Bilateria')\n self.taxon_tester('Eumetazoa')\n self.taxon_tester('Metazoa')\n self.taxon_tester('Holozoa')\n self.taxon_tester('Opisthokonta')\n self.taxon_tester('Eukaryota')","def test_bootstrap_support_labeled(self):\r\n master_tree = parse_newick('((a:2,b:3)ab:2,(c:1,d:2)cd:7)rt;')\r\n \"\"\"\r\n /-------.5 /-a\r\n ---1| \\-b\r\n \\------.5 /-c\r\n \\-d\r\n \"\"\"\r\n t1 = parse_newick('((a:6,b:8.2)hi:2,(c:1,d:2):7);') # same structure\r\n t2 = parse_newick('((a:2,b:3,c:33)ho:2,d:7);') # abc are siblings\r\n new_master, bootstraps = tc.bootstrap_support(master_tree, [t1, t2])\r\n expected = dict([('ab', .5), ('cd', .5), ('rt', 1.0)])\r\n self.assertDictEqual(bootstraps, expected)","def test_title(names):","def test_verbose_name_group(self): \n field_verboses = {\n \"title\": \"Название группы\",\n \"slug\": \"Слаг\",\n \"description\": \"Описание группы\",\n }\n for value, expected in field_verboses.items():\n with self.subTest(value=value):\n self.assertEqual(self.group._meta.get_field(value).verbose_name, expected)","def plugin_second_label():\n return \"second\"","def test_product_labels(self):\n\n prd = Product.objects.get(id=1)\n # label name\n label_name = prd._meta.get_field('name').verbose_name\n self.assertEqual(label_name, 'name')\n # label description\n label_name = prd._meta.get_field('description').verbose_name\n self.assertEqual(label_name, 'description')\n # label nutrition_grade\n label_name = prd._meta.get_field('nutrition_grade').name\n self.assertEqual(label_name, 'nutrition_grade')\n # label barcode\n label_name = prd._meta.get_field('barcode').verbose_name\n self.assertEqual(label_name, 'barcode')\n # label url\n label_name = prd._meta.get_field('url').verbose_name\n self.assertEqual(label_name, 'url')\n # label url_pic\n label_name = prd._meta.get_field('url_pic').name\n self.assertEqual(label_name, 'url_pic')\n # label store\n label_name = prd._meta.get_field('store').verbose_name\n self.assertEqual(label_name, 'store')\n # label prd_cat\n label_name = prd._meta.get_field('prd_cat').name\n self.assertEqual(label_name, 'prd_cat')\n # label fat\n label_name = prd._meta.get_field('fat').verbose_name\n self.assertEqual(label_name, 'fat')\n # label saturated_fat\n label_name = prd._meta.get_field('saturated_fat').name\n self.assertEqual(label_name, 'saturated_fat')\n # label sugar\n label_name = prd._meta.get_field('sugar').verbose_name\n self.assertEqual(label_name, 'sugar')\n # label salt\n label_name = prd._meta.get_field('salt').verbose_name\n self.assertEqual(label_name, 'salt')","def is_test(self):\r\n return self.has_label('tests')","def setUp(self):\n\n\n # InverseLabeling\n invLabeling0 = {'L0': [0, 1, 2]}\n\n invLabeling1 = {'L0' : [0, 2],\n 'L1' : [1]}\n\n invLabeling2 = {\n 'L0' : [0],\n 'L1' : [1],\n 'L2' : [2]\n }\n\n invLabeling3 = {\n 'L1' : [0, 1],\n 'L2' : [2]\n }\n\n invLabeling4 = {\n 'L0' : [0,1],\n 'L1' : [0],\n 'L2' : [2]\n }\n\n invLabeling5 = {\n 'L0': [0, 1, 2],\n 'L1': []\n }\n \n # Create some ontologies\n ontology0 = {'L0': ['L0']}\n\n ontology1 = {}\n\n ontology2 = {'L0': ['L1']}\n\n ontology3 = {'L0': ['L1', 'L2'],\n 'L1': ['L2'],\n 'L2': ['L0']}\n\n if self.id().split('.')[-1] == 'test_createLinkograph':\n self.testParams = [\n {'inverseLabeling': invLabeling0,\n 'ontology': ontology0,\n 'ExpectedLinkograph':\n linkoCreate.Linkograph(\n [({'L0'}, set(), {1, 2}),\n ({'L0'}, {0}, {2}),\n ({'L0'}, {0,1}, set())] \n )},\n\n {'inverseLabeling': invLabeling0,\n 'ontology': ontology1,\n 'ExpectedLinkograph':\n linkoCreate.Linkograph(\n [({'L0'}, set(), set()),\n ({'L0'}, set(), set()),\n ({'L0'}, set(), set())]\n )},\n\n {'inverseLabeling': invLabeling0,\n 'ontology': ontology2,\n 'ExpectedLinkograph':\n linkoCreate.Linkograph(\n [({'L0'}, set(), set()),\n ({'L0'}, set(), set()),\n ({'L0'}, set(), set())]\n )},\n\n\n {'inverseLabeling': invLabeling1,\n 'ontology': ontology0,\n 'ExpectedLinkograph':\n linkoCreate.Linkograph(\n [({'L0'}, set(), {2}),\n ({'L1'}, set(), set()),\n ({'L0'}, {0}, set())]\n )},\n\n {'inverseLabeling': invLabeling1,\n 'ontology': ontology1,\n 'ExpectedLinkograph':\n linkoCreate.Linkograph(\n [({'L0'}, set(), set()),\n ({'L1'}, set(), set()),\n ({'L0'}, set(), set())]\n )},\n\n {'inverseLabeling': invLabeling1,\n 'ontology': ontology2,\n 'ExpectedLinkograph':\n linkoCreate.Linkograph(\n [({'L0'}, set(), {1}),\n ({'L1'}, {0}, set()),\n ({'L0'}, set(), set())]\n )},\n\n {'inverseLabeling': invLabeling0,\n 'ontology': ontology3,\n 'ExpectedLinkograph':\n linkoCreate.Linkograph(\n [({'L0'}, set(), set()),\n ({'L0'}, set(), set()),\n ({'L0'}, set(), set())]\n )},\n\n {'inverseLabeling': invLabeling1,\n 'ontology': ontology3,\n 'ExpectedLinkograph':\n linkoCreate.Linkograph(\n [({'L0'}, set(), {1}),\n ({'L1'}, {0}, set()),\n ({'L0'}, set(), set())]\n )},\n\n {'inverseLabeling': invLabeling2,\n 'ontology': ontology3,\n 'ExpectedLinkograph':\n linkoCreate.Linkograph(\n [({'L0'}, set(), {1,2}),\n ({'L1'}, {0}, {2}),\n ({'L2'}, {0, 1}, set())]\n )},\n\n {'inverseLabeling': invLabeling3,\n 'ontology': ontology3,\n 'ExpectedLinkograph':\n linkoCreate.Linkograph(\n [({'L1'}, set(), {2}),\n ({'L1'}, set(), {2}),\n ({'L2'}, {0, 1}, set())]\n )},\n\n {'inverseLabeling': invLabeling4,\n 'ontology': ontology3,\n 'ExpectedLinkograph':\n linkoCreate.Linkograph(\n [({'L0', 'L1'}, set(), {2}),\n ({'L0'}, set(), {2}),\n ({'L2'}, {0, 1}, set())]\n )},\n\n {'inverseLabeling': invLabeling5,\n 'ontology': ontology3,\n 'ExpectedLinkograph':\n linkoCreate.Linkograph(\n [({'L0'}, set(), set()),\n ({'L0'}, set(), set()),\n ({'L0'}, set(), set())]\n )},\n\n ]","def test_mutual_exclusivity_of_labels(self, tmpdir, docker_tasker, labels, expected_fail):\n runner = mock_env(tmpdir, docker_tasker, labels=labels)\n if expected_fail:\n with pytest.raises(PluginFailedException) as e:\n runner.run()\n assert 'only one of labels' in str(e.value)\n else:\n runner.run()","def helper_label(helper):\n return helper.info","def test_Tree():","def test_col_data_label_with_attrs(self):\n help_tag = 'span'\n help_text_br = False\n names = ('first', 'billing_address_1')\n attrs = {'style': 'width: 10rem; display: inline-block'}\n label_attrs = {name: attrs for name in names}\n txt = '{}=\"{}\"'.format(*list(attrs.items())[0])\n expected = ['<label for=\"id_first\" {}>First:</label>'.format(txt)]\n expected.append('<label for=\"id_billing_address_1\" {}>street address (line 1):</label>'.format(txt))\n actual = []\n for name in names:\n field = self.form.fields[name]\n response = self.form.collect_col_data(name, field, help_tag, help_text_br, label_attrs)\n actual.append(response.get('label'))\n\n for expect, got in zip(expected, actual):\n self.assertEqual(expect, got)","def test_help_text_group(self): \n field_help_text = {\n \"title\": \"Дайте назание группе\",\n \"slug\": ('Укажите адрес для группы. Используйте '\n 'только латиницу, цифры, дефисы и знаки '\n 'подчёркивания'),\n } \n for value, expected in field_help_text.items():\n with self.subTest(value=value):\n self.assertEqual(self.group._meta.get_field(value).help_text, expected)","def test_label_choices(self):\n test_classes = (\n (0, 'No'),\n (1, 'Yes')\n )\n\n form = SingleLabelClassifierForm(classes=test_classes)\n self.assertEqual(tuple(form.fields['label'].choices), test_classes)\n\n form = MultiLabelClassifierForm(classes=test_classes)\n self.assertEqual(tuple(form.fields['label'].choices), test_classes)","def test_filter_tree(self):\r\n actual = [e.Name for e in filter_tree(\r\n self.tree1, ['bbb', 'ccc']).tips()]\r\n #(a_a:10,(b_b:2,c_c:4):5);\r\n expected = [\r\n e.Name for e in DndParser(\r\n \"((bbb:2,ccc:4));\",\r\n PhyloNode).tips(\r\n )]\r\n self.assertEqual(actual, expected)\r\n\r\n actual = [e.Name for e in filter_tree(\r\n self.tree2, ['bbb', 'ccc']).tips()]\r\n #(a_a:10,(b_b:2,c_c:4):5);\r\n expected = [\r\n e.Name for e in DndParser(\r\n \"(('bbb':2,ccc:4));\",\r\n PhyloNode).tips(\r\n )]\r\n self.assertEqual(actual, expected)","def test_radiotextgroup(self):\r\n self.check_group('radiotextgroup', 'choice', 'radio')","def gen_test_case_combination(self):\n\n cases = '\\n'\n\n binary_ops = list(self.BINARY_OPS)\n binary_ops.reverse()\n for op1 in self.BINARY_OPS:\n for op2 in binary_ops:\n\n result = []\n ret = IntOp.binary_op(op2, '0', '1', self.lane_width)\n ret = IntOp.binary_op(op1, ret, '2', self.lane_width)\n result.append(ret)\n\n cases += '\\n' + str(AssertReturn('{lane_type}.{op1}-{lane_type}.{op2}'.format(lane_type=self.LANE_TYPE, op1=op1, op2=op2),\n [SIMD.v128_const('0', self.LANE_TYPE),\n SIMD.v128_const('1', self.LANE_TYPE),\n SIMD.v128_const('2', self.LANE_TYPE)],\n SIMD.v128_const(result, self.LANE_TYPE)))\n cases += '\\n'\n return cases","def test_multiple_task_groups_dag(\n self, test_multiple_taskgroups_dag, multiple_taskgroups_dag_expected_edges\n ):\n (\n dag,\n group1,\n group2,\n group3,\n (\n group1_emp1,\n group1_emp2,\n group1_emp3,\n group2_emp1,\n group2_emp2,\n group2_emp3,\n group2_op1,\n group2_op2,\n group3_emp1,\n group3_emp2,\n group3_emp3,\n emp_in1,\n emp_in2,\n emp_in3,\n emp_in4,\n emp_out1,\n emp_out2,\n emp_out3,\n emp_out4,\n op_in1,\n op_out1,\n ),\n ) = test_multiple_taskgroups_dag\n\n group1_emp1 >> Label(\"label group1.group1_emp1 <=> group1.group1_emp2\") >> group1_emp3\n\n emp_in1 >> group1\n emp_in2 >> Label(\"label emp_in2 <=> group1\") >> group1\n [emp_in3, emp_in4] >> Label(\"label emp_in3/emp_in4 <=> group1\") >> group1\n XComArg(op_in1, \"test_key\") >> Label(\"label op_in1 <=> group1\") >> group1\n\n (\n [group2_emp1, group2_emp2]\n >> Label(\"label group2.group2_emp1/group2.group2_emp2 <=> group2.group2_emp3\")\n >> group2_emp3\n )\n (\n group2_emp1\n >> Label(\"label group2.group2_emp1 <=> group2.group2_emp2/group2.group2_emp3\")\n >> [group2_emp2, group2_emp3]\n )\n group2_emp3 >> Label(\"label group2.group2_emp3 <=> group3\") >> group3\n\n (\n XComArg(group2_op1, \"test_key\")\n >> Label(\"label group2.group2_op1 <=> group2.group2_op2\")\n >> XComArg(group2_op2, \"test_key\")\n )\n XComArg(group2_op2, \"test_key\") >> Label(\"label group2.group2_op2 <=> group3\") >> group3\n\n group3 >> emp_out1\n group3 >> Label(\"label group3 <=> emp_out2\") >> emp_out2\n group3 >> Label(\"label group3 <=> emp_out3/emp_out4\") >> [emp_out3, emp_out4]\n group3 >> Label(\"label group3 <=> op_out1\") >> XComArg(op_out1, \"test_key\")\n\n group1 >> Label(\"label group1 <=> group2\") >> group2\n\n compare_dag_edges(dag_edges(dag), multiple_taskgroups_dag_expected_edges)","def test_issue_create_label(self):\n pass","def test__create_label_w_no_ent_id(ruler: SpaczzRuler) -> None:\n assert ruler._create_label(\"TEST\", None) == \"TEST\"","def test_grouping(self):\n s = self.create(ComponentItem, UML.Component)\n uc1 = self.create(UseCaseItem, UML.UseCase)\n uc2 = self.create(UseCaseItem, UML.UseCase)\n\n self.group(s, uc1)\n assert 1 == len(uc1.subject.subject)\n self.group(s, uc2)\n assert 1 == len(uc2.subject.subject)\n\n # Classifier.useCase is not navigable to UseCase\n # self.assertEqual(2, len(s.subject.useCase))","def setLabel2(*args):","def tests_ti_document_get_label(self):\n super().group_get_label()","def test_render_label(self):\n label = self.block.meta.label\n self.assertEqual(label, 'Google Calendar', 'The labels are not the same')","def check_elm(orphan_root, obj, orphan_labels, orphan_widgets):\n\n oid = obj.attrib.get('id')\n klass = obj.attrib.get('class')\n\n # \"Don't care\" special case\n if klass in widgets_ignored:\n return\n for suffix in widgets_suffixignored:\n if klass[-len(suffix):] == suffix:\n return\n\n # Widgets usual do not strictly require a label, i.e. a labelled parent\n # is enough for context, but some do always need one.\n requires_label = klass in widgets_needlabel\n\n if oid is not None:\n # Check that ids are unique\n if oid in ids_dup:\n if ids[oid] == obj:\n # We are the first, warn\n duplicates = tree.findall(\".//object[@id='\" + oid + \"']\")\n err(filename, tree, obj, \"duplicate-id\", \"has the same id as other elements \" + elms_names_lines(duplicates))\n\n # Check label-for and their dual labelled-by\n label_for = check_rels(filename, tree, root, obj, \"label-for\", \"labelled-by\")\n\n # Check labelled-by and its dual label-for\n labelled_by = check_rels(filename, tree, root, obj, \"labelled-by\", \"label-for\")\n\n # Check label-for and their dual labelled-by\n description_for = check_rels(filename, tree, root, obj, \"description-for\", \"described-by\")\n\n # Check labelled-by and its dual label-for\n described_by = check_rels(filename, tree, root, obj, \"described-by\", \"description-for\")\n\n # Should have only one label\n if len(labelled_by) >= 1:\n if oid in mnemonic_for_elm:\n warn(filename, tree, obj, \"labelled-by-and-mnemonic\",\n \"has both a mnemonic \" + elm_name_line(mnemonic_for_elm[oid][0]) + \"and labelled-by relation\")\n if len(labelled_by) > 1:\n warn(filename, tree, obj, \"multiple-labelled-by\", \"has multiple labelled-by relations\")\n if oid in label_for_elm:\n if len(label_for_elm[oid]) > 1:\n warn(filename, tree, obj, \"duplicate-label-for\", \"is referenced by multiple label-for \" + elms_names_lines(label_for_elm[oid]))\n if oid in mnemonic_for_elm:\n if len(mnemonic_for_elm[oid]) > 1:\n warn(filename, tree, obj, \"duplicate-mnemonic\", \"is referenced by multiple mnemonic_widget \" + elms_names_lines(mnemonic_for_elm[oid]))\n\n # Check member-of\n member_of = check_rels(filename, tree, root, obj, \"member-of\")\n\n # Labels special case\n if klass in widgets_labels:\n properties = check_props(filename, tree, root, obj, \"mnemonic_widget\") + \\\n check_props(filename, tree, root, obj, \"mnemonic-widget\")\n if len(properties) > 1:\n err(filename, tree, obj, \"multiple-mnemonic\", \"has multiple mnemonic_widgets properties\"\n \"%s\" % elms_lines(properties))\n\n # Emit orphaning warnings\n if warn_orphan_labels or orphan_widgets:\n is_orphan_label(filename, tree, root, obj, orphan_root, True)\n\n # We are done with the label\n return\n\n # Not a label, will perhaps need one\n\n # Emit orphaning warnings\n is_orphan_widget(filename, tree, root, obj, orphan_labels, orphan_root, True)","def get_label(self, hierarchy: List[str]) -> Any:","def test_first_level_from_bids_no_duplicate_sub_labels(bids_dataset):\n models, *_ = first_level_from_bids(\n dataset_path=bids_dataset,\n task_label='main',\n sub_labels=[\"01\", \"01\"],\n space_label='MNI',\n img_filters=[('desc', 'preproc')],\n slice_time_ref=None,\n )\n\n assert len(models) == 1","def test_add_empty_nodes_with_label_when_splitting(self):\n print \"----- test_add_empty_nodes_with_label_when_splitting -----\"\n sel_axis = (lambda axis: axis)\n \n #create tree, first node splits in x direction\n tree = kdtree.createNewTree([[0.5, 0.5]],axis = 0, sel_axis= sel_axis)\n kdtree.visualize(tree)\n \n point_left = [0.4, 0.5]\n tree.split2(point_left, axis = 0)\n kdtree.visualize(tree)\n \n point1 = [0.3, 0.5]\n found_node = tree.get_path_to_leaf(point1)[-1]\n correct_node1 = 3\n self.assertEqual(found_node.label, correct_node1, \"Not correct node found\")\n \n point_right = [0.6, 0.5]\n tree.split2(point_right, axis = 1)\n kdtree.visualize(tree)\n \n point2 = [0.6, 0.7]\n found_node = tree.get_path_to_leaf(point2)[-1]\n correct_node2 = 6\n self.assertEqual(found_node.label, correct_node2, \"Not correct node found\")\n \n print \"----- end: test_add_empty_nodes_with_label_when_splitting -----\"","def test_render_value_label(self):\n self.check_html(\n self.widget(choices=self.beatles),\n \"beatles\",\n [\"John\"],\n html=(\n \"\"\"<select multiple name=\"beatles\">\n <option value=\"J\">John</option>\n <option value=\"P\">Paul</option>\n <option value=\"G\">George</option>\n <option value=\"R\">Ringo</option>\n </select>\"\"\"\n ),\n )","def test_issue_add_label(self):\n pass","def test_create_metering_label(self):\r\n resource = 'metering_label'\r\n cmd = metering.CreateMeteringLabel(\r\n test_cli20.MyApp(sys.stdout), None)\r\n name = 'my label'\r\n myid = 'myid'\r\n description = 'my description'\r\n args = [name, '--description', description, '--shared']\r\n position_names = ['name', 'description', 'shared']\r\n position_values = [name, description, True]\r\n self._test_create_resource(resource, cmd, name, myid, args,\r\n position_names, position_values)","def getLabel(*args):","def getLabel(*args):","def getLabel(*args):","def _make_vbenf_label(chain_parts):\n\n # toy label for development: run simple and dijet independently.\n # simple makes Et cuts on two jets. Independently (sharing possible)\n # of jets choosean by simple, the dijet\n # scenario requires a dijet of mass > 900, and opening angle in phi > 2.6\n\n assert len(chain_parts) == 1\n scenario = chain_parts[0]['hypoScenario']\n assert scenario.startswith('vbenf')\n args = _args_from_scenario(scenario)\n if not args:\n return 'and([]simple([(50et)(70et)])combgen([(2)] dijet([(900djmass, 26djdphi)])))' \n arg_res = [\n re.compile(r'(?P<lo>\\d*)(?P<key>fbet)(?P<hi>\\d*)'),\n re.compile(r'(?P<lo>\\d*)(?P<key>mass)(?P<hi>\\d*)'),\n re.compile(r'(?P<lo>\\d*)(?P<key>et)(?P<hi>\\d*)'),\n ]\n\n defaults = {\n 'et': ('101', 'inf'),\n 'mass': ('800', 'inf'),\n 'fbet': ('501', 'inf'),\n }\n\n argvals = {}\n while args:\n assert len(args) == len(arg_res)\n arg = args.pop()\n for r in arg_res:\n m = r.match(arg)\n if m is not None:\n arg_res.remove(r)\n gd = m.groupdict()\n key = gd['key']\n try:\n lo = float(gd['lo'])\n except ValueError:\n lo = defaults[key][0]\n argvals[key+'lo'] = lo \n try:\n hi = float(gd['hi'])\n except ValueError:\n hi = defaults[key][1]\n argvals[key+'hi'] = hi\n\n assert len(args) == len(arg_res)\n assert len(args) == 0\n\n return \"\"\"\n and\n (\n []\n simple\n (\n [(%(etlo).0fet, 500neta)(%(etlo).0fet, peta500)]\n )\n combgen\n (\n [(10et, 0eta320)]\n dijet\n (\n [(%(masslo).0fdjmass, 26djdphi)]\n ) \n simple\n (\n [(10et, 0eta320)(20et, 0eta320)]\n )\n )\n )\"\"\" % argvals","def testFormatLabelAndValue(self):\n\n self.assertEqual('Abc: xyz', self.inv._FormatLabelAndValue('abc', 'xyz', 1))\n self.assertEqual('ABc: xyz', self.inv._FormatLabelAndValue('abc', 'xyz', 2))\n self.assertEqual('ABC: xyz', self.inv._FormatLabelAndValue('abc', 'xyz', 4))","def test_recipe_nutrition_label_image(self):\n pass","def test_label_10_targets_with_a_b_c_(self):\r\n user_input = '[{\"a\":\"target1\"}, \\\r\n {\"b\":\"target2\"},{\"c\":\"target3\"},{\"a\":\"target4\"},{\"b\":\"target5\"}, \\\r\n {\"c\":\"target6\"}, {\"a\":\"target7\"},{\"b\":\"target8\"},{\"c\":\"target9\"}, \\\r\n {\"a\":\"target10\"}]'\r\n correct_answer = [\r\n {\r\n 'draggables': ['a'],\r\n 'targets': ['target1', 'target4', 'target7', 'target10'],\r\n 'rule': 'unordered_equal'\r\n },\r\n {\r\n 'draggables': ['b'],\r\n 'targets': ['target2', 'target5', 'target8'],\r\n 'rule': 'unordered_equal'\r\n },\r\n {\r\n 'draggables': ['c'],\r\n 'targets': ['target3', 'target6', 'target9'],\r\n 'rule': 'unordered_equal'\r\n }\r\n ]\r\n self.assertTrue(draganddrop.grade(user_input, correct_answer))","def test_label_10_targets_with_a_b_c_multiple(self):\r\n user_input = '[{\"a\":\"target1\"}, \\\r\n {\"b\":\"target2\"},{\"c\":\"target3\"},{\"b\":\"target5\"}, \\\r\n {\"c\":\"target6\"}, {\"a\":\"target7\"},{\"b\":\"target8\"},{\"c\":\"target9\"}, \\\r\n {\"a\":\"target1\"}]'\r\n correct_answer = [\r\n {\r\n 'draggables': ['a', 'a', 'a'],\r\n 'targets': ['target1', 'target4', 'target7', 'target10'],\r\n 'rule': 'anyof+number'\r\n },\r\n {\r\n 'draggables': ['b', 'b', 'b'],\r\n 'targets': ['target2', 'target5', 'target8'],\r\n 'rule': 'anyof+number'\r\n },\r\n {\r\n 'draggables': ['c', 'c', 'c'],\r\n 'targets': ['target3', 'target6', 'target9'],\r\n 'rule': 'anyof+number'\r\n }\r\n ]\r\n self.assertTrue(draganddrop.grade(user_input, correct_answer))","def test_subsystems(self):\n pass","def test_multiply_some_type_links():","def test_build_match_tree_with_pairs():\n abbreviation_list = [[\"ELIF\", \"ELI.\"], [\"ELSE\", \"E.\"]]\n expected_tree = {\"E\": {\"L\": {\"I\": {\"F\": \"ELI.\"}, \"S\": {\"E\": \"E.\"}}}}\n tree = build_match_tree(abbreviation_list)\n assert repr(tree) == repr(expected_tree)","def check_a11y_relation(filename, tree):\n global widgets_ignored, ids, label_for_elm, labelled_by_elm, description_for_elm, described_by_elm, mnemonic_for_elm\n\n def check_elm(orphan_root, obj, orphan_labels, orphan_widgets):\n \"\"\"\n Check one element, knowing that orphan_labels/widgets tell whether\n there are orphan labels and widgets within orphan_root\n \"\"\"\n\n oid = obj.attrib.get('id')\n klass = obj.attrib.get('class')\n\n # \"Don't care\" special case\n if klass in widgets_ignored:\n return\n for suffix in widgets_suffixignored:\n if klass[-len(suffix):] == suffix:\n return\n\n # Widgets usual do not strictly require a label, i.e. a labelled parent\n # is enough for context, but some do always need one.\n requires_label = klass in widgets_needlabel\n\n if oid is not None:\n # Check that ids are unique\n if oid in ids_dup:\n if ids[oid] == obj:\n # We are the first, warn\n duplicates = tree.findall(\".//object[@id='\" + oid + \"']\")\n err(filename, tree, obj, \"duplicate-id\", \"has the same id as other elements \" + elms_names_lines(duplicates))\n\n # Check label-for and their dual labelled-by\n label_for = check_rels(filename, tree, root, obj, \"label-for\", \"labelled-by\")\n\n # Check labelled-by and its dual label-for\n labelled_by = check_rels(filename, tree, root, obj, \"labelled-by\", \"label-for\")\n\n # Check label-for and their dual labelled-by\n description_for = check_rels(filename, tree, root, obj, \"description-for\", \"described-by\")\n\n # Check labelled-by and its dual label-for\n described_by = check_rels(filename, tree, root, obj, \"described-by\", \"description-for\")\n\n # Should have only one label\n if len(labelled_by) >= 1:\n if oid in mnemonic_for_elm:\n warn(filename, tree, obj, \"labelled-by-and-mnemonic\",\n \"has both a mnemonic \" + elm_name_line(mnemonic_for_elm[oid][0]) + \"and labelled-by relation\")\n if len(labelled_by) > 1:\n warn(filename, tree, obj, \"multiple-labelled-by\", \"has multiple labelled-by relations\")\n if oid in label_for_elm:\n if len(label_for_elm[oid]) > 1:\n warn(filename, tree, obj, \"duplicate-label-for\", \"is referenced by multiple label-for \" + elms_names_lines(label_for_elm[oid]))\n if oid in mnemonic_for_elm:\n if len(mnemonic_for_elm[oid]) > 1:\n warn(filename, tree, obj, \"duplicate-mnemonic\", \"is referenced by multiple mnemonic_widget \" + elms_names_lines(mnemonic_for_elm[oid]))\n\n # Check member-of\n member_of = check_rels(filename, tree, root, obj, \"member-of\")\n\n # Labels special case\n if klass in widgets_labels:\n properties = check_props(filename, tree, root, obj, \"mnemonic_widget\") + \\\n check_props(filename, tree, root, obj, \"mnemonic-widget\")\n if len(properties) > 1:\n err(filename, tree, obj, \"multiple-mnemonic\", \"has multiple mnemonic_widgets properties\"\n \"%s\" % elms_lines(properties))\n\n # Emit orphaning warnings\n if warn_orphan_labels or orphan_widgets:\n is_orphan_label(filename, tree, root, obj, orphan_root, True)\n\n # We are done with the label\n return\n\n # Not a label, will perhaps need one\n\n # Emit orphaning warnings\n is_orphan_widget(filename, tree, root, obj, orphan_labels, orphan_root, True)\n\n root = tree.getroot()\n\n # Flush ids and relations from previous files\n ids = {}\n ids_dup = {}\n labelled_by_elm = {}\n label_for_elm = {}\n described_by_elm = {}\n description_for_elm = {}\n mnemonic_for_elm = {}\n\n # First pass to get links into hash tables, no warning, just record duplicates\n for obj in root.iter('object'):\n oid = obj.attrib.get('id')\n if oid is not None:\n if oid not in ids:\n ids[oid] = obj\n else:\n ids_dup[oid] = True\n\n labelled_by = obj.findall(\"accessibility/relation[@type='labelled-by']\")\n labelled_by += obj.findall(\"accessibility/relation[@name='labelled-by']\")\n for rel in labelled_by:\n target = rel.attrib.get('target')\n if target is not None:\n if target not in labelled_by_elm:\n labelled_by_elm[target] = [ obj ]\n else:\n labelled_by_elm[target].append(obj)\n\n label_for = obj.findall(\"accessibility/relation[@type='label-for']\")\n label_for += obj.findall(\"accessibility/relation[@name='label-for']\")\n for rel in label_for:\n target = rel.attrib.get('target')\n if target is not None:\n if target not in label_for_elm:\n label_for_elm[target] = [ obj ]\n else:\n label_for_elm[target].append(obj)\n\n described_by = obj.findall(\"accessibility/relation[@type='described-by']\")\n described_by += obj.findall(\"accessibility/relation[@name='described-by']\")\n for rel in described_by:\n target = rel.attrib.get('target')\n if target is not None:\n if target not in described_by_elm:\n described_by_elm[target] = [ obj ]\n else:\n described_by_elm[target].append(obj)\n\n description_for = obj.findall(\"accessibility/relation[@type='description-for']\")\n description_for += obj.findall(\"accessibility/relation[@name='description-for']\")\n for rel in description_for:\n target = rel.attrib.get('target')\n if target is not None:\n if target not in description_for_elm:\n description_for_elm[target] = [ obj ]\n else:\n description_for_elm[target].append(obj)\n\n mnemonic_for = obj.findall(\"property[@name='mnemonic_widget']\") + \\\n obj.findall(\"property[@name='mnemonic-widget']\")\n for rel in mnemonic_for:\n target = rel.text\n if target is not None:\n if target not in mnemonic_for_elm:\n mnemonic_for_elm[target] = [ obj ]\n else:\n mnemonic_for_elm[target].append(obj)\n\n # Second pass, recursive depth-first, to be able to efficiently know whether\n # there are orphan labels within a part of the tree.\n def recurse(orphan_root, obj, orphan_labels, orphan_widgets):\n if obj == root or is_labelled_parent(obj):\n orphan_root = obj\n orphan_labels, orphan_widgets = orphan_items(filename, tree, root, obj)\n\n if obj.tag == 'object':\n check_elm(orphan_root, obj, orphan_labels, orphan_widgets)\n\n for o in obj:\n recurse(orphan_root, o, orphan_labels, orphan_widgets)\n\n recurse(root, root, False, False)","def test_stratis_list_default(self):\n for subcommand in [[\"pool\"], [\"filesystem\"], [\"blockdev\"]]:\n for prefix in [[], [\"--propagate\"]]:\n self.assertEqual(RUNNER(prefix + subcommand), 0)","def pytest_can_run_together(item1, item2):","def test_series_in_features(self):\n assert parse_command({'test{{A,B}}': {'depends_on': 'name{{A,B}}'}}) == [\n ('testA', {'depends_on': 'nameA'}), ('testB', {'depends_on': 'nameB'})]","def test_first_level_from_bids_with_subject_labels(bids_dataset):\n warning_message = ('Subject label foo is not present in'\n ' the dataset and cannot be processed')\n with pytest.warns(UserWarning, match=warning_message):\n models, *_ = first_level_from_bids(\n dataset_path=bids_dataset,\n task_label='main',\n sub_labels=[\"foo\", \"01\"],\n space_label='MNI',\n img_filters=[('desc', 'preproc')],\n slice_time_ref=None,\n )\n\n assert models[0].subject_label == '01'","def test_pathop12(self):\n xpb = XPathBuilder()\n # braces not needed\n xp = xpb.foo & (xpb.bar.foo).parenthesize() | xpb.foobar\n exp = '/foo and (/bar/foo) or /foobar'\n self.assertEqual(xp.tostring(), exp)","def test_dummy6(self):\n xpb = XPathBuilder()\n xp = xpb.dummy()\n xp = xpb.bar | xp\n exp = '/bar'\n self.assertEqual(xp.tostring(), exp)","def test_create_labels(self):\n test_labels = {\"app\": \"my_app\", \"host\": \"examplehost\"}\n labels = pmp.utils.create_labels(test_labels)\n self.assertIsInstance(labels, list)\n self.assertTrue(all([isinstance(x, pmp.LabelPair) for x in labels]))","def test_xdist_and_select_test_by_bdd_label(xdist_runner: AllurePytestRunner):\n\n output = xdist_runner.run_docstring(\"-v\", \"--allure-features=boo\", \"-n1\")\n\n assert_that(output, has_only_testcases(\n has_entry(\n \"fullName\",\n ends_with(\"test_with_feature_boo\")\n )\n ))","def test_nested_condition() -> None:\n\n @argcomb(Or(And(\"a\", \"b\"), And(\"c\", \"d\")))\n def f(a: Any = None, b: Any = None, c: Any = None, d: Any = None) -> None:\n ...\n\n # valid\n f(a=1, b=1)\n f(c=1, d=1)\n f(a=1, b=1, c=1, d=1)\n\n # invalid\n with pytest.raises(InvalidArgumentCombination):\n f(a=1)\n with pytest.raises(InvalidArgumentCombination):\n f(a=1, c=1)\n with pytest.raises(InvalidArgumentCombination):\n f()","def test_abbreviation(self):\n self.assertEqual(self.compound.abbreviation, \"Cool\")","def test_general_subset_all():\n pass","def test_check_tree_exact_match(self):\r\n\r\n fasta_labels = ['seq1_1', 'seq1_2', 'seq2_3', 'seq3_4']\r\n\r\n actual_subset_results = check_tree_exact_match(fasta_labels,\r\n self.sample_tree_3tips_fp)\r\n\r\n # Should find all and give True, True result\r\n\r\n self.assertEqual(actual_subset_results, [True, True])\r\n\r\n # Should get tips not found in fasta labels with 5 tip tree\r\n\r\n fasta_labels = ['seq1_1', 'seq1_2', 'seq2_3', 'seq3_4']\r\n\r\n actual_subset_results = check_tree_exact_match(fasta_labels,\r\n self.sample_tree_5tips_fp)\r\n\r\n # Should find all and give True result\r\n\r\n self.assertEqual(actual_subset_results, [True, ['seq5', 'seq4']])\r\n\r\n # Change two of the fasta labels to not match tree tips\r\n\r\n fasta_labels = ['seq1_1', 'seqX_2', 'seq2_3', 'seqY_4']\r\n\r\n actual_subset_results = check_tree_exact_match(fasta_labels,\r\n self.sample_tree_5tips_fp)\r\n\r\n # Should find seqX and seqY as not being a subset\r\n\r\n self.assertEqual(actual_subset_results, [['seqX', 'seqY'],\r\n ['seq3', 'seq5', 'seq4']])","def test_03_visit_special(self):","def test_labels(ruler: SpaczzRuler) -> None:\n assert all(\n [label in ruler.labels for label in [\"GPE\", \"STREET\", \"DRUG\", \"NAME\", \"BAND\"]]\n )\n assert len(ruler.labels) == 5","def test_createSubLinkographWithoutCommands(self):\n self.performTestForParams()","def test_first_level_from_bids_several_labels_per_entity(tmp_path, entity):\n n_sub = 1\n n_ses = 1\n tasks = [\"main\"]\n n_runs = [1]\n\n bids_path = create_fake_bids_dataset(\n base_dir=tmp_path,\n n_sub=n_sub,\n n_ses=n_ses,\n tasks=tasks,\n n_runs=n_runs,\n entities={entity: [\"A\", \"B\"]},\n )\n\n models, m_imgs, m_events, m_confounds = first_level_from_bids(\n dataset_path=bids_path,\n task_label=\"main\",\n space_label=\"MNI\",\n img_filters=[(\"desc\", \"preproc\"), (entity, \"A\")],\n slice_time_ref=None,\n )\n\n _check_output_first_level_from_bids(n_sub,\n models,\n m_imgs,\n m_events,\n m_confounds)\n n_imgs_expected = n_ses * n_runs[0]\n assert len(m_imgs[0]) == n_imgs_expected","def test_setter_child_list_tuple(self):\n root = netapp_api.NaElement('root')\n root['l'] = ['l1', 'l2']\n root['t'] = ('t1', 't2')\n l = root.get_child_by_name('l')\n self.assertIsInstance(l, netapp_api.NaElement)\n t = root.get_child_by_name('t')\n self.assertIsInstance(t, netapp_api.NaElement)\n for le in l.get_children():\n self.assertIn(le.get_name(), ['l1', 'l2'])\n for te in t.get_children():\n self.assertIn(te.get_name(), ['t1', 't2'])","def test_tree_support(self):\r\n master_tree = parse_newick('((a:2,b:3)ab:2,(c:1,d:2)cd:7)rt;')\r\n \"\"\"\r\n /-------.5 /-a\r\n ---1| \\-b\r\n \\------.5 /-c\r\n \\-d\r\n \"\"\"\r\n t2 = parse_newick('((a:2,b:3,c:33)ho:2,d:7);') # abc are siblings\r\n\r\n tc.tree_support(master_tree, t2)\r\n assert_almost_equal(\r\n master_tree.getNodeMatchingName('rt').bootstrap_support, 1.0)","def test_labels(self):\n return self._test_labels","def test_issue_edit_label(self):\n pass","def test_dbpa002_radio_items(dash_duo):\n app = Dash()\n\n options = {\n \"OptionA\": \"Option 1\",\n \"OptionB\": \"Option 2\",\n \"OptionC\": \"Option 3\",\n }\n\n value = \"OptionB\"\n\n with_keywords = RadioItems(\n options=options,\n value=value,\n id=\"with-keywords\",\n )\n without_keywords = RadioItems(options, value, id=\"without-keywords\")\n\n app.layout = html.Div([with_keywords, without_keywords])\n\n dash_duo.start_server(app)\n\n # Check values\n assert [\n a.get_attribute(\"value\")\n for a in dash_duo.wait_for_element(\n \"#with-keywords\"\n ).find_elements_by_tag_name(\"input\")\n ] == [\n a.get_attribute(\"value\")\n for a in dash_duo.wait_for_element(\n \"#without-keywords\"\n ).find_elements_by_tag_name(\"input\")\n ]\n\n # Check labels\n assert [\n a.text\n for a in dash_duo.wait_for_element(\n \"#with-keywords\"\n ).find_elements_by_tag_name(\"label\")\n ] == [\n a.text\n for a in dash_duo.wait_for_element(\n \"#without-keywords\"\n ).find_elements_by_tag_name(\"label\")\n ]","def test(self):\n for doc, label in zip(self.test_docs(), self.test_labels()):\n yield doc, label","def test_get_parent_type_name(self):\n pass","def test_pathop8(self):\n xpb = XPathBuilder()\n xp = (xpb.foo.bar | xpb.foobar).parenthesize() & xpb.action.source\n exp = '(/foo/bar or /foobar) and /action/source'\n self.assertEqual(xp.tostring(), exp)","def test_setter_child_list_tuple(self):\n root = netapp_api.NaElement('root')\n root['l'] = ['l1', 'l2']\n root['t'] = ('t1', 't2')\n l_element = root.get_child_by_name('l')\n self.assertIsInstance(l_element, netapp_api.NaElement)\n t = root.get_child_by_name('t')\n self.assertIsInstance(t, netapp_api.NaElement)\n for le in l_element.get_children():\n self.assertIn(le.get_name(), ['l1', 'l2'])\n for te in t.get_children():\n self.assertIn(te.get_name(), ['t1', 't2'])","def __init__(self, root_node, label1, label2):\n super().__init__(self.PROBLEM_NAME)\n self.root_node = root_node\n self.label1 = label1\n self.label2 = label2","def test_radioselect_field():","def test_label_callback():\n release_numbers = dict(a='123')\n data = dict(revision='a', attributes=dict(b='c'))\n data2 = dict(revision='b', attributes=dict(d='e'))\n\n assert _label_callback(data, release_numbers) == u'a\\n- Release: 123\\n- b: c'\n assert _label_callback(data2) == u'b\\n- Release: Unknown\\n- d: e'","def _make_simple_partition_label(chain_dict):\n\n cps = chain_dict['chainParts']\n if not (_select_simple_chainparts(cps)):\n raise NotImplementedError(\n 'chain fails substring selection: not \"simple\": %s' % (\n chain_dict['chainName']))\n \n label = 'simplepartition(['\n for cp in cps:\n smcstr = str(cp['smc'])\n if smcstr == 'nosmc':\n smcstr = ''\n for i in range(int(cp['multiplicity'])):\n # condition_str = '(%set,%s,%s)' % (str(cp['threshold']),\n # str(cp['etaRange']),\n # smcstr,)\n condition_str = '(%set,%s' % (str(cp['threshold']),\n str(cp['etaRange']),)\n if smcstr:\n condition_str += ',%s)'\n else:\n condition_str += ')'\n label += condition_str\n label += '])'\n return label","def test_case1(self):\n\n graph = BipartiteGraph()\n\n graph.addEdge(\"supervisor1\",\"student1\")\n\n val1 = graph.getStudents(\"supervisor1\")\n val2 = graph.getSupervisors(\"student1\")\n\n expected1 = [\"student1\"]\n expected2 = [\"supervisor1\"]\n\n self.assertEqual((val1,val2),(expected1,expected2))","def test_with_multiple_descriptions():\n soup = generate_case(\"with_descriptions\")\n\n tests.html_schema_doc_asserts.assert_descriptions(\n soup,\n [\n \"Exact address\",\n \"Exact address\",\n \"Delivery info depending on the delivery type\",\n \"The delivery is a gift, no prices displayed\",\n ],\n )","def test_BuildModel2(self):\n print(\"\\nTest 6: Building a Model with Concat\")\n builder = StaticBuilder(\"Concat\")\n in1 = builder.addInput(10)\n in2 = builder.addInput(20)\n enc1 = builder.addInner(3, num_islots=2)\n out1 = builder.addOutput()\n\n builder.addDirectedLink(in1, enc1, islot=0)\n builder.addDirectedLink(in2, enc1, islot=1)\n builder.addDirectedLink(enc1, out1)\n \n builder.build()","def test_multiple_label_traversals(self):\r\n TestEdge.create(self.v1, self.v2)\r\n OtherTestEdge.create(self.v1, self.v3)\r\n YetAnotherTestEdge.create(self.v1, self.v4)\r\n\r\n assert len(self.v1.outV()) == 3\r\n\r\n assert len(self.v1.outV(TestEdge)) == 1\r\n assert len(self.v1.outV(OtherTestEdge)) == 1\r\n assert len(self.v1.outV(YetAnotherTestEdge)) == 1\r\n\r\n out = self.v1.outV(TestEdge, OtherTestEdge)\r\n assert len(out) == 2\r\n assert self.v2.vid in [v.vid for v in out]\r\n assert self.v3.vid in [v.vid for v in out]\r\n\r\n out = self.v1.outV(OtherTestEdge, YetAnotherTestEdge)\r\n assert len(out) == 2\r\n assert self.v3.vid in [v.vid for v in out]\r\n assert self.v4.vid in [v.vid for v in out]","def test_label_10_targets_with_a_b_c_false(self):\r\n user_input = '[{\"a\":\"target1\"}, \\\r\n {\"b\":\"target2\"},{\"c\":\"target3\"},{\"a\":\"target4\"},{\"b\":\"target5\"}, \\\r\n {\"c\":\"target6\"}, {\"a\":\"target7\"},{\"b\":\"target8\"},{\"c\":\"target9\"}, \\\r\n {\"a\":\"target1\"}]'\r\n correct_answer = [\r\n {\r\n 'draggables': ['a'],\r\n 'targets': ['target1', 'target4', 'target7', 'target10'],\r\n 'rule': 'unordered_equal'\r\n },\r\n {\r\n 'draggables': ['b'],\r\n 'targets': ['target2', 'target5', 'target8'],\r\n 'rule': 'unordered_equal'\r\n },\r\n {\r\n 'draggables': ['c'],\r\n 'targets': ['target3', 'target6', 'target9'],\r\n 'rule': 'unordered_equal'\r\n }\r\n ]\r\n self.assertFalse(draganddrop.grade(user_input, correct_answer))"],"string":"[\n \"def test_sums():\\n assert label_parent(1, 2) == 3\\n assert label_parent (1, 4) == 8\\n # Should ignore arg order\\n assert label_parent(4, 1) == 8\",\n \"def _make_partitionsTest_label(chain_parts):\\n\\n assert len(chain_parts) == 1\\n scenario = chain_parts[0]['hypoScenario']\\n \\n assert scenario == 'partitionsTest'\\n\\n \\n\\n return \\\"\\\"\\\"\\n partgen(\\n [(20et, 0eta320)]\\n \\n simple([(40et, 0eta320) (50et, 0eta320)])\\n simple([(35et, 0eta240) (55et, 0eta240)])\\n )\\\"\\\"\\\"\",\n \"def test_recipe_nutrition_label_widget(self):\\n pass\",\n \"def test_select_label(self):\\n title = ('Transportation Challenges Limit Education Choices for '\\n 'Denver Parents')\\n summary = \\\"\\\"\\\"\\n Many families in the Denver metro area use public\\n transportation instead of a school bus because for them, a\\n quality education is worth hours of daily commuting. Colorado's\\n school choice program is meant to foster educational equity,\\n but the families who benefit most are those who have time and\\n money to travel. Low-income families are often left in a lurch.\\n \\\"\\\"\\\"\\n byline = \\\"Mile High Connects\\\"\\n story = create_story(title=title, summary=summary, byline=byline)\\n layout = SectionLayout.objects.get(sectionlayouttranslation__name=\\\"Side by Side\\\")\\n section1 = create_section(title=\\\"Test Section 1\\\", story=story, layout=layout)\\n section2 = create_section(title=\\\"Test Section 2\\\", story=story, layout=layout)\\n form = SectionRelationAdminForm()\\n choices_list = list(form.fields['parent'].widget.choices)\\n self.assertIn(story.title, choices_list[1][1])\\n self.assertIn(story.title, choices_list[2][1])\",\n \"def setUp(self):\\n\\n singleLabels = linkoCreate.Linkograph(\\n [({'A'}, set(), {1,2,3}),\\n ({'D'}, {0}, {3,4}),\\n ({'A'}, {0}, {4}),\\n ({'C'}, {0,1}, {4}),\\n ({'A'}, {1,2,3}, set())],\\n ['A', 'B', 'C', 'D'])\\n\\n singleSubLinko0_2 = linkoCreate.Linkograph(\\n [({'A'}, set(), {1,2}),\\n ({'D'}, {0}, set()),\\n ({'A'}, {0}, set())],\\n ['A', 'B', 'C', 'D'])\\n\\n singleSubLinko0_1 = linkoCreate.Linkograph(\\n [({'A'}, set(), {1}),\\n ({'D'}, {0}, set())],\\n ['A', 'B', 'C', 'D'])\\n\\n singleSubLinko0_0 = linkoCreate.Linkograph(\\n [({'A'}, set(), set())],\\n ['A', 'B', 'C', 'D'])\\n\\n singleSubLinko1_2 = linkoCreate.Linkograph(\\n [({'D'}, set(), set()),\\n ({'A'}, set(), set())],\\n ['A', 'B', 'C', 'D'])\\n\\n singleSubLinko1_1 = linkoCreate.Linkograph(\\n [({'D'}, set(), set())],\\n ['A', 'B', 'C', 'D'])\\n\\n trivialLinkograph = linkoCreate.Linkograph(\\n [], ['A', 'B', 'C', 'D'])\\n\\n\\n singleSubLinko1_4 = linkoCreate.Linkograph(\\n [({'D'}, set(), {2,3}),\\n ({'A'}, set(), {3}),\\n ({'C'}, {0}, {3}),\\n ({'A'}, {0,1,2}, set())],\\n ['A', 'B', 'C', 'D'])\\n\\n singleSubLinko2_4 = linkoCreate.Linkograph(\\n [({'A'}, set(), {2}),\\n ({'C'}, set(), {2}),\\n ({'A'}, {0,1}, set())],\\n ['A', 'B', 'C', 'D'])\\n\\n singleSubLinko3_4 = linkoCreate.Linkograph(\\n [({'C'}, set(), {1}),\\n ({'A'}, {0}, set())],\\n ['A', 'B', 'C', 'D'])\\n\\n singleSubLinko4_4 = linkoCreate.Linkograph(\\n [({'A'}, set(), set())],\\n ['A', 'B', 'C', 'D'])\\n\\n simpleLinko = linkoCreate.Linkograph(\\n [({'A', 'B', 'C'}, set(), {1,2,3}),\\n ({'D'}, {0}, {3,4}),\\n ({'A'}, {0}, {4}),\\n ({'B', 'C'}, {0,1}, {4}),\\n ({'A'}, {1,2,3}, set())],\\n ['A', 'B', 'C', 'D'])\\n\\n if self.id().split('.')[-1] == 'test_createSubLinkographWithoutCommands':\\n self.testParams = [\\n {'linko': singleLabels,\\n 'lowerBound': None,\\n 'upperBound': None,\\n 'ExpectedLinkograph': singleLabels},\\n\\n {'linko': singleLabels,\\n 'lowerBound': 0,\\n 'upperBound': 4,\\n 'ExpectedLinkograph': singleLabels},\\n\\n {'linko': singleLabels,\\n 'lowerBound': 0,\\n 'upperBound': 5,\\n 'ExpectedLinkograph': singleLabels},\\n\\n {'linko': singleLabels,\\n 'lowerBound': 0,\\n 'upperBound': 2,\\n 'ExpectedLinkograph': singleSubLinko0_2},\\n\\n {'linko': singleLabels,\\n 'lowerBound': -1,\\n 'upperBound': 2,\\n 'ExpectedLinkograph': singleSubLinko0_2},\\n\\n {'linko': singleLabels,\\n 'lowerBound': None,\\n 'upperBound': 2,\\n 'ExpectedLinkograph': singleSubLinko0_2},\\n\\n {'linko': singleLabels,\\n 'lowerBound': 0,\\n 'upperBound': 1,\\n 'ExpectedLinkograph': singleSubLinko0_1},\\n\\n {'linko': singleLabels,\\n 'lowerBound': 0,\\n 'upperBound': 0,\\n 'ExpectedLinkograph': singleSubLinko0_0},\\n\\n {'linko': singleLabels,\\n 'lowerBound': 0,\\n 'upperBound': -1,\\n 'ExpectedLinkograph': trivialLinkograph},\\n\\n {'linko': singleLabels,\\n 'lowerBound': 1,\\n 'upperBound': 2,\\n 'ExpectedLinkograph': singleSubLinko1_2},\\n\\n {'linko': singleLabels,\\n 'lowerBound': 1,\\n 'upperBound': 1,\\n 'ExpectedLinkograph': singleSubLinko1_1},\\n\\n {'linko': singleLabels,\\n 'lowerBound': 1,\\n 'upperBound': 0,\\n 'ExpectedLinkograph': trivialLinkograph},\\n\\n {'linko': singleLabels,\\n 'lowerBound': -1,\\n 'upperBound': -1,\\n 'ExpectedLinkograph': trivialLinkograph},\\n\\n {'linko': singleLabels,\\n 'lowerBound': 1,\\n 'upperBound': 4,\\n 'ExpectedLinkograph': singleSubLinko1_4},\\n\\n {'linko': singleLabels,\\n 'lowerBound': 2,\\n 'upperBound': 4,\\n 'ExpectedLinkograph': singleSubLinko2_4},\\n\\n {'linko': singleLabels,\\n 'lowerBound': 3,\\n 'upperBound': 4,\\n 'ExpectedLinkograph': singleSubLinko3_4},\\n\\n {'linko': singleLabels,\\n 'lowerBound': 4,\\n 'upperBound': 4,\\n 'ExpectedLinkograph': singleSubLinko4_4},\\n\\n ]\",\n \"def test_labels(self):\\n self.compliance_tester.test_labels(self.oi)\",\n \"def test_parent_label(self):\\n l = self.d.label(1)\\n l2 = self.d.label(31405)\\n\\n self.assertTrue(l.parent_label is None)\\n self.assertTrue(l2 in l.sublabels)\\n self.assertEqual(l2.parent_label, l)\",\n \"def test_simple(self):\\n exp = [{'type': NewickEvents.OPEN_SUBTREE, 'comments': []},\\n {'type': NewickEvents.OPEN_SUBTREE, 'comments': []},\\n {'edge_info': None, 'type': NewickEvents.TIP, 'comments': [], 'label': 'h'},\\n {'edge_info': None, 'type': NewickEvents.TIP, 'comments': [], 'label': 'p'},\\n {'edge_info': '1', 'type': NewickEvents.CLOSE_SUBTREE,\\n 'comments': [], 'label': 'hp'},\\n {'edge_info': None, 'type': NewickEvents.TIP, 'comments': [], 'label': 'g'},\\n {'edge_info': None, 'type': NewickEvents.CLOSE_SUBTREE,\\n 'comments': [], 'label': 'hpg'}\\n ]\\n content = '((h,p)hp:1,g)hpg;'\\n self._do_test(content, exp)\\n content = '((h,[pretest]p[test][posttest])hp,g)hpg;'\\n exp = [{'type': NewickEvents.OPEN_SUBTREE, 'comments': []},\\n {'type': NewickEvents.OPEN_SUBTREE, 'comments': []},\\n {'edge_info': None, 'type': NewickEvents.TIP, 'comments': [], 'label': 'h'},\\n {'edge_info': None, 'type': NewickEvents.TIP,\\n 'comments': ['pretest', 'test', 'posttest'], 'label': 'p'},\\n {'edge_info': None, 'type': NewickEvents.CLOSE_SUBTREE,\\n 'comments': [], 'label': 'hp'},\\n {'edge_info': None, 'type': NewickEvents.TIP, 'comments': [], 'label': 'g'},\\n {'edge_info': None, 'type': NewickEvents.CLOSE_SUBTREE,\\n 'comments': [], 'label': 'hpg'}\\n ]\\n self._do_test(content, exp)\",\n \"def test_label(self):\\n xs = t.Label(t.Exactly(\\\"x\\\"), 'CustomLabel')\\n self.assertEqual(writePython(xs),\\n dd(\\\"\\\"\\\"\\n def _G_label_1():\\n _G_exactly_2, lastError = self.exactly('x')\\n self.considerError(lastError, None)\\n return (_G_exactly_2, self.currentError)\\n _G_label_3, lastError = self.label(_G_label_1, \\\"CustomLabel\\\")\\n self.considerError(lastError, None)\\n _G_label_3\\n \\\"\\\"\\\"))\",\n \"def addLabels(t):\\n if not t.label:\\n t.label = \\\"\\\".join([choice(\\\"abcdefghijklmnopqrstuvwxyz\\\") for i in range(4)])\\n for r,w in t.children:\\n addLabels(r)\",\n \"def test_general_subset_level():\\n pass\",\n \"def _make_simple_comb_label(chain_dict):\\n\\n cps = chain_dict['chainParts']\\n if not (_select_simple_chainparts(cps)):\\n raise NotImplementedError(\\n 'chain fails substring selection: not \\\"simple\\\": %s' % (\\n chain_dict['chainName']))\\n \\n simple_strs = []\\n\\n for cp in cps:\\n print(cp)\\n simple_strs.append(_make_simple_label([cp]))\\n\\n label = 'combgen([(%d)]' % len(cps)\\n for s in simple_strs:\\n label += ' %s ' % s\\n label += ')'\\n return label\",\n \"def _generateLabelAndName(self, obj, **args):\\n result = []\\n label = self._generateLabel(obj, **args)\\n name = self._generateName(obj, **args)\\n result.extend(label)\\n if not len(label):\\n result.extend(name)\\n elif len(name) and name[0].strip() != label[0].strip():\\n result.extend(name)\\n return result\",\n \"def tests_ti_document_add_label(self):\\n super().group_add_label()\",\n \"def getLabel2(*args):\",\n \"def getLabel2(*args):\",\n \"def test_checkboxtextgroup(self):\\r\\n self.check_group('checkboxtextgroup', 'choice', 'checkbox')\",\n \"def _generateTableCell2ChildLabel(self, obj, **args):\\n result = []\\n\\n # If this table cell has 2 children and one of them has a\\n # 'toggle' action and the other does not, then present this\\n # as a checkbox where:\\n # 1) we get the checked state from the cell with the 'toggle' action\\n # 2) we get the label from the other cell.\\n # See Orca bug #376015 for more details.\\n #\\n if obj.childCount == 2:\\n cellOrder = []\\n hasToggle = [False, False]\\n for i, child in enumerate(obj):\\n if self._script.utilities.hasMeaningfulToggleAction(child):\\n hasToggle[i] = True\\n break\\n if hasToggle[0] and not hasToggle[1]:\\n cellOrder = [ 1, 0 ]\\n elif not hasToggle[0] and hasToggle[1]:\\n cellOrder = [ 0, 1 ]\\n if cellOrder:\\n for i in cellOrder:\\n if not hasToggle[i]:\\n result.extend(self.generate(obj[i], **args))\\n return result\",\n \"def test_process_label_in_node(self):\\n tree = Node(children=[\\n Node(\\\"Defining secret phrase.\\\", label=['AB', 'a']),\\n Node(\\\"Has secret phrase. Then some other content\\\", \\n label=['AB', 'b'])\\n ], label=['AB'])\\n t = Terms(tree)\\n t.scoped_terms = {\\n ('AB',): [Ref(\\\"secret phrase\\\", \\\"AB-a\\\", (9,22))]\\n }\\n # Term is defined in the first child\\n self.assertEqual([], t.process(tree.children[0]))\\n self.assertEqual(1, len(t.process(tree.children[1])))\",\n \"def get_extra_label(self, label_name: str, hierarchy: List[str]) -> Any:\",\n \"def test_get_scenarios_expanded(self):\\n pass\",\n \"def test_nested():\\n res = conf.status.conditions.choose(lambda c: (c.type, c.reason, c.root.metadata.choose(lambda m: (m[\\\"name\\\"], m.uid))))\\n assert \\\"type\\\" in res # from conditions\\n assert \\\"reason\\\" in res # from conditions\\n assert \\\"name\\\" in res # from metadata\\n assert \\\"uid\\\" in res # from metadata\",\n \"def _make_simple_label(chain_parts):\\n \\n if not _select_simple_chainparts(chain_parts):\\n msg = 'Jet Configuration error: '\\\\\\n 'chain fails substring selection: not \\\"simple\\\" '\\n\\n raise NotImplementedError(msg)\\n \\n label = 'simple(['\\n for cp in chain_parts:\\n smcstr = str(cp['smc'])\\n jvtstr = str(cp['jvt'])\\n if smcstr == 'nosmc':\\n smcstr = ''\\n for i in range(int(cp['multiplicity'])):\\n # condition_str = '(%set,%s,%s)' % (str(cp['threshold']),\\n # str(cp['etaRange']),\\n # smcstr,)\\n condition_str = '(%set,%s' % (str(cp['threshold']),\\n str(cp['etaRange']),)\\n if smcstr: # Run 2 chains have \\\"INF\\\" in the SMC substring\\n condition_str += ',%s)' % smcstr.replace('INF','')\\n elif jvtstr:\\n condition_str += ',%s)' % jvtstr\\n else:\\n condition_str += ')'\\n label += condition_str\\n label += '])'\\n return label\",\n \"def test_nested_sequence(self):\\n\\n self.taxon_tester('Apis mellifera')\\n self.taxon_tester('Apis')\\n self.taxon_tester('Apini')\\n self.taxon_tester('Apinae')\\n # Apidae at 5680 species is a struggle\\n self.taxon_tester('Apidae')\\n if False:\\n # Apoidea: 19566 takes 223 seconds\\n self.taxon_tester('Apoidea')\\n # Aculeata fails after 339 seconds\\n self.taxon_tester('Aculeata')\\n self.taxon_tester('Apocrita')\\n self.taxon_tester('Hymenoptera')\\n self.taxon_tester('Endopterygota')\\n self.taxon_tester('Neoptera')\\n self.taxon_tester('Pterygota')\\n self.taxon_tester('Dicondylia')\\n self.taxon_tester('Insecta')\\n self.taxon_tester('Hexapoda')\\n self.taxon_tester('Pancrustacea')\\n self.taxon_tester('Mandibulata')\\n self.taxon_tester('Arthropoda')\\n self.taxon_tester('Panarthropoda')\\n self.taxon_tester('Ecdysozoa')\\n self.taxon_tester('Protostomia')\\n self.taxon_tester('Bilateria')\\n self.taxon_tester('Eumetazoa')\\n self.taxon_tester('Metazoa')\\n self.taxon_tester('Holozoa')\\n self.taxon_tester('Opisthokonta')\\n self.taxon_tester('Eukaryota')\",\n \"def test_bootstrap_support_labeled(self):\\r\\n master_tree = parse_newick('((a:2,b:3)ab:2,(c:1,d:2)cd:7)rt;')\\r\\n \\\"\\\"\\\"\\r\\n /-------.5 /-a\\r\\n ---1| \\\\-b\\r\\n \\\\------.5 /-c\\r\\n \\\\-d\\r\\n \\\"\\\"\\\"\\r\\n t1 = parse_newick('((a:6,b:8.2)hi:2,(c:1,d:2):7);') # same structure\\r\\n t2 = parse_newick('((a:2,b:3,c:33)ho:2,d:7);') # abc are siblings\\r\\n new_master, bootstraps = tc.bootstrap_support(master_tree, [t1, t2])\\r\\n expected = dict([('ab', .5), ('cd', .5), ('rt', 1.0)])\\r\\n self.assertDictEqual(bootstraps, expected)\",\n \"def test_title(names):\",\n \"def test_verbose_name_group(self): \\n field_verboses = {\\n \\\"title\\\": \\\"Название группы\\\",\\n \\\"slug\\\": \\\"Слаг\\\",\\n \\\"description\\\": \\\"Описание группы\\\",\\n }\\n for value, expected in field_verboses.items():\\n with self.subTest(value=value):\\n self.assertEqual(self.group._meta.get_field(value).verbose_name, expected)\",\n \"def plugin_second_label():\\n return \\\"second\\\"\",\n \"def test_product_labels(self):\\n\\n prd = Product.objects.get(id=1)\\n # label name\\n label_name = prd._meta.get_field('name').verbose_name\\n self.assertEqual(label_name, 'name')\\n # label description\\n label_name = prd._meta.get_field('description').verbose_name\\n self.assertEqual(label_name, 'description')\\n # label nutrition_grade\\n label_name = prd._meta.get_field('nutrition_grade').name\\n self.assertEqual(label_name, 'nutrition_grade')\\n # label barcode\\n label_name = prd._meta.get_field('barcode').verbose_name\\n self.assertEqual(label_name, 'barcode')\\n # label url\\n label_name = prd._meta.get_field('url').verbose_name\\n self.assertEqual(label_name, 'url')\\n # label url_pic\\n label_name = prd._meta.get_field('url_pic').name\\n self.assertEqual(label_name, 'url_pic')\\n # label store\\n label_name = prd._meta.get_field('store').verbose_name\\n self.assertEqual(label_name, 'store')\\n # label prd_cat\\n label_name = prd._meta.get_field('prd_cat').name\\n self.assertEqual(label_name, 'prd_cat')\\n # label fat\\n label_name = prd._meta.get_field('fat').verbose_name\\n self.assertEqual(label_name, 'fat')\\n # label saturated_fat\\n label_name = prd._meta.get_field('saturated_fat').name\\n self.assertEqual(label_name, 'saturated_fat')\\n # label sugar\\n label_name = prd._meta.get_field('sugar').verbose_name\\n self.assertEqual(label_name, 'sugar')\\n # label salt\\n label_name = prd._meta.get_field('salt').verbose_name\\n self.assertEqual(label_name, 'salt')\",\n \"def is_test(self):\\r\\n return self.has_label('tests')\",\n \"def setUp(self):\\n\\n\\n # InverseLabeling\\n invLabeling0 = {'L0': [0, 1, 2]}\\n\\n invLabeling1 = {'L0' : [0, 2],\\n 'L1' : [1]}\\n\\n invLabeling2 = {\\n 'L0' : [0],\\n 'L1' : [1],\\n 'L2' : [2]\\n }\\n\\n invLabeling3 = {\\n 'L1' : [0, 1],\\n 'L2' : [2]\\n }\\n\\n invLabeling4 = {\\n 'L0' : [0,1],\\n 'L1' : [0],\\n 'L2' : [2]\\n }\\n\\n invLabeling5 = {\\n 'L0': [0, 1, 2],\\n 'L1': []\\n }\\n \\n # Create some ontologies\\n ontology0 = {'L0': ['L0']}\\n\\n ontology1 = {}\\n\\n ontology2 = {'L0': ['L1']}\\n\\n ontology3 = {'L0': ['L1', 'L2'],\\n 'L1': ['L2'],\\n 'L2': ['L0']}\\n\\n if self.id().split('.')[-1] == 'test_createLinkograph':\\n self.testParams = [\\n {'inverseLabeling': invLabeling0,\\n 'ontology': ontology0,\\n 'ExpectedLinkograph':\\n linkoCreate.Linkograph(\\n [({'L0'}, set(), {1, 2}),\\n ({'L0'}, {0}, {2}),\\n ({'L0'}, {0,1}, set())] \\n )},\\n\\n {'inverseLabeling': invLabeling0,\\n 'ontology': ontology1,\\n 'ExpectedLinkograph':\\n linkoCreate.Linkograph(\\n [({'L0'}, set(), set()),\\n ({'L0'}, set(), set()),\\n ({'L0'}, set(), set())]\\n )},\\n\\n {'inverseLabeling': invLabeling0,\\n 'ontology': ontology2,\\n 'ExpectedLinkograph':\\n linkoCreate.Linkograph(\\n [({'L0'}, set(), set()),\\n ({'L0'}, set(), set()),\\n ({'L0'}, set(), set())]\\n )},\\n\\n\\n {'inverseLabeling': invLabeling1,\\n 'ontology': ontology0,\\n 'ExpectedLinkograph':\\n linkoCreate.Linkograph(\\n [({'L0'}, set(), {2}),\\n ({'L1'}, set(), set()),\\n ({'L0'}, {0}, set())]\\n )},\\n\\n {'inverseLabeling': invLabeling1,\\n 'ontology': ontology1,\\n 'ExpectedLinkograph':\\n linkoCreate.Linkograph(\\n [({'L0'}, set(), set()),\\n ({'L1'}, set(), set()),\\n ({'L0'}, set(), set())]\\n )},\\n\\n {'inverseLabeling': invLabeling1,\\n 'ontology': ontology2,\\n 'ExpectedLinkograph':\\n linkoCreate.Linkograph(\\n [({'L0'}, set(), {1}),\\n ({'L1'}, {0}, set()),\\n ({'L0'}, set(), set())]\\n )},\\n\\n {'inverseLabeling': invLabeling0,\\n 'ontology': ontology3,\\n 'ExpectedLinkograph':\\n linkoCreate.Linkograph(\\n [({'L0'}, set(), set()),\\n ({'L0'}, set(), set()),\\n ({'L0'}, set(), set())]\\n )},\\n\\n {'inverseLabeling': invLabeling1,\\n 'ontology': ontology3,\\n 'ExpectedLinkograph':\\n linkoCreate.Linkograph(\\n [({'L0'}, set(), {1}),\\n ({'L1'}, {0}, set()),\\n ({'L0'}, set(), set())]\\n )},\\n\\n {'inverseLabeling': invLabeling2,\\n 'ontology': ontology3,\\n 'ExpectedLinkograph':\\n linkoCreate.Linkograph(\\n [({'L0'}, set(), {1,2}),\\n ({'L1'}, {0}, {2}),\\n ({'L2'}, {0, 1}, set())]\\n )},\\n\\n {'inverseLabeling': invLabeling3,\\n 'ontology': ontology3,\\n 'ExpectedLinkograph':\\n linkoCreate.Linkograph(\\n [({'L1'}, set(), {2}),\\n ({'L1'}, set(), {2}),\\n ({'L2'}, {0, 1}, set())]\\n )},\\n\\n {'inverseLabeling': invLabeling4,\\n 'ontology': ontology3,\\n 'ExpectedLinkograph':\\n linkoCreate.Linkograph(\\n [({'L0', 'L1'}, set(), {2}),\\n ({'L0'}, set(), {2}),\\n ({'L2'}, {0, 1}, set())]\\n )},\\n\\n {'inverseLabeling': invLabeling5,\\n 'ontology': ontology3,\\n 'ExpectedLinkograph':\\n linkoCreate.Linkograph(\\n [({'L0'}, set(), set()),\\n ({'L0'}, set(), set()),\\n ({'L0'}, set(), set())]\\n )},\\n\\n ]\",\n \"def test_mutual_exclusivity_of_labels(self, tmpdir, docker_tasker, labels, expected_fail):\\n runner = mock_env(tmpdir, docker_tasker, labels=labels)\\n if expected_fail:\\n with pytest.raises(PluginFailedException) as e:\\n runner.run()\\n assert 'only one of labels' in str(e.value)\\n else:\\n runner.run()\",\n \"def helper_label(helper):\\n return helper.info\",\n \"def test_Tree():\",\n \"def test_col_data_label_with_attrs(self):\\n help_tag = 'span'\\n help_text_br = False\\n names = ('first', 'billing_address_1')\\n attrs = {'style': 'width: 10rem; display: inline-block'}\\n label_attrs = {name: attrs for name in names}\\n txt = '{}=\\\"{}\\\"'.format(*list(attrs.items())[0])\\n expected = ['<label for=\\\"id_first\\\" {}>First:</label>'.format(txt)]\\n expected.append('<label for=\\\"id_billing_address_1\\\" {}>street address (line 1):</label>'.format(txt))\\n actual = []\\n for name in names:\\n field = self.form.fields[name]\\n response = self.form.collect_col_data(name, field, help_tag, help_text_br, label_attrs)\\n actual.append(response.get('label'))\\n\\n for expect, got in zip(expected, actual):\\n self.assertEqual(expect, got)\",\n \"def test_help_text_group(self): \\n field_help_text = {\\n \\\"title\\\": \\\"Дайте назание группе\\\",\\n \\\"slug\\\": ('Укажите адрес для группы. Используйте '\\n 'только латиницу, цифры, дефисы и знаки '\\n 'подчёркивания'),\\n } \\n for value, expected in field_help_text.items():\\n with self.subTest(value=value):\\n self.assertEqual(self.group._meta.get_field(value).help_text, expected)\",\n \"def test_label_choices(self):\\n test_classes = (\\n (0, 'No'),\\n (1, 'Yes')\\n )\\n\\n form = SingleLabelClassifierForm(classes=test_classes)\\n self.assertEqual(tuple(form.fields['label'].choices), test_classes)\\n\\n form = MultiLabelClassifierForm(classes=test_classes)\\n self.assertEqual(tuple(form.fields['label'].choices), test_classes)\",\n \"def test_filter_tree(self):\\r\\n actual = [e.Name for e in filter_tree(\\r\\n self.tree1, ['bbb', 'ccc']).tips()]\\r\\n #(a_a:10,(b_b:2,c_c:4):5);\\r\\n expected = [\\r\\n e.Name for e in DndParser(\\r\\n \\\"((bbb:2,ccc:4));\\\",\\r\\n PhyloNode).tips(\\r\\n )]\\r\\n self.assertEqual(actual, expected)\\r\\n\\r\\n actual = [e.Name for e in filter_tree(\\r\\n self.tree2, ['bbb', 'ccc']).tips()]\\r\\n #(a_a:10,(b_b:2,c_c:4):5);\\r\\n expected = [\\r\\n e.Name for e in DndParser(\\r\\n \\\"(('bbb':2,ccc:4));\\\",\\r\\n PhyloNode).tips(\\r\\n )]\\r\\n self.assertEqual(actual, expected)\",\n \"def test_radiotextgroup(self):\\r\\n self.check_group('radiotextgroup', 'choice', 'radio')\",\n \"def gen_test_case_combination(self):\\n\\n cases = '\\\\n'\\n\\n binary_ops = list(self.BINARY_OPS)\\n binary_ops.reverse()\\n for op1 in self.BINARY_OPS:\\n for op2 in binary_ops:\\n\\n result = []\\n ret = IntOp.binary_op(op2, '0', '1', self.lane_width)\\n ret = IntOp.binary_op(op1, ret, '2', self.lane_width)\\n result.append(ret)\\n\\n cases += '\\\\n' + str(AssertReturn('{lane_type}.{op1}-{lane_type}.{op2}'.format(lane_type=self.LANE_TYPE, op1=op1, op2=op2),\\n [SIMD.v128_const('0', self.LANE_TYPE),\\n SIMD.v128_const('1', self.LANE_TYPE),\\n SIMD.v128_const('2', self.LANE_TYPE)],\\n SIMD.v128_const(result, self.LANE_TYPE)))\\n cases += '\\\\n'\\n return cases\",\n \"def test_multiple_task_groups_dag(\\n self, test_multiple_taskgroups_dag, multiple_taskgroups_dag_expected_edges\\n ):\\n (\\n dag,\\n group1,\\n group2,\\n group3,\\n (\\n group1_emp1,\\n group1_emp2,\\n group1_emp3,\\n group2_emp1,\\n group2_emp2,\\n group2_emp3,\\n group2_op1,\\n group2_op2,\\n group3_emp1,\\n group3_emp2,\\n group3_emp3,\\n emp_in1,\\n emp_in2,\\n emp_in3,\\n emp_in4,\\n emp_out1,\\n emp_out2,\\n emp_out3,\\n emp_out4,\\n op_in1,\\n op_out1,\\n ),\\n ) = test_multiple_taskgroups_dag\\n\\n group1_emp1 >> Label(\\\"label group1.group1_emp1 <=> group1.group1_emp2\\\") >> group1_emp3\\n\\n emp_in1 >> group1\\n emp_in2 >> Label(\\\"label emp_in2 <=> group1\\\") >> group1\\n [emp_in3, emp_in4] >> Label(\\\"label emp_in3/emp_in4 <=> group1\\\") >> group1\\n XComArg(op_in1, \\\"test_key\\\") >> Label(\\\"label op_in1 <=> group1\\\") >> group1\\n\\n (\\n [group2_emp1, group2_emp2]\\n >> Label(\\\"label group2.group2_emp1/group2.group2_emp2 <=> group2.group2_emp3\\\")\\n >> group2_emp3\\n )\\n (\\n group2_emp1\\n >> Label(\\\"label group2.group2_emp1 <=> group2.group2_emp2/group2.group2_emp3\\\")\\n >> [group2_emp2, group2_emp3]\\n )\\n group2_emp3 >> Label(\\\"label group2.group2_emp3 <=> group3\\\") >> group3\\n\\n (\\n XComArg(group2_op1, \\\"test_key\\\")\\n >> Label(\\\"label group2.group2_op1 <=> group2.group2_op2\\\")\\n >> XComArg(group2_op2, \\\"test_key\\\")\\n )\\n XComArg(group2_op2, \\\"test_key\\\") >> Label(\\\"label group2.group2_op2 <=> group3\\\") >> group3\\n\\n group3 >> emp_out1\\n group3 >> Label(\\\"label group3 <=> emp_out2\\\") >> emp_out2\\n group3 >> Label(\\\"label group3 <=> emp_out3/emp_out4\\\") >> [emp_out3, emp_out4]\\n group3 >> Label(\\\"label group3 <=> op_out1\\\") >> XComArg(op_out1, \\\"test_key\\\")\\n\\n group1 >> Label(\\\"label group1 <=> group2\\\") >> group2\\n\\n compare_dag_edges(dag_edges(dag), multiple_taskgroups_dag_expected_edges)\",\n \"def test_issue_create_label(self):\\n pass\",\n \"def test__create_label_w_no_ent_id(ruler: SpaczzRuler) -> None:\\n assert ruler._create_label(\\\"TEST\\\", None) == \\\"TEST\\\"\",\n \"def test_grouping(self):\\n s = self.create(ComponentItem, UML.Component)\\n uc1 = self.create(UseCaseItem, UML.UseCase)\\n uc2 = self.create(UseCaseItem, UML.UseCase)\\n\\n self.group(s, uc1)\\n assert 1 == len(uc1.subject.subject)\\n self.group(s, uc2)\\n assert 1 == len(uc2.subject.subject)\\n\\n # Classifier.useCase is not navigable to UseCase\\n # self.assertEqual(2, len(s.subject.useCase))\",\n \"def setLabel2(*args):\",\n \"def tests_ti_document_get_label(self):\\n super().group_get_label()\",\n \"def test_render_label(self):\\n label = self.block.meta.label\\n self.assertEqual(label, 'Google Calendar', 'The labels are not the same')\",\n \"def check_elm(orphan_root, obj, orphan_labels, orphan_widgets):\\n\\n oid = obj.attrib.get('id')\\n klass = obj.attrib.get('class')\\n\\n # \\\"Don't care\\\" special case\\n if klass in widgets_ignored:\\n return\\n for suffix in widgets_suffixignored:\\n if klass[-len(suffix):] == suffix:\\n return\\n\\n # Widgets usual do not strictly require a label, i.e. a labelled parent\\n # is enough for context, but some do always need one.\\n requires_label = klass in widgets_needlabel\\n\\n if oid is not None:\\n # Check that ids are unique\\n if oid in ids_dup:\\n if ids[oid] == obj:\\n # We are the first, warn\\n duplicates = tree.findall(\\\".//object[@id='\\\" + oid + \\\"']\\\")\\n err(filename, tree, obj, \\\"duplicate-id\\\", \\\"has the same id as other elements \\\" + elms_names_lines(duplicates))\\n\\n # Check label-for and their dual labelled-by\\n label_for = check_rels(filename, tree, root, obj, \\\"label-for\\\", \\\"labelled-by\\\")\\n\\n # Check labelled-by and its dual label-for\\n labelled_by = check_rels(filename, tree, root, obj, \\\"labelled-by\\\", \\\"label-for\\\")\\n\\n # Check label-for and their dual labelled-by\\n description_for = check_rels(filename, tree, root, obj, \\\"description-for\\\", \\\"described-by\\\")\\n\\n # Check labelled-by and its dual label-for\\n described_by = check_rels(filename, tree, root, obj, \\\"described-by\\\", \\\"description-for\\\")\\n\\n # Should have only one label\\n if len(labelled_by) >= 1:\\n if oid in mnemonic_for_elm:\\n warn(filename, tree, obj, \\\"labelled-by-and-mnemonic\\\",\\n \\\"has both a mnemonic \\\" + elm_name_line(mnemonic_for_elm[oid][0]) + \\\"and labelled-by relation\\\")\\n if len(labelled_by) > 1:\\n warn(filename, tree, obj, \\\"multiple-labelled-by\\\", \\\"has multiple labelled-by relations\\\")\\n if oid in label_for_elm:\\n if len(label_for_elm[oid]) > 1:\\n warn(filename, tree, obj, \\\"duplicate-label-for\\\", \\\"is referenced by multiple label-for \\\" + elms_names_lines(label_for_elm[oid]))\\n if oid in mnemonic_for_elm:\\n if len(mnemonic_for_elm[oid]) > 1:\\n warn(filename, tree, obj, \\\"duplicate-mnemonic\\\", \\\"is referenced by multiple mnemonic_widget \\\" + elms_names_lines(mnemonic_for_elm[oid]))\\n\\n # Check member-of\\n member_of = check_rels(filename, tree, root, obj, \\\"member-of\\\")\\n\\n # Labels special case\\n if klass in widgets_labels:\\n properties = check_props(filename, tree, root, obj, \\\"mnemonic_widget\\\") + \\\\\\n check_props(filename, tree, root, obj, \\\"mnemonic-widget\\\")\\n if len(properties) > 1:\\n err(filename, tree, obj, \\\"multiple-mnemonic\\\", \\\"has multiple mnemonic_widgets properties\\\"\\n \\\"%s\\\" % elms_lines(properties))\\n\\n # Emit orphaning warnings\\n if warn_orphan_labels or orphan_widgets:\\n is_orphan_label(filename, tree, root, obj, orphan_root, True)\\n\\n # We are done with the label\\n return\\n\\n # Not a label, will perhaps need one\\n\\n # Emit orphaning warnings\\n is_orphan_widget(filename, tree, root, obj, orphan_labels, orphan_root, True)\",\n \"def get_label(self, hierarchy: List[str]) -> Any:\",\n \"def test_first_level_from_bids_no_duplicate_sub_labels(bids_dataset):\\n models, *_ = first_level_from_bids(\\n dataset_path=bids_dataset,\\n task_label='main',\\n sub_labels=[\\\"01\\\", \\\"01\\\"],\\n space_label='MNI',\\n img_filters=[('desc', 'preproc')],\\n slice_time_ref=None,\\n )\\n\\n assert len(models) == 1\",\n \"def test_add_empty_nodes_with_label_when_splitting(self):\\n print \\\"----- test_add_empty_nodes_with_label_when_splitting -----\\\"\\n sel_axis = (lambda axis: axis)\\n \\n #create tree, first node splits in x direction\\n tree = kdtree.createNewTree([[0.5, 0.5]],axis = 0, sel_axis= sel_axis)\\n kdtree.visualize(tree)\\n \\n point_left = [0.4, 0.5]\\n tree.split2(point_left, axis = 0)\\n kdtree.visualize(tree)\\n \\n point1 = [0.3, 0.5]\\n found_node = tree.get_path_to_leaf(point1)[-1]\\n correct_node1 = 3\\n self.assertEqual(found_node.label, correct_node1, \\\"Not correct node found\\\")\\n \\n point_right = [0.6, 0.5]\\n tree.split2(point_right, axis = 1)\\n kdtree.visualize(tree)\\n \\n point2 = [0.6, 0.7]\\n found_node = tree.get_path_to_leaf(point2)[-1]\\n correct_node2 = 6\\n self.assertEqual(found_node.label, correct_node2, \\\"Not correct node found\\\")\\n \\n print \\\"----- end: test_add_empty_nodes_with_label_when_splitting -----\\\"\",\n \"def test_render_value_label(self):\\n self.check_html(\\n self.widget(choices=self.beatles),\\n \\\"beatles\\\",\\n [\\\"John\\\"],\\n html=(\\n \\\"\\\"\\\"<select multiple name=\\\"beatles\\\">\\n <option value=\\\"J\\\">John</option>\\n <option value=\\\"P\\\">Paul</option>\\n <option value=\\\"G\\\">George</option>\\n <option value=\\\"R\\\">Ringo</option>\\n </select>\\\"\\\"\\\"\\n ),\\n )\",\n \"def test_issue_add_label(self):\\n pass\",\n \"def test_create_metering_label(self):\\r\\n resource = 'metering_label'\\r\\n cmd = metering.CreateMeteringLabel(\\r\\n test_cli20.MyApp(sys.stdout), None)\\r\\n name = 'my label'\\r\\n myid = 'myid'\\r\\n description = 'my description'\\r\\n args = [name, '--description', description, '--shared']\\r\\n position_names = ['name', 'description', 'shared']\\r\\n position_values = [name, description, True]\\r\\n self._test_create_resource(resource, cmd, name, myid, args,\\r\\n position_names, position_values)\",\n \"def getLabel(*args):\",\n \"def getLabel(*args):\",\n \"def getLabel(*args):\",\n \"def _make_vbenf_label(chain_parts):\\n\\n # toy label for development: run simple and dijet independently.\\n # simple makes Et cuts on two jets. Independently (sharing possible)\\n # of jets choosean by simple, the dijet\\n # scenario requires a dijet of mass > 900, and opening angle in phi > 2.6\\n\\n assert len(chain_parts) == 1\\n scenario = chain_parts[0]['hypoScenario']\\n assert scenario.startswith('vbenf')\\n args = _args_from_scenario(scenario)\\n if not args:\\n return 'and([]simple([(50et)(70et)])combgen([(2)] dijet([(900djmass, 26djdphi)])))' \\n arg_res = [\\n re.compile(r'(?P<lo>\\\\d*)(?P<key>fbet)(?P<hi>\\\\d*)'),\\n re.compile(r'(?P<lo>\\\\d*)(?P<key>mass)(?P<hi>\\\\d*)'),\\n re.compile(r'(?P<lo>\\\\d*)(?P<key>et)(?P<hi>\\\\d*)'),\\n ]\\n\\n defaults = {\\n 'et': ('101', 'inf'),\\n 'mass': ('800', 'inf'),\\n 'fbet': ('501', 'inf'),\\n }\\n\\n argvals = {}\\n while args:\\n assert len(args) == len(arg_res)\\n arg = args.pop()\\n for r in arg_res:\\n m = r.match(arg)\\n if m is not None:\\n arg_res.remove(r)\\n gd = m.groupdict()\\n key = gd['key']\\n try:\\n lo = float(gd['lo'])\\n except ValueError:\\n lo = defaults[key][0]\\n argvals[key+'lo'] = lo \\n try:\\n hi = float(gd['hi'])\\n except ValueError:\\n hi = defaults[key][1]\\n argvals[key+'hi'] = hi\\n\\n assert len(args) == len(arg_res)\\n assert len(args) == 0\\n\\n return \\\"\\\"\\\"\\n and\\n (\\n []\\n simple\\n (\\n [(%(etlo).0fet, 500neta)(%(etlo).0fet, peta500)]\\n )\\n combgen\\n (\\n [(10et, 0eta320)]\\n dijet\\n (\\n [(%(masslo).0fdjmass, 26djdphi)]\\n ) \\n simple\\n (\\n [(10et, 0eta320)(20et, 0eta320)]\\n )\\n )\\n )\\\"\\\"\\\" % argvals\",\n \"def testFormatLabelAndValue(self):\\n\\n self.assertEqual('Abc: xyz', self.inv._FormatLabelAndValue('abc', 'xyz', 1))\\n self.assertEqual('ABc: xyz', self.inv._FormatLabelAndValue('abc', 'xyz', 2))\\n self.assertEqual('ABC: xyz', self.inv._FormatLabelAndValue('abc', 'xyz', 4))\",\n \"def test_recipe_nutrition_label_image(self):\\n pass\",\n \"def test_label_10_targets_with_a_b_c_(self):\\r\\n user_input = '[{\\\"a\\\":\\\"target1\\\"}, \\\\\\r\\n {\\\"b\\\":\\\"target2\\\"},{\\\"c\\\":\\\"target3\\\"},{\\\"a\\\":\\\"target4\\\"},{\\\"b\\\":\\\"target5\\\"}, \\\\\\r\\n {\\\"c\\\":\\\"target6\\\"}, {\\\"a\\\":\\\"target7\\\"},{\\\"b\\\":\\\"target8\\\"},{\\\"c\\\":\\\"target9\\\"}, \\\\\\r\\n {\\\"a\\\":\\\"target10\\\"}]'\\r\\n correct_answer = [\\r\\n {\\r\\n 'draggables': ['a'],\\r\\n 'targets': ['target1', 'target4', 'target7', 'target10'],\\r\\n 'rule': 'unordered_equal'\\r\\n },\\r\\n {\\r\\n 'draggables': ['b'],\\r\\n 'targets': ['target2', 'target5', 'target8'],\\r\\n 'rule': 'unordered_equal'\\r\\n },\\r\\n {\\r\\n 'draggables': ['c'],\\r\\n 'targets': ['target3', 'target6', 'target9'],\\r\\n 'rule': 'unordered_equal'\\r\\n }\\r\\n ]\\r\\n self.assertTrue(draganddrop.grade(user_input, correct_answer))\",\n \"def test_label_10_targets_with_a_b_c_multiple(self):\\r\\n user_input = '[{\\\"a\\\":\\\"target1\\\"}, \\\\\\r\\n {\\\"b\\\":\\\"target2\\\"},{\\\"c\\\":\\\"target3\\\"},{\\\"b\\\":\\\"target5\\\"}, \\\\\\r\\n {\\\"c\\\":\\\"target6\\\"}, {\\\"a\\\":\\\"target7\\\"},{\\\"b\\\":\\\"target8\\\"},{\\\"c\\\":\\\"target9\\\"}, \\\\\\r\\n {\\\"a\\\":\\\"target1\\\"}]'\\r\\n correct_answer = [\\r\\n {\\r\\n 'draggables': ['a', 'a', 'a'],\\r\\n 'targets': ['target1', 'target4', 'target7', 'target10'],\\r\\n 'rule': 'anyof+number'\\r\\n },\\r\\n {\\r\\n 'draggables': ['b', 'b', 'b'],\\r\\n 'targets': ['target2', 'target5', 'target8'],\\r\\n 'rule': 'anyof+number'\\r\\n },\\r\\n {\\r\\n 'draggables': ['c', 'c', 'c'],\\r\\n 'targets': ['target3', 'target6', 'target9'],\\r\\n 'rule': 'anyof+number'\\r\\n }\\r\\n ]\\r\\n self.assertTrue(draganddrop.grade(user_input, correct_answer))\",\n \"def test_subsystems(self):\\n pass\",\n \"def test_multiply_some_type_links():\",\n \"def test_build_match_tree_with_pairs():\\n abbreviation_list = [[\\\"ELIF\\\", \\\"ELI.\\\"], [\\\"ELSE\\\", \\\"E.\\\"]]\\n expected_tree = {\\\"E\\\": {\\\"L\\\": {\\\"I\\\": {\\\"F\\\": \\\"ELI.\\\"}, \\\"S\\\": {\\\"E\\\": \\\"E.\\\"}}}}\\n tree = build_match_tree(abbreviation_list)\\n assert repr(tree) == repr(expected_tree)\",\n \"def check_a11y_relation(filename, tree):\\n global widgets_ignored, ids, label_for_elm, labelled_by_elm, description_for_elm, described_by_elm, mnemonic_for_elm\\n\\n def check_elm(orphan_root, obj, orphan_labels, orphan_widgets):\\n \\\"\\\"\\\"\\n Check one element, knowing that orphan_labels/widgets tell whether\\n there are orphan labels and widgets within orphan_root\\n \\\"\\\"\\\"\\n\\n oid = obj.attrib.get('id')\\n klass = obj.attrib.get('class')\\n\\n # \\\"Don't care\\\" special case\\n if klass in widgets_ignored:\\n return\\n for suffix in widgets_suffixignored:\\n if klass[-len(suffix):] == suffix:\\n return\\n\\n # Widgets usual do not strictly require a label, i.e. a labelled parent\\n # is enough for context, but some do always need one.\\n requires_label = klass in widgets_needlabel\\n\\n if oid is not None:\\n # Check that ids are unique\\n if oid in ids_dup:\\n if ids[oid] == obj:\\n # We are the first, warn\\n duplicates = tree.findall(\\\".//object[@id='\\\" + oid + \\\"']\\\")\\n err(filename, tree, obj, \\\"duplicate-id\\\", \\\"has the same id as other elements \\\" + elms_names_lines(duplicates))\\n\\n # Check label-for and their dual labelled-by\\n label_for = check_rels(filename, tree, root, obj, \\\"label-for\\\", \\\"labelled-by\\\")\\n\\n # Check labelled-by and its dual label-for\\n labelled_by = check_rels(filename, tree, root, obj, \\\"labelled-by\\\", \\\"label-for\\\")\\n\\n # Check label-for and their dual labelled-by\\n description_for = check_rels(filename, tree, root, obj, \\\"description-for\\\", \\\"described-by\\\")\\n\\n # Check labelled-by and its dual label-for\\n described_by = check_rels(filename, tree, root, obj, \\\"described-by\\\", \\\"description-for\\\")\\n\\n # Should have only one label\\n if len(labelled_by) >= 1:\\n if oid in mnemonic_for_elm:\\n warn(filename, tree, obj, \\\"labelled-by-and-mnemonic\\\",\\n \\\"has both a mnemonic \\\" + elm_name_line(mnemonic_for_elm[oid][0]) + \\\"and labelled-by relation\\\")\\n if len(labelled_by) > 1:\\n warn(filename, tree, obj, \\\"multiple-labelled-by\\\", \\\"has multiple labelled-by relations\\\")\\n if oid in label_for_elm:\\n if len(label_for_elm[oid]) > 1:\\n warn(filename, tree, obj, \\\"duplicate-label-for\\\", \\\"is referenced by multiple label-for \\\" + elms_names_lines(label_for_elm[oid]))\\n if oid in mnemonic_for_elm:\\n if len(mnemonic_for_elm[oid]) > 1:\\n warn(filename, tree, obj, \\\"duplicate-mnemonic\\\", \\\"is referenced by multiple mnemonic_widget \\\" + elms_names_lines(mnemonic_for_elm[oid]))\\n\\n # Check member-of\\n member_of = check_rels(filename, tree, root, obj, \\\"member-of\\\")\\n\\n # Labels special case\\n if klass in widgets_labels:\\n properties = check_props(filename, tree, root, obj, \\\"mnemonic_widget\\\") + \\\\\\n check_props(filename, tree, root, obj, \\\"mnemonic-widget\\\")\\n if len(properties) > 1:\\n err(filename, tree, obj, \\\"multiple-mnemonic\\\", \\\"has multiple mnemonic_widgets properties\\\"\\n \\\"%s\\\" % elms_lines(properties))\\n\\n # Emit orphaning warnings\\n if warn_orphan_labels or orphan_widgets:\\n is_orphan_label(filename, tree, root, obj, orphan_root, True)\\n\\n # We are done with the label\\n return\\n\\n # Not a label, will perhaps need one\\n\\n # Emit orphaning warnings\\n is_orphan_widget(filename, tree, root, obj, orphan_labels, orphan_root, True)\\n\\n root = tree.getroot()\\n\\n # Flush ids and relations from previous files\\n ids = {}\\n ids_dup = {}\\n labelled_by_elm = {}\\n label_for_elm = {}\\n described_by_elm = {}\\n description_for_elm = {}\\n mnemonic_for_elm = {}\\n\\n # First pass to get links into hash tables, no warning, just record duplicates\\n for obj in root.iter('object'):\\n oid = obj.attrib.get('id')\\n if oid is not None:\\n if oid not in ids:\\n ids[oid] = obj\\n else:\\n ids_dup[oid] = True\\n\\n labelled_by = obj.findall(\\\"accessibility/relation[@type='labelled-by']\\\")\\n labelled_by += obj.findall(\\\"accessibility/relation[@name='labelled-by']\\\")\\n for rel in labelled_by:\\n target = rel.attrib.get('target')\\n if target is not None:\\n if target not in labelled_by_elm:\\n labelled_by_elm[target] = [ obj ]\\n else:\\n labelled_by_elm[target].append(obj)\\n\\n label_for = obj.findall(\\\"accessibility/relation[@type='label-for']\\\")\\n label_for += obj.findall(\\\"accessibility/relation[@name='label-for']\\\")\\n for rel in label_for:\\n target = rel.attrib.get('target')\\n if target is not None:\\n if target not in label_for_elm:\\n label_for_elm[target] = [ obj ]\\n else:\\n label_for_elm[target].append(obj)\\n\\n described_by = obj.findall(\\\"accessibility/relation[@type='described-by']\\\")\\n described_by += obj.findall(\\\"accessibility/relation[@name='described-by']\\\")\\n for rel in described_by:\\n target = rel.attrib.get('target')\\n if target is not None:\\n if target not in described_by_elm:\\n described_by_elm[target] = [ obj ]\\n else:\\n described_by_elm[target].append(obj)\\n\\n description_for = obj.findall(\\\"accessibility/relation[@type='description-for']\\\")\\n description_for += obj.findall(\\\"accessibility/relation[@name='description-for']\\\")\\n for rel in description_for:\\n target = rel.attrib.get('target')\\n if target is not None:\\n if target not in description_for_elm:\\n description_for_elm[target] = [ obj ]\\n else:\\n description_for_elm[target].append(obj)\\n\\n mnemonic_for = obj.findall(\\\"property[@name='mnemonic_widget']\\\") + \\\\\\n obj.findall(\\\"property[@name='mnemonic-widget']\\\")\\n for rel in mnemonic_for:\\n target = rel.text\\n if target is not None:\\n if target not in mnemonic_for_elm:\\n mnemonic_for_elm[target] = [ obj ]\\n else:\\n mnemonic_for_elm[target].append(obj)\\n\\n # Second pass, recursive depth-first, to be able to efficiently know whether\\n # there are orphan labels within a part of the tree.\\n def recurse(orphan_root, obj, orphan_labels, orphan_widgets):\\n if obj == root or is_labelled_parent(obj):\\n orphan_root = obj\\n orphan_labels, orphan_widgets = orphan_items(filename, tree, root, obj)\\n\\n if obj.tag == 'object':\\n check_elm(orphan_root, obj, orphan_labels, orphan_widgets)\\n\\n for o in obj:\\n recurse(orphan_root, o, orphan_labels, orphan_widgets)\\n\\n recurse(root, root, False, False)\",\n \"def test_stratis_list_default(self):\\n for subcommand in [[\\\"pool\\\"], [\\\"filesystem\\\"], [\\\"blockdev\\\"]]:\\n for prefix in [[], [\\\"--propagate\\\"]]:\\n self.assertEqual(RUNNER(prefix + subcommand), 0)\",\n \"def pytest_can_run_together(item1, item2):\",\n \"def test_series_in_features(self):\\n assert parse_command({'test{{A,B}}': {'depends_on': 'name{{A,B}}'}}) == [\\n ('testA', {'depends_on': 'nameA'}), ('testB', {'depends_on': 'nameB'})]\",\n \"def test_first_level_from_bids_with_subject_labels(bids_dataset):\\n warning_message = ('Subject label foo is not present in'\\n ' the dataset and cannot be processed')\\n with pytest.warns(UserWarning, match=warning_message):\\n models, *_ = first_level_from_bids(\\n dataset_path=bids_dataset,\\n task_label='main',\\n sub_labels=[\\\"foo\\\", \\\"01\\\"],\\n space_label='MNI',\\n img_filters=[('desc', 'preproc')],\\n slice_time_ref=None,\\n )\\n\\n assert models[0].subject_label == '01'\",\n \"def test_pathop12(self):\\n xpb = XPathBuilder()\\n # braces not needed\\n xp = xpb.foo & (xpb.bar.foo).parenthesize() | xpb.foobar\\n exp = '/foo and (/bar/foo) or /foobar'\\n self.assertEqual(xp.tostring(), exp)\",\n \"def test_dummy6(self):\\n xpb = XPathBuilder()\\n xp = xpb.dummy()\\n xp = xpb.bar | xp\\n exp = '/bar'\\n self.assertEqual(xp.tostring(), exp)\",\n \"def test_create_labels(self):\\n test_labels = {\\\"app\\\": \\\"my_app\\\", \\\"host\\\": \\\"examplehost\\\"}\\n labels = pmp.utils.create_labels(test_labels)\\n self.assertIsInstance(labels, list)\\n self.assertTrue(all([isinstance(x, pmp.LabelPair) for x in labels]))\",\n \"def test_xdist_and_select_test_by_bdd_label(xdist_runner: AllurePytestRunner):\\n\\n output = xdist_runner.run_docstring(\\\"-v\\\", \\\"--allure-features=boo\\\", \\\"-n1\\\")\\n\\n assert_that(output, has_only_testcases(\\n has_entry(\\n \\\"fullName\\\",\\n ends_with(\\\"test_with_feature_boo\\\")\\n )\\n ))\",\n \"def test_nested_condition() -> None:\\n\\n @argcomb(Or(And(\\\"a\\\", \\\"b\\\"), And(\\\"c\\\", \\\"d\\\")))\\n def f(a: Any = None, b: Any = None, c: Any = None, d: Any = None) -> None:\\n ...\\n\\n # valid\\n f(a=1, b=1)\\n f(c=1, d=1)\\n f(a=1, b=1, c=1, d=1)\\n\\n # invalid\\n with pytest.raises(InvalidArgumentCombination):\\n f(a=1)\\n with pytest.raises(InvalidArgumentCombination):\\n f(a=1, c=1)\\n with pytest.raises(InvalidArgumentCombination):\\n f()\",\n \"def test_abbreviation(self):\\n self.assertEqual(self.compound.abbreviation, \\\"Cool\\\")\",\n \"def test_general_subset_all():\\n pass\",\n \"def test_check_tree_exact_match(self):\\r\\n\\r\\n fasta_labels = ['seq1_1', 'seq1_2', 'seq2_3', 'seq3_4']\\r\\n\\r\\n actual_subset_results = check_tree_exact_match(fasta_labels,\\r\\n self.sample_tree_3tips_fp)\\r\\n\\r\\n # Should find all and give True, True result\\r\\n\\r\\n self.assertEqual(actual_subset_results, [True, True])\\r\\n\\r\\n # Should get tips not found in fasta labels with 5 tip tree\\r\\n\\r\\n fasta_labels = ['seq1_1', 'seq1_2', 'seq2_3', 'seq3_4']\\r\\n\\r\\n actual_subset_results = check_tree_exact_match(fasta_labels,\\r\\n self.sample_tree_5tips_fp)\\r\\n\\r\\n # Should find all and give True result\\r\\n\\r\\n self.assertEqual(actual_subset_results, [True, ['seq5', 'seq4']])\\r\\n\\r\\n # Change two of the fasta labels to not match tree tips\\r\\n\\r\\n fasta_labels = ['seq1_1', 'seqX_2', 'seq2_3', 'seqY_4']\\r\\n\\r\\n actual_subset_results = check_tree_exact_match(fasta_labels,\\r\\n self.sample_tree_5tips_fp)\\r\\n\\r\\n # Should find seqX and seqY as not being a subset\\r\\n\\r\\n self.assertEqual(actual_subset_results, [['seqX', 'seqY'],\\r\\n ['seq3', 'seq5', 'seq4']])\",\n \"def test_03_visit_special(self):\",\n \"def test_labels(ruler: SpaczzRuler) -> None:\\n assert all(\\n [label in ruler.labels for label in [\\\"GPE\\\", \\\"STREET\\\", \\\"DRUG\\\", \\\"NAME\\\", \\\"BAND\\\"]]\\n )\\n assert len(ruler.labels) == 5\",\n \"def test_createSubLinkographWithoutCommands(self):\\n self.performTestForParams()\",\n \"def test_first_level_from_bids_several_labels_per_entity(tmp_path, entity):\\n n_sub = 1\\n n_ses = 1\\n tasks = [\\\"main\\\"]\\n n_runs = [1]\\n\\n bids_path = create_fake_bids_dataset(\\n base_dir=tmp_path,\\n n_sub=n_sub,\\n n_ses=n_ses,\\n tasks=tasks,\\n n_runs=n_runs,\\n entities={entity: [\\\"A\\\", \\\"B\\\"]},\\n )\\n\\n models, m_imgs, m_events, m_confounds = first_level_from_bids(\\n dataset_path=bids_path,\\n task_label=\\\"main\\\",\\n space_label=\\\"MNI\\\",\\n img_filters=[(\\\"desc\\\", \\\"preproc\\\"), (entity, \\\"A\\\")],\\n slice_time_ref=None,\\n )\\n\\n _check_output_first_level_from_bids(n_sub,\\n models,\\n m_imgs,\\n m_events,\\n m_confounds)\\n n_imgs_expected = n_ses * n_runs[0]\\n assert len(m_imgs[0]) == n_imgs_expected\",\n \"def test_setter_child_list_tuple(self):\\n root = netapp_api.NaElement('root')\\n root['l'] = ['l1', 'l2']\\n root['t'] = ('t1', 't2')\\n l = root.get_child_by_name('l')\\n self.assertIsInstance(l, netapp_api.NaElement)\\n t = root.get_child_by_name('t')\\n self.assertIsInstance(t, netapp_api.NaElement)\\n for le in l.get_children():\\n self.assertIn(le.get_name(), ['l1', 'l2'])\\n for te in t.get_children():\\n self.assertIn(te.get_name(), ['t1', 't2'])\",\n \"def test_tree_support(self):\\r\\n master_tree = parse_newick('((a:2,b:3)ab:2,(c:1,d:2)cd:7)rt;')\\r\\n \\\"\\\"\\\"\\r\\n /-------.5 /-a\\r\\n ---1| \\\\-b\\r\\n \\\\------.5 /-c\\r\\n \\\\-d\\r\\n \\\"\\\"\\\"\\r\\n t2 = parse_newick('((a:2,b:3,c:33)ho:2,d:7);') # abc are siblings\\r\\n\\r\\n tc.tree_support(master_tree, t2)\\r\\n assert_almost_equal(\\r\\n master_tree.getNodeMatchingName('rt').bootstrap_support, 1.0)\",\n \"def test_labels(self):\\n return self._test_labels\",\n \"def test_issue_edit_label(self):\\n pass\",\n \"def test_dbpa002_radio_items(dash_duo):\\n app = Dash()\\n\\n options = {\\n \\\"OptionA\\\": \\\"Option 1\\\",\\n \\\"OptionB\\\": \\\"Option 2\\\",\\n \\\"OptionC\\\": \\\"Option 3\\\",\\n }\\n\\n value = \\\"OptionB\\\"\\n\\n with_keywords = RadioItems(\\n options=options,\\n value=value,\\n id=\\\"with-keywords\\\",\\n )\\n without_keywords = RadioItems(options, value, id=\\\"without-keywords\\\")\\n\\n app.layout = html.Div([with_keywords, without_keywords])\\n\\n dash_duo.start_server(app)\\n\\n # Check values\\n assert [\\n a.get_attribute(\\\"value\\\")\\n for a in dash_duo.wait_for_element(\\n \\\"#with-keywords\\\"\\n ).find_elements_by_tag_name(\\\"input\\\")\\n ] == [\\n a.get_attribute(\\\"value\\\")\\n for a in dash_duo.wait_for_element(\\n \\\"#without-keywords\\\"\\n ).find_elements_by_tag_name(\\\"input\\\")\\n ]\\n\\n # Check labels\\n assert [\\n a.text\\n for a in dash_duo.wait_for_element(\\n \\\"#with-keywords\\\"\\n ).find_elements_by_tag_name(\\\"label\\\")\\n ] == [\\n a.text\\n for a in dash_duo.wait_for_element(\\n \\\"#without-keywords\\\"\\n ).find_elements_by_tag_name(\\\"label\\\")\\n ]\",\n \"def test(self):\\n for doc, label in zip(self.test_docs(), self.test_labels()):\\n yield doc, label\",\n \"def test_get_parent_type_name(self):\\n pass\",\n \"def test_pathop8(self):\\n xpb = XPathBuilder()\\n xp = (xpb.foo.bar | xpb.foobar).parenthesize() & xpb.action.source\\n exp = '(/foo/bar or /foobar) and /action/source'\\n self.assertEqual(xp.tostring(), exp)\",\n \"def test_setter_child_list_tuple(self):\\n root = netapp_api.NaElement('root')\\n root['l'] = ['l1', 'l2']\\n root['t'] = ('t1', 't2')\\n l_element = root.get_child_by_name('l')\\n self.assertIsInstance(l_element, netapp_api.NaElement)\\n t = root.get_child_by_name('t')\\n self.assertIsInstance(t, netapp_api.NaElement)\\n for le in l_element.get_children():\\n self.assertIn(le.get_name(), ['l1', 'l2'])\\n for te in t.get_children():\\n self.assertIn(te.get_name(), ['t1', 't2'])\",\n \"def __init__(self, root_node, label1, label2):\\n super().__init__(self.PROBLEM_NAME)\\n self.root_node = root_node\\n self.label1 = label1\\n self.label2 = label2\",\n \"def test_radioselect_field():\",\n \"def test_label_callback():\\n release_numbers = dict(a='123')\\n data = dict(revision='a', attributes=dict(b='c'))\\n data2 = dict(revision='b', attributes=dict(d='e'))\\n\\n assert _label_callback(data, release_numbers) == u'a\\\\n- Release: 123\\\\n- b: c'\\n assert _label_callback(data2) == u'b\\\\n- Release: Unknown\\\\n- d: e'\",\n \"def _make_simple_partition_label(chain_dict):\\n\\n cps = chain_dict['chainParts']\\n if not (_select_simple_chainparts(cps)):\\n raise NotImplementedError(\\n 'chain fails substring selection: not \\\"simple\\\": %s' % (\\n chain_dict['chainName']))\\n \\n label = 'simplepartition(['\\n for cp in cps:\\n smcstr = str(cp['smc'])\\n if smcstr == 'nosmc':\\n smcstr = ''\\n for i in range(int(cp['multiplicity'])):\\n # condition_str = '(%set,%s,%s)' % (str(cp['threshold']),\\n # str(cp['etaRange']),\\n # smcstr,)\\n condition_str = '(%set,%s' % (str(cp['threshold']),\\n str(cp['etaRange']),)\\n if smcstr:\\n condition_str += ',%s)'\\n else:\\n condition_str += ')'\\n label += condition_str\\n label += '])'\\n return label\",\n \"def test_case1(self):\\n\\n graph = BipartiteGraph()\\n\\n graph.addEdge(\\\"supervisor1\\\",\\\"student1\\\")\\n\\n val1 = graph.getStudents(\\\"supervisor1\\\")\\n val2 = graph.getSupervisors(\\\"student1\\\")\\n\\n expected1 = [\\\"student1\\\"]\\n expected2 = [\\\"supervisor1\\\"]\\n\\n self.assertEqual((val1,val2),(expected1,expected2))\",\n \"def test_with_multiple_descriptions():\\n soup = generate_case(\\\"with_descriptions\\\")\\n\\n tests.html_schema_doc_asserts.assert_descriptions(\\n soup,\\n [\\n \\\"Exact address\\\",\\n \\\"Exact address\\\",\\n \\\"Delivery info depending on the delivery type\\\",\\n \\\"The delivery is a gift, no prices displayed\\\",\\n ],\\n )\",\n \"def test_BuildModel2(self):\\n print(\\\"\\\\nTest 6: Building a Model with Concat\\\")\\n builder = StaticBuilder(\\\"Concat\\\")\\n in1 = builder.addInput(10)\\n in2 = builder.addInput(20)\\n enc1 = builder.addInner(3, num_islots=2)\\n out1 = builder.addOutput()\\n\\n builder.addDirectedLink(in1, enc1, islot=0)\\n builder.addDirectedLink(in2, enc1, islot=1)\\n builder.addDirectedLink(enc1, out1)\\n \\n builder.build()\",\n \"def test_multiple_label_traversals(self):\\r\\n TestEdge.create(self.v1, self.v2)\\r\\n OtherTestEdge.create(self.v1, self.v3)\\r\\n YetAnotherTestEdge.create(self.v1, self.v4)\\r\\n\\r\\n assert len(self.v1.outV()) == 3\\r\\n\\r\\n assert len(self.v1.outV(TestEdge)) == 1\\r\\n assert len(self.v1.outV(OtherTestEdge)) == 1\\r\\n assert len(self.v1.outV(YetAnotherTestEdge)) == 1\\r\\n\\r\\n out = self.v1.outV(TestEdge, OtherTestEdge)\\r\\n assert len(out) == 2\\r\\n assert self.v2.vid in [v.vid for v in out]\\r\\n assert self.v3.vid in [v.vid for v in out]\\r\\n\\r\\n out = self.v1.outV(OtherTestEdge, YetAnotherTestEdge)\\r\\n assert len(out) == 2\\r\\n assert self.v3.vid in [v.vid for v in out]\\r\\n assert self.v4.vid in [v.vid for v in out]\",\n \"def test_label_10_targets_with_a_b_c_false(self):\\r\\n user_input = '[{\\\"a\\\":\\\"target1\\\"}, \\\\\\r\\n {\\\"b\\\":\\\"target2\\\"},{\\\"c\\\":\\\"target3\\\"},{\\\"a\\\":\\\"target4\\\"},{\\\"b\\\":\\\"target5\\\"}, \\\\\\r\\n {\\\"c\\\":\\\"target6\\\"}, {\\\"a\\\":\\\"target7\\\"},{\\\"b\\\":\\\"target8\\\"},{\\\"c\\\":\\\"target9\\\"}, \\\\\\r\\n {\\\"a\\\":\\\"target1\\\"}]'\\r\\n correct_answer = [\\r\\n {\\r\\n 'draggables': ['a'],\\r\\n 'targets': ['target1', 'target4', 'target7', 'target10'],\\r\\n 'rule': 'unordered_equal'\\r\\n },\\r\\n {\\r\\n 'draggables': ['b'],\\r\\n 'targets': ['target2', 'target5', 'target8'],\\r\\n 'rule': 'unordered_equal'\\r\\n },\\r\\n {\\r\\n 'draggables': ['c'],\\r\\n 'targets': ['target3', 'target6', 'target9'],\\r\\n 'rule': 'unordered_equal'\\r\\n }\\r\\n ]\\r\\n self.assertFalse(draganddrop.grade(user_input, correct_answer))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6137433","0.6108757","0.60195917","0.5986544","0.5936767","0.58589","0.5759686","0.56950617","0.5624841","0.55902916","0.55750483","0.5560212","0.5554626","0.55542696","0.5553175","0.5553175","0.55467266","0.5503819","0.5457172","0.5451371","0.54313546","0.53999746","0.5376586","0.5375577","0.5364844","0.5359766","0.535864","0.5338235","0.53258616","0.53186446","0.5317656","0.5315998","0.5315065","0.528178","0.5272056","0.5271867","0.5262255","0.5256516","0.5254785","0.5251119","0.5245671","0.52348095","0.5232146","0.5209617","0.520278","0.52023655","0.51976585","0.51973414","0.5193984","0.5191381","0.51910853","0.5168662","0.51612574","0.5156716","0.5155904","0.5155904","0.5155904","0.515586","0.51550406","0.51405126","0.51366323","0.5126447","0.51249856","0.5119241","0.5116798","0.5115688","0.5107617","0.510387","0.5094173","0.5092521","0.5089139","0.50838256","0.5078707","0.5075308","0.50716203","0.5061532","0.5061452","0.50607544","0.50605214","0.50554216","0.50476885","0.5047116","0.50363714","0.5028754","0.5026291","0.5024467","0.50243545","0.5023076","0.50198036","0.5014891","0.5011064","0.5007032","0.50008494","0.49937844","0.49911672","0.49879867","0.49861643","0.49833554","0.49800858","0.49767923"],"string":"[\n \"0.6137433\",\n \"0.6108757\",\n \"0.60195917\",\n \"0.5986544\",\n \"0.5936767\",\n \"0.58589\",\n \"0.5759686\",\n \"0.56950617\",\n \"0.5624841\",\n \"0.55902916\",\n \"0.55750483\",\n \"0.5560212\",\n \"0.5554626\",\n \"0.55542696\",\n \"0.5553175\",\n \"0.5553175\",\n \"0.55467266\",\n \"0.5503819\",\n \"0.5457172\",\n \"0.5451371\",\n \"0.54313546\",\n \"0.53999746\",\n \"0.5376586\",\n \"0.5375577\",\n \"0.5364844\",\n \"0.5359766\",\n \"0.535864\",\n \"0.5338235\",\n \"0.53258616\",\n \"0.53186446\",\n \"0.5317656\",\n \"0.5315998\",\n \"0.5315065\",\n \"0.528178\",\n \"0.5272056\",\n \"0.5271867\",\n \"0.5262255\",\n \"0.5256516\",\n \"0.5254785\",\n \"0.5251119\",\n \"0.5245671\",\n \"0.52348095\",\n \"0.5232146\",\n \"0.5209617\",\n \"0.520278\",\n \"0.52023655\",\n \"0.51976585\",\n \"0.51973414\",\n \"0.5193984\",\n \"0.5191381\",\n \"0.51910853\",\n \"0.5168662\",\n \"0.51612574\",\n \"0.5156716\",\n \"0.5155904\",\n \"0.5155904\",\n \"0.5155904\",\n \"0.515586\",\n \"0.51550406\",\n \"0.51405126\",\n \"0.51366323\",\n \"0.5126447\",\n \"0.51249856\",\n \"0.5119241\",\n \"0.5116798\",\n \"0.5115688\",\n \"0.5107617\",\n \"0.510387\",\n \"0.5094173\",\n \"0.5092521\",\n \"0.5089139\",\n \"0.50838256\",\n \"0.5078707\",\n \"0.5075308\",\n \"0.50716203\",\n \"0.5061532\",\n \"0.5061452\",\n \"0.50607544\",\n \"0.50605214\",\n \"0.50554216\",\n \"0.50476885\",\n \"0.5047116\",\n \"0.50363714\",\n \"0.5028754\",\n \"0.5026291\",\n \"0.5024467\",\n \"0.50243545\",\n \"0.5023076\",\n \"0.50198036\",\n \"0.5014891\",\n \"0.5011064\",\n \"0.5007032\",\n \"0.50008494\",\n \"0.49937844\",\n \"0.49911672\",\n \"0.49879867\",\n \"0.49861643\",\n \"0.49833554\",\n \"0.49800858\",\n \"0.49767923\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6972838"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":8791,"cells":{"query":{"kind":"string","value":"make test label for combinations helper with two simple children."},"document":{"kind":"string","value":"def _make_partitionsTest_label(chain_parts):\n\n assert len(chain_parts) == 1\n scenario = chain_parts[0]['hypoScenario']\n \n assert scenario == 'partitionsTest'\n\n \n\n return \"\"\"\n partgen(\n [(20et, 0eta320)]\n \n simple([(40et, 0eta320) (50et, 0eta320)])\n simple([(35et, 0eta240) (55et, 0eta240)])\n )\"\"\""},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _make_combinationsTest_label(chain_parts):\n\n assert len(chain_parts) == 1\n scenario = chain_parts[0]['hypoScenario']\n \n assert scenario == 'combinationsTest'\n\n \n\n return \"\"\"\n combgen(\n [(2)(20et, 0eta320)]\n \n simple([(40et, 0eta320) (50et, 0eta320)])\n simple([(35et, 0eta240) (55et, 0eta240)])\n )\"\"\"","def test_sums():\n assert label_parent(1, 2) == 3\n assert label_parent (1, 4) == 8\n # Should ignore arg order\n assert label_parent(4, 1) == 8","def test_recipe_nutrition_label_widget(self):\n pass","def test_select_label(self):\n title = ('Transportation Challenges Limit Education Choices for '\n 'Denver Parents')\n summary = \"\"\"\n Many families in the Denver metro area use public\n transportation instead of a school bus because for them, a\n quality education is worth hours of daily commuting. Colorado's\n school choice program is meant to foster educational equity,\n but the families who benefit most are those who have time and\n money to travel. Low-income families are often left in a lurch.\n \"\"\"\n byline = \"Mile High Connects\"\n story = create_story(title=title, summary=summary, byline=byline)\n layout = SectionLayout.objects.get(sectionlayouttranslation__name=\"Side by Side\")\n section1 = create_section(title=\"Test Section 1\", story=story, layout=layout)\n section2 = create_section(title=\"Test Section 2\", story=story, layout=layout)\n form = SectionRelationAdminForm()\n choices_list = list(form.fields['parent'].widget.choices)\n self.assertIn(story.title, choices_list[1][1])\n self.assertIn(story.title, choices_list[2][1])","def setUp(self):\n\n singleLabels = linkoCreate.Linkograph(\n [({'A'}, set(), {1,2,3}),\n ({'D'}, {0}, {3,4}),\n ({'A'}, {0}, {4}),\n ({'C'}, {0,1}, {4}),\n ({'A'}, {1,2,3}, set())],\n ['A', 'B', 'C', 'D'])\n\n singleSubLinko0_2 = linkoCreate.Linkograph(\n [({'A'}, set(), {1,2}),\n ({'D'}, {0}, set()),\n ({'A'}, {0}, set())],\n ['A', 'B', 'C', 'D'])\n\n singleSubLinko0_1 = linkoCreate.Linkograph(\n [({'A'}, set(), {1}),\n ({'D'}, {0}, set())],\n ['A', 'B', 'C', 'D'])\n\n singleSubLinko0_0 = linkoCreate.Linkograph(\n [({'A'}, set(), set())],\n ['A', 'B', 'C', 'D'])\n\n singleSubLinko1_2 = linkoCreate.Linkograph(\n [({'D'}, set(), set()),\n ({'A'}, set(), set())],\n ['A', 'B', 'C', 'D'])\n\n singleSubLinko1_1 = linkoCreate.Linkograph(\n [({'D'}, set(), set())],\n ['A', 'B', 'C', 'D'])\n\n trivialLinkograph = linkoCreate.Linkograph(\n [], ['A', 'B', 'C', 'D'])\n\n\n singleSubLinko1_4 = linkoCreate.Linkograph(\n [({'D'}, set(), {2,3}),\n ({'A'}, set(), {3}),\n ({'C'}, {0}, {3}),\n ({'A'}, {0,1,2}, set())],\n ['A', 'B', 'C', 'D'])\n\n singleSubLinko2_4 = linkoCreate.Linkograph(\n [({'A'}, set(), {2}),\n ({'C'}, set(), {2}),\n ({'A'}, {0,1}, set())],\n ['A', 'B', 'C', 'D'])\n\n singleSubLinko3_4 = linkoCreate.Linkograph(\n [({'C'}, set(), {1}),\n ({'A'}, {0}, set())],\n ['A', 'B', 'C', 'D'])\n\n singleSubLinko4_4 = linkoCreate.Linkograph(\n [({'A'}, set(), set())],\n ['A', 'B', 'C', 'D'])\n\n simpleLinko = linkoCreate.Linkograph(\n [({'A', 'B', 'C'}, set(), {1,2,3}),\n ({'D'}, {0}, {3,4}),\n ({'A'}, {0}, {4}),\n ({'B', 'C'}, {0,1}, {4}),\n ({'A'}, {1,2,3}, set())],\n ['A', 'B', 'C', 'D'])\n\n if self.id().split('.')[-1] == 'test_createSubLinkographWithoutCommands':\n self.testParams = [\n {'linko': singleLabels,\n 'lowerBound': None,\n 'upperBound': None,\n 'ExpectedLinkograph': singleLabels},\n\n {'linko': singleLabels,\n 'lowerBound': 0,\n 'upperBound': 4,\n 'ExpectedLinkograph': singleLabels},\n\n {'linko': singleLabels,\n 'lowerBound': 0,\n 'upperBound': 5,\n 'ExpectedLinkograph': singleLabels},\n\n {'linko': singleLabels,\n 'lowerBound': 0,\n 'upperBound': 2,\n 'ExpectedLinkograph': singleSubLinko0_2},\n\n {'linko': singleLabels,\n 'lowerBound': -1,\n 'upperBound': 2,\n 'ExpectedLinkograph': singleSubLinko0_2},\n\n {'linko': singleLabels,\n 'lowerBound': None,\n 'upperBound': 2,\n 'ExpectedLinkograph': singleSubLinko0_2},\n\n {'linko': singleLabels,\n 'lowerBound': 0,\n 'upperBound': 1,\n 'ExpectedLinkograph': singleSubLinko0_1},\n\n {'linko': singleLabels,\n 'lowerBound': 0,\n 'upperBound': 0,\n 'ExpectedLinkograph': singleSubLinko0_0},\n\n {'linko': singleLabels,\n 'lowerBound': 0,\n 'upperBound': -1,\n 'ExpectedLinkograph': trivialLinkograph},\n\n {'linko': singleLabels,\n 'lowerBound': 1,\n 'upperBound': 2,\n 'ExpectedLinkograph': singleSubLinko1_2},\n\n {'linko': singleLabels,\n 'lowerBound': 1,\n 'upperBound': 1,\n 'ExpectedLinkograph': singleSubLinko1_1},\n\n {'linko': singleLabels,\n 'lowerBound': 1,\n 'upperBound': 0,\n 'ExpectedLinkograph': trivialLinkograph},\n\n {'linko': singleLabels,\n 'lowerBound': -1,\n 'upperBound': -1,\n 'ExpectedLinkograph': trivialLinkograph},\n\n {'linko': singleLabels,\n 'lowerBound': 1,\n 'upperBound': 4,\n 'ExpectedLinkograph': singleSubLinko1_4},\n\n {'linko': singleLabels,\n 'lowerBound': 2,\n 'upperBound': 4,\n 'ExpectedLinkograph': singleSubLinko2_4},\n\n {'linko': singleLabels,\n 'lowerBound': 3,\n 'upperBound': 4,\n 'ExpectedLinkograph': singleSubLinko3_4},\n\n {'linko': singleLabels,\n 'lowerBound': 4,\n 'upperBound': 4,\n 'ExpectedLinkograph': singleSubLinko4_4},\n\n ]","def test_labels(self):\n self.compliance_tester.test_labels(self.oi)","def test_parent_label(self):\n l = self.d.label(1)\n l2 = self.d.label(31405)\n\n self.assertTrue(l.parent_label is None)\n self.assertTrue(l2 in l.sublabels)\n self.assertEqual(l2.parent_label, l)","def test_simple(self):\n exp = [{'type': NewickEvents.OPEN_SUBTREE, 'comments': []},\n {'type': NewickEvents.OPEN_SUBTREE, 'comments': []},\n {'edge_info': None, 'type': NewickEvents.TIP, 'comments': [], 'label': 'h'},\n {'edge_info': None, 'type': NewickEvents.TIP, 'comments': [], 'label': 'p'},\n {'edge_info': '1', 'type': NewickEvents.CLOSE_SUBTREE,\n 'comments': [], 'label': 'hp'},\n {'edge_info': None, 'type': NewickEvents.TIP, 'comments': [], 'label': 'g'},\n {'edge_info': None, 'type': NewickEvents.CLOSE_SUBTREE,\n 'comments': [], 'label': 'hpg'}\n ]\n content = '((h,p)hp:1,g)hpg;'\n self._do_test(content, exp)\n content = '((h,[pretest]p[test][posttest])hp,g)hpg;'\n exp = [{'type': NewickEvents.OPEN_SUBTREE, 'comments': []},\n {'type': NewickEvents.OPEN_SUBTREE, 'comments': []},\n {'edge_info': None, 'type': NewickEvents.TIP, 'comments': [], 'label': 'h'},\n {'edge_info': None, 'type': NewickEvents.TIP,\n 'comments': ['pretest', 'test', 'posttest'], 'label': 'p'},\n {'edge_info': None, 'type': NewickEvents.CLOSE_SUBTREE,\n 'comments': [], 'label': 'hp'},\n {'edge_info': None, 'type': NewickEvents.TIP, 'comments': [], 'label': 'g'},\n {'edge_info': None, 'type': NewickEvents.CLOSE_SUBTREE,\n 'comments': [], 'label': 'hpg'}\n ]\n self._do_test(content, exp)","def test_label(self):\n xs = t.Label(t.Exactly(\"x\"), 'CustomLabel')\n self.assertEqual(writePython(xs),\n dd(\"\"\"\n def _G_label_1():\n _G_exactly_2, lastError = self.exactly('x')\n self.considerError(lastError, None)\n return (_G_exactly_2, self.currentError)\n _G_label_3, lastError = self.label(_G_label_1, \"CustomLabel\")\n self.considerError(lastError, None)\n _G_label_3\n \"\"\"))","def addLabels(t):\n if not t.label:\n t.label = \"\".join([choice(\"abcdefghijklmnopqrstuvwxyz\") for i in range(4)])\n for r,w in t.children:\n addLabels(r)","def test_general_subset_level():\n pass","def _make_simple_comb_label(chain_dict):\n\n cps = chain_dict['chainParts']\n if not (_select_simple_chainparts(cps)):\n raise NotImplementedError(\n 'chain fails substring selection: not \"simple\": %s' % (\n chain_dict['chainName']))\n \n simple_strs = []\n\n for cp in cps:\n print(cp)\n simple_strs.append(_make_simple_label([cp]))\n\n label = 'combgen([(%d)]' % len(cps)\n for s in simple_strs:\n label += ' %s ' % s\n label += ')'\n return label","def _generateLabelAndName(self, obj, **args):\n result = []\n label = self._generateLabel(obj, **args)\n name = self._generateName(obj, **args)\n result.extend(label)\n if not len(label):\n result.extend(name)\n elif len(name) and name[0].strip() != label[0].strip():\n result.extend(name)\n return result","def tests_ti_document_add_label(self):\n super().group_add_label()","def getLabel2(*args):","def getLabel2(*args):","def test_checkboxtextgroup(self):\r\n self.check_group('checkboxtextgroup', 'choice', 'checkbox')","def _generateTableCell2ChildLabel(self, obj, **args):\n result = []\n\n # If this table cell has 2 children and one of them has a\n # 'toggle' action and the other does not, then present this\n # as a checkbox where:\n # 1) we get the checked state from the cell with the 'toggle' action\n # 2) we get the label from the other cell.\n # See Orca bug #376015 for more details.\n #\n if obj.childCount == 2:\n cellOrder = []\n hasToggle = [False, False]\n for i, child in enumerate(obj):\n if self._script.utilities.hasMeaningfulToggleAction(child):\n hasToggle[i] = True\n break\n if hasToggle[0] and not hasToggle[1]:\n cellOrder = [ 1, 0 ]\n elif not hasToggle[0] and hasToggle[1]:\n cellOrder = [ 0, 1 ]\n if cellOrder:\n for i in cellOrder:\n if not hasToggle[i]:\n result.extend(self.generate(obj[i], **args))\n return result","def test_process_label_in_node(self):\n tree = Node(children=[\n Node(\"Defining secret phrase.\", label=['AB', 'a']),\n Node(\"Has secret phrase. Then some other content\", \n label=['AB', 'b'])\n ], label=['AB'])\n t = Terms(tree)\n t.scoped_terms = {\n ('AB',): [Ref(\"secret phrase\", \"AB-a\", (9,22))]\n }\n # Term is defined in the first child\n self.assertEqual([], t.process(tree.children[0]))\n self.assertEqual(1, len(t.process(tree.children[1])))","def get_extra_label(self, label_name: str, hierarchy: List[str]) -> Any:","def test_get_scenarios_expanded(self):\n pass","def test_nested():\n res = conf.status.conditions.choose(lambda c: (c.type, c.reason, c.root.metadata.choose(lambda m: (m[\"name\"], m.uid))))\n assert \"type\" in res # from conditions\n assert \"reason\" in res # from conditions\n assert \"name\" in res # from metadata\n assert \"uid\" in res # from metadata","def _make_simple_label(chain_parts):\n \n if not _select_simple_chainparts(chain_parts):\n msg = 'Jet Configuration error: '\\\n 'chain fails substring selection: not \"simple\" '\n\n raise NotImplementedError(msg)\n \n label = 'simple(['\n for cp in chain_parts:\n smcstr = str(cp['smc'])\n jvtstr = str(cp['jvt'])\n if smcstr == 'nosmc':\n smcstr = ''\n for i in range(int(cp['multiplicity'])):\n # condition_str = '(%set,%s,%s)' % (str(cp['threshold']),\n # str(cp['etaRange']),\n # smcstr,)\n condition_str = '(%set,%s' % (str(cp['threshold']),\n str(cp['etaRange']),)\n if smcstr: # Run 2 chains have \"INF\" in the SMC substring\n condition_str += ',%s)' % smcstr.replace('INF','')\n elif jvtstr:\n condition_str += ',%s)' % jvtstr\n else:\n condition_str += ')'\n label += condition_str\n label += '])'\n return label","def test_nested_sequence(self):\n\n self.taxon_tester('Apis mellifera')\n self.taxon_tester('Apis')\n self.taxon_tester('Apini')\n self.taxon_tester('Apinae')\n # Apidae at 5680 species is a struggle\n self.taxon_tester('Apidae')\n if False:\n # Apoidea: 19566 takes 223 seconds\n self.taxon_tester('Apoidea')\n # Aculeata fails after 339 seconds\n self.taxon_tester('Aculeata')\n self.taxon_tester('Apocrita')\n self.taxon_tester('Hymenoptera')\n self.taxon_tester('Endopterygota')\n self.taxon_tester('Neoptera')\n self.taxon_tester('Pterygota')\n self.taxon_tester('Dicondylia')\n self.taxon_tester('Insecta')\n self.taxon_tester('Hexapoda')\n self.taxon_tester('Pancrustacea')\n self.taxon_tester('Mandibulata')\n self.taxon_tester('Arthropoda')\n self.taxon_tester('Panarthropoda')\n self.taxon_tester('Ecdysozoa')\n self.taxon_tester('Protostomia')\n self.taxon_tester('Bilateria')\n self.taxon_tester('Eumetazoa')\n self.taxon_tester('Metazoa')\n self.taxon_tester('Holozoa')\n self.taxon_tester('Opisthokonta')\n self.taxon_tester('Eukaryota')","def test_bootstrap_support_labeled(self):\r\n master_tree = parse_newick('((a:2,b:3)ab:2,(c:1,d:2)cd:7)rt;')\r\n \"\"\"\r\n /-------.5 /-a\r\n ---1| \\-b\r\n \\------.5 /-c\r\n \\-d\r\n \"\"\"\r\n t1 = parse_newick('((a:6,b:8.2)hi:2,(c:1,d:2):7);') # same structure\r\n t2 = parse_newick('((a:2,b:3,c:33)ho:2,d:7);') # abc are siblings\r\n new_master, bootstraps = tc.bootstrap_support(master_tree, [t1, t2])\r\n expected = dict([('ab', .5), ('cd', .5), ('rt', 1.0)])\r\n self.assertDictEqual(bootstraps, expected)","def test_title(names):","def test_verbose_name_group(self): \n field_verboses = {\n \"title\": \"Название группы\",\n \"slug\": \"Слаг\",\n \"description\": \"Описание группы\",\n }\n for value, expected in field_verboses.items():\n with self.subTest(value=value):\n self.assertEqual(self.group._meta.get_field(value).verbose_name, expected)","def plugin_second_label():\n return \"second\"","def test_product_labels(self):\n\n prd = Product.objects.get(id=1)\n # label name\n label_name = prd._meta.get_field('name').verbose_name\n self.assertEqual(label_name, 'name')\n # label description\n label_name = prd._meta.get_field('description').verbose_name\n self.assertEqual(label_name, 'description')\n # label nutrition_grade\n label_name = prd._meta.get_field('nutrition_grade').name\n self.assertEqual(label_name, 'nutrition_grade')\n # label barcode\n label_name = prd._meta.get_field('barcode').verbose_name\n self.assertEqual(label_name, 'barcode')\n # label url\n label_name = prd._meta.get_field('url').verbose_name\n self.assertEqual(label_name, 'url')\n # label url_pic\n label_name = prd._meta.get_field('url_pic').name\n self.assertEqual(label_name, 'url_pic')\n # label store\n label_name = prd._meta.get_field('store').verbose_name\n self.assertEqual(label_name, 'store')\n # label prd_cat\n label_name = prd._meta.get_field('prd_cat').name\n self.assertEqual(label_name, 'prd_cat')\n # label fat\n label_name = prd._meta.get_field('fat').verbose_name\n self.assertEqual(label_name, 'fat')\n # label saturated_fat\n label_name = prd._meta.get_field('saturated_fat').name\n self.assertEqual(label_name, 'saturated_fat')\n # label sugar\n label_name = prd._meta.get_field('sugar').verbose_name\n self.assertEqual(label_name, 'sugar')\n # label salt\n label_name = prd._meta.get_field('salt').verbose_name\n self.assertEqual(label_name, 'salt')","def is_test(self):\r\n return self.has_label('tests')","def setUp(self):\n\n\n # InverseLabeling\n invLabeling0 = {'L0': [0, 1, 2]}\n\n invLabeling1 = {'L0' : [0, 2],\n 'L1' : [1]}\n\n invLabeling2 = {\n 'L0' : [0],\n 'L1' : [1],\n 'L2' : [2]\n }\n\n invLabeling3 = {\n 'L1' : [0, 1],\n 'L2' : [2]\n }\n\n invLabeling4 = {\n 'L0' : [0,1],\n 'L1' : [0],\n 'L2' : [2]\n }\n\n invLabeling5 = {\n 'L0': [0, 1, 2],\n 'L1': []\n }\n \n # Create some ontologies\n ontology0 = {'L0': ['L0']}\n\n ontology1 = {}\n\n ontology2 = {'L0': ['L1']}\n\n ontology3 = {'L0': ['L1', 'L2'],\n 'L1': ['L2'],\n 'L2': ['L0']}\n\n if self.id().split('.')[-1] == 'test_createLinkograph':\n self.testParams = [\n {'inverseLabeling': invLabeling0,\n 'ontology': ontology0,\n 'ExpectedLinkograph':\n linkoCreate.Linkograph(\n [({'L0'}, set(), {1, 2}),\n ({'L0'}, {0}, {2}),\n ({'L0'}, {0,1}, set())] \n )},\n\n {'inverseLabeling': invLabeling0,\n 'ontology': ontology1,\n 'ExpectedLinkograph':\n linkoCreate.Linkograph(\n [({'L0'}, set(), set()),\n ({'L0'}, set(), set()),\n ({'L0'}, set(), set())]\n )},\n\n {'inverseLabeling': invLabeling0,\n 'ontology': ontology2,\n 'ExpectedLinkograph':\n linkoCreate.Linkograph(\n [({'L0'}, set(), set()),\n ({'L0'}, set(), set()),\n ({'L0'}, set(), set())]\n )},\n\n\n {'inverseLabeling': invLabeling1,\n 'ontology': ontology0,\n 'ExpectedLinkograph':\n linkoCreate.Linkograph(\n [({'L0'}, set(), {2}),\n ({'L1'}, set(), set()),\n ({'L0'}, {0}, set())]\n )},\n\n {'inverseLabeling': invLabeling1,\n 'ontology': ontology1,\n 'ExpectedLinkograph':\n linkoCreate.Linkograph(\n [({'L0'}, set(), set()),\n ({'L1'}, set(), set()),\n ({'L0'}, set(), set())]\n )},\n\n {'inverseLabeling': invLabeling1,\n 'ontology': ontology2,\n 'ExpectedLinkograph':\n linkoCreate.Linkograph(\n [({'L0'}, set(), {1}),\n ({'L1'}, {0}, set()),\n ({'L0'}, set(), set())]\n )},\n\n {'inverseLabeling': invLabeling0,\n 'ontology': ontology3,\n 'ExpectedLinkograph':\n linkoCreate.Linkograph(\n [({'L0'}, set(), set()),\n ({'L0'}, set(), set()),\n ({'L0'}, set(), set())]\n )},\n\n {'inverseLabeling': invLabeling1,\n 'ontology': ontology3,\n 'ExpectedLinkograph':\n linkoCreate.Linkograph(\n [({'L0'}, set(), {1}),\n ({'L1'}, {0}, set()),\n ({'L0'}, set(), set())]\n )},\n\n {'inverseLabeling': invLabeling2,\n 'ontology': ontology3,\n 'ExpectedLinkograph':\n linkoCreate.Linkograph(\n [({'L0'}, set(), {1,2}),\n ({'L1'}, {0}, {2}),\n ({'L2'}, {0, 1}, set())]\n )},\n\n {'inverseLabeling': invLabeling3,\n 'ontology': ontology3,\n 'ExpectedLinkograph':\n linkoCreate.Linkograph(\n [({'L1'}, set(), {2}),\n ({'L1'}, set(), {2}),\n ({'L2'}, {0, 1}, set())]\n )},\n\n {'inverseLabeling': invLabeling4,\n 'ontology': ontology3,\n 'ExpectedLinkograph':\n linkoCreate.Linkograph(\n [({'L0', 'L1'}, set(), {2}),\n ({'L0'}, set(), {2}),\n ({'L2'}, {0, 1}, set())]\n )},\n\n {'inverseLabeling': invLabeling5,\n 'ontology': ontology3,\n 'ExpectedLinkograph':\n linkoCreate.Linkograph(\n [({'L0'}, set(), set()),\n ({'L0'}, set(), set()),\n ({'L0'}, set(), set())]\n )},\n\n ]","def test_mutual_exclusivity_of_labels(self, tmpdir, docker_tasker, labels, expected_fail):\n runner = mock_env(tmpdir, docker_tasker, labels=labels)\n if expected_fail:\n with pytest.raises(PluginFailedException) as e:\n runner.run()\n assert 'only one of labels' in str(e.value)\n else:\n runner.run()","def helper_label(helper):\n return helper.info","def test_Tree():","def test_col_data_label_with_attrs(self):\n help_tag = 'span'\n help_text_br = False\n names = ('first', 'billing_address_1')\n attrs = {'style': 'width: 10rem; display: inline-block'}\n label_attrs = {name: attrs for name in names}\n txt = '{}=\"{}\"'.format(*list(attrs.items())[0])\n expected = ['<label for=\"id_first\" {}>First:</label>'.format(txt)]\n expected.append('<label for=\"id_billing_address_1\" {}>street address (line 1):</label>'.format(txt))\n actual = []\n for name in names:\n field = self.form.fields[name]\n response = self.form.collect_col_data(name, field, help_tag, help_text_br, label_attrs)\n actual.append(response.get('label'))\n\n for expect, got in zip(expected, actual):\n self.assertEqual(expect, got)","def test_help_text_group(self): \n field_help_text = {\n \"title\": \"Дайте назание группе\",\n \"slug\": ('Укажите адрес для группы. Используйте '\n 'только латиницу, цифры, дефисы и знаки '\n 'подчёркивания'),\n } \n for value, expected in field_help_text.items():\n with self.subTest(value=value):\n self.assertEqual(self.group._meta.get_field(value).help_text, expected)","def test_label_choices(self):\n test_classes = (\n (0, 'No'),\n (1, 'Yes')\n )\n\n form = SingleLabelClassifierForm(classes=test_classes)\n self.assertEqual(tuple(form.fields['label'].choices), test_classes)\n\n form = MultiLabelClassifierForm(classes=test_classes)\n self.assertEqual(tuple(form.fields['label'].choices), test_classes)","def test_filter_tree(self):\r\n actual = [e.Name for e in filter_tree(\r\n self.tree1, ['bbb', 'ccc']).tips()]\r\n #(a_a:10,(b_b:2,c_c:4):5);\r\n expected = [\r\n e.Name for e in DndParser(\r\n \"((bbb:2,ccc:4));\",\r\n PhyloNode).tips(\r\n )]\r\n self.assertEqual(actual, expected)\r\n\r\n actual = [e.Name for e in filter_tree(\r\n self.tree2, ['bbb', 'ccc']).tips()]\r\n #(a_a:10,(b_b:2,c_c:4):5);\r\n expected = [\r\n e.Name for e in DndParser(\r\n \"(('bbb':2,ccc:4));\",\r\n PhyloNode).tips(\r\n )]\r\n self.assertEqual(actual, expected)","def test_radiotextgroup(self):\r\n self.check_group('radiotextgroup', 'choice', 'radio')","def gen_test_case_combination(self):\n\n cases = '\\n'\n\n binary_ops = list(self.BINARY_OPS)\n binary_ops.reverse()\n for op1 in self.BINARY_OPS:\n for op2 in binary_ops:\n\n result = []\n ret = IntOp.binary_op(op2, '0', '1', self.lane_width)\n ret = IntOp.binary_op(op1, ret, '2', self.lane_width)\n result.append(ret)\n\n cases += '\\n' + str(AssertReturn('{lane_type}.{op1}-{lane_type}.{op2}'.format(lane_type=self.LANE_TYPE, op1=op1, op2=op2),\n [SIMD.v128_const('0', self.LANE_TYPE),\n SIMD.v128_const('1', self.LANE_TYPE),\n SIMD.v128_const('2', self.LANE_TYPE)],\n SIMD.v128_const(result, self.LANE_TYPE)))\n cases += '\\n'\n return cases","def test_multiple_task_groups_dag(\n self, test_multiple_taskgroups_dag, multiple_taskgroups_dag_expected_edges\n ):\n (\n dag,\n group1,\n group2,\n group3,\n (\n group1_emp1,\n group1_emp2,\n group1_emp3,\n group2_emp1,\n group2_emp2,\n group2_emp3,\n group2_op1,\n group2_op2,\n group3_emp1,\n group3_emp2,\n group3_emp3,\n emp_in1,\n emp_in2,\n emp_in3,\n emp_in4,\n emp_out1,\n emp_out2,\n emp_out3,\n emp_out4,\n op_in1,\n op_out1,\n ),\n ) = test_multiple_taskgroups_dag\n\n group1_emp1 >> Label(\"label group1.group1_emp1 <=> group1.group1_emp2\") >> group1_emp3\n\n emp_in1 >> group1\n emp_in2 >> Label(\"label emp_in2 <=> group1\") >> group1\n [emp_in3, emp_in4] >> Label(\"label emp_in3/emp_in4 <=> group1\") >> group1\n XComArg(op_in1, \"test_key\") >> Label(\"label op_in1 <=> group1\") >> group1\n\n (\n [group2_emp1, group2_emp2]\n >> Label(\"label group2.group2_emp1/group2.group2_emp2 <=> group2.group2_emp3\")\n >> group2_emp3\n )\n (\n group2_emp1\n >> Label(\"label group2.group2_emp1 <=> group2.group2_emp2/group2.group2_emp3\")\n >> [group2_emp2, group2_emp3]\n )\n group2_emp3 >> Label(\"label group2.group2_emp3 <=> group3\") >> group3\n\n (\n XComArg(group2_op1, \"test_key\")\n >> Label(\"label group2.group2_op1 <=> group2.group2_op2\")\n >> XComArg(group2_op2, \"test_key\")\n )\n XComArg(group2_op2, \"test_key\") >> Label(\"label group2.group2_op2 <=> group3\") >> group3\n\n group3 >> emp_out1\n group3 >> Label(\"label group3 <=> emp_out2\") >> emp_out2\n group3 >> Label(\"label group3 <=> emp_out3/emp_out4\") >> [emp_out3, emp_out4]\n group3 >> Label(\"label group3 <=> op_out1\") >> XComArg(op_out1, \"test_key\")\n\n group1 >> Label(\"label group1 <=> group2\") >> group2\n\n compare_dag_edges(dag_edges(dag), multiple_taskgroups_dag_expected_edges)","def test_issue_create_label(self):\n pass","def test__create_label_w_no_ent_id(ruler: SpaczzRuler) -> None:\n assert ruler._create_label(\"TEST\", None) == \"TEST\"","def test_grouping(self):\n s = self.create(ComponentItem, UML.Component)\n uc1 = self.create(UseCaseItem, UML.UseCase)\n uc2 = self.create(UseCaseItem, UML.UseCase)\n\n self.group(s, uc1)\n assert 1 == len(uc1.subject.subject)\n self.group(s, uc2)\n assert 1 == len(uc2.subject.subject)\n\n # Classifier.useCase is not navigable to UseCase\n # self.assertEqual(2, len(s.subject.useCase))","def setLabel2(*args):","def tests_ti_document_get_label(self):\n super().group_get_label()","def test_render_label(self):\n label = self.block.meta.label\n self.assertEqual(label, 'Google Calendar', 'The labels are not the same')","def check_elm(orphan_root, obj, orphan_labels, orphan_widgets):\n\n oid = obj.attrib.get('id')\n klass = obj.attrib.get('class')\n\n # \"Don't care\" special case\n if klass in widgets_ignored:\n return\n for suffix in widgets_suffixignored:\n if klass[-len(suffix):] == suffix:\n return\n\n # Widgets usual do not strictly require a label, i.e. a labelled parent\n # is enough for context, but some do always need one.\n requires_label = klass in widgets_needlabel\n\n if oid is not None:\n # Check that ids are unique\n if oid in ids_dup:\n if ids[oid] == obj:\n # We are the first, warn\n duplicates = tree.findall(\".//object[@id='\" + oid + \"']\")\n err(filename, tree, obj, \"duplicate-id\", \"has the same id as other elements \" + elms_names_lines(duplicates))\n\n # Check label-for and their dual labelled-by\n label_for = check_rels(filename, tree, root, obj, \"label-for\", \"labelled-by\")\n\n # Check labelled-by and its dual label-for\n labelled_by = check_rels(filename, tree, root, obj, \"labelled-by\", \"label-for\")\n\n # Check label-for and their dual labelled-by\n description_for = check_rels(filename, tree, root, obj, \"description-for\", \"described-by\")\n\n # Check labelled-by and its dual label-for\n described_by = check_rels(filename, tree, root, obj, \"described-by\", \"description-for\")\n\n # Should have only one label\n if len(labelled_by) >= 1:\n if oid in mnemonic_for_elm:\n warn(filename, tree, obj, \"labelled-by-and-mnemonic\",\n \"has both a mnemonic \" + elm_name_line(mnemonic_for_elm[oid][0]) + \"and labelled-by relation\")\n if len(labelled_by) > 1:\n warn(filename, tree, obj, \"multiple-labelled-by\", \"has multiple labelled-by relations\")\n if oid in label_for_elm:\n if len(label_for_elm[oid]) > 1:\n warn(filename, tree, obj, \"duplicate-label-for\", \"is referenced by multiple label-for \" + elms_names_lines(label_for_elm[oid]))\n if oid in mnemonic_for_elm:\n if len(mnemonic_for_elm[oid]) > 1:\n warn(filename, tree, obj, \"duplicate-mnemonic\", \"is referenced by multiple mnemonic_widget \" + elms_names_lines(mnemonic_for_elm[oid]))\n\n # Check member-of\n member_of = check_rels(filename, tree, root, obj, \"member-of\")\n\n # Labels special case\n if klass in widgets_labels:\n properties = check_props(filename, tree, root, obj, \"mnemonic_widget\") + \\\n check_props(filename, tree, root, obj, \"mnemonic-widget\")\n if len(properties) > 1:\n err(filename, tree, obj, \"multiple-mnemonic\", \"has multiple mnemonic_widgets properties\"\n \"%s\" % elms_lines(properties))\n\n # Emit orphaning warnings\n if warn_orphan_labels or orphan_widgets:\n is_orphan_label(filename, tree, root, obj, orphan_root, True)\n\n # We are done with the label\n return\n\n # Not a label, will perhaps need one\n\n # Emit orphaning warnings\n is_orphan_widget(filename, tree, root, obj, orphan_labels, orphan_root, True)","def get_label(self, hierarchy: List[str]) -> Any:","def test_first_level_from_bids_no_duplicate_sub_labels(bids_dataset):\n models, *_ = first_level_from_bids(\n dataset_path=bids_dataset,\n task_label='main',\n sub_labels=[\"01\", \"01\"],\n space_label='MNI',\n img_filters=[('desc', 'preproc')],\n slice_time_ref=None,\n )\n\n assert len(models) == 1","def test_add_empty_nodes_with_label_when_splitting(self):\n print \"----- test_add_empty_nodes_with_label_when_splitting -----\"\n sel_axis = (lambda axis: axis)\n \n #create tree, first node splits in x direction\n tree = kdtree.createNewTree([[0.5, 0.5]],axis = 0, sel_axis= sel_axis)\n kdtree.visualize(tree)\n \n point_left = [0.4, 0.5]\n tree.split2(point_left, axis = 0)\n kdtree.visualize(tree)\n \n point1 = [0.3, 0.5]\n found_node = tree.get_path_to_leaf(point1)[-1]\n correct_node1 = 3\n self.assertEqual(found_node.label, correct_node1, \"Not correct node found\")\n \n point_right = [0.6, 0.5]\n tree.split2(point_right, axis = 1)\n kdtree.visualize(tree)\n \n point2 = [0.6, 0.7]\n found_node = tree.get_path_to_leaf(point2)[-1]\n correct_node2 = 6\n self.assertEqual(found_node.label, correct_node2, \"Not correct node found\")\n \n print \"----- end: test_add_empty_nodes_with_label_when_splitting -----\"","def test_render_value_label(self):\n self.check_html(\n self.widget(choices=self.beatles),\n \"beatles\",\n [\"John\"],\n html=(\n \"\"\"<select multiple name=\"beatles\">\n <option value=\"J\">John</option>\n <option value=\"P\">Paul</option>\n <option value=\"G\">George</option>\n <option value=\"R\">Ringo</option>\n </select>\"\"\"\n ),\n )","def test_issue_add_label(self):\n pass","def test_create_metering_label(self):\r\n resource = 'metering_label'\r\n cmd = metering.CreateMeteringLabel(\r\n test_cli20.MyApp(sys.stdout), None)\r\n name = 'my label'\r\n myid = 'myid'\r\n description = 'my description'\r\n args = [name, '--description', description, '--shared']\r\n position_names = ['name', 'description', 'shared']\r\n position_values = [name, description, True]\r\n self._test_create_resource(resource, cmd, name, myid, args,\r\n position_names, position_values)","def getLabel(*args):","def getLabel(*args):","def getLabel(*args):","def _make_vbenf_label(chain_parts):\n\n # toy label for development: run simple and dijet independently.\n # simple makes Et cuts on two jets. Independently (sharing possible)\n # of jets choosean by simple, the dijet\n # scenario requires a dijet of mass > 900, and opening angle in phi > 2.6\n\n assert len(chain_parts) == 1\n scenario = chain_parts[0]['hypoScenario']\n assert scenario.startswith('vbenf')\n args = _args_from_scenario(scenario)\n if not args:\n return 'and([]simple([(50et)(70et)])combgen([(2)] dijet([(900djmass, 26djdphi)])))' \n arg_res = [\n re.compile(r'(?P<lo>\\d*)(?P<key>fbet)(?P<hi>\\d*)'),\n re.compile(r'(?P<lo>\\d*)(?P<key>mass)(?P<hi>\\d*)'),\n re.compile(r'(?P<lo>\\d*)(?P<key>et)(?P<hi>\\d*)'),\n ]\n\n defaults = {\n 'et': ('101', 'inf'),\n 'mass': ('800', 'inf'),\n 'fbet': ('501', 'inf'),\n }\n\n argvals = {}\n while args:\n assert len(args) == len(arg_res)\n arg = args.pop()\n for r in arg_res:\n m = r.match(arg)\n if m is not None:\n arg_res.remove(r)\n gd = m.groupdict()\n key = gd['key']\n try:\n lo = float(gd['lo'])\n except ValueError:\n lo = defaults[key][0]\n argvals[key+'lo'] = lo \n try:\n hi = float(gd['hi'])\n except ValueError:\n hi = defaults[key][1]\n argvals[key+'hi'] = hi\n\n assert len(args) == len(arg_res)\n assert len(args) == 0\n\n return \"\"\"\n and\n (\n []\n simple\n (\n [(%(etlo).0fet, 500neta)(%(etlo).0fet, peta500)]\n )\n combgen\n (\n [(10et, 0eta320)]\n dijet\n (\n [(%(masslo).0fdjmass, 26djdphi)]\n ) \n simple\n (\n [(10et, 0eta320)(20et, 0eta320)]\n )\n )\n )\"\"\" % argvals","def testFormatLabelAndValue(self):\n\n self.assertEqual('Abc: xyz', self.inv._FormatLabelAndValue('abc', 'xyz', 1))\n self.assertEqual('ABc: xyz', self.inv._FormatLabelAndValue('abc', 'xyz', 2))\n self.assertEqual('ABC: xyz', self.inv._FormatLabelAndValue('abc', 'xyz', 4))","def test_recipe_nutrition_label_image(self):\n pass","def test_label_10_targets_with_a_b_c_(self):\r\n user_input = '[{\"a\":\"target1\"}, \\\r\n {\"b\":\"target2\"},{\"c\":\"target3\"},{\"a\":\"target4\"},{\"b\":\"target5\"}, \\\r\n {\"c\":\"target6\"}, {\"a\":\"target7\"},{\"b\":\"target8\"},{\"c\":\"target9\"}, \\\r\n {\"a\":\"target10\"}]'\r\n correct_answer = [\r\n {\r\n 'draggables': ['a'],\r\n 'targets': ['target1', 'target4', 'target7', 'target10'],\r\n 'rule': 'unordered_equal'\r\n },\r\n {\r\n 'draggables': ['b'],\r\n 'targets': ['target2', 'target5', 'target8'],\r\n 'rule': 'unordered_equal'\r\n },\r\n {\r\n 'draggables': ['c'],\r\n 'targets': ['target3', 'target6', 'target9'],\r\n 'rule': 'unordered_equal'\r\n }\r\n ]\r\n self.assertTrue(draganddrop.grade(user_input, correct_answer))","def test_label_10_targets_with_a_b_c_multiple(self):\r\n user_input = '[{\"a\":\"target1\"}, \\\r\n {\"b\":\"target2\"},{\"c\":\"target3\"},{\"b\":\"target5\"}, \\\r\n {\"c\":\"target6\"}, {\"a\":\"target7\"},{\"b\":\"target8\"},{\"c\":\"target9\"}, \\\r\n {\"a\":\"target1\"}]'\r\n correct_answer = [\r\n {\r\n 'draggables': ['a', 'a', 'a'],\r\n 'targets': ['target1', 'target4', 'target7', 'target10'],\r\n 'rule': 'anyof+number'\r\n },\r\n {\r\n 'draggables': ['b', 'b', 'b'],\r\n 'targets': ['target2', 'target5', 'target8'],\r\n 'rule': 'anyof+number'\r\n },\r\n {\r\n 'draggables': ['c', 'c', 'c'],\r\n 'targets': ['target3', 'target6', 'target9'],\r\n 'rule': 'anyof+number'\r\n }\r\n ]\r\n self.assertTrue(draganddrop.grade(user_input, correct_answer))","def test_subsystems(self):\n pass","def test_multiply_some_type_links():","def test_build_match_tree_with_pairs():\n abbreviation_list = [[\"ELIF\", \"ELI.\"], [\"ELSE\", \"E.\"]]\n expected_tree = {\"E\": {\"L\": {\"I\": {\"F\": \"ELI.\"}, \"S\": {\"E\": \"E.\"}}}}\n tree = build_match_tree(abbreviation_list)\n assert repr(tree) == repr(expected_tree)","def check_a11y_relation(filename, tree):\n global widgets_ignored, ids, label_for_elm, labelled_by_elm, description_for_elm, described_by_elm, mnemonic_for_elm\n\n def check_elm(orphan_root, obj, orphan_labels, orphan_widgets):\n \"\"\"\n Check one element, knowing that orphan_labels/widgets tell whether\n there are orphan labels and widgets within orphan_root\n \"\"\"\n\n oid = obj.attrib.get('id')\n klass = obj.attrib.get('class')\n\n # \"Don't care\" special case\n if klass in widgets_ignored:\n return\n for suffix in widgets_suffixignored:\n if klass[-len(suffix):] == suffix:\n return\n\n # Widgets usual do not strictly require a label, i.e. a labelled parent\n # is enough for context, but some do always need one.\n requires_label = klass in widgets_needlabel\n\n if oid is not None:\n # Check that ids are unique\n if oid in ids_dup:\n if ids[oid] == obj:\n # We are the first, warn\n duplicates = tree.findall(\".//object[@id='\" + oid + \"']\")\n err(filename, tree, obj, \"duplicate-id\", \"has the same id as other elements \" + elms_names_lines(duplicates))\n\n # Check label-for and their dual labelled-by\n label_for = check_rels(filename, tree, root, obj, \"label-for\", \"labelled-by\")\n\n # Check labelled-by and its dual label-for\n labelled_by = check_rels(filename, tree, root, obj, \"labelled-by\", \"label-for\")\n\n # Check label-for and their dual labelled-by\n description_for = check_rels(filename, tree, root, obj, \"description-for\", \"described-by\")\n\n # Check labelled-by and its dual label-for\n described_by = check_rels(filename, tree, root, obj, \"described-by\", \"description-for\")\n\n # Should have only one label\n if len(labelled_by) >= 1:\n if oid in mnemonic_for_elm:\n warn(filename, tree, obj, \"labelled-by-and-mnemonic\",\n \"has both a mnemonic \" + elm_name_line(mnemonic_for_elm[oid][0]) + \"and labelled-by relation\")\n if len(labelled_by) > 1:\n warn(filename, tree, obj, \"multiple-labelled-by\", \"has multiple labelled-by relations\")\n if oid in label_for_elm:\n if len(label_for_elm[oid]) > 1:\n warn(filename, tree, obj, \"duplicate-label-for\", \"is referenced by multiple label-for \" + elms_names_lines(label_for_elm[oid]))\n if oid in mnemonic_for_elm:\n if len(mnemonic_for_elm[oid]) > 1:\n warn(filename, tree, obj, \"duplicate-mnemonic\", \"is referenced by multiple mnemonic_widget \" + elms_names_lines(mnemonic_for_elm[oid]))\n\n # Check member-of\n member_of = check_rels(filename, tree, root, obj, \"member-of\")\n\n # Labels special case\n if klass in widgets_labels:\n properties = check_props(filename, tree, root, obj, \"mnemonic_widget\") + \\\n check_props(filename, tree, root, obj, \"mnemonic-widget\")\n if len(properties) > 1:\n err(filename, tree, obj, \"multiple-mnemonic\", \"has multiple mnemonic_widgets properties\"\n \"%s\" % elms_lines(properties))\n\n # Emit orphaning warnings\n if warn_orphan_labels or orphan_widgets:\n is_orphan_label(filename, tree, root, obj, orphan_root, True)\n\n # We are done with the label\n return\n\n # Not a label, will perhaps need one\n\n # Emit orphaning warnings\n is_orphan_widget(filename, tree, root, obj, orphan_labels, orphan_root, True)\n\n root = tree.getroot()\n\n # Flush ids and relations from previous files\n ids = {}\n ids_dup = {}\n labelled_by_elm = {}\n label_for_elm = {}\n described_by_elm = {}\n description_for_elm = {}\n mnemonic_for_elm = {}\n\n # First pass to get links into hash tables, no warning, just record duplicates\n for obj in root.iter('object'):\n oid = obj.attrib.get('id')\n if oid is not None:\n if oid not in ids:\n ids[oid] = obj\n else:\n ids_dup[oid] = True\n\n labelled_by = obj.findall(\"accessibility/relation[@type='labelled-by']\")\n labelled_by += obj.findall(\"accessibility/relation[@name='labelled-by']\")\n for rel in labelled_by:\n target = rel.attrib.get('target')\n if target is not None:\n if target not in labelled_by_elm:\n labelled_by_elm[target] = [ obj ]\n else:\n labelled_by_elm[target].append(obj)\n\n label_for = obj.findall(\"accessibility/relation[@type='label-for']\")\n label_for += obj.findall(\"accessibility/relation[@name='label-for']\")\n for rel in label_for:\n target = rel.attrib.get('target')\n if target is not None:\n if target not in label_for_elm:\n label_for_elm[target] = [ obj ]\n else:\n label_for_elm[target].append(obj)\n\n described_by = obj.findall(\"accessibility/relation[@type='described-by']\")\n described_by += obj.findall(\"accessibility/relation[@name='described-by']\")\n for rel in described_by:\n target = rel.attrib.get('target')\n if target is not None:\n if target not in described_by_elm:\n described_by_elm[target] = [ obj ]\n else:\n described_by_elm[target].append(obj)\n\n description_for = obj.findall(\"accessibility/relation[@type='description-for']\")\n description_for += obj.findall(\"accessibility/relation[@name='description-for']\")\n for rel in description_for:\n target = rel.attrib.get('target')\n if target is not None:\n if target not in description_for_elm:\n description_for_elm[target] = [ obj ]\n else:\n description_for_elm[target].append(obj)\n\n mnemonic_for = obj.findall(\"property[@name='mnemonic_widget']\") + \\\n obj.findall(\"property[@name='mnemonic-widget']\")\n for rel in mnemonic_for:\n target = rel.text\n if target is not None:\n if target not in mnemonic_for_elm:\n mnemonic_for_elm[target] = [ obj ]\n else:\n mnemonic_for_elm[target].append(obj)\n\n # Second pass, recursive depth-first, to be able to efficiently know whether\n # there are orphan labels within a part of the tree.\n def recurse(orphan_root, obj, orphan_labels, orphan_widgets):\n if obj == root or is_labelled_parent(obj):\n orphan_root = obj\n orphan_labels, orphan_widgets = orphan_items(filename, tree, root, obj)\n\n if obj.tag == 'object':\n check_elm(orphan_root, obj, orphan_labels, orphan_widgets)\n\n for o in obj:\n recurse(orphan_root, o, orphan_labels, orphan_widgets)\n\n recurse(root, root, False, False)","def test_stratis_list_default(self):\n for subcommand in [[\"pool\"], [\"filesystem\"], [\"blockdev\"]]:\n for prefix in [[], [\"--propagate\"]]:\n self.assertEqual(RUNNER(prefix + subcommand), 0)","def pytest_can_run_together(item1, item2):","def test_series_in_features(self):\n assert parse_command({'test{{A,B}}': {'depends_on': 'name{{A,B}}'}}) == [\n ('testA', {'depends_on': 'nameA'}), ('testB', {'depends_on': 'nameB'})]","def test_first_level_from_bids_with_subject_labels(bids_dataset):\n warning_message = ('Subject label foo is not present in'\n ' the dataset and cannot be processed')\n with pytest.warns(UserWarning, match=warning_message):\n models, *_ = first_level_from_bids(\n dataset_path=bids_dataset,\n task_label='main',\n sub_labels=[\"foo\", \"01\"],\n space_label='MNI',\n img_filters=[('desc', 'preproc')],\n slice_time_ref=None,\n )\n\n assert models[0].subject_label == '01'","def test_pathop12(self):\n xpb = XPathBuilder()\n # braces not needed\n xp = xpb.foo & (xpb.bar.foo).parenthesize() | xpb.foobar\n exp = '/foo and (/bar/foo) or /foobar'\n self.assertEqual(xp.tostring(), exp)","def test_dummy6(self):\n xpb = XPathBuilder()\n xp = xpb.dummy()\n xp = xpb.bar | xp\n exp = '/bar'\n self.assertEqual(xp.tostring(), exp)","def test_create_labels(self):\n test_labels = {\"app\": \"my_app\", \"host\": \"examplehost\"}\n labels = pmp.utils.create_labels(test_labels)\n self.assertIsInstance(labels, list)\n self.assertTrue(all([isinstance(x, pmp.LabelPair) for x in labels]))","def test_xdist_and_select_test_by_bdd_label(xdist_runner: AllurePytestRunner):\n\n output = xdist_runner.run_docstring(\"-v\", \"--allure-features=boo\", \"-n1\")\n\n assert_that(output, has_only_testcases(\n has_entry(\n \"fullName\",\n ends_with(\"test_with_feature_boo\")\n )\n ))","def test_nested_condition() -> None:\n\n @argcomb(Or(And(\"a\", \"b\"), And(\"c\", \"d\")))\n def f(a: Any = None, b: Any = None, c: Any = None, d: Any = None) -> None:\n ...\n\n # valid\n f(a=1, b=1)\n f(c=1, d=1)\n f(a=1, b=1, c=1, d=1)\n\n # invalid\n with pytest.raises(InvalidArgumentCombination):\n f(a=1)\n with pytest.raises(InvalidArgumentCombination):\n f(a=1, c=1)\n with pytest.raises(InvalidArgumentCombination):\n f()","def test_abbreviation(self):\n self.assertEqual(self.compound.abbreviation, \"Cool\")","def test_general_subset_all():\n pass","def test_check_tree_exact_match(self):\r\n\r\n fasta_labels = ['seq1_1', 'seq1_2', 'seq2_3', 'seq3_4']\r\n\r\n actual_subset_results = check_tree_exact_match(fasta_labels,\r\n self.sample_tree_3tips_fp)\r\n\r\n # Should find all and give True, True result\r\n\r\n self.assertEqual(actual_subset_results, [True, True])\r\n\r\n # Should get tips not found in fasta labels with 5 tip tree\r\n\r\n fasta_labels = ['seq1_1', 'seq1_2', 'seq2_3', 'seq3_4']\r\n\r\n actual_subset_results = check_tree_exact_match(fasta_labels,\r\n self.sample_tree_5tips_fp)\r\n\r\n # Should find all and give True result\r\n\r\n self.assertEqual(actual_subset_results, [True, ['seq5', 'seq4']])\r\n\r\n # Change two of the fasta labels to not match tree tips\r\n\r\n fasta_labels = ['seq1_1', 'seqX_2', 'seq2_3', 'seqY_4']\r\n\r\n actual_subset_results = check_tree_exact_match(fasta_labels,\r\n self.sample_tree_5tips_fp)\r\n\r\n # Should find seqX and seqY as not being a subset\r\n\r\n self.assertEqual(actual_subset_results, [['seqX', 'seqY'],\r\n ['seq3', 'seq5', 'seq4']])","def test_03_visit_special(self):","def test_labels(ruler: SpaczzRuler) -> None:\n assert all(\n [label in ruler.labels for label in [\"GPE\", \"STREET\", \"DRUG\", \"NAME\", \"BAND\"]]\n )\n assert len(ruler.labels) == 5","def test_createSubLinkographWithoutCommands(self):\n self.performTestForParams()","def test_first_level_from_bids_several_labels_per_entity(tmp_path, entity):\n n_sub = 1\n n_ses = 1\n tasks = [\"main\"]\n n_runs = [1]\n\n bids_path = create_fake_bids_dataset(\n base_dir=tmp_path,\n n_sub=n_sub,\n n_ses=n_ses,\n tasks=tasks,\n n_runs=n_runs,\n entities={entity: [\"A\", \"B\"]},\n )\n\n models, m_imgs, m_events, m_confounds = first_level_from_bids(\n dataset_path=bids_path,\n task_label=\"main\",\n space_label=\"MNI\",\n img_filters=[(\"desc\", \"preproc\"), (entity, \"A\")],\n slice_time_ref=None,\n )\n\n _check_output_first_level_from_bids(n_sub,\n models,\n m_imgs,\n m_events,\n m_confounds)\n n_imgs_expected = n_ses * n_runs[0]\n assert len(m_imgs[0]) == n_imgs_expected","def test_setter_child_list_tuple(self):\n root = netapp_api.NaElement('root')\n root['l'] = ['l1', 'l2']\n root['t'] = ('t1', 't2')\n l = root.get_child_by_name('l')\n self.assertIsInstance(l, netapp_api.NaElement)\n t = root.get_child_by_name('t')\n self.assertIsInstance(t, netapp_api.NaElement)\n for le in l.get_children():\n self.assertIn(le.get_name(), ['l1', 'l2'])\n for te in t.get_children():\n self.assertIn(te.get_name(), ['t1', 't2'])","def test_tree_support(self):\r\n master_tree = parse_newick('((a:2,b:3)ab:2,(c:1,d:2)cd:7)rt;')\r\n \"\"\"\r\n /-------.5 /-a\r\n ---1| \\-b\r\n \\------.5 /-c\r\n \\-d\r\n \"\"\"\r\n t2 = parse_newick('((a:2,b:3,c:33)ho:2,d:7);') # abc are siblings\r\n\r\n tc.tree_support(master_tree, t2)\r\n assert_almost_equal(\r\n master_tree.getNodeMatchingName('rt').bootstrap_support, 1.0)","def test_labels(self):\n return self._test_labels","def test_issue_edit_label(self):\n pass","def test_dbpa002_radio_items(dash_duo):\n app = Dash()\n\n options = {\n \"OptionA\": \"Option 1\",\n \"OptionB\": \"Option 2\",\n \"OptionC\": \"Option 3\",\n }\n\n value = \"OptionB\"\n\n with_keywords = RadioItems(\n options=options,\n value=value,\n id=\"with-keywords\",\n )\n without_keywords = RadioItems(options, value, id=\"without-keywords\")\n\n app.layout = html.Div([with_keywords, without_keywords])\n\n dash_duo.start_server(app)\n\n # Check values\n assert [\n a.get_attribute(\"value\")\n for a in dash_duo.wait_for_element(\n \"#with-keywords\"\n ).find_elements_by_tag_name(\"input\")\n ] == [\n a.get_attribute(\"value\")\n for a in dash_duo.wait_for_element(\n \"#without-keywords\"\n ).find_elements_by_tag_name(\"input\")\n ]\n\n # Check labels\n assert [\n a.text\n for a in dash_duo.wait_for_element(\n \"#with-keywords\"\n ).find_elements_by_tag_name(\"label\")\n ] == [\n a.text\n for a in dash_duo.wait_for_element(\n \"#without-keywords\"\n ).find_elements_by_tag_name(\"label\")\n ]","def test(self):\n for doc, label in zip(self.test_docs(), self.test_labels()):\n yield doc, label","def test_get_parent_type_name(self):\n pass","def test_pathop8(self):\n xpb = XPathBuilder()\n xp = (xpb.foo.bar | xpb.foobar).parenthesize() & xpb.action.source\n exp = '(/foo/bar or /foobar) and /action/source'\n self.assertEqual(xp.tostring(), exp)","def test_setter_child_list_tuple(self):\n root = netapp_api.NaElement('root')\n root['l'] = ['l1', 'l2']\n root['t'] = ('t1', 't2')\n l_element = root.get_child_by_name('l')\n self.assertIsInstance(l_element, netapp_api.NaElement)\n t = root.get_child_by_name('t')\n self.assertIsInstance(t, netapp_api.NaElement)\n for le in l_element.get_children():\n self.assertIn(le.get_name(), ['l1', 'l2'])\n for te in t.get_children():\n self.assertIn(te.get_name(), ['t1', 't2'])","def __init__(self, root_node, label1, label2):\n super().__init__(self.PROBLEM_NAME)\n self.root_node = root_node\n self.label1 = label1\n self.label2 = label2","def test_radioselect_field():","def test_label_callback():\n release_numbers = dict(a='123')\n data = dict(revision='a', attributes=dict(b='c'))\n data2 = dict(revision='b', attributes=dict(d='e'))\n\n assert _label_callback(data, release_numbers) == u'a\\n- Release: 123\\n- b: c'\n assert _label_callback(data2) == u'b\\n- Release: Unknown\\n- d: e'","def _make_simple_partition_label(chain_dict):\n\n cps = chain_dict['chainParts']\n if not (_select_simple_chainparts(cps)):\n raise NotImplementedError(\n 'chain fails substring selection: not \"simple\": %s' % (\n chain_dict['chainName']))\n \n label = 'simplepartition(['\n for cp in cps:\n smcstr = str(cp['smc'])\n if smcstr == 'nosmc':\n smcstr = ''\n for i in range(int(cp['multiplicity'])):\n # condition_str = '(%set,%s,%s)' % (str(cp['threshold']),\n # str(cp['etaRange']),\n # smcstr,)\n condition_str = '(%set,%s' % (str(cp['threshold']),\n str(cp['etaRange']),)\n if smcstr:\n condition_str += ',%s)'\n else:\n condition_str += ')'\n label += condition_str\n label += '])'\n return label","def test_case1(self):\n\n graph = BipartiteGraph()\n\n graph.addEdge(\"supervisor1\",\"student1\")\n\n val1 = graph.getStudents(\"supervisor1\")\n val2 = graph.getSupervisors(\"student1\")\n\n expected1 = [\"student1\"]\n expected2 = [\"supervisor1\"]\n\n self.assertEqual((val1,val2),(expected1,expected2))","def test_with_multiple_descriptions():\n soup = generate_case(\"with_descriptions\")\n\n tests.html_schema_doc_asserts.assert_descriptions(\n soup,\n [\n \"Exact address\",\n \"Exact address\",\n \"Delivery info depending on the delivery type\",\n \"The delivery is a gift, no prices displayed\",\n ],\n )","def test_BuildModel2(self):\n print(\"\\nTest 6: Building a Model with Concat\")\n builder = StaticBuilder(\"Concat\")\n in1 = builder.addInput(10)\n in2 = builder.addInput(20)\n enc1 = builder.addInner(3, num_islots=2)\n out1 = builder.addOutput()\n\n builder.addDirectedLink(in1, enc1, islot=0)\n builder.addDirectedLink(in2, enc1, islot=1)\n builder.addDirectedLink(enc1, out1)\n \n builder.build()","def test_multiple_label_traversals(self):\r\n TestEdge.create(self.v1, self.v2)\r\n OtherTestEdge.create(self.v1, self.v3)\r\n YetAnotherTestEdge.create(self.v1, self.v4)\r\n\r\n assert len(self.v1.outV()) == 3\r\n\r\n assert len(self.v1.outV(TestEdge)) == 1\r\n assert len(self.v1.outV(OtherTestEdge)) == 1\r\n assert len(self.v1.outV(YetAnotherTestEdge)) == 1\r\n\r\n out = self.v1.outV(TestEdge, OtherTestEdge)\r\n assert len(out) == 2\r\n assert self.v2.vid in [v.vid for v in out]\r\n assert self.v3.vid in [v.vid for v in out]\r\n\r\n out = self.v1.outV(OtherTestEdge, YetAnotherTestEdge)\r\n assert len(out) == 2\r\n assert self.v3.vid in [v.vid for v in out]\r\n assert self.v4.vid in [v.vid for v in out]","def test_label_10_targets_with_a_b_c_false(self):\r\n user_input = '[{\"a\":\"target1\"}, \\\r\n {\"b\":\"target2\"},{\"c\":\"target3\"},{\"a\":\"target4\"},{\"b\":\"target5\"}, \\\r\n {\"c\":\"target6\"}, {\"a\":\"target7\"},{\"b\":\"target8\"},{\"c\":\"target9\"}, \\\r\n {\"a\":\"target1\"}]'\r\n correct_answer = [\r\n {\r\n 'draggables': ['a'],\r\n 'targets': ['target1', 'target4', 'target7', 'target10'],\r\n 'rule': 'unordered_equal'\r\n },\r\n {\r\n 'draggables': ['b'],\r\n 'targets': ['target2', 'target5', 'target8'],\r\n 'rule': 'unordered_equal'\r\n },\r\n {\r\n 'draggables': ['c'],\r\n 'targets': ['target3', 'target6', 'target9'],\r\n 'rule': 'unordered_equal'\r\n }\r\n ]\r\n self.assertFalse(draganddrop.grade(user_input, correct_answer))"],"string":"[\n \"def _make_combinationsTest_label(chain_parts):\\n\\n assert len(chain_parts) == 1\\n scenario = chain_parts[0]['hypoScenario']\\n \\n assert scenario == 'combinationsTest'\\n\\n \\n\\n return \\\"\\\"\\\"\\n combgen(\\n [(2)(20et, 0eta320)]\\n \\n simple([(40et, 0eta320) (50et, 0eta320)])\\n simple([(35et, 0eta240) (55et, 0eta240)])\\n )\\\"\\\"\\\"\",\n \"def test_sums():\\n assert label_parent(1, 2) == 3\\n assert label_parent (1, 4) == 8\\n # Should ignore arg order\\n assert label_parent(4, 1) == 8\",\n \"def test_recipe_nutrition_label_widget(self):\\n pass\",\n \"def test_select_label(self):\\n title = ('Transportation Challenges Limit Education Choices for '\\n 'Denver Parents')\\n summary = \\\"\\\"\\\"\\n Many families in the Denver metro area use public\\n transportation instead of a school bus because for them, a\\n quality education is worth hours of daily commuting. Colorado's\\n school choice program is meant to foster educational equity,\\n but the families who benefit most are those who have time and\\n money to travel. Low-income families are often left in a lurch.\\n \\\"\\\"\\\"\\n byline = \\\"Mile High Connects\\\"\\n story = create_story(title=title, summary=summary, byline=byline)\\n layout = SectionLayout.objects.get(sectionlayouttranslation__name=\\\"Side by Side\\\")\\n section1 = create_section(title=\\\"Test Section 1\\\", story=story, layout=layout)\\n section2 = create_section(title=\\\"Test Section 2\\\", story=story, layout=layout)\\n form = SectionRelationAdminForm()\\n choices_list = list(form.fields['parent'].widget.choices)\\n self.assertIn(story.title, choices_list[1][1])\\n self.assertIn(story.title, choices_list[2][1])\",\n \"def setUp(self):\\n\\n singleLabels = linkoCreate.Linkograph(\\n [({'A'}, set(), {1,2,3}),\\n ({'D'}, {0}, {3,4}),\\n ({'A'}, {0}, {4}),\\n ({'C'}, {0,1}, {4}),\\n ({'A'}, {1,2,3}, set())],\\n ['A', 'B', 'C', 'D'])\\n\\n singleSubLinko0_2 = linkoCreate.Linkograph(\\n [({'A'}, set(), {1,2}),\\n ({'D'}, {0}, set()),\\n ({'A'}, {0}, set())],\\n ['A', 'B', 'C', 'D'])\\n\\n singleSubLinko0_1 = linkoCreate.Linkograph(\\n [({'A'}, set(), {1}),\\n ({'D'}, {0}, set())],\\n ['A', 'B', 'C', 'D'])\\n\\n singleSubLinko0_0 = linkoCreate.Linkograph(\\n [({'A'}, set(), set())],\\n ['A', 'B', 'C', 'D'])\\n\\n singleSubLinko1_2 = linkoCreate.Linkograph(\\n [({'D'}, set(), set()),\\n ({'A'}, set(), set())],\\n ['A', 'B', 'C', 'D'])\\n\\n singleSubLinko1_1 = linkoCreate.Linkograph(\\n [({'D'}, set(), set())],\\n ['A', 'B', 'C', 'D'])\\n\\n trivialLinkograph = linkoCreate.Linkograph(\\n [], ['A', 'B', 'C', 'D'])\\n\\n\\n singleSubLinko1_4 = linkoCreate.Linkograph(\\n [({'D'}, set(), {2,3}),\\n ({'A'}, set(), {3}),\\n ({'C'}, {0}, {3}),\\n ({'A'}, {0,1,2}, set())],\\n ['A', 'B', 'C', 'D'])\\n\\n singleSubLinko2_4 = linkoCreate.Linkograph(\\n [({'A'}, set(), {2}),\\n ({'C'}, set(), {2}),\\n ({'A'}, {0,1}, set())],\\n ['A', 'B', 'C', 'D'])\\n\\n singleSubLinko3_4 = linkoCreate.Linkograph(\\n [({'C'}, set(), {1}),\\n ({'A'}, {0}, set())],\\n ['A', 'B', 'C', 'D'])\\n\\n singleSubLinko4_4 = linkoCreate.Linkograph(\\n [({'A'}, set(), set())],\\n ['A', 'B', 'C', 'D'])\\n\\n simpleLinko = linkoCreate.Linkograph(\\n [({'A', 'B', 'C'}, set(), {1,2,3}),\\n ({'D'}, {0}, {3,4}),\\n ({'A'}, {0}, {4}),\\n ({'B', 'C'}, {0,1}, {4}),\\n ({'A'}, {1,2,3}, set())],\\n ['A', 'B', 'C', 'D'])\\n\\n if self.id().split('.')[-1] == 'test_createSubLinkographWithoutCommands':\\n self.testParams = [\\n {'linko': singleLabels,\\n 'lowerBound': None,\\n 'upperBound': None,\\n 'ExpectedLinkograph': singleLabels},\\n\\n {'linko': singleLabels,\\n 'lowerBound': 0,\\n 'upperBound': 4,\\n 'ExpectedLinkograph': singleLabels},\\n\\n {'linko': singleLabels,\\n 'lowerBound': 0,\\n 'upperBound': 5,\\n 'ExpectedLinkograph': singleLabels},\\n\\n {'linko': singleLabels,\\n 'lowerBound': 0,\\n 'upperBound': 2,\\n 'ExpectedLinkograph': singleSubLinko0_2},\\n\\n {'linko': singleLabels,\\n 'lowerBound': -1,\\n 'upperBound': 2,\\n 'ExpectedLinkograph': singleSubLinko0_2},\\n\\n {'linko': singleLabels,\\n 'lowerBound': None,\\n 'upperBound': 2,\\n 'ExpectedLinkograph': singleSubLinko0_2},\\n\\n {'linko': singleLabels,\\n 'lowerBound': 0,\\n 'upperBound': 1,\\n 'ExpectedLinkograph': singleSubLinko0_1},\\n\\n {'linko': singleLabels,\\n 'lowerBound': 0,\\n 'upperBound': 0,\\n 'ExpectedLinkograph': singleSubLinko0_0},\\n\\n {'linko': singleLabels,\\n 'lowerBound': 0,\\n 'upperBound': -1,\\n 'ExpectedLinkograph': trivialLinkograph},\\n\\n {'linko': singleLabels,\\n 'lowerBound': 1,\\n 'upperBound': 2,\\n 'ExpectedLinkograph': singleSubLinko1_2},\\n\\n {'linko': singleLabels,\\n 'lowerBound': 1,\\n 'upperBound': 1,\\n 'ExpectedLinkograph': singleSubLinko1_1},\\n\\n {'linko': singleLabels,\\n 'lowerBound': 1,\\n 'upperBound': 0,\\n 'ExpectedLinkograph': trivialLinkograph},\\n\\n {'linko': singleLabels,\\n 'lowerBound': -1,\\n 'upperBound': -1,\\n 'ExpectedLinkograph': trivialLinkograph},\\n\\n {'linko': singleLabels,\\n 'lowerBound': 1,\\n 'upperBound': 4,\\n 'ExpectedLinkograph': singleSubLinko1_4},\\n\\n {'linko': singleLabels,\\n 'lowerBound': 2,\\n 'upperBound': 4,\\n 'ExpectedLinkograph': singleSubLinko2_4},\\n\\n {'linko': singleLabels,\\n 'lowerBound': 3,\\n 'upperBound': 4,\\n 'ExpectedLinkograph': singleSubLinko3_4},\\n\\n {'linko': singleLabels,\\n 'lowerBound': 4,\\n 'upperBound': 4,\\n 'ExpectedLinkograph': singleSubLinko4_4},\\n\\n ]\",\n \"def test_labels(self):\\n self.compliance_tester.test_labels(self.oi)\",\n \"def test_parent_label(self):\\n l = self.d.label(1)\\n l2 = self.d.label(31405)\\n\\n self.assertTrue(l.parent_label is None)\\n self.assertTrue(l2 in l.sublabels)\\n self.assertEqual(l2.parent_label, l)\",\n \"def test_simple(self):\\n exp = [{'type': NewickEvents.OPEN_SUBTREE, 'comments': []},\\n {'type': NewickEvents.OPEN_SUBTREE, 'comments': []},\\n {'edge_info': None, 'type': NewickEvents.TIP, 'comments': [], 'label': 'h'},\\n {'edge_info': None, 'type': NewickEvents.TIP, 'comments': [], 'label': 'p'},\\n {'edge_info': '1', 'type': NewickEvents.CLOSE_SUBTREE,\\n 'comments': [], 'label': 'hp'},\\n {'edge_info': None, 'type': NewickEvents.TIP, 'comments': [], 'label': 'g'},\\n {'edge_info': None, 'type': NewickEvents.CLOSE_SUBTREE,\\n 'comments': [], 'label': 'hpg'}\\n ]\\n content = '((h,p)hp:1,g)hpg;'\\n self._do_test(content, exp)\\n content = '((h,[pretest]p[test][posttest])hp,g)hpg;'\\n exp = [{'type': NewickEvents.OPEN_SUBTREE, 'comments': []},\\n {'type': NewickEvents.OPEN_SUBTREE, 'comments': []},\\n {'edge_info': None, 'type': NewickEvents.TIP, 'comments': [], 'label': 'h'},\\n {'edge_info': None, 'type': NewickEvents.TIP,\\n 'comments': ['pretest', 'test', 'posttest'], 'label': 'p'},\\n {'edge_info': None, 'type': NewickEvents.CLOSE_SUBTREE,\\n 'comments': [], 'label': 'hp'},\\n {'edge_info': None, 'type': NewickEvents.TIP, 'comments': [], 'label': 'g'},\\n {'edge_info': None, 'type': NewickEvents.CLOSE_SUBTREE,\\n 'comments': [], 'label': 'hpg'}\\n ]\\n self._do_test(content, exp)\",\n \"def test_label(self):\\n xs = t.Label(t.Exactly(\\\"x\\\"), 'CustomLabel')\\n self.assertEqual(writePython(xs),\\n dd(\\\"\\\"\\\"\\n def _G_label_1():\\n _G_exactly_2, lastError = self.exactly('x')\\n self.considerError(lastError, None)\\n return (_G_exactly_2, self.currentError)\\n _G_label_3, lastError = self.label(_G_label_1, \\\"CustomLabel\\\")\\n self.considerError(lastError, None)\\n _G_label_3\\n \\\"\\\"\\\"))\",\n \"def addLabels(t):\\n if not t.label:\\n t.label = \\\"\\\".join([choice(\\\"abcdefghijklmnopqrstuvwxyz\\\") for i in range(4)])\\n for r,w in t.children:\\n addLabels(r)\",\n \"def test_general_subset_level():\\n pass\",\n \"def _make_simple_comb_label(chain_dict):\\n\\n cps = chain_dict['chainParts']\\n if not (_select_simple_chainparts(cps)):\\n raise NotImplementedError(\\n 'chain fails substring selection: not \\\"simple\\\": %s' % (\\n chain_dict['chainName']))\\n \\n simple_strs = []\\n\\n for cp in cps:\\n print(cp)\\n simple_strs.append(_make_simple_label([cp]))\\n\\n label = 'combgen([(%d)]' % len(cps)\\n for s in simple_strs:\\n label += ' %s ' % s\\n label += ')'\\n return label\",\n \"def _generateLabelAndName(self, obj, **args):\\n result = []\\n label = self._generateLabel(obj, **args)\\n name = self._generateName(obj, **args)\\n result.extend(label)\\n if not len(label):\\n result.extend(name)\\n elif len(name) and name[0].strip() != label[0].strip():\\n result.extend(name)\\n return result\",\n \"def tests_ti_document_add_label(self):\\n super().group_add_label()\",\n \"def getLabel2(*args):\",\n \"def getLabel2(*args):\",\n \"def test_checkboxtextgroup(self):\\r\\n self.check_group('checkboxtextgroup', 'choice', 'checkbox')\",\n \"def _generateTableCell2ChildLabel(self, obj, **args):\\n result = []\\n\\n # If this table cell has 2 children and one of them has a\\n # 'toggle' action and the other does not, then present this\\n # as a checkbox where:\\n # 1) we get the checked state from the cell with the 'toggle' action\\n # 2) we get the label from the other cell.\\n # See Orca bug #376015 for more details.\\n #\\n if obj.childCount == 2:\\n cellOrder = []\\n hasToggle = [False, False]\\n for i, child in enumerate(obj):\\n if self._script.utilities.hasMeaningfulToggleAction(child):\\n hasToggle[i] = True\\n break\\n if hasToggle[0] and not hasToggle[1]:\\n cellOrder = [ 1, 0 ]\\n elif not hasToggle[0] and hasToggle[1]:\\n cellOrder = [ 0, 1 ]\\n if cellOrder:\\n for i in cellOrder:\\n if not hasToggle[i]:\\n result.extend(self.generate(obj[i], **args))\\n return result\",\n \"def test_process_label_in_node(self):\\n tree = Node(children=[\\n Node(\\\"Defining secret phrase.\\\", label=['AB', 'a']),\\n Node(\\\"Has secret phrase. Then some other content\\\", \\n label=['AB', 'b'])\\n ], label=['AB'])\\n t = Terms(tree)\\n t.scoped_terms = {\\n ('AB',): [Ref(\\\"secret phrase\\\", \\\"AB-a\\\", (9,22))]\\n }\\n # Term is defined in the first child\\n self.assertEqual([], t.process(tree.children[0]))\\n self.assertEqual(1, len(t.process(tree.children[1])))\",\n \"def get_extra_label(self, label_name: str, hierarchy: List[str]) -> Any:\",\n \"def test_get_scenarios_expanded(self):\\n pass\",\n \"def test_nested():\\n res = conf.status.conditions.choose(lambda c: (c.type, c.reason, c.root.metadata.choose(lambda m: (m[\\\"name\\\"], m.uid))))\\n assert \\\"type\\\" in res # from conditions\\n assert \\\"reason\\\" in res # from conditions\\n assert \\\"name\\\" in res # from metadata\\n assert \\\"uid\\\" in res # from metadata\",\n \"def _make_simple_label(chain_parts):\\n \\n if not _select_simple_chainparts(chain_parts):\\n msg = 'Jet Configuration error: '\\\\\\n 'chain fails substring selection: not \\\"simple\\\" '\\n\\n raise NotImplementedError(msg)\\n \\n label = 'simple(['\\n for cp in chain_parts:\\n smcstr = str(cp['smc'])\\n jvtstr = str(cp['jvt'])\\n if smcstr == 'nosmc':\\n smcstr = ''\\n for i in range(int(cp['multiplicity'])):\\n # condition_str = '(%set,%s,%s)' % (str(cp['threshold']),\\n # str(cp['etaRange']),\\n # smcstr,)\\n condition_str = '(%set,%s' % (str(cp['threshold']),\\n str(cp['etaRange']),)\\n if smcstr: # Run 2 chains have \\\"INF\\\" in the SMC substring\\n condition_str += ',%s)' % smcstr.replace('INF','')\\n elif jvtstr:\\n condition_str += ',%s)' % jvtstr\\n else:\\n condition_str += ')'\\n label += condition_str\\n label += '])'\\n return label\",\n \"def test_nested_sequence(self):\\n\\n self.taxon_tester('Apis mellifera')\\n self.taxon_tester('Apis')\\n self.taxon_tester('Apini')\\n self.taxon_tester('Apinae')\\n # Apidae at 5680 species is a struggle\\n self.taxon_tester('Apidae')\\n if False:\\n # Apoidea: 19566 takes 223 seconds\\n self.taxon_tester('Apoidea')\\n # Aculeata fails after 339 seconds\\n self.taxon_tester('Aculeata')\\n self.taxon_tester('Apocrita')\\n self.taxon_tester('Hymenoptera')\\n self.taxon_tester('Endopterygota')\\n self.taxon_tester('Neoptera')\\n self.taxon_tester('Pterygota')\\n self.taxon_tester('Dicondylia')\\n self.taxon_tester('Insecta')\\n self.taxon_tester('Hexapoda')\\n self.taxon_tester('Pancrustacea')\\n self.taxon_tester('Mandibulata')\\n self.taxon_tester('Arthropoda')\\n self.taxon_tester('Panarthropoda')\\n self.taxon_tester('Ecdysozoa')\\n self.taxon_tester('Protostomia')\\n self.taxon_tester('Bilateria')\\n self.taxon_tester('Eumetazoa')\\n self.taxon_tester('Metazoa')\\n self.taxon_tester('Holozoa')\\n self.taxon_tester('Opisthokonta')\\n self.taxon_tester('Eukaryota')\",\n \"def test_bootstrap_support_labeled(self):\\r\\n master_tree = parse_newick('((a:2,b:3)ab:2,(c:1,d:2)cd:7)rt;')\\r\\n \\\"\\\"\\\"\\r\\n /-------.5 /-a\\r\\n ---1| \\\\-b\\r\\n \\\\------.5 /-c\\r\\n \\\\-d\\r\\n \\\"\\\"\\\"\\r\\n t1 = parse_newick('((a:6,b:8.2)hi:2,(c:1,d:2):7);') # same structure\\r\\n t2 = parse_newick('((a:2,b:3,c:33)ho:2,d:7);') # abc are siblings\\r\\n new_master, bootstraps = tc.bootstrap_support(master_tree, [t1, t2])\\r\\n expected = dict([('ab', .5), ('cd', .5), ('rt', 1.0)])\\r\\n self.assertDictEqual(bootstraps, expected)\",\n \"def test_title(names):\",\n \"def test_verbose_name_group(self): \\n field_verboses = {\\n \\\"title\\\": \\\"Название группы\\\",\\n \\\"slug\\\": \\\"Слаг\\\",\\n \\\"description\\\": \\\"Описание группы\\\",\\n }\\n for value, expected in field_verboses.items():\\n with self.subTest(value=value):\\n self.assertEqual(self.group._meta.get_field(value).verbose_name, expected)\",\n \"def plugin_second_label():\\n return \\\"second\\\"\",\n \"def test_product_labels(self):\\n\\n prd = Product.objects.get(id=1)\\n # label name\\n label_name = prd._meta.get_field('name').verbose_name\\n self.assertEqual(label_name, 'name')\\n # label description\\n label_name = prd._meta.get_field('description').verbose_name\\n self.assertEqual(label_name, 'description')\\n # label nutrition_grade\\n label_name = prd._meta.get_field('nutrition_grade').name\\n self.assertEqual(label_name, 'nutrition_grade')\\n # label barcode\\n label_name = prd._meta.get_field('barcode').verbose_name\\n self.assertEqual(label_name, 'barcode')\\n # label url\\n label_name = prd._meta.get_field('url').verbose_name\\n self.assertEqual(label_name, 'url')\\n # label url_pic\\n label_name = prd._meta.get_field('url_pic').name\\n self.assertEqual(label_name, 'url_pic')\\n # label store\\n label_name = prd._meta.get_field('store').verbose_name\\n self.assertEqual(label_name, 'store')\\n # label prd_cat\\n label_name = prd._meta.get_field('prd_cat').name\\n self.assertEqual(label_name, 'prd_cat')\\n # label fat\\n label_name = prd._meta.get_field('fat').verbose_name\\n self.assertEqual(label_name, 'fat')\\n # label saturated_fat\\n label_name = prd._meta.get_field('saturated_fat').name\\n self.assertEqual(label_name, 'saturated_fat')\\n # label sugar\\n label_name = prd._meta.get_field('sugar').verbose_name\\n self.assertEqual(label_name, 'sugar')\\n # label salt\\n label_name = prd._meta.get_field('salt').verbose_name\\n self.assertEqual(label_name, 'salt')\",\n \"def is_test(self):\\r\\n return self.has_label('tests')\",\n \"def setUp(self):\\n\\n\\n # InverseLabeling\\n invLabeling0 = {'L0': [0, 1, 2]}\\n\\n invLabeling1 = {'L0' : [0, 2],\\n 'L1' : [1]}\\n\\n invLabeling2 = {\\n 'L0' : [0],\\n 'L1' : [1],\\n 'L2' : [2]\\n }\\n\\n invLabeling3 = {\\n 'L1' : [0, 1],\\n 'L2' : [2]\\n }\\n\\n invLabeling4 = {\\n 'L0' : [0,1],\\n 'L1' : [0],\\n 'L2' : [2]\\n }\\n\\n invLabeling5 = {\\n 'L0': [0, 1, 2],\\n 'L1': []\\n }\\n \\n # Create some ontologies\\n ontology0 = {'L0': ['L0']}\\n\\n ontology1 = {}\\n\\n ontology2 = {'L0': ['L1']}\\n\\n ontology3 = {'L0': ['L1', 'L2'],\\n 'L1': ['L2'],\\n 'L2': ['L0']}\\n\\n if self.id().split('.')[-1] == 'test_createLinkograph':\\n self.testParams = [\\n {'inverseLabeling': invLabeling0,\\n 'ontology': ontology0,\\n 'ExpectedLinkograph':\\n linkoCreate.Linkograph(\\n [({'L0'}, set(), {1, 2}),\\n ({'L0'}, {0}, {2}),\\n ({'L0'}, {0,1}, set())] \\n )},\\n\\n {'inverseLabeling': invLabeling0,\\n 'ontology': ontology1,\\n 'ExpectedLinkograph':\\n linkoCreate.Linkograph(\\n [({'L0'}, set(), set()),\\n ({'L0'}, set(), set()),\\n ({'L0'}, set(), set())]\\n )},\\n\\n {'inverseLabeling': invLabeling0,\\n 'ontology': ontology2,\\n 'ExpectedLinkograph':\\n linkoCreate.Linkograph(\\n [({'L0'}, set(), set()),\\n ({'L0'}, set(), set()),\\n ({'L0'}, set(), set())]\\n )},\\n\\n\\n {'inverseLabeling': invLabeling1,\\n 'ontology': ontology0,\\n 'ExpectedLinkograph':\\n linkoCreate.Linkograph(\\n [({'L0'}, set(), {2}),\\n ({'L1'}, set(), set()),\\n ({'L0'}, {0}, set())]\\n )},\\n\\n {'inverseLabeling': invLabeling1,\\n 'ontology': ontology1,\\n 'ExpectedLinkograph':\\n linkoCreate.Linkograph(\\n [({'L0'}, set(), set()),\\n ({'L1'}, set(), set()),\\n ({'L0'}, set(), set())]\\n )},\\n\\n {'inverseLabeling': invLabeling1,\\n 'ontology': ontology2,\\n 'ExpectedLinkograph':\\n linkoCreate.Linkograph(\\n [({'L0'}, set(), {1}),\\n ({'L1'}, {0}, set()),\\n ({'L0'}, set(), set())]\\n )},\\n\\n {'inverseLabeling': invLabeling0,\\n 'ontology': ontology3,\\n 'ExpectedLinkograph':\\n linkoCreate.Linkograph(\\n [({'L0'}, set(), set()),\\n ({'L0'}, set(), set()),\\n ({'L0'}, set(), set())]\\n )},\\n\\n {'inverseLabeling': invLabeling1,\\n 'ontology': ontology3,\\n 'ExpectedLinkograph':\\n linkoCreate.Linkograph(\\n [({'L0'}, set(), {1}),\\n ({'L1'}, {0}, set()),\\n ({'L0'}, set(), set())]\\n )},\\n\\n {'inverseLabeling': invLabeling2,\\n 'ontology': ontology3,\\n 'ExpectedLinkograph':\\n linkoCreate.Linkograph(\\n [({'L0'}, set(), {1,2}),\\n ({'L1'}, {0}, {2}),\\n ({'L2'}, {0, 1}, set())]\\n )},\\n\\n {'inverseLabeling': invLabeling3,\\n 'ontology': ontology3,\\n 'ExpectedLinkograph':\\n linkoCreate.Linkograph(\\n [({'L1'}, set(), {2}),\\n ({'L1'}, set(), {2}),\\n ({'L2'}, {0, 1}, set())]\\n )},\\n\\n {'inverseLabeling': invLabeling4,\\n 'ontology': ontology3,\\n 'ExpectedLinkograph':\\n linkoCreate.Linkograph(\\n [({'L0', 'L1'}, set(), {2}),\\n ({'L0'}, set(), {2}),\\n ({'L2'}, {0, 1}, set())]\\n )},\\n\\n {'inverseLabeling': invLabeling5,\\n 'ontology': ontology3,\\n 'ExpectedLinkograph':\\n linkoCreate.Linkograph(\\n [({'L0'}, set(), set()),\\n ({'L0'}, set(), set()),\\n ({'L0'}, set(), set())]\\n )},\\n\\n ]\",\n \"def test_mutual_exclusivity_of_labels(self, tmpdir, docker_tasker, labels, expected_fail):\\n runner = mock_env(tmpdir, docker_tasker, labels=labels)\\n if expected_fail:\\n with pytest.raises(PluginFailedException) as e:\\n runner.run()\\n assert 'only one of labels' in str(e.value)\\n else:\\n runner.run()\",\n \"def helper_label(helper):\\n return helper.info\",\n \"def test_Tree():\",\n \"def test_col_data_label_with_attrs(self):\\n help_tag = 'span'\\n help_text_br = False\\n names = ('first', 'billing_address_1')\\n attrs = {'style': 'width: 10rem; display: inline-block'}\\n label_attrs = {name: attrs for name in names}\\n txt = '{}=\\\"{}\\\"'.format(*list(attrs.items())[0])\\n expected = ['<label for=\\\"id_first\\\" {}>First:</label>'.format(txt)]\\n expected.append('<label for=\\\"id_billing_address_1\\\" {}>street address (line 1):</label>'.format(txt))\\n actual = []\\n for name in names:\\n field = self.form.fields[name]\\n response = self.form.collect_col_data(name, field, help_tag, help_text_br, label_attrs)\\n actual.append(response.get('label'))\\n\\n for expect, got in zip(expected, actual):\\n self.assertEqual(expect, got)\",\n \"def test_help_text_group(self): \\n field_help_text = {\\n \\\"title\\\": \\\"Дайте назание группе\\\",\\n \\\"slug\\\": ('Укажите адрес для группы. Используйте '\\n 'только латиницу, цифры, дефисы и знаки '\\n 'подчёркивания'),\\n } \\n for value, expected in field_help_text.items():\\n with self.subTest(value=value):\\n self.assertEqual(self.group._meta.get_field(value).help_text, expected)\",\n \"def test_label_choices(self):\\n test_classes = (\\n (0, 'No'),\\n (1, 'Yes')\\n )\\n\\n form = SingleLabelClassifierForm(classes=test_classes)\\n self.assertEqual(tuple(form.fields['label'].choices), test_classes)\\n\\n form = MultiLabelClassifierForm(classes=test_classes)\\n self.assertEqual(tuple(form.fields['label'].choices), test_classes)\",\n \"def test_filter_tree(self):\\r\\n actual = [e.Name for e in filter_tree(\\r\\n self.tree1, ['bbb', 'ccc']).tips()]\\r\\n #(a_a:10,(b_b:2,c_c:4):5);\\r\\n expected = [\\r\\n e.Name for e in DndParser(\\r\\n \\\"((bbb:2,ccc:4));\\\",\\r\\n PhyloNode).tips(\\r\\n )]\\r\\n self.assertEqual(actual, expected)\\r\\n\\r\\n actual = [e.Name for e in filter_tree(\\r\\n self.tree2, ['bbb', 'ccc']).tips()]\\r\\n #(a_a:10,(b_b:2,c_c:4):5);\\r\\n expected = [\\r\\n e.Name for e in DndParser(\\r\\n \\\"(('bbb':2,ccc:4));\\\",\\r\\n PhyloNode).tips(\\r\\n )]\\r\\n self.assertEqual(actual, expected)\",\n \"def test_radiotextgroup(self):\\r\\n self.check_group('radiotextgroup', 'choice', 'radio')\",\n \"def gen_test_case_combination(self):\\n\\n cases = '\\\\n'\\n\\n binary_ops = list(self.BINARY_OPS)\\n binary_ops.reverse()\\n for op1 in self.BINARY_OPS:\\n for op2 in binary_ops:\\n\\n result = []\\n ret = IntOp.binary_op(op2, '0', '1', self.lane_width)\\n ret = IntOp.binary_op(op1, ret, '2', self.lane_width)\\n result.append(ret)\\n\\n cases += '\\\\n' + str(AssertReturn('{lane_type}.{op1}-{lane_type}.{op2}'.format(lane_type=self.LANE_TYPE, op1=op1, op2=op2),\\n [SIMD.v128_const('0', self.LANE_TYPE),\\n SIMD.v128_const('1', self.LANE_TYPE),\\n SIMD.v128_const('2', self.LANE_TYPE)],\\n SIMD.v128_const(result, self.LANE_TYPE)))\\n cases += '\\\\n'\\n return cases\",\n \"def test_multiple_task_groups_dag(\\n self, test_multiple_taskgroups_dag, multiple_taskgroups_dag_expected_edges\\n ):\\n (\\n dag,\\n group1,\\n group2,\\n group3,\\n (\\n group1_emp1,\\n group1_emp2,\\n group1_emp3,\\n group2_emp1,\\n group2_emp2,\\n group2_emp3,\\n group2_op1,\\n group2_op2,\\n group3_emp1,\\n group3_emp2,\\n group3_emp3,\\n emp_in1,\\n emp_in2,\\n emp_in3,\\n emp_in4,\\n emp_out1,\\n emp_out2,\\n emp_out3,\\n emp_out4,\\n op_in1,\\n op_out1,\\n ),\\n ) = test_multiple_taskgroups_dag\\n\\n group1_emp1 >> Label(\\\"label group1.group1_emp1 <=> group1.group1_emp2\\\") >> group1_emp3\\n\\n emp_in1 >> group1\\n emp_in2 >> Label(\\\"label emp_in2 <=> group1\\\") >> group1\\n [emp_in3, emp_in4] >> Label(\\\"label emp_in3/emp_in4 <=> group1\\\") >> group1\\n XComArg(op_in1, \\\"test_key\\\") >> Label(\\\"label op_in1 <=> group1\\\") >> group1\\n\\n (\\n [group2_emp1, group2_emp2]\\n >> Label(\\\"label group2.group2_emp1/group2.group2_emp2 <=> group2.group2_emp3\\\")\\n >> group2_emp3\\n )\\n (\\n group2_emp1\\n >> Label(\\\"label group2.group2_emp1 <=> group2.group2_emp2/group2.group2_emp3\\\")\\n >> [group2_emp2, group2_emp3]\\n )\\n group2_emp3 >> Label(\\\"label group2.group2_emp3 <=> group3\\\") >> group3\\n\\n (\\n XComArg(group2_op1, \\\"test_key\\\")\\n >> Label(\\\"label group2.group2_op1 <=> group2.group2_op2\\\")\\n >> XComArg(group2_op2, \\\"test_key\\\")\\n )\\n XComArg(group2_op2, \\\"test_key\\\") >> Label(\\\"label group2.group2_op2 <=> group3\\\") >> group3\\n\\n group3 >> emp_out1\\n group3 >> Label(\\\"label group3 <=> emp_out2\\\") >> emp_out2\\n group3 >> Label(\\\"label group3 <=> emp_out3/emp_out4\\\") >> [emp_out3, emp_out4]\\n group3 >> Label(\\\"label group3 <=> op_out1\\\") >> XComArg(op_out1, \\\"test_key\\\")\\n\\n group1 >> Label(\\\"label group1 <=> group2\\\") >> group2\\n\\n compare_dag_edges(dag_edges(dag), multiple_taskgroups_dag_expected_edges)\",\n \"def test_issue_create_label(self):\\n pass\",\n \"def test__create_label_w_no_ent_id(ruler: SpaczzRuler) -> None:\\n assert ruler._create_label(\\\"TEST\\\", None) == \\\"TEST\\\"\",\n \"def test_grouping(self):\\n s = self.create(ComponentItem, UML.Component)\\n uc1 = self.create(UseCaseItem, UML.UseCase)\\n uc2 = self.create(UseCaseItem, UML.UseCase)\\n\\n self.group(s, uc1)\\n assert 1 == len(uc1.subject.subject)\\n self.group(s, uc2)\\n assert 1 == len(uc2.subject.subject)\\n\\n # Classifier.useCase is not navigable to UseCase\\n # self.assertEqual(2, len(s.subject.useCase))\",\n \"def setLabel2(*args):\",\n \"def tests_ti_document_get_label(self):\\n super().group_get_label()\",\n \"def test_render_label(self):\\n label = self.block.meta.label\\n self.assertEqual(label, 'Google Calendar', 'The labels are not the same')\",\n \"def check_elm(orphan_root, obj, orphan_labels, orphan_widgets):\\n\\n oid = obj.attrib.get('id')\\n klass = obj.attrib.get('class')\\n\\n # \\\"Don't care\\\" special case\\n if klass in widgets_ignored:\\n return\\n for suffix in widgets_suffixignored:\\n if klass[-len(suffix):] == suffix:\\n return\\n\\n # Widgets usual do not strictly require a label, i.e. a labelled parent\\n # is enough for context, but some do always need one.\\n requires_label = klass in widgets_needlabel\\n\\n if oid is not None:\\n # Check that ids are unique\\n if oid in ids_dup:\\n if ids[oid] == obj:\\n # We are the first, warn\\n duplicates = tree.findall(\\\".//object[@id='\\\" + oid + \\\"']\\\")\\n err(filename, tree, obj, \\\"duplicate-id\\\", \\\"has the same id as other elements \\\" + elms_names_lines(duplicates))\\n\\n # Check label-for and their dual labelled-by\\n label_for = check_rels(filename, tree, root, obj, \\\"label-for\\\", \\\"labelled-by\\\")\\n\\n # Check labelled-by and its dual label-for\\n labelled_by = check_rels(filename, tree, root, obj, \\\"labelled-by\\\", \\\"label-for\\\")\\n\\n # Check label-for and their dual labelled-by\\n description_for = check_rels(filename, tree, root, obj, \\\"description-for\\\", \\\"described-by\\\")\\n\\n # Check labelled-by and its dual label-for\\n described_by = check_rels(filename, tree, root, obj, \\\"described-by\\\", \\\"description-for\\\")\\n\\n # Should have only one label\\n if len(labelled_by) >= 1:\\n if oid in mnemonic_for_elm:\\n warn(filename, tree, obj, \\\"labelled-by-and-mnemonic\\\",\\n \\\"has both a mnemonic \\\" + elm_name_line(mnemonic_for_elm[oid][0]) + \\\"and labelled-by relation\\\")\\n if len(labelled_by) > 1:\\n warn(filename, tree, obj, \\\"multiple-labelled-by\\\", \\\"has multiple labelled-by relations\\\")\\n if oid in label_for_elm:\\n if len(label_for_elm[oid]) > 1:\\n warn(filename, tree, obj, \\\"duplicate-label-for\\\", \\\"is referenced by multiple label-for \\\" + elms_names_lines(label_for_elm[oid]))\\n if oid in mnemonic_for_elm:\\n if len(mnemonic_for_elm[oid]) > 1:\\n warn(filename, tree, obj, \\\"duplicate-mnemonic\\\", \\\"is referenced by multiple mnemonic_widget \\\" + elms_names_lines(mnemonic_for_elm[oid]))\\n\\n # Check member-of\\n member_of = check_rels(filename, tree, root, obj, \\\"member-of\\\")\\n\\n # Labels special case\\n if klass in widgets_labels:\\n properties = check_props(filename, tree, root, obj, \\\"mnemonic_widget\\\") + \\\\\\n check_props(filename, tree, root, obj, \\\"mnemonic-widget\\\")\\n if len(properties) > 1:\\n err(filename, tree, obj, \\\"multiple-mnemonic\\\", \\\"has multiple mnemonic_widgets properties\\\"\\n \\\"%s\\\" % elms_lines(properties))\\n\\n # Emit orphaning warnings\\n if warn_orphan_labels or orphan_widgets:\\n is_orphan_label(filename, tree, root, obj, orphan_root, True)\\n\\n # We are done with the label\\n return\\n\\n # Not a label, will perhaps need one\\n\\n # Emit orphaning warnings\\n is_orphan_widget(filename, tree, root, obj, orphan_labels, orphan_root, True)\",\n \"def get_label(self, hierarchy: List[str]) -> Any:\",\n \"def test_first_level_from_bids_no_duplicate_sub_labels(bids_dataset):\\n models, *_ = first_level_from_bids(\\n dataset_path=bids_dataset,\\n task_label='main',\\n sub_labels=[\\\"01\\\", \\\"01\\\"],\\n space_label='MNI',\\n img_filters=[('desc', 'preproc')],\\n slice_time_ref=None,\\n )\\n\\n assert len(models) == 1\",\n \"def test_add_empty_nodes_with_label_when_splitting(self):\\n print \\\"----- test_add_empty_nodes_with_label_when_splitting -----\\\"\\n sel_axis = (lambda axis: axis)\\n \\n #create tree, first node splits in x direction\\n tree = kdtree.createNewTree([[0.5, 0.5]],axis = 0, sel_axis= sel_axis)\\n kdtree.visualize(tree)\\n \\n point_left = [0.4, 0.5]\\n tree.split2(point_left, axis = 0)\\n kdtree.visualize(tree)\\n \\n point1 = [0.3, 0.5]\\n found_node = tree.get_path_to_leaf(point1)[-1]\\n correct_node1 = 3\\n self.assertEqual(found_node.label, correct_node1, \\\"Not correct node found\\\")\\n \\n point_right = [0.6, 0.5]\\n tree.split2(point_right, axis = 1)\\n kdtree.visualize(tree)\\n \\n point2 = [0.6, 0.7]\\n found_node = tree.get_path_to_leaf(point2)[-1]\\n correct_node2 = 6\\n self.assertEqual(found_node.label, correct_node2, \\\"Not correct node found\\\")\\n \\n print \\\"----- end: test_add_empty_nodes_with_label_when_splitting -----\\\"\",\n \"def test_render_value_label(self):\\n self.check_html(\\n self.widget(choices=self.beatles),\\n \\\"beatles\\\",\\n [\\\"John\\\"],\\n html=(\\n \\\"\\\"\\\"<select multiple name=\\\"beatles\\\">\\n <option value=\\\"J\\\">John</option>\\n <option value=\\\"P\\\">Paul</option>\\n <option value=\\\"G\\\">George</option>\\n <option value=\\\"R\\\">Ringo</option>\\n </select>\\\"\\\"\\\"\\n ),\\n )\",\n \"def test_issue_add_label(self):\\n pass\",\n \"def test_create_metering_label(self):\\r\\n resource = 'metering_label'\\r\\n cmd = metering.CreateMeteringLabel(\\r\\n test_cli20.MyApp(sys.stdout), None)\\r\\n name = 'my label'\\r\\n myid = 'myid'\\r\\n description = 'my description'\\r\\n args = [name, '--description', description, '--shared']\\r\\n position_names = ['name', 'description', 'shared']\\r\\n position_values = [name, description, True]\\r\\n self._test_create_resource(resource, cmd, name, myid, args,\\r\\n position_names, position_values)\",\n \"def getLabel(*args):\",\n \"def getLabel(*args):\",\n \"def getLabel(*args):\",\n \"def _make_vbenf_label(chain_parts):\\n\\n # toy label for development: run simple and dijet independently.\\n # simple makes Et cuts on two jets. Independently (sharing possible)\\n # of jets choosean by simple, the dijet\\n # scenario requires a dijet of mass > 900, and opening angle in phi > 2.6\\n\\n assert len(chain_parts) == 1\\n scenario = chain_parts[0]['hypoScenario']\\n assert scenario.startswith('vbenf')\\n args = _args_from_scenario(scenario)\\n if not args:\\n return 'and([]simple([(50et)(70et)])combgen([(2)] dijet([(900djmass, 26djdphi)])))' \\n arg_res = [\\n re.compile(r'(?P<lo>\\\\d*)(?P<key>fbet)(?P<hi>\\\\d*)'),\\n re.compile(r'(?P<lo>\\\\d*)(?P<key>mass)(?P<hi>\\\\d*)'),\\n re.compile(r'(?P<lo>\\\\d*)(?P<key>et)(?P<hi>\\\\d*)'),\\n ]\\n\\n defaults = {\\n 'et': ('101', 'inf'),\\n 'mass': ('800', 'inf'),\\n 'fbet': ('501', 'inf'),\\n }\\n\\n argvals = {}\\n while args:\\n assert len(args) == len(arg_res)\\n arg = args.pop()\\n for r in arg_res:\\n m = r.match(arg)\\n if m is not None:\\n arg_res.remove(r)\\n gd = m.groupdict()\\n key = gd['key']\\n try:\\n lo = float(gd['lo'])\\n except ValueError:\\n lo = defaults[key][0]\\n argvals[key+'lo'] = lo \\n try:\\n hi = float(gd['hi'])\\n except ValueError:\\n hi = defaults[key][1]\\n argvals[key+'hi'] = hi\\n\\n assert len(args) == len(arg_res)\\n assert len(args) == 0\\n\\n return \\\"\\\"\\\"\\n and\\n (\\n []\\n simple\\n (\\n [(%(etlo).0fet, 500neta)(%(etlo).0fet, peta500)]\\n )\\n combgen\\n (\\n [(10et, 0eta320)]\\n dijet\\n (\\n [(%(masslo).0fdjmass, 26djdphi)]\\n ) \\n simple\\n (\\n [(10et, 0eta320)(20et, 0eta320)]\\n )\\n )\\n )\\\"\\\"\\\" % argvals\",\n \"def testFormatLabelAndValue(self):\\n\\n self.assertEqual('Abc: xyz', self.inv._FormatLabelAndValue('abc', 'xyz', 1))\\n self.assertEqual('ABc: xyz', self.inv._FormatLabelAndValue('abc', 'xyz', 2))\\n self.assertEqual('ABC: xyz', self.inv._FormatLabelAndValue('abc', 'xyz', 4))\",\n \"def test_recipe_nutrition_label_image(self):\\n pass\",\n \"def test_label_10_targets_with_a_b_c_(self):\\r\\n user_input = '[{\\\"a\\\":\\\"target1\\\"}, \\\\\\r\\n {\\\"b\\\":\\\"target2\\\"},{\\\"c\\\":\\\"target3\\\"},{\\\"a\\\":\\\"target4\\\"},{\\\"b\\\":\\\"target5\\\"}, \\\\\\r\\n {\\\"c\\\":\\\"target6\\\"}, {\\\"a\\\":\\\"target7\\\"},{\\\"b\\\":\\\"target8\\\"},{\\\"c\\\":\\\"target9\\\"}, \\\\\\r\\n {\\\"a\\\":\\\"target10\\\"}]'\\r\\n correct_answer = [\\r\\n {\\r\\n 'draggables': ['a'],\\r\\n 'targets': ['target1', 'target4', 'target7', 'target10'],\\r\\n 'rule': 'unordered_equal'\\r\\n },\\r\\n {\\r\\n 'draggables': ['b'],\\r\\n 'targets': ['target2', 'target5', 'target8'],\\r\\n 'rule': 'unordered_equal'\\r\\n },\\r\\n {\\r\\n 'draggables': ['c'],\\r\\n 'targets': ['target3', 'target6', 'target9'],\\r\\n 'rule': 'unordered_equal'\\r\\n }\\r\\n ]\\r\\n self.assertTrue(draganddrop.grade(user_input, correct_answer))\",\n \"def test_label_10_targets_with_a_b_c_multiple(self):\\r\\n user_input = '[{\\\"a\\\":\\\"target1\\\"}, \\\\\\r\\n {\\\"b\\\":\\\"target2\\\"},{\\\"c\\\":\\\"target3\\\"},{\\\"b\\\":\\\"target5\\\"}, \\\\\\r\\n {\\\"c\\\":\\\"target6\\\"}, {\\\"a\\\":\\\"target7\\\"},{\\\"b\\\":\\\"target8\\\"},{\\\"c\\\":\\\"target9\\\"}, \\\\\\r\\n {\\\"a\\\":\\\"target1\\\"}]'\\r\\n correct_answer = [\\r\\n {\\r\\n 'draggables': ['a', 'a', 'a'],\\r\\n 'targets': ['target1', 'target4', 'target7', 'target10'],\\r\\n 'rule': 'anyof+number'\\r\\n },\\r\\n {\\r\\n 'draggables': ['b', 'b', 'b'],\\r\\n 'targets': ['target2', 'target5', 'target8'],\\r\\n 'rule': 'anyof+number'\\r\\n },\\r\\n {\\r\\n 'draggables': ['c', 'c', 'c'],\\r\\n 'targets': ['target3', 'target6', 'target9'],\\r\\n 'rule': 'anyof+number'\\r\\n }\\r\\n ]\\r\\n self.assertTrue(draganddrop.grade(user_input, correct_answer))\",\n \"def test_subsystems(self):\\n pass\",\n \"def test_multiply_some_type_links():\",\n \"def test_build_match_tree_with_pairs():\\n abbreviation_list = [[\\\"ELIF\\\", \\\"ELI.\\\"], [\\\"ELSE\\\", \\\"E.\\\"]]\\n expected_tree = {\\\"E\\\": {\\\"L\\\": {\\\"I\\\": {\\\"F\\\": \\\"ELI.\\\"}, \\\"S\\\": {\\\"E\\\": \\\"E.\\\"}}}}\\n tree = build_match_tree(abbreviation_list)\\n assert repr(tree) == repr(expected_tree)\",\n \"def check_a11y_relation(filename, tree):\\n global widgets_ignored, ids, label_for_elm, labelled_by_elm, description_for_elm, described_by_elm, mnemonic_for_elm\\n\\n def check_elm(orphan_root, obj, orphan_labels, orphan_widgets):\\n \\\"\\\"\\\"\\n Check one element, knowing that orphan_labels/widgets tell whether\\n there are orphan labels and widgets within orphan_root\\n \\\"\\\"\\\"\\n\\n oid = obj.attrib.get('id')\\n klass = obj.attrib.get('class')\\n\\n # \\\"Don't care\\\" special case\\n if klass in widgets_ignored:\\n return\\n for suffix in widgets_suffixignored:\\n if klass[-len(suffix):] == suffix:\\n return\\n\\n # Widgets usual do not strictly require a label, i.e. a labelled parent\\n # is enough for context, but some do always need one.\\n requires_label = klass in widgets_needlabel\\n\\n if oid is not None:\\n # Check that ids are unique\\n if oid in ids_dup:\\n if ids[oid] == obj:\\n # We are the first, warn\\n duplicates = tree.findall(\\\".//object[@id='\\\" + oid + \\\"']\\\")\\n err(filename, tree, obj, \\\"duplicate-id\\\", \\\"has the same id as other elements \\\" + elms_names_lines(duplicates))\\n\\n # Check label-for and their dual labelled-by\\n label_for = check_rels(filename, tree, root, obj, \\\"label-for\\\", \\\"labelled-by\\\")\\n\\n # Check labelled-by and its dual label-for\\n labelled_by = check_rels(filename, tree, root, obj, \\\"labelled-by\\\", \\\"label-for\\\")\\n\\n # Check label-for and their dual labelled-by\\n description_for = check_rels(filename, tree, root, obj, \\\"description-for\\\", \\\"described-by\\\")\\n\\n # Check labelled-by and its dual label-for\\n described_by = check_rels(filename, tree, root, obj, \\\"described-by\\\", \\\"description-for\\\")\\n\\n # Should have only one label\\n if len(labelled_by) >= 1:\\n if oid in mnemonic_for_elm:\\n warn(filename, tree, obj, \\\"labelled-by-and-mnemonic\\\",\\n \\\"has both a mnemonic \\\" + elm_name_line(mnemonic_for_elm[oid][0]) + \\\"and labelled-by relation\\\")\\n if len(labelled_by) > 1:\\n warn(filename, tree, obj, \\\"multiple-labelled-by\\\", \\\"has multiple labelled-by relations\\\")\\n if oid in label_for_elm:\\n if len(label_for_elm[oid]) > 1:\\n warn(filename, tree, obj, \\\"duplicate-label-for\\\", \\\"is referenced by multiple label-for \\\" + elms_names_lines(label_for_elm[oid]))\\n if oid in mnemonic_for_elm:\\n if len(mnemonic_for_elm[oid]) > 1:\\n warn(filename, tree, obj, \\\"duplicate-mnemonic\\\", \\\"is referenced by multiple mnemonic_widget \\\" + elms_names_lines(mnemonic_for_elm[oid]))\\n\\n # Check member-of\\n member_of = check_rels(filename, tree, root, obj, \\\"member-of\\\")\\n\\n # Labels special case\\n if klass in widgets_labels:\\n properties = check_props(filename, tree, root, obj, \\\"mnemonic_widget\\\") + \\\\\\n check_props(filename, tree, root, obj, \\\"mnemonic-widget\\\")\\n if len(properties) > 1:\\n err(filename, tree, obj, \\\"multiple-mnemonic\\\", \\\"has multiple mnemonic_widgets properties\\\"\\n \\\"%s\\\" % elms_lines(properties))\\n\\n # Emit orphaning warnings\\n if warn_orphan_labels or orphan_widgets:\\n is_orphan_label(filename, tree, root, obj, orphan_root, True)\\n\\n # We are done with the label\\n return\\n\\n # Not a label, will perhaps need one\\n\\n # Emit orphaning warnings\\n is_orphan_widget(filename, tree, root, obj, orphan_labels, orphan_root, True)\\n\\n root = tree.getroot()\\n\\n # Flush ids and relations from previous files\\n ids = {}\\n ids_dup = {}\\n labelled_by_elm = {}\\n label_for_elm = {}\\n described_by_elm = {}\\n description_for_elm = {}\\n mnemonic_for_elm = {}\\n\\n # First pass to get links into hash tables, no warning, just record duplicates\\n for obj in root.iter('object'):\\n oid = obj.attrib.get('id')\\n if oid is not None:\\n if oid not in ids:\\n ids[oid] = obj\\n else:\\n ids_dup[oid] = True\\n\\n labelled_by = obj.findall(\\\"accessibility/relation[@type='labelled-by']\\\")\\n labelled_by += obj.findall(\\\"accessibility/relation[@name='labelled-by']\\\")\\n for rel in labelled_by:\\n target = rel.attrib.get('target')\\n if target is not None:\\n if target not in labelled_by_elm:\\n labelled_by_elm[target] = [ obj ]\\n else:\\n labelled_by_elm[target].append(obj)\\n\\n label_for = obj.findall(\\\"accessibility/relation[@type='label-for']\\\")\\n label_for += obj.findall(\\\"accessibility/relation[@name='label-for']\\\")\\n for rel in label_for:\\n target = rel.attrib.get('target')\\n if target is not None:\\n if target not in label_for_elm:\\n label_for_elm[target] = [ obj ]\\n else:\\n label_for_elm[target].append(obj)\\n\\n described_by = obj.findall(\\\"accessibility/relation[@type='described-by']\\\")\\n described_by += obj.findall(\\\"accessibility/relation[@name='described-by']\\\")\\n for rel in described_by:\\n target = rel.attrib.get('target')\\n if target is not None:\\n if target not in described_by_elm:\\n described_by_elm[target] = [ obj ]\\n else:\\n described_by_elm[target].append(obj)\\n\\n description_for = obj.findall(\\\"accessibility/relation[@type='description-for']\\\")\\n description_for += obj.findall(\\\"accessibility/relation[@name='description-for']\\\")\\n for rel in description_for:\\n target = rel.attrib.get('target')\\n if target is not None:\\n if target not in description_for_elm:\\n description_for_elm[target] = [ obj ]\\n else:\\n description_for_elm[target].append(obj)\\n\\n mnemonic_for = obj.findall(\\\"property[@name='mnemonic_widget']\\\") + \\\\\\n obj.findall(\\\"property[@name='mnemonic-widget']\\\")\\n for rel in mnemonic_for:\\n target = rel.text\\n if target is not None:\\n if target not in mnemonic_for_elm:\\n mnemonic_for_elm[target] = [ obj ]\\n else:\\n mnemonic_for_elm[target].append(obj)\\n\\n # Second pass, recursive depth-first, to be able to efficiently know whether\\n # there are orphan labels within a part of the tree.\\n def recurse(orphan_root, obj, orphan_labels, orphan_widgets):\\n if obj == root or is_labelled_parent(obj):\\n orphan_root = obj\\n orphan_labels, orphan_widgets = orphan_items(filename, tree, root, obj)\\n\\n if obj.tag == 'object':\\n check_elm(orphan_root, obj, orphan_labels, orphan_widgets)\\n\\n for o in obj:\\n recurse(orphan_root, o, orphan_labels, orphan_widgets)\\n\\n recurse(root, root, False, False)\",\n \"def test_stratis_list_default(self):\\n for subcommand in [[\\\"pool\\\"], [\\\"filesystem\\\"], [\\\"blockdev\\\"]]:\\n for prefix in [[], [\\\"--propagate\\\"]]:\\n self.assertEqual(RUNNER(prefix + subcommand), 0)\",\n \"def pytest_can_run_together(item1, item2):\",\n \"def test_series_in_features(self):\\n assert parse_command({'test{{A,B}}': {'depends_on': 'name{{A,B}}'}}) == [\\n ('testA', {'depends_on': 'nameA'}), ('testB', {'depends_on': 'nameB'})]\",\n \"def test_first_level_from_bids_with_subject_labels(bids_dataset):\\n warning_message = ('Subject label foo is not present in'\\n ' the dataset and cannot be processed')\\n with pytest.warns(UserWarning, match=warning_message):\\n models, *_ = first_level_from_bids(\\n dataset_path=bids_dataset,\\n task_label='main',\\n sub_labels=[\\\"foo\\\", \\\"01\\\"],\\n space_label='MNI',\\n img_filters=[('desc', 'preproc')],\\n slice_time_ref=None,\\n )\\n\\n assert models[0].subject_label == '01'\",\n \"def test_pathop12(self):\\n xpb = XPathBuilder()\\n # braces not needed\\n xp = xpb.foo & (xpb.bar.foo).parenthesize() | xpb.foobar\\n exp = '/foo and (/bar/foo) or /foobar'\\n self.assertEqual(xp.tostring(), exp)\",\n \"def test_dummy6(self):\\n xpb = XPathBuilder()\\n xp = xpb.dummy()\\n xp = xpb.bar | xp\\n exp = '/bar'\\n self.assertEqual(xp.tostring(), exp)\",\n \"def test_create_labels(self):\\n test_labels = {\\\"app\\\": \\\"my_app\\\", \\\"host\\\": \\\"examplehost\\\"}\\n labels = pmp.utils.create_labels(test_labels)\\n self.assertIsInstance(labels, list)\\n self.assertTrue(all([isinstance(x, pmp.LabelPair) for x in labels]))\",\n \"def test_xdist_and_select_test_by_bdd_label(xdist_runner: AllurePytestRunner):\\n\\n output = xdist_runner.run_docstring(\\\"-v\\\", \\\"--allure-features=boo\\\", \\\"-n1\\\")\\n\\n assert_that(output, has_only_testcases(\\n has_entry(\\n \\\"fullName\\\",\\n ends_with(\\\"test_with_feature_boo\\\")\\n )\\n ))\",\n \"def test_nested_condition() -> None:\\n\\n @argcomb(Or(And(\\\"a\\\", \\\"b\\\"), And(\\\"c\\\", \\\"d\\\")))\\n def f(a: Any = None, b: Any = None, c: Any = None, d: Any = None) -> None:\\n ...\\n\\n # valid\\n f(a=1, b=1)\\n f(c=1, d=1)\\n f(a=1, b=1, c=1, d=1)\\n\\n # invalid\\n with pytest.raises(InvalidArgumentCombination):\\n f(a=1)\\n with pytest.raises(InvalidArgumentCombination):\\n f(a=1, c=1)\\n with pytest.raises(InvalidArgumentCombination):\\n f()\",\n \"def test_abbreviation(self):\\n self.assertEqual(self.compound.abbreviation, \\\"Cool\\\")\",\n \"def test_general_subset_all():\\n pass\",\n \"def test_check_tree_exact_match(self):\\r\\n\\r\\n fasta_labels = ['seq1_1', 'seq1_2', 'seq2_3', 'seq3_4']\\r\\n\\r\\n actual_subset_results = check_tree_exact_match(fasta_labels,\\r\\n self.sample_tree_3tips_fp)\\r\\n\\r\\n # Should find all and give True, True result\\r\\n\\r\\n self.assertEqual(actual_subset_results, [True, True])\\r\\n\\r\\n # Should get tips not found in fasta labels with 5 tip tree\\r\\n\\r\\n fasta_labels = ['seq1_1', 'seq1_2', 'seq2_3', 'seq3_4']\\r\\n\\r\\n actual_subset_results = check_tree_exact_match(fasta_labels,\\r\\n self.sample_tree_5tips_fp)\\r\\n\\r\\n # Should find all and give True result\\r\\n\\r\\n self.assertEqual(actual_subset_results, [True, ['seq5', 'seq4']])\\r\\n\\r\\n # Change two of the fasta labels to not match tree tips\\r\\n\\r\\n fasta_labels = ['seq1_1', 'seqX_2', 'seq2_3', 'seqY_4']\\r\\n\\r\\n actual_subset_results = check_tree_exact_match(fasta_labels,\\r\\n self.sample_tree_5tips_fp)\\r\\n\\r\\n # Should find seqX and seqY as not being a subset\\r\\n\\r\\n self.assertEqual(actual_subset_results, [['seqX', 'seqY'],\\r\\n ['seq3', 'seq5', 'seq4']])\",\n \"def test_03_visit_special(self):\",\n \"def test_labels(ruler: SpaczzRuler) -> None:\\n assert all(\\n [label in ruler.labels for label in [\\\"GPE\\\", \\\"STREET\\\", \\\"DRUG\\\", \\\"NAME\\\", \\\"BAND\\\"]]\\n )\\n assert len(ruler.labels) == 5\",\n \"def test_createSubLinkographWithoutCommands(self):\\n self.performTestForParams()\",\n \"def test_first_level_from_bids_several_labels_per_entity(tmp_path, entity):\\n n_sub = 1\\n n_ses = 1\\n tasks = [\\\"main\\\"]\\n n_runs = [1]\\n\\n bids_path = create_fake_bids_dataset(\\n base_dir=tmp_path,\\n n_sub=n_sub,\\n n_ses=n_ses,\\n tasks=tasks,\\n n_runs=n_runs,\\n entities={entity: [\\\"A\\\", \\\"B\\\"]},\\n )\\n\\n models, m_imgs, m_events, m_confounds = first_level_from_bids(\\n dataset_path=bids_path,\\n task_label=\\\"main\\\",\\n space_label=\\\"MNI\\\",\\n img_filters=[(\\\"desc\\\", \\\"preproc\\\"), (entity, \\\"A\\\")],\\n slice_time_ref=None,\\n )\\n\\n _check_output_first_level_from_bids(n_sub,\\n models,\\n m_imgs,\\n m_events,\\n m_confounds)\\n n_imgs_expected = n_ses * n_runs[0]\\n assert len(m_imgs[0]) == n_imgs_expected\",\n \"def test_setter_child_list_tuple(self):\\n root = netapp_api.NaElement('root')\\n root['l'] = ['l1', 'l2']\\n root['t'] = ('t1', 't2')\\n l = root.get_child_by_name('l')\\n self.assertIsInstance(l, netapp_api.NaElement)\\n t = root.get_child_by_name('t')\\n self.assertIsInstance(t, netapp_api.NaElement)\\n for le in l.get_children():\\n self.assertIn(le.get_name(), ['l1', 'l2'])\\n for te in t.get_children():\\n self.assertIn(te.get_name(), ['t1', 't2'])\",\n \"def test_tree_support(self):\\r\\n master_tree = parse_newick('((a:2,b:3)ab:2,(c:1,d:2)cd:7)rt;')\\r\\n \\\"\\\"\\\"\\r\\n /-------.5 /-a\\r\\n ---1| \\\\-b\\r\\n \\\\------.5 /-c\\r\\n \\\\-d\\r\\n \\\"\\\"\\\"\\r\\n t2 = parse_newick('((a:2,b:3,c:33)ho:2,d:7);') # abc are siblings\\r\\n\\r\\n tc.tree_support(master_tree, t2)\\r\\n assert_almost_equal(\\r\\n master_tree.getNodeMatchingName('rt').bootstrap_support, 1.0)\",\n \"def test_labels(self):\\n return self._test_labels\",\n \"def test_issue_edit_label(self):\\n pass\",\n \"def test_dbpa002_radio_items(dash_duo):\\n app = Dash()\\n\\n options = {\\n \\\"OptionA\\\": \\\"Option 1\\\",\\n \\\"OptionB\\\": \\\"Option 2\\\",\\n \\\"OptionC\\\": \\\"Option 3\\\",\\n }\\n\\n value = \\\"OptionB\\\"\\n\\n with_keywords = RadioItems(\\n options=options,\\n value=value,\\n id=\\\"with-keywords\\\",\\n )\\n without_keywords = RadioItems(options, value, id=\\\"without-keywords\\\")\\n\\n app.layout = html.Div([with_keywords, without_keywords])\\n\\n dash_duo.start_server(app)\\n\\n # Check values\\n assert [\\n a.get_attribute(\\\"value\\\")\\n for a in dash_duo.wait_for_element(\\n \\\"#with-keywords\\\"\\n ).find_elements_by_tag_name(\\\"input\\\")\\n ] == [\\n a.get_attribute(\\\"value\\\")\\n for a in dash_duo.wait_for_element(\\n \\\"#without-keywords\\\"\\n ).find_elements_by_tag_name(\\\"input\\\")\\n ]\\n\\n # Check labels\\n assert [\\n a.text\\n for a in dash_duo.wait_for_element(\\n \\\"#with-keywords\\\"\\n ).find_elements_by_tag_name(\\\"label\\\")\\n ] == [\\n a.text\\n for a in dash_duo.wait_for_element(\\n \\\"#without-keywords\\\"\\n ).find_elements_by_tag_name(\\\"label\\\")\\n ]\",\n \"def test(self):\\n for doc, label in zip(self.test_docs(), self.test_labels()):\\n yield doc, label\",\n \"def test_get_parent_type_name(self):\\n pass\",\n \"def test_pathop8(self):\\n xpb = XPathBuilder()\\n xp = (xpb.foo.bar | xpb.foobar).parenthesize() & xpb.action.source\\n exp = '(/foo/bar or /foobar) and /action/source'\\n self.assertEqual(xp.tostring(), exp)\",\n \"def test_setter_child_list_tuple(self):\\n root = netapp_api.NaElement('root')\\n root['l'] = ['l1', 'l2']\\n root['t'] = ('t1', 't2')\\n l_element = root.get_child_by_name('l')\\n self.assertIsInstance(l_element, netapp_api.NaElement)\\n t = root.get_child_by_name('t')\\n self.assertIsInstance(t, netapp_api.NaElement)\\n for le in l_element.get_children():\\n self.assertIn(le.get_name(), ['l1', 'l2'])\\n for te in t.get_children():\\n self.assertIn(te.get_name(), ['t1', 't2'])\",\n \"def __init__(self, root_node, label1, label2):\\n super().__init__(self.PROBLEM_NAME)\\n self.root_node = root_node\\n self.label1 = label1\\n self.label2 = label2\",\n \"def test_radioselect_field():\",\n \"def test_label_callback():\\n release_numbers = dict(a='123')\\n data = dict(revision='a', attributes=dict(b='c'))\\n data2 = dict(revision='b', attributes=dict(d='e'))\\n\\n assert _label_callback(data, release_numbers) == u'a\\\\n- Release: 123\\\\n- b: c'\\n assert _label_callback(data2) == u'b\\\\n- Release: Unknown\\\\n- d: e'\",\n \"def _make_simple_partition_label(chain_dict):\\n\\n cps = chain_dict['chainParts']\\n if not (_select_simple_chainparts(cps)):\\n raise NotImplementedError(\\n 'chain fails substring selection: not \\\"simple\\\": %s' % (\\n chain_dict['chainName']))\\n \\n label = 'simplepartition(['\\n for cp in cps:\\n smcstr = str(cp['smc'])\\n if smcstr == 'nosmc':\\n smcstr = ''\\n for i in range(int(cp['multiplicity'])):\\n # condition_str = '(%set,%s,%s)' % (str(cp['threshold']),\\n # str(cp['etaRange']),\\n # smcstr,)\\n condition_str = '(%set,%s' % (str(cp['threshold']),\\n str(cp['etaRange']),)\\n if smcstr:\\n condition_str += ',%s)'\\n else:\\n condition_str += ')'\\n label += condition_str\\n label += '])'\\n return label\",\n \"def test_case1(self):\\n\\n graph = BipartiteGraph()\\n\\n graph.addEdge(\\\"supervisor1\\\",\\\"student1\\\")\\n\\n val1 = graph.getStudents(\\\"supervisor1\\\")\\n val2 = graph.getSupervisors(\\\"student1\\\")\\n\\n expected1 = [\\\"student1\\\"]\\n expected2 = [\\\"supervisor1\\\"]\\n\\n self.assertEqual((val1,val2),(expected1,expected2))\",\n \"def test_with_multiple_descriptions():\\n soup = generate_case(\\\"with_descriptions\\\")\\n\\n tests.html_schema_doc_asserts.assert_descriptions(\\n soup,\\n [\\n \\\"Exact address\\\",\\n \\\"Exact address\\\",\\n \\\"Delivery info depending on the delivery type\\\",\\n \\\"The delivery is a gift, no prices displayed\\\",\\n ],\\n )\",\n \"def test_BuildModel2(self):\\n print(\\\"\\\\nTest 6: Building a Model with Concat\\\")\\n builder = StaticBuilder(\\\"Concat\\\")\\n in1 = builder.addInput(10)\\n in2 = builder.addInput(20)\\n enc1 = builder.addInner(3, num_islots=2)\\n out1 = builder.addOutput()\\n\\n builder.addDirectedLink(in1, enc1, islot=0)\\n builder.addDirectedLink(in2, enc1, islot=1)\\n builder.addDirectedLink(enc1, out1)\\n \\n builder.build()\",\n \"def test_multiple_label_traversals(self):\\r\\n TestEdge.create(self.v1, self.v2)\\r\\n OtherTestEdge.create(self.v1, self.v3)\\r\\n YetAnotherTestEdge.create(self.v1, self.v4)\\r\\n\\r\\n assert len(self.v1.outV()) == 3\\r\\n\\r\\n assert len(self.v1.outV(TestEdge)) == 1\\r\\n assert len(self.v1.outV(OtherTestEdge)) == 1\\r\\n assert len(self.v1.outV(YetAnotherTestEdge)) == 1\\r\\n\\r\\n out = self.v1.outV(TestEdge, OtherTestEdge)\\r\\n assert len(out) == 2\\r\\n assert self.v2.vid in [v.vid for v in out]\\r\\n assert self.v3.vid in [v.vid for v in out]\\r\\n\\r\\n out = self.v1.outV(OtherTestEdge, YetAnotherTestEdge)\\r\\n assert len(out) == 2\\r\\n assert self.v3.vid in [v.vid for v in out]\\r\\n assert self.v4.vid in [v.vid for v in out]\",\n \"def test_label_10_targets_with_a_b_c_false(self):\\r\\n user_input = '[{\\\"a\\\":\\\"target1\\\"}, \\\\\\r\\n {\\\"b\\\":\\\"target2\\\"},{\\\"c\\\":\\\"target3\\\"},{\\\"a\\\":\\\"target4\\\"},{\\\"b\\\":\\\"target5\\\"}, \\\\\\r\\n {\\\"c\\\":\\\"target6\\\"}, {\\\"a\\\":\\\"target7\\\"},{\\\"b\\\":\\\"target8\\\"},{\\\"c\\\":\\\"target9\\\"}, \\\\\\r\\n {\\\"a\\\":\\\"target1\\\"}]'\\r\\n correct_answer = [\\r\\n {\\r\\n 'draggables': ['a'],\\r\\n 'targets': ['target1', 'target4', 'target7', 'target10'],\\r\\n 'rule': 'unordered_equal'\\r\\n },\\r\\n {\\r\\n 'draggables': ['b'],\\r\\n 'targets': ['target2', 'target5', 'target8'],\\r\\n 'rule': 'unordered_equal'\\r\\n },\\r\\n {\\r\\n 'draggables': ['c'],\\r\\n 'targets': ['target3', 'target6', 'target9'],\\r\\n 'rule': 'unordered_equal'\\r\\n }\\r\\n ]\\r\\n self.assertFalse(draganddrop.grade(user_input, correct_answer))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6972838","0.6137433","0.60195917","0.5986544","0.5936767","0.58589","0.5759686","0.56950617","0.5624841","0.55902916","0.55750483","0.5560212","0.5554626","0.55542696","0.5553175","0.5553175","0.55467266","0.5503819","0.5457172","0.5451371","0.54313546","0.53999746","0.5376586","0.5375577","0.5364844","0.5359766","0.535864","0.5338235","0.53258616","0.53186446","0.5317656","0.5315998","0.5315065","0.528178","0.5272056","0.5271867","0.5262255","0.5256516","0.5254785","0.5251119","0.5245671","0.52348095","0.5232146","0.5209617","0.520278","0.52023655","0.51976585","0.51973414","0.5193984","0.5191381","0.51910853","0.5168662","0.51612574","0.5156716","0.5155904","0.5155904","0.5155904","0.515586","0.51550406","0.51405126","0.51366323","0.5126447","0.51249856","0.5119241","0.5116798","0.5115688","0.5107617","0.510387","0.5094173","0.5092521","0.5089139","0.50838256","0.5078707","0.5075308","0.50716203","0.5061532","0.5061452","0.50607544","0.50605214","0.50554216","0.50476885","0.5047116","0.50363714","0.5028754","0.5026291","0.5024467","0.50243545","0.5023076","0.50198036","0.5014891","0.5011064","0.5007032","0.50008494","0.49937844","0.49911672","0.49879867","0.49861643","0.49833554","0.49800858","0.49767923"],"string":"[\n \"0.6972838\",\n \"0.6137433\",\n \"0.60195917\",\n \"0.5986544\",\n \"0.5936767\",\n \"0.58589\",\n \"0.5759686\",\n \"0.56950617\",\n \"0.5624841\",\n \"0.55902916\",\n \"0.55750483\",\n \"0.5560212\",\n \"0.5554626\",\n \"0.55542696\",\n \"0.5553175\",\n \"0.5553175\",\n \"0.55467266\",\n \"0.5503819\",\n \"0.5457172\",\n \"0.5451371\",\n \"0.54313546\",\n \"0.53999746\",\n \"0.5376586\",\n \"0.5375577\",\n \"0.5364844\",\n \"0.5359766\",\n \"0.535864\",\n \"0.5338235\",\n \"0.53258616\",\n \"0.53186446\",\n \"0.5317656\",\n \"0.5315998\",\n \"0.5315065\",\n \"0.528178\",\n \"0.5272056\",\n \"0.5271867\",\n \"0.5262255\",\n \"0.5256516\",\n \"0.5254785\",\n \"0.5251119\",\n \"0.5245671\",\n \"0.52348095\",\n \"0.5232146\",\n \"0.5209617\",\n \"0.520278\",\n \"0.52023655\",\n \"0.51976585\",\n \"0.51973414\",\n \"0.5193984\",\n \"0.5191381\",\n \"0.51910853\",\n \"0.5168662\",\n \"0.51612574\",\n \"0.5156716\",\n \"0.5155904\",\n \"0.5155904\",\n \"0.5155904\",\n \"0.515586\",\n \"0.51550406\",\n \"0.51405126\",\n \"0.51366323\",\n \"0.5126447\",\n \"0.51249856\",\n \"0.5119241\",\n \"0.5116798\",\n \"0.5115688\",\n \"0.5107617\",\n \"0.510387\",\n \"0.5094173\",\n \"0.5092521\",\n \"0.5089139\",\n \"0.50838256\",\n \"0.5078707\",\n \"0.5075308\",\n \"0.50716203\",\n \"0.5061532\",\n \"0.5061452\",\n \"0.50607544\",\n \"0.50605214\",\n \"0.50554216\",\n \"0.50476885\",\n \"0.5047116\",\n \"0.50363714\",\n \"0.5028754\",\n \"0.5026291\",\n \"0.5024467\",\n \"0.50243545\",\n \"0.5023076\",\n \"0.50198036\",\n \"0.5014891\",\n \"0.5011064\",\n \"0.5007032\",\n \"0.50008494\",\n \"0.49937844\",\n \"0.49911672\",\n \"0.49879867\",\n \"0.49861643\",\n \"0.49833554\",\n \"0.49800858\",\n \"0.49767923\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6108757"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":8792,"cells":{"query":{"kind":"string","value":"Entry point to this Module. Return a chain label according to the value of cp['hypoScenario'], where cp is an element of list/ chainDict['chainPart']"},"document":{"kind":"string","value":"def chainDict2jetLabel(chain_dict):\n\n # suported scenarios \n router = {\n 'simple': _make_simple_label,\n 'HT': _make_ht_label,\n 'vbenf': _make_vbenf_label,\n 'dijet': _make_dijet_label,\n 'combinationsTest': _make_combinationsTest_label,\n 'partitionsTest': _make_partitionsTest_label,\n }\n\n # chain_part - scenario association\n cp_sorter = {}\n for k in router: cp_sorter[k] = []\n\n for cp in chain_dict['chainParts']:\n if cp['signature'] != 'Jet' and cp['signature'] != 'Bjet': \n continue\n for k in cp_sorter:\n if cp['hypoScenario'].startswith(k):\n cp_sorter[k].append(cp)\n break\n\n # obtain labels by scenario.\n labels = []\n for k, chain_parts in cp_sorter.items():\n if chain_parts: labels.append(router[k](chain_parts))\n\n assert labels\n nlabels = len(labels)\n if nlabels == 1: return labels[0]\n if nlabels == 2:\n alabel = \"\"\"\\\nand([]\n %s\n %s)\"\"\" % (tuple(labels))\n return alabel\n\n # more than 2 labels is not expected\n assert False"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _make_ht_label(chain_parts):\n\n assert len(chain_parts) == 1, '_make_ht_label, no. of chain parts != 1'\n scenario = chain_parts[0]['hypoScenario']\n \n assert scenario.startswith('HT'), '_make_ht_label(): scenario does not start with HT'\n\n arg_res = [\n re.compile(r'^(?P<lo>\\d*)(?P<key>ht)(?P<hi>\\d*)$'),\n re.compile(r'^(?P<lo>\\d*)(?P<key>et)(?P<hi>\\d*)$'),\n re.compile(r'^(?P<lo>\\d*)(?P<key>eta)(?P<hi>\\d*)$'),\n ]\n\n defaults = {\n 'ht': ('0', 'inf'),\n 'et': ('0', 'inf'),\n 'eta': ('0', 'inf'),\n }\n\n\n args = _args_from_scenario(scenario)\n argvals = {}\n nargs = len(args)\n assert len(args) <= len(arg_res), 'bad num of args %d, expected < %d' % (len(args),\n len(arg_res))\n\n # obtain argument values frrom scenario\n while args:\n arg = args.pop()\n for r in arg_res:\n m = r.match(arg)\n if m is not None:\n arg_res.remove(r)\n gd = m.groupdict()\n key = gd['key']\n\n try:\n lo = float(gd['lo'])\n except ValueError:\n lo = float(defaults[key][0])\n argvals[key+'lo'] = lo \n try:\n hi = float(gd['hi'])\n except ValueError:\n hi = float(defaults[key][1])\n argvals[key+'hi'] = hi\n\n print (argvals)\n assert len(argvals) == 2*nargs, 'no of args: %d, expected %d' % (len(argvals), 2*nargs)\n\n print ('sent 100')\n result = \"\"\"\n ht([(%(htlo).0fht) \n (%(etlo).0fet)\n (%(etalo).0feta%(etahi).0f)\n ])\"\"\" % argvals\n print (result)\n return result","def _make_combinationsTest_label(chain_parts):\n\n assert len(chain_parts) == 1\n scenario = chain_parts[0]['hypoScenario']\n \n assert scenario == 'combinationsTest'\n\n \n\n return \"\"\"\n combgen(\n [(2)(20et, 0eta320)]\n \n simple([(40et, 0eta320) (50et, 0eta320)])\n simple([(35et, 0eta240) (55et, 0eta240)])\n )\"\"\"","def _make_simple_comb_label(chain_dict):\n\n cps = chain_dict['chainParts']\n if not (_select_simple_chainparts(cps)):\n raise NotImplementedError(\n 'chain fails substring selection: not \"simple\": %s' % (\n chain_dict['chainName']))\n \n simple_strs = []\n\n for cp in cps:\n print(cp)\n simple_strs.append(_make_simple_label([cp]))\n\n label = 'combgen([(%d)]' % len(cps)\n for s in simple_strs:\n label += ' %s ' % s\n label += ')'\n return label","def _make_simple_label(chain_parts):\n \n if not _select_simple_chainparts(chain_parts):\n msg = 'Jet Configuration error: '\\\n 'chain fails substring selection: not \"simple\" '\n\n raise NotImplementedError(msg)\n \n label = 'simple(['\n for cp in chain_parts:\n smcstr = str(cp['smc'])\n jvtstr = str(cp['jvt'])\n if smcstr == 'nosmc':\n smcstr = ''\n for i in range(int(cp['multiplicity'])):\n # condition_str = '(%set,%s,%s)' % (str(cp['threshold']),\n # str(cp['etaRange']),\n # smcstr,)\n condition_str = '(%set,%s' % (str(cp['threshold']),\n str(cp['etaRange']),)\n if smcstr: # Run 2 chains have \"INF\" in the SMC substring\n condition_str += ',%s)' % smcstr.replace('INF','')\n elif jvtstr:\n condition_str += ',%s)' % jvtstr\n else:\n condition_str += ')'\n label += condition_str\n label += '])'\n return label","def _make_simple_partition_label(chain_dict):\n\n cps = chain_dict['chainParts']\n if not (_select_simple_chainparts(cps)):\n raise NotImplementedError(\n 'chain fails substring selection: not \"simple\": %s' % (\n chain_dict['chainName']))\n \n label = 'simplepartition(['\n for cp in cps:\n smcstr = str(cp['smc'])\n if smcstr == 'nosmc':\n smcstr = ''\n for i in range(int(cp['multiplicity'])):\n # condition_str = '(%set,%s,%s)' % (str(cp['threshold']),\n # str(cp['etaRange']),\n # smcstr,)\n condition_str = '(%set,%s' % (str(cp['threshold']),\n str(cp['etaRange']),)\n if smcstr:\n condition_str += ',%s)'\n else:\n condition_str += ')'\n label += condition_str\n label += '])'\n return label","def _make_partitionsTest_label(chain_parts):\n\n assert len(chain_parts) == 1\n scenario = chain_parts[0]['hypoScenario']\n \n assert scenario == 'partitionsTest'\n\n \n\n return \"\"\"\n partgen(\n [(20et, 0eta320)]\n \n simple([(40et, 0eta320) (50et, 0eta320)])\n simple([(35et, 0eta240) (55et, 0eta240)])\n )\"\"\"","def _make_dijet_label(chain_parts):\n\n assert len(chain_parts) == 1\n scenario = chain_parts[0]['hypoScenario']\n \n assert scenario.startswith('dijet')\n\n arg_res = [\n re.compile(r'^(?P<lo>\\d*)(?P<key>djmass)(?P<hi>\\d*)$'),\n re.compile(r'^(?P<lo>\\d*)(?P<key>j1et)(?P<hi>\\d*)$'),\n re.compile(r'^(?P<lo>\\d*)(?P<key>j1eta)(?P<hi>\\d*)$'),\n re.compile(r'^(?P<lo>\\d*)(?P<key>j2et)(?P<hi>\\d*)$'),\n re.compile(r'^(?P<lo>\\d*)(?P<key>j2eta)(?P<hi>\\d*)$'),\n ]\n\n defaults = {\n 'j1et': ('100', 'inf'),\n 'j2et': ('100', 'inf'),\n 'j1eta': ('0', '320'),\n 'j2eta': ('0', '320'),\n 'djmass': ('1000', 'inf'),\n }\n\n\n args = _args_from_scenario(scenario)\n argvals = {}\n while args:\n assert len(args) == len(arg_res)\n arg = args.pop()\n for r in arg_res:\n m = r.match(arg)\n if m is not None:\n arg_res.remove(r)\n gd = m.groupdict()\n key = gd['key']\n\n try:\n lo = float(gd['lo'])\n except ValueError:\n lo = defaults[key][0]\n argvals[key+'lo'] = lo \n try:\n hi = float(gd['hi'])\n except ValueError:\n hi = defaults[key][1]\n argvals[key+'hi'] = hi\n\n assert len(args) == len(arg_res)\n assert len(args) == 0\n\n return \"\"\"\n combgen(\n [(2)(%(j1etlo).0fet, %(j1etalo).0feta%(j1etahi).0f)\n (%(j1etlo).0fet, %(j1etalo).0feta%(j1etahi).0f)\n ]\n \n dijet(\n [(%(djmasslo).0fdjmass)])\n simple([(%(j1etlo).0fet, %(j1etalo).0feta%(j1etahi).0f)\n (%(j2etlo).0fet, %(j2etalo).0feta%(j2etahi).0f)])\n )\"\"\" % argvals","def get_label(self, hierarchy: List[str]) -> Any:","def _make_vbenf_label(chain_parts):\n\n # toy label for development: run simple and dijet independently.\n # simple makes Et cuts on two jets. Independently (sharing possible)\n # of jets choosean by simple, the dijet\n # scenario requires a dijet of mass > 900, and opening angle in phi > 2.6\n\n assert len(chain_parts) == 1\n scenario = chain_parts[0]['hypoScenario']\n assert scenario.startswith('vbenf')\n args = _args_from_scenario(scenario)\n if not args:\n return 'and([]simple([(50et)(70et)])combgen([(2)] dijet([(900djmass, 26djdphi)])))' \n arg_res = [\n re.compile(r'(?P<lo>\\d*)(?P<key>fbet)(?P<hi>\\d*)'),\n re.compile(r'(?P<lo>\\d*)(?P<key>mass)(?P<hi>\\d*)'),\n re.compile(r'(?P<lo>\\d*)(?P<key>et)(?P<hi>\\d*)'),\n ]\n\n defaults = {\n 'et': ('101', 'inf'),\n 'mass': ('800', 'inf'),\n 'fbet': ('501', 'inf'),\n }\n\n argvals = {}\n while args:\n assert len(args) == len(arg_res)\n arg = args.pop()\n for r in arg_res:\n m = r.match(arg)\n if m is not None:\n arg_res.remove(r)\n gd = m.groupdict()\n key = gd['key']\n try:\n lo = float(gd['lo'])\n except ValueError:\n lo = defaults[key][0]\n argvals[key+'lo'] = lo \n try:\n hi = float(gd['hi'])\n except ValueError:\n hi = defaults[key][1]\n argvals[key+'hi'] = hi\n\n assert len(args) == len(arg_res)\n assert len(args) == 0\n\n return \"\"\"\n and\n (\n []\n simple\n (\n [(%(etlo).0fet, 500neta)(%(etlo).0fet, peta500)]\n )\n combgen\n (\n [(10et, 0eta320)]\n dijet\n (\n [(%(masslo).0fdjmass, 26djdphi)]\n ) \n simple\n (\n [(10et, 0eta320)(20et, 0eta320)]\n )\n )\n )\"\"\" % argvals","def chain():\n chain_identifier, url = get_vars(request, [\"id\", \"data\"])\n info('chain=%s' % chain_identifier)\n chain = LAPPS_SERVICE_CHAINS.get_chain(chain_identifier)\n info('source-url=%s' % url)\n data = requests.get(url).text\n result = chain.run({\n \"discriminator\": \"http://vocab.lappsgrid.org/ns/media/text\", \n \"payload\": data})\n info(\"discriminator=%s\" % result.get('discriminator'))\n return render_template(\"chain.html\",\n chain=chain,\n fname=url,\n result=result,\n builder=HtmlBuilder())","def chain_name(self) -> str:\n return pulumi.get(self, \"chain_name\")","def _get_label(self):\n if self.model.name == '':\n return \"KPI\"\n return \"KPI: {} ({})\".format(self.model.name, self.model.objective)","def get_extra_label(self, label_name: str, hierarchy: List[str]) -> Any:","def chainLabel(self,i):\n assert(i >= 0 and i < self.nAtoms())\n assert(self._c_structure is not NULL)\n cdef char label[2]\n label[0] = freesasa_structure_atom_chain(self._c_structure,i)\n label[1] = '\\0'\n return label","def __init__(self, **kwargs):\n\n polymer_type = \"PE\"\n helice = Helice()\n num_monomers = 30\n tacticity = \"\"\n chiriality = \"\"\n head_tail_defect_ratio = 0\n configs = 30\n infinite = False\n\n for key in kwargs:\n if key == \"polymer_type\":\n polymer_type = kwargs[\"polymer_type\"]\n elif key == \"helice\":\n helice = kwargs[\"helice\"]\n elif key == \"num_monomers\":\n num_monomers = kwargs[\"num_monomers\"]\n if is_integer_num(num_monomers):\n if num_monomers < 1:\n raise ValueError(\n \"Number of monomers should be equal or larger than 1\"\n )\n else:\n raise ValueError(\"Number of monomers should be an integer\")\n elif key == \"tacticity\":\n tacticity = kwargs[\"tacticity\"]\n elif key == \"chiriality\":\n chiriality = kwargs[\"chiriality\"]\n elif key == \"head_tail_defect_ratio\":\n head_tail_defect_ratio = kwargs[\"head_tail_defect_ratio\"]\n elif key == \"configs\":\n configs = kwargs[\"configs\"]\n elif key == \"infinite\":\n infinite = kwargs[\"infinite\"]\n else:\n raise KeyError(\n \"Unknown input %s for Chain class\\n Please see help for more information\"\n % key\n )\n\n if polymer_type not in polymer_types:\n raise ValueError(\n polymer_type\n + \" do not exist in our library, please consider using custom feature\"\n )\n self.polymer_type = polymer_types[polymer_type]\n\n if self.polymer_type.helicity:\n self.custom = 0\n else:\n self.custom = 1\n\n if self.custom:\n print(\"Warning: Custom type, only read helice motifs and turns info\")\n self.helice = helice\n\n if not 0 <= (head_tail_defect_ratio) <= 1:\n raise ValueError(\n \"Defect ratio of head to head and tail to tail connections is\",\n head_tail_defect_ratio,\n \"and should be in the range of [0,1]\",\n )\n self.head_tail_defect_ratio = head_tail_defect_ratio\n\n self.unit_num_monomers = 1\n if \"num_monomers\" not in kwargs:\n if infinite:\n num_monomers = 2\n else:\n num_monomers = 1\n\n self.num_monomers = num_monomers\n\n self.tacticity = tacticity\n if self.tacticity:\n if self.tacticity == \"N/A\":\n self.tacticity = \"\"\n else:\n print(\"Warning: Custom type does not have tacticity\")\n self.tacticity = \"\"\n\n self.chiriality = chiriality\n if self.chiriality:\n if self.chiriality == \"N/A\":\n self.chiriality = \"\"\n else:\n print(\"Warning: Custom type does not have chiriality\")\n self.chiriality = \"\"\n\n self.infinite = infinite\n\n else:\n monomer_backbone_atoms = len(self.polymer_type.backbone_atoms)\n\n if helice.atoms % monomer_backbone_atoms:\n raise Exception(\n \"Number of backbone atoms in a motif must be multiple of number of monomer backbone atoms %d\\n\"\n % monomer_backbone_atoms\n )\n if tacticity == \"syndiotactic\":\n multiple = int(monomer_backbone_atoms * 2 / helice.atoms)\n if (multiple * helice.atoms) % (monomer_backbone_atoms * 2):\n raise Exception(\n \"Number of backbone atoms in a motif for syndiotactic configuration must be multiple of twice of \\\n the number of monomer backbone atoms %d\\n\"\n % monomer_backbone_atoms\n * 2\n )\n elif multiple != 1:\n print(\n \"Number of backbone atoms in a motif for syndiotactic configuration should be multiple of twice \\\n of the number of monomer backbone atoms %d\\n\"\n % (monomer_backbone_atoms * 2)\n )\n print(\n \"Trying Helice_%d_%d_%d...\"\n % (\n helice.atoms * multiple,\n helice.motifs,\n helice.turns * multiple,\n )\n )\n helice = Helice(\n helice.atoms * multiple, helice.motifs, helice.turns * multiple\n )\n # else:\n # if monomer_backbone_atoms != helice.atoms:\n # raise ValueError(\"Number of backbone atoms in a motif must be %d\" % helice.atoms)\n helice_backbone_atoms = helice.atoms * helice.motifs\n self.helice = helice\n\n if not 0 <= (head_tail_defect_ratio) <= 1:\n raise ValueError(\n \"Defect ratio of head to head and tail to tail connections is\",\n head_tail_defect_ratio,\n \"and should be in the range of [0,1]\",\n )\n self.head_tail_defect_ratio = head_tail_defect_ratio\n\n self.unit_num_monomers = int(helice_backbone_atoms / monomer_backbone_atoms)\n if \"num_monomers\" not in kwargs:\n if infinite:\n if tacticity == \"atactic\" or head_tail_defect_ratio:\n num_monomers = 10 * self.unit_num_monomers\n elif helice_backbone_atoms > 2:\n num_monomers = self.unit_num_monomers\n else:\n num_monomers = 2\n\n if num_monomers < self.unit_num_monomers:\n raise ValueError(\n \"Number of monomers should be equal or larger than %d in order to generate Helice_%s chain.\\nCurrent \\\n number of monomers is %d\"\n % (self.unit_num_monomers, helice, num_monomers)\n )\n\n if infinite:\n if num_monomers % self.unit_num_monomers:\n raise ValueError(\n \"Number of monomers should be multiple of %d in order to generate infinite periodic Helice_%s \\\n chain.\\nCurrent number of monomers is %d\"\n % (self.unit_num_monomers, helice, num_monomers)\n )\n elif num_monomers * monomer_backbone_atoms < 3:\n raise ValueError(\n \"Number of backbone atoms should be more than 2 in order to create infinite periodic \\\n chain.\\nCurrent number of backbone atoms along the periodic chain is %d\\nPlease increate \\\n number of monomers.\"\n % (num_monomers * monomer_backbone_atoms)\n )\n self.num_monomers = num_monomers + 2 if infinite else num_monomers\n\n self.tacticity = tacticity\n if self.tacticity:\n if self.tacticity == \"N/A\":\n self.tacticity = \"\"\n elif self.tacticity not in [\"isotactic\", \"atactic\", \"syndiotactic\"]:\n raise TypeError(\n \"Unknown tacticity, please specify one of the following: isotactic, atactic and syndiotactic\"\n )\n elif not self.polymer_type.side_atom:\n raise ValueError(\"Please specify side_atom\")\n\n self.chiriality = chiriality\n if str(self.helice) in [\"2_1_1\", \"4_1_2\"]:\n self.torsion_seq = [180, 180, 180, 180]\n if self.chiriality:\n self.chiriality = \"\"\n print(\"Zig-zag conformation does not have chiriality\")\n elif str(self.helice) in [\"2_2_1\", \"4_2_2\"]:\n if self.chiriality == \"left\":\n self.torsion_seq = [300, 300, 300, 300]\n elif self.chiriality == \"right\":\n self.torsion_seq = [60, 60, 60, 60]\n else:\n raise ValueError(\"Please specify chiriality: left or right\")\n elif str(self.helice) in [\"2_3_1\", \"4_3_2\"]:\n if self.chiriality == \"left\":\n self.torsion_seq = [180, 300, 180, 300]\n elif self.chiriality == \"right\":\n self.torsion_seq = [60, 180, 60, 180]\n else:\n raise ValueError(\"Please specify chiriality: left or right\")\n elif str(self.helice) == \"4_1_1\":\n self.torsion_seq = [60, 180, 300, 180]\n if self.chiriality:\n self.chiriality = \"\"\n print(\"Helice_4_1_1 conformation does not have chiriality\")\n elif str(self.helice) == \"4_2_1\":\n if self.chiriality == \"left\":\n self.torsion_seq = [180, 180, 300, 300]\n elif self.chiriality == \"right\":\n self.torsion_seq = [60, 60, 180, 180]\n else:\n raise ValueError(\"Please specify chiriality: left or right\")\n elif str(self.helice) == \"4_3_1\":\n if self.chiriality == \"left\":\n if self.helice.sub_type:\n self.torsion_seq = [180, 300, 300, 300]\n else:\n self.torsion_seq = [180, 180, 180, 300]\n elif self.chiriality == \"right\":\n if self.helice.sub_type:\n self.torsion_seq = [60, 60, 60, 180]\n else:\n self.torsion_seq = [60, 180, 180, 180]\n else:\n raise ValueError(\"Please specify chiriality: left or right\")\n else:\n raise Exception(\"Helice_%s is currently not supported\" % self.helice)\n\n self.configs = configs\n self.infinite = infinite\n # self.pattern = 0\n self.monomers = []\n self.weights = {}","def describe(self):\n branch = randint(0,62)\n \n if 0 <= branch <= 29: \n if self.casteOrder[0] == 'soldiers':\n if self.genesis == 'escape persecution': \n self.description = '{2}: A full service {3} for retired {1}'.format(choice(self.__class__.badjectives), choice(self.__class__.soldierSynonyms), self.name, choice(self.__class__.settlements[self.tech])) \n elif self.genesis == 'maintain control': \n self.description = 'The penal mining colony for {0} {1} on {2}'.format(choice(self.__class__.badjectives), choice(self.__class__.casteSynonyms[self.casteOrder[5]]), self.name, choice(self.__class__.settlements[self.tech])) \n elif self.genesis == 'explore the unknown':\n self.description = 'The frontier garrison and {2} {0} recently conquered {1}'.format(choice(self.__class__.techPreps[self.tech]), self.name, choice(self.__class__.settlements[self.tech]))\n elif self.genesis == 'seed the galaxy with life':\n self.description = 'The militarized {3} and bonsai garden for the mandatory contemplation of {0} {1} {2}'.format(choice(self.__class__.seedIdeals), choice(self.__class__.techPreps[self.tech]), self.name, choice(self.__class__.settlements[self.tech]))\n elif self.genesis == 'spread the gospel':\n self.description = 'An outpost for crusaders who took up arms to defend {2} {3} on {0} {1}'.format(choice(self.__class__.techAdjectives[self.tech]), self.name, choice(self.__class__.badjectives), choice(self.__class__.priestSynonyms)) \n elif self.casteOrder[0] == 'scientists':\n if self.genesis == 'escape persecution': \n self.description = 'A sanctuary for {0} who challenged the dogma of powerful {1} {2} {3}'.format(choice(self.__class__.scientistSynonyms), choice(self.__class__.priestSynonyms), choice(self.__class__.techPreps[self.tech]), self.name) \n elif self.genesis == 'maintain control': \n self.description = '{0}, home to a coalition of {1} eugenicists and their {2} servants'.format(self.name, choice(self.__class__.scientistAdjectives), choice(self.__class__.casteAdjectives[self.casteOrder[5]]))\n elif self.genesis == 'explore the unknown':\n self.description = 'An Extremely Large Hadron Collider {0} {1} {2}'.format(choice(self.__class__.techPreps[self.tech]), choice(self.__class__.techAdjectives[self.tech]), self.name)\n elif self.genesis == 'seed the galaxy with life':\n self.description = 'The research institute and {2} for abiogenesis on {0} {1}'.format(choice(self.__class__.techAdjectives[self.tech]), self.name, choice(self.__class__.settlements[self.tech]))\n elif self.genesis == 'spread the gospel':\n self.description = 'The Galactic Academy of Sciences founded by {0} {1} {2} {3}'.format(choice(self.__class__.scientistAdjectives), choice(self.__class__.scientistSynonyms), choice(self.__class__.techPreps[self.tech]), self.name)\n elif self.casteOrder[0] == 'laborers':\n if self.genesis == 'escape persecution':\n self.description = 'The {0} for unionized {1} {2} {3}'.format(choice(self.__class__.settlements[self.tech]), choice(self.__class__.laborerSynonyms), choice(self.__class__.techPreps[self.tech]), self.name)\n elif self.genesis == 'maintain control':\n self.description = '{0} {1}: divisional headquarters for the communist party in this region of the galaxy (where evidence of {2} has been redacted)'.format(choice(self.__class__.techAdjectives[self.tech]).capitalize(), self.name, choice(self.__class__.controlIdeals))\n elif self.genesis == 'explore the unknown':\n self.description = 'A team of robot {0} sent to survey {1} {2}'.format(choice(self.__class__.laborerSynonyms), choice(self.__class__.techAdjectives[self.tech]), self.name)\n elif self.genesis == 'seed the galaxy with life':\n self.description = 'Drones sent to terraform {0} {1} and build {2}'.format(choice(self.__class__.techAdjectives[self.tech]), self.name, choice(self.__class__.seedPlaces))\n elif self.genesis == 'spread the gospel':\n self.description = 'The {0} {1} {2} where a hard day\\'s work is highly valued'.format(choice(self.__class__.settlements[self.tech]), choice(self.__class__.techPreps[self.tech]), self.name)\n elif self.casteOrder[0] == 'merchants':\n if self.genesis == 'escape persecution':\n self.description = '{0} {1}: a refuge for {2} who fled a communist revolution on their home planet'.format(choice(self.__class__.techAdjectives[self.tech]).capitalize(), self.name, choice(self.__class__.merchantSynonyms))\n elif self.genesis == 'maintain control':\n self.description = 'The monopolistic conglomerate of {0} {1} {2} {3}'.format(choice(self.__class__.merchantAdjectives), choice(self.__class__.merchantSynonyms), choice(self.__class__.techPreps[self.tech]), self.name)\n elif self.genesis == 'explore the unknown':\n self.description = '{3} {0}, home to a consortium of {1} seeking to monetize {2}'.format(self.name, choice(self.__class__.merchantSynonyms), choice(self.__class__.genesisIdeals[choice(self.__class__.genesisReasons)]), choice(self.__class__.techAdjectives[self.tech]).capitalize())\n elif self.genesis == 'seed the galaxy with life':\n self.description = 'An oligarchy of wealthy {0} who recently opened a for-profit {1} on {2}'.format(choice(self.__class__.merchantSynonyms), choice(self.__class__.settlements[self.tech]), self.name)\n elif self.genesis == 'spread the gospel':\n self.description = 'An orbital printing press that rains down copies of {0} onto {1} {2}'.format(choice(self.__class__.merchantBooks), choice(self.__class__.techAdjectives[self.tech]), self.name)\n elif self.casteOrder[0] == 'artists':\n if self.genesis == 'escape persecution':\n self.description = 'The {0}\\' commune for the free and naked expression of {1} {2} {3}'.format(choice(self.__class__.artistSynonyms), choice(self.__class__.escapeIdeals), choice(self.__class__.techPreps[self.tech]), self.name)\n elif self.genesis == 'maintain control':\n self.description = 'The {0} with mandatory art classes on {1} {2}'.format(choice(self.__class__.settlements[self.tech]), choice(self.__class__.techAdjectives[self.tech]), self.name)\n elif self.genesis == 'explore the unknown':\n self.description = '{0} {1}, an observation deck where {2} observe naked and confined {3} to better understand the mysteries of {4}'.format(choice(self.__class__.techPreps[self.tech]).capitalize(), self.name, choice(self.__class__.artistSynonyms), choice(self.__class__.casteSynonyms[self.casteOrder[5]]), choice(self.__class__.genesisIdeals[choice(self.__class__.genesisReasons)]))\n elif self.genesis == 'seed the galaxy with life':\n self.description = 'The {0} for {1} {2} who choose to better understand their craft through lovemaking on {3}'.format(choice(self.__class__.settlements[self.tech]), choice(self.__class__.seedAdjectives), choice(self.__class__.artistSynonyms), self.name)\n elif self.genesis == 'spread the gospel':\n self.description = 'A {0} on {1} that hosts an annual conference for pop {2}'.format(choice(self.__class__.settlements[self.tech]), self.name, choice(self.__class__.artistSynonyms))\n elif self.casteOrder[0] == 'priests':\n if self.genesis == 'escape persecution':\n self.description = '{3} {0}, home to an order of heretical {1} who reject the {2} doctrine of their people'.format(self.name, choice(self.__class__.priestSynonyms), choice(self.__class__.gospelAdjectives), choice(self.__class__.techAdjectives[self.tech]).capitalize())\n elif self.genesis == 'maintain control':\n self.description = 'The orthodox {0} for {1} {2} {3} {4}'.format(choice(self.__class__.gospelPlaces), choice(self.__class__.gospelAdjectives), choice(self.__class__.priestSynonyms), choice(self.__class__.techPreps[self.tech]), self.name)\n elif self.genesis == 'explore the unknown':\n self.description = '{0} {1}, a seminary for the metaphysical contemplation of {2}'.format(choice(self.__class__.techPreps[self.tech]).capitalize(), self.name, choice(self.__class__.gospelIdeals))\n elif self.genesis == 'seed the galaxy with life':\n self.description = 'The marriage counseling clinic and devotional {2} {0} {1}'.format(choice(self.__class__.techPreps[self.tech]), self.name, choice(self.__class__.settlements[self.tech])) \n elif self.genesis == 'spread the gospel':\n self.description = 'A {0} mission on {1} {2} for converting {3} natives'.format(choice(self.__class__.gospelAdjectives), choice(self.__class__.techAdjectives[self.tech]), self.name, choice(self.__class__.badjectives))\n \n elif 30 <= branch <= 44:\n if self.tech == 'pre-industrial technology':\n if self.genesis == 'explore the unknown':\n self.description = '{0}, home to a historical reenactment society of {2} {1}'.format(self.name, choice(self.__class__.casteSynonyms[self.casteOrder[0]]), choice(self.__class__.badjectives))\n elif self.genesis == 'escape persecution':\n self.description = '{1}: a {2} of {0} Luddites'.format(choice(self.__class__.casteAdjectives[self.casteOrder[0]]), self.name, choice(self.__class__.preindustrialSettlements))\n elif self.genesis == 'maintain control':\n self.description = 'The {0} fiefdoms of {1}, where {2} serve their {3} liege lord'.format(choice(self.__class__.preindustrialAdjectives), self.name, choice(self.__class__.casteSynonyms[self.casteOrder[5]]), choice(self.__class__.casteAdjectives[self.casteOrder[0]]))\n elif self.genesis == 'seed the galaxy with life':\n self.description = 'A harem of {0} {1} on medieval {2}'.format(choice(self.__class__.seedAdjectives), choice(self.__class__.casteSynonyms[self.casteOrder[0]]), self.name)\n elif self.genesis == 'spread the gospel':\n self.description = 'The Puritan {0} for evangelical {1} on {2}'.format(choice(self.__class__.preindustrialSettlements), choice(self.__class__.casteSynonyms[self.casteOrder[0]]), self.name)\n elif self.tech == 'machine technology':\n if self.genesis == 'explore the unknown':\n self.description = 'An array of radio telescopes outside the {0} on {1} {2}'.format(choice(self.__class__.machineSettlements), choice(self.__class__.machineAdjectives), self.name)\n elif self.genesis == 'escape persecution':\n self.description = 'Public housing for {0} {1} gentrified {2}'.format(choice(self.__class__.casteSynonyms[self.casteOrder[0]]), choice(self.__class__.machinePreps), self.name) \n elif self.genesis == 'maintain control':\n self.description = 'The juvenile detention center for {0} children who obsess over {1} on {2}'.format(choice(self.__class__.badjectives), choice(self.__class__.genesisIdeals[choice(self.__class__.genesisReasons)]), self.name)\n elif self.genesis == 'seed the galaxy with life':\n self.description = 'Just a giant cruise ship full of {0} {1} on {2}'.format(choice(self.__class__.seedAdjectives), choice(self.__class__.casteSynonyms[self.casteOrder[0]]), self.name)\n elif self.genesis == 'spread the gospel':\n self.description = 'A megachurch run by {0} {1}, broadcasting live from {2}'.format(choice(self.__class__.priestAdjectives), choice(self.__class__.casteSynonyms[self.casteOrder[0]]), self.name)\n elif self.tech == 'ubiquitous technology':\n if self.genesis == 'explore the unknown':\n self.description = 'A quantum data center for simulating the lives of {0} {1} {2} {3}'.format(choice(self.__class__.casteAdjectives[self.casteOrder[0]]), choice(self.__class__.casteSynonyms[choice(self.__class__.castes)]), choice(self.__class__.techPreps[self.tech]), self.name)\n elif self.genesis == 'escape persecution':\n self.description = 'The cryogenics facility for the preservation of {0} {1} {2} {3}'.format(choice(self.__class__.badjectives), choice(self.__class__.casteSynonyms[self.casteOrder[0]]), choice(self.__class__.techPreps[self.tech]), self.name)\n elif self.genesis == 'maintain control':\n self.description = 'Orbiting {0}: a socially stratified {1} governed by {2}'.format(self.name, choice(self.__class__.ubiqitousSettlements), choice(self.__class__.casteSynonyms[self.casteOrder[0]]))\n elif self.genesis == 'seed the galaxy with life':\n self.description = '{0} {1}, home to an assembly plant for android {2}'.format(choice(self.__class__.ubiqitousAdjectives).capitalize(), self.name, choice(self.__class__.casteSynonyms[self.casteOrder[0]]))\n elif self.genesis == 'spread the gospel':\n self.description = '{0}, home to an anthropological society of {1} who covertly inject the theme of {2} into the folklore of other civilizations'.format(self.name, choice(self.__class__.casteSynonyms[self.casteOrder[0]]), choice(self.__class__.genesisIdeals[choice(self.__class__.genesisReasons)]))\n \n elif 45 <= branch <= 62:\n if self.casteOrder[0] == 'laborers':\n if self.tech == 'pre-industrial technology':\n self.description = 'A kibbutz for {0} {1} on {2}'.format(choice(self.__class__.genesisAdjectives[self.genesis]), choice(self.laborerSynonyms), self.name)\n elif self.tech == 'machine technology':\n self.description = 'The worker-owned and operated {1} of {2} {0}'.format(self.name, choice(self.__class__.genesisPlaces[self.genesis]), choice(self.__class__.machineAdjectives))\n elif self.tech == 'ubiquitous technology':\n self.description = '{0}, host to a psychic hivemind of {1} {2}'.format(self.name, choice(self.__class__.genesisAdjectives[self.genesis]), choice(self.__class__.laborerSynonyms))\n elif self.casteOrder[0] == 'artists':\n if self.tech == 'pre-industrial technology':\n self.description = 'The conservatory for neoclassical {0} who explore the theme of {1} on {2}'.format(choice(self.__class__.artistSynonyms), choice(self.__class__.genesisIdeals[self.genesis]), self.name)\n elif self.tech == 'machine technology':\n self.description = 'A series of art installations conceived by {1} at various {0} on {2}'.format(choice(self.__class__.genesisPlaces[self.genesis]), choice(self.__class__.artistSynonyms), self.name)\n elif self.tech == 'ubiquitous technology':\n self.description = '{0}: a collective of AI {1} who parody the human theme of {2}'.format(self.name, choice(self.__class__.artistSynonyms), choice(self.__class__.genesisIdeals[self.genesis]))\n elif self.casteOrder[0] == 'priests':\n if self.tech == 'pre-industrial technology':\n self.description = '{0} {1}, home to a scriptorium dedicated to the penning of meditations on {2}'.format(choice(self.__class__.preindustrialAdjectives).capitalize(), self.name, choice(self.__class__.genesisIdeals[self.genesis]))\n elif self.tech == 'machine technology':\n self.description = 'Polygamous cultists who live among the {0} of {1} {2}'.format(choice(self.__class__.genesisPlaces[self.genesis]), choice(self.__class__.machineAdjectives), self.name)\n elif self.tech == 'ubiquitous technology':\n self.description = 'A pyramidic burial chamber and monument to {0} {1} {2}'.format(choice(self.__class__.genesisIdeals[self.genesis]), choice(self.__class__.ubiquitousPreps), self.name)\n elif self.casteOrder[0] == 'scientists':\n if self.tech == 'pre-industrial technology':\n self.description = '{0}, home to a collective of {1} {2} who reproduce scientific experiments from pre-industrial Earth'.format(self.name, choice(self.genesisAdjectives[self.genesis]), choice(self.__class__.scientistSynonyms))\n elif self.tech == 'machine technology':\n self.description = 'A society of {0} who work simulated jobs at {1} on {3} to better understand {2}'.format(choice(self.__class__.scientistSynonyms), choice(self.__class__.genesisPlaces[self.genesis]), choice(self.__class__.genesisIdeals[self.genesis]), self.name)\n elif self.tech == 'ubiquitous technology':\n self.description = 'The postdoctoral program for {0} tenure-track {1} {2} {3}'.format(choice(self.__class__.genesisAdjectives[self.genesis]), choice(self.__class__.scientistSynonyms), choice(self.__class__.ubiquitousPreps), self.name)\n elif self.casteOrder[0] == 'soldiers':\n if self.tech == 'pre-industrial technology':\n self.description = '{0}, where {1} {2} study their martial arts in the quiet isolation of a {3}'.format(self.name, choice(self.__class__.genesisAdjectives[self.genesis]), choice(self.__class__.soldierSynonyms), choice(self.__class__.preindustrialSettlements))\n elif self.tech == 'machine technology':\n self.description = '{0}, where {1} {2} spar each other to overcome their frustrations surrounding {3}'.format(self.name, choice(self.__class__.badjectives), choice(self.__class__.soldierSynonyms), choice(self.__class__.genesisIdeals[self.genesis]))\n elif self.tech == 'ubiquitous technology':\n self.description = 'The highly militarized {0} {1} {2}'.format(choice(self.__class__.genesisPlaces[self.genesis]), choice(self.__class__.ubiquitousPreps), self.name)\n elif self.casteOrder[0] == 'merchants':\n if self.tech == 'pre-industrial technology':\n self.description = 'An antique fair on {0} where 1% of the proceeds are donated to the study of {1}'.format(self.name, choice(self.__class__.genesisIdeals[self.genesis]))\n elif self.tech == 'machine technology':\n self.description = 'A chain of retail {0} near the {1} on {2}'.format(choice(self.__class__.genesisPlaces[self.genesis]), choice(self.__class__.machineSettlements), self.name)\n elif self.tech == 'ubiquitous technology':\n self.description = 'A pay-by-the-hour computer simulation {0} {1} where patrons can experience {2}'.format(choice(self.__class__.ubiquitousPreps), self.name, choice(self.__class__.genesisIdeals[self.genesis]))","def main(codelabel):\n try:\n code = Code.get_from_string(codelabel)\n except NotExistent:\n print(\"The code '{}' does not exist\".format(codelabel))\n sys.exit(1)\n\n print(\"Testing CP2K ENERGY on H2 (DFT) without StructureData...\")\n\n # parameters\n parameters = Dict(\n dict={\n 'FORCE_EVAL': {\n 'METHOD': 'Quickstep',\n 'DFT': {\n 'BASIS_SET_FILE_NAME': 'BASIS_MOLOPT',\n 'QS': {\n 'EPS_DEFAULT': 1.0e-12,\n 'WF_INTERPOLATION': 'ps',\n 'EXTRAPOLATION_ORDER': 3,\n },\n 'MGRID': {\n 'NGRIDS': 4,\n 'CUTOFF': 280,\n 'REL_CUTOFF': 30,\n },\n 'XC': {\n 'XC_FUNCTIONAL': {\n '_': 'LDA',\n },\n },\n 'POISSON': {\n 'PERIODIC': 'none',\n 'PSOLVER': 'MT',\n },\n },\n 'SUBSYS': {\n # structure directly included in parameters\n 'CELL': {\n 'ABC': '4.0 4.0 4.75'\n },\n 'COORD': {\n ' ': ['H 2.0 2.0 2.737166', 'H 2.0 2.0 2.000000']\n },\n 'KIND': [\n {\n '_': 'O',\n 'BASIS_SET': 'DZVP-MOLOPT-SR-GTH',\n 'POTENTIAL': 'GTH-LDA-q6'\n },\n {\n '_': 'H',\n 'BASIS_SET': 'DZVP-MOLOPT-SR-GTH',\n 'POTENTIAL': 'GTH-LDA-q1'\n },\n ],\n },\n }\n })\n\n # resources\n options = {\n \"resources\": {\n \"num_machines\": 1,\n \"num_mpiprocs_per_machine\": 1,\n },\n \"max_wallclock_seconds\": 1 * 3 * 60,\n }\n\n inputs = {'parameters': parameters, 'code': code, 'metadata': {'options': options,}}\n\n print(\"submitted calculation...\")\n calc = run(Cp2kCalculation, **inputs)\n\n # check energy\n expected_energy = -1.14005678487\n if abs(calc['output_parameters'].dict.energy - expected_energy) < 1e-10:\n print(\"OK, energy has the expected value\")\n else:\n print(\"ERROR!\")\n print(\"Expected energy value: {}\".format(expected_energy))\n print(\"Actual energy value: {}\".format(calc['output_parameters'].dict.energy))\n sys.exit(3)\n\n sys.exit(0)","def load_label(self, pr):\n return","def get_step_label_at_index(self, index):\n return self[index][1]","def get_label(genotype_type):\n if genotype_type == \"Hom\":\n return 0\n elif genotype_type == \"Het\":\n return 1\n elif genotype_type == \"Hom_alt\":\n return 2","def label(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"label\")","def label(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"label\")","def label(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"label\")","def t_labeling_cohort(**kargs): \n def read_ids(fname): \n assert fname.find('.id') > 0\n fp = os.path.join(basedir, fname)\n assert os.path.exists(fp), 'Invalid input: %s' % fp\n df_id = pd.read_csv(fp, sep=sep, header=0, index_col=False, error_bad_lines=True)\n return df_id['person_id'].values\n def seq_to_str(seqx, sep=','): \n return [sep.join(str(s) for s in seq) for seq in seqx] \n def str_to_seq(df, col='sequence', sep=','):\n seqx = []\n for seqstr in df[col].values: \n s = seqstr.split(sep)\n seqx.append(s)\n return seqx\n def to_str(tokens, sep='+'): \n return sep.join([str(tok) for tok in tokens])\n\n # import labeling\n import seqReader as sr\n\n ### CKD cohort \n # basedir = sys_config.read('DataIn') # data-in simlink to data ... 10.17 \n # 'data-in' is reserved for input data not generated from within the system \n basedir = sys_config.read('DataExpRoot')\n \n # cohort attributes\n cohort_name = 'CKD'\n fname = 'eMerge_NKF_Stage_20170818.csv' \n header = ['patientId', 'Case_Control_Unknown_Status', 'NKF_Stage', ]\n sep = ','\n\n fpath = os.path.join(basedir, fname)\n df = pd.read_csv(fpath, sep=sep, header=0, index_col=False, error_bad_lines=True)\n\n # use stages as labels \n labelset = list(df['NKF_Stage'].unique())\n print('info> cohort: %s | labels (n=%d):\\n%s\\n' % (cohort_name, len(labelset), labelset))\n # [log] 7 labels\n\n labels = df['NKF_Stage']\n\n # only read documents with data \n idx = person_ids = getPersonIDs(cohort=cohort_name, inputdir=basedir, sep=sep) # cohort, inputdir, sep, sep_compo\n seqparams.TDoc.verifyIDs(idx) # ascending order? duplicates? \n\n n_persons = len(idx)\n print('info> n_persons: %d' % n_persons)\n\n ### find labels\n # don't use the data source's ordering of IDs, which when made via seqMaker2.py was sorted\n # ERROR: labels = df.loc[df['patientId'].isin(idx)]['NKF_Stage'].values\n \n sort_keys = ['patientId', ]\n # df_test1 = df.sort_values(sort_keys, ascending=True)\n # l = df['patientId'].values\n # assert all(l[i] <= l[i+1] for i in xrange(len(l)-1)) # passed\n # assert all(l == idx) # passed\n\n # filter > sort > extract (good!)\n # output np.array\n # labels = labels_ref = labelDocByDataFrame(, person_ids=idx, id_field='patientId', label_field='NKF_Stage')\n labels = labels_ref = labelDocByFile(fpath, person_ids=idx, id_field='patientId', label_field='NKF_Stage')\n\n # n_labels = len(labels)\n # print('info> Got %d labels' % n_labels)\n\n # [test] verify the ID and labels\n # print('status> verifying the match between IDs and labels')\n # for i, (r, row) in enumerate(df_test1.iterrows()): # sorted entries\n # pid, label = row['patientId'], row['NKF_Stage']\n # if pid in idx: \n # assert label == labels[i], \"%d-th label: %s <> %s\" % (i, label, labels[i])\n ## [conclusion] the label ordering via df_test1 does not agree!!! \n\n # extract labels according to the ID ordering\n # sampleIDs = random.sample(range(n_persons), 50)\n # labels = []\n # for pid in idx: \n # row = df.loc[df['patientId']==pid] # row is a dataframe\n # assert row.shape[0] == 1, 'Found dups: id=%s => %s' % (pid, row)\n # l = list(row['NKF_Stage'].values)\n # labels.extend(l)\n # assert len(labels) == len(labels_ref) == len(idx) # passed\n # assert all(labels_ref == labels), \"ordering inconsistency:\\n%s\\n VS \\n%s\\n\" % (labels_ref[:50], labels[:50]) # passed\n\n n_labels = len(labels)\n print('info> verified %d labels' % n_labels)\n\n # double check with structured version of the sequences produced by seqMaker2 (header: person_id, sequence, timestamp)\n # tfile = 'condition_drug_timed_seq-%s.csv' % cohort_name # test file\n # fpath2 = os.path.join(basedir, tfile)\n # # if os.path.exists(fpath2): \n # dft = pd.read_csv(fpath2, sep='|', header=0, index_col=False, error_bad_lines=True)\n # print('info> from timed_seq .csv | n_persons: %d =?= n_labels: %d' % (dft.shape[0], n_labels)) # n_persons: 2833 =?= n_labels: 2833\n\n ### Read Sequences\n\n print('info> 1. CSeq from .csv')\n ret = readDocFromCSV(cohort=cohort_name, inputdir=basedir)\n print('info> making structured format of the coding sequences (cohort:%s, n_labels:%d)' % (cohort_name, n_labels))\n # df = readToCSV(cohort=cohort_name, labels=labels)\n \n seqx = ret['sequence'] # list(dft['sequence'].values)\n tseqx = ret.get('timestamp', []) # list(dft['timestamp'].values)\n if tseqx: \n assert len(seqx) == len(tseqx), \"len(seqx)=%d, len(times)=%d\" % (len(seqx), len(tseqx))\n\n print('info> 2. CSeq from .dat')\n seqx2, tseqx2 = readDoc(cohort=cohort_name, inputdir=basedir, include_timestamps=True) # ifiles\n\n # can then create .csv via readDocToCSV() # [params] cohort, basedir, ifiles, labels\n\n if tseqx2: \n assert len(seqx2) == len(tseqx2), \"len(seqx)=%d, len(times)=%d\" % (len(seqx2), len(tseqx2))\n n_docs, n_docs2 = len(seqx), len(seqx2)\n \n # print('info> read %d from .dat =?= %d from .csv' % (n_docs2, n_docs))\n assert n_docs == n_docs2, \".dat and .csv formats are not consistent n_doc: %d (csv) <> %d (dat)\" % (n_docs, n_docs2)\n\n # when did they diverge? \n # n_matched = 0\n # for i, seq in enumerate(seqx): \n # s1 = seq # list of tokens\n\n # try: \n # s2 = seqx2[i] # list of tokens\n # except: \n # s2 = []\n\n # if s1 == s2: \n # n_matched += 1 \n # else: \n # msg = \".csv not consistent with .dat (n_matched=%d)=>\\n%s\\nVS\\n%s\\n\" % (n_matched, s1, s2)\n # raise ValueError, msg \n\n n_docs_src = df.shape[0]\n assert n_docs == n_labels, \"n_labels: %d <> n_docs: %d ...\" % (n_labels, n_docs)\n\n print('input> n_doc_src (cohort source document): %d, n_doc (parsed, has data in DB): %d' % (n_docs_src, n_docs))\n\n print('info> writing labels to .csv')\n df2 = sr.readDocToCSV(cohort=cohort_name, labels=labels)\n print('info> created .csv format with columns:\\n%s\\n' % df2.columns.values)\n n_docs3 = df2.shape[0]\n assert n_docs3 == n_docs\n\n return","def print_common_hub_words(rem_stop_words):\n results = {'_removing stop-words':rem_stop_words}\n\n print '------ CLASSIFICATION EVALUATION --------'\n print '> Reading cases..'\n descriptions_path = '../data/tasa/TASA900_dependencies'\n texts, labels = data.read_files(descriptions_path)\n\n print '> Creating representations..'\n fd = nltk.probability.FreqDist()\n for i, text in enumerate(texts):\n if i%100==0: print ' ',str(i)+'/'+str(len(texts))\n g = graph_representation.construct_dependency_network(text, remove_stop_words=rem_stop_words)\n hubs = graph.get_hubs(g, 10)\n for h in hubs:\n fd.inc(h[0])\n g = None # just to make sure..\n\n results['tasa'] = fd.keys()\n\n print '------ RETRIEVAL EVALUATION --------'\n print '> Reading cases..'\n descriptions_path = '../data/air/problem_descriptions_dependencies'\n description_texts, labels = data.read_files(descriptions_path)\n\n print '> Creating representations..'\n fd = nltk.probability.FreqDist()\n for i, text in enumerate(description_texts):\n if i%100==0: print ' ',str(i)+'/'+str(len(description_texts))\n g = graph_representation.construct_dependency_network(text, remove_stop_words=rem_stop_words)\n hubs = graph.get_hubs(g, 10)\n for h in hubs:\n fd.inc(h[0])\n g = None # just to make sure..\n\n results['air'] = fd.keys()\n\n if rem_stop_words:\n modifier = 'without'\n else:\n modifier = 'with'\n data.pickle_to_file(results, 'output/dependencies/common_hubs_'+modifier+'stop_words')\n\n pp.pprint(results)\n return results","def get_parent_struc (chain, added_chains_dict):\n if \"-\" in chain.id:\n structure = added_chains_dict[chain.id]\n else:\n structure = chain.get_parent().get_parent()\n return structure","def get_label(settings):","def _generate_pipeline_labels(self, job):\n jobname = self._get_jobname(job)\n labels = {\"name\": jobname, \"app\": \"snakemake\"}\n return labels","def plugin_second_label():\n return \"second\"","def main(structure, label, return_type):\n sequence = get_sequence(structure=structure, label=label,\n return_type=return_type)\n if sequence is not None:\n click.echo(sequence)","def __init__(self):\n self.label = \"Grand WOFE\"\n self.description = \"From list of Evidence layers generate weights tables and output rasters from Calculate Respons and Logistic Regression.\"\n self.canRunInBackground = False\n self.category = \"Weights of Evidence\"","def get_chain(self, chain_id):\n if self.default_model is None:\n return None\n if self.default_model.chain_dict.has_key(chain_id):\n return self.default_model.chain_dict[chain_id]\n return None","def pred_wine_type():\n \n Alcohol\t=request.args.get('Alcohol')\n Malic=request.args.get('Malic')\n Ash=request.args.get('Ash')\n Alcalinity=request.args.get('Alcalinity')\n Magnesium=request.args.get('Magnesium')\n Phenols=request.args.get('Phenols')\n Flavanoids=request.args.get('Flavanoids')\n Nonflavanoids=request.args.get('Nonflavanoids')\n Proanthocyanins=request.args.get('Proanthocyanins')\n Color=request.args.get('Color')\n Hue=request.args.get('Hue')\n Dilution=request.args.get('Dilution')\n Proline=request.args.get('Proline')\n prediction=classifier.predict([[Alcohol,Malic,Ash,Alcalinity,Magnesium,Phenols,Flavanoids,Nonflavanoids,Proanthocyanins,Color,Hue,Dilution,Proline]])\n return 'The predicted value is'+str(prediction)","def chain(self, chain_id, model_num = 0):\n return self.struct[model_num][chain_id]","def default_chain(self):\n self.name = \"Default Chain Mail Armor\"\n self.rarity = \"Common\"\n self.pdef_value = 15\n self.mdef_value = 2\n self.increase_crit = 0\n self.desc = \"A rusty piece of chain mail, old and discoloured\"","def get_step_label_at_index(self, index):\n return self.routine_template.get_step_label_at_index(index)","def get_clarifications_winogrande(ex, nlp, comet_model):\n personx, persony = ex['option1'], ex['option2']\n\n # Only extract relations for people\n if personx[0] != personx[0].upper() or persony[0] != persony[0].upper():\n return []\n\n input_event = ex[\"sentence\"]\n outputs = {category: comet_model.predict(input_event, category, num_beams=5) for category in comet_model.categories}\n\n curr_events = []\n for category, prefix in CATEGORY_TO_PREFIX.items():\n for out_event in outputs[category]:\n if out_event != \"none\" and out_event != \"\":\n if not out_event.lower().startswith(\"person\") and not out_event.lower().startswith(\"other\"):\n out_event = \" \".join((prefix, out_event))\n\n out_event = re.sub(\"personx\", personx, out_event, flags=re.I)\n out_event = re.sub(\"person x\", personx, out_event, flags=re.I)\n out_event = re.sub(\"persony\", persony, out_event, flags=re.I)\n out_event = re.sub(\"person y\", persony, out_event, flags=re.I)\n\n question = CATEGORY_TO_QUESTION[category].replace(\"PersonX\", personx)\n curr_events.append((question, out_event))\n\n return curr_events","def test_get_nested_attribute(self):\n result = self.runner.invoke(\n cli,\n [\n *CLI_LOG_OPTION,\n \"config\",\n \"get\",\n \"skills.dummy.behaviours.dummy.class_name\",\n ],\n standalone_mode=False,\n )\n assert result.exit_code == 0\n assert result.output == \"DummyBehaviour\\n\"","def q_getdifficulty(abe, page, chain):\n if chain is None:\n return 'Shows the difficulty of the last block in CHAIN.\\n' \\\n '/chain/CHAIN/q/getdifficulty\\n'\n target = abe.store.get_target(chain.id)\n return \"\" if target is None else util.target_to_difficulty(target)","def label_rule_for_company(text: str) -> str:\n match = re.search(LABEL_SPECIFICATION[\"RE_COMPANY_PRIMARY\"], text)\n if not match:\n match = re.search(LABEL_SPECIFICATION[\"RE_COMPANY_SECONDARY\"], text)\n if match:\n text = match.group(\"label\").strip()\n if len(text) > 1:\n return text\n else:\n return \"\"\n return \"\"","def get_label(name):\n lower = name.lower()\n vals = lower.split('_')\n if 'ho' in vals:\n name = 'Independent Estimate'\n elif 'alldata' in vals:\n name = 'Extra-Data Estimate'\n elif 'ris' in vals[0]:\n name = 'RIS'\n if 'w' in vals[0]:\n name += ' WIS'\n if 'pd' in vals[0]:\n name += ' PDIS'\n elif 'is' in vals[0]:\n name = 'OIS'\n if 'w' in vals[0]:\n name += ' WIS'\n if 'pd' in vals[0]:\n name += ' PDIS'\n if 'dr' in vals:\n name += ' DR'\n if 'wdr' in vals:\n name += ' WDR'\n return name","def label(self, cfg):\n rep = \"\"\n nl = \"\"\n for node in cfg.nodes:\n rep += nl + \"{}\\tgen={}\\tkill={}\\tout={}\".format(\n node, \n set(self.gen.get(node)),\n set(self.kill.get(node)),\n set(self.out.get(node)))\n nl = \"\\n\"\n return rep","def test_get_skill_name(self):\n result = self.runner.invoke(\n cli,\n [*CLI_LOG_OPTION, \"config\", \"get\", \"skills.dummy.name\"],\n standalone_mode=False,\n )\n assert result.exit_code == 0\n assert result.output == \"dummy\\n\"","def test_label_callback():\n release_numbers = dict(a='123')\n data = dict(revision='a', attributes=dict(b='c'))\n data2 = dict(revision='b', attributes=dict(d='e'))\n\n assert _label_callback(data, release_numbers) == u'a\\n- Release: 123\\n- b: c'\n assert _label_callback(data2) == u'b\\n- Release: Unknown\\n- d: e'","def get_label():\n inp = option_text('Input label name (leave blank for no label):')\n add_to_collected('label', inp)\n OPTIONS['label'] = inp\n return","def _GenerateConfLine(self, term, precedence=None):\n if term.term.qos in self.qos_value_map:\n target = []\n qos_value = self.qos_value_map[term.term.qos]\n target.append('match protocol ip src-ip any src-port any')\n target.append('dst-ip any dst-port any application')\n target.append(term.term.name)\n if precedence:\n target.append('dscp %s set traffic-class 1' %\n self.precedence_value_map[precedence])\n else:\n target.append('dscp any set traffic-class 1')\n target.append('lan-qos-dscp %s wan-qos-dscp %s\\n\\n' %\n (qos_value, qos_value))\n return ' '.join(target)\n return ''","def get_clarifications_copa(ex, nlp, comet_model):\n category_to_prefix_causes = {\"xIntent\": CATEGORY_TO_PREFIX[\"xIntent\"],\n \"xNeed\": CATEGORY_TO_PREFIX[\"xNeed\"]}\n\n category_to_prefix_effects = CATEGORY_TO_PREFIX.copy()\n category_to_prefix_effects.pop(\"xIntent\")\n category_to_prefix_effects.pop(\"xNeed\")\n category_to_prefix_effects.pop(\"xAttr\")\n\n input_event = ex[\"premise\"]\n personx, is_named_entity = get_personx(nlp, input_event)\n\n if personx == \"\":\n return []\n\n personx = personx if (is_named_entity or personx == \"I\") else personx.lower()\n outputs = {category: comet_model.predict(input_event, category, num_beams=5) for category in comet_model.categories}\n\n if ex[\"question\"] == \"cause\":\n category_to_prefix = category_to_prefix_causes\n else:\n category_to_prefix = category_to_prefix_effects\n\n curr_events = []\n for category, prefix in category_to_prefix.items():\n for out_event in outputs[category]:\n if out_event != \"none\" and out_event != \"\":\n if not out_event.lower().startswith(\"person\") and not out_event.lower().startswith(\"other\"):\n out_event = \" \".join((prefix, out_event))\n\n out_event = re.sub(\"personx\", personx, out_event, flags=re.I)\n out_event = re.sub(\"person x\", personx, out_event, flags=re.I)\n out_event = re.sub(\"persony\", \"others\", out_event, flags=re.I)\n out_event = re.sub(\"person y\", \"others\", out_event, flags=re.I)\n\n question = CATEGORY_TO_QUESTION[category].replace(\"PersonX\", personx)\n curr_events.append((question, out_event))\n\n return curr_events","def make_text(chain_dict):\n\n# This selects the first random key to begin the chain.\n \n random_key = random.choice(chain_dict.keys())\n\n# This creates a random text list to append a random value from the original random key.\n# The random key is then reassigned to a tuple containing the second key in the random keys tuple,\n# and adds the randomly generated value of the earlier random key tuple as the second tuple value. \n# Convert tuples in random_key to strings, then added all strings together, then added to empty list\n\n first_words = ' '.join(map(str,random_key)) \n random_text_list = [first_words]\n \n for i in range(1,100):\n #while random_key in chain_dict: \n next = random.choice(chain_dict[random_key]) \n random_text_list.append(next)\n random_key = (random_key[1],next)\n\n pretty_text = []\n pretty_text = ' '.join(map(str, random_text_list)) \n return pretty_text","def label_rule_for_others(text: str, label_type: str) -> str:\n match = re.search(LABEL_SPECIFICATION[f\"RE_{label_type.upper()}\"], text)\n if match:\n return match.group(\"label\").strip()\n return \"\"","def main(argv):\n global fileName, hyp, run_type, rep_type, n_processor, output_dir # Used by both master and slave processes\n fileName = args.outPrefix\n hyp_default = args.default\n hyp_adjust = args.hyperparam\n output_dir = args.outPrefix\n n_processor = args.num_worker\n run_type = args.type1\n rep_type = args.type2\n\n hyp = loadHyp(pFileName=hyp_default)\n updateHyp(hyp,hyp_adjust)\n print(hyp)\n\n master()","def get_label(urs):\n return assign_term(urs)[1]","def gen_hts_lab_mono(self):\n chosen_fields_lst = ['start', 'stop', 'phone']\n\n self._hts_lab_mono_ttpl = \\\n lst.transp_ttpl(\n tuple(\n tuple(self._proc_ldic[field]) for field in chosen_fields_lst\n )\n )\n\n self._hts_lab_mono_ttpl = tuple(tuple([\"{:>10}\".format(row[0]), \"{:>10}\".format(row[1]), row[2]])\n for row in self._hts_lab_mono_ttpl)\n\n self.hts_lab_mono_prn = tuple(' '.join(l) for l in self._hts_lab_mono_ttpl)","def get_label_from_analysis_model(analysis_model, id_hash):\n\n root = os.path.basename(os.path.dirname(analysis_model.compilation)).replace(\"_\", \" \")\n output = analysis_model.output_directory.replace(\"_\", \" \") if analysis_model.output_directory else \"analysis\"\n return \"{0} -> {1}, ({2})\".format(root, output, id_hash[-6:])","def main( argv = None ):\n\n if argv == None: argv = sys.argv\n\n # setup command line parser\n parser = E.OptionParser( version = \"%prog version: $Id$\", \n usage = globals()[\"__doc__\"] )\n\n parser.add_option(\"--category\", dest=\"category\", type=\"choice\",\n choices = (\"B\", \"C\"), help=\"supply help\" )\n\n ## add common options (-h/--help, ...) and parse command line \n (options, args) = E.Start( parser, argv = argv )\n\n data = getData(options.stdin)\n if options.category == \"B\":\n options.stdout.write(\"Category B pathway\\tKO\\tGenes\\tDescriptions\\n\")\n for pathway, descriptions in b2ko(data).iteritems():\n options.stdout.write(\"\\t\".join([pathway, \"; \".join(descriptions[0]), \"; \".join(descriptions[1]), \"; \".join(descriptions[2])]) + \"\\n\")\n\n elif options.category == \"C\":\n options.stdout.write(\"Category C pathway\\tKO\\tGenes\\tDescriptions\\n\")\n for pathway, descriptions in c2ko(data).iteritems():\n options.stdout.write(\"\\t\".join([pathway, \"; \".join(descriptions[0]), \"; \".join(descriptions[1]), \"; \".join(descriptions[2])]) + \"\\n\")\n else:\n raise ValueError(\"must specify the category of pathway\")\n\n\n ## write footer and output benchmark information.\n E.Stop()","def __str__(self):\n return self.piece_behavior.summary","def get_labels(self):\n if self.option == \"term\":\n return ['platform characteristics', 'atmospheric winds', 'radio wave','weather events', 'geomagnetism', 'atmospheric electricity','microwave', 'atmospheric temperature', 'atmospheric water vapor','atmospheric pressure', 'aerosols', 'atmospheric radiation','atmospheric chemistry', 'precipitation', 'sensor characteristics','radar', 'infrared wavelengths', 'visible wavelengths','weather/climate advisories', 'clouds', 'lidar', 'ocean optics','ultraviolet wavelengths', 'cryospheric indicators','land use/land cover', 'topography', 'surface thermal properties','spectral/engineering', 'soils', 'snow/ice', 'geothermal dynamics','natural hazards', 'surface water', 'vegetation','land surface/agriculture indicators','gravity/gravitational field', 'marine advisories', 'altitude','water quality/water chemistry', 'ocean temperature','ocean winds', 'atmospheric/ocean indicators', 'coastal processes','erosion/sedimentation', 'marine sediments', 'ocean chemistry','salinity/density', 'ocean color', 'aquatic ecosystems','vegetation2', 'landscape', 'cloud properties','surface radiative properties', 'geodetics','agricultural plant science', 'forest science','ecological dynamics', 'environmental impacts', 'sustainability','boundaries', 'ecosystems', 'air quality', 'population','infrastructure', 'environmental governance/management','public health', 'economic resources', 'socioeconomics','environmental vulnerability index (evi)', 'human settlements','agricultural chemicals', 'animal science','habitat conversion/fragmentation', 'animals/vertebrates','earth gases/liquids', 'rocks/minerals/crystals','social behavior', 'ground water', 'frozen ground','terrestrial hydrosphere indicators', 'ocean heat budget','biospheric indicators', 'animal commodities', 'fungi', 'plants','carbon flux', 'geomorphic landforms/processes','paleoclimate indicators', 'ocean circulation', 'sea ice','geochemistry', 'visualization/image processing','subsetting/supersetting', 'transformation/conversion','ocean pressure', 'glaciers/ice sheets', 'protists','solar activity', 'sun-earth interactions','sea surface topography', 'solar energetic particle properties','solar energetic particle flux','ionosphere/magnetosphere dynamics']\n elif self.option == \"mostdepth\":\n return ['flight data logs', 'turbulence', 'radio wave flux', 'lightning', 'magnetic field', 'atmospheric conductivity', 'electric field', 'data synchronization time', 'brightness temperature', 'vertical profiles', 'water vapor profiles', 'air temperature', 'upper level winds', 'atmospheric pressure measurements', 'upper air temperature', 'humidity', 'dew point temperature', 'aerosol particle properties', 'emissivity', 'trace gases/trace species', 'liquid precipitation', 'cloud liquid water/ice', 'microwave radiance', 'sensor counts', 'total pressure', 'airspeed/ground speed', 'total temperature', 'static pressure', 'wind speed', 'wind direction', 'radar reflectivity', 'doppler velocity', 'infrared imagery', 'visible imagery', 'water vapor', 'vertical wind velocity/speed', 'aerosol backscatter', 'weather forecast', 'tropical cyclones', 'visible radiance', 'infrared radiance', 'total precipitable water', 'boundary layer temperature', 'atmospheric temperature indices', 'cloud height', 'flight level winds', 'cloud droplet distribution', 'cloud droplet concentration/size', 'cloud condensation nuclei', 'cloud microphysics', 'hydrometeors', 'ozone', 'wind profiles', 'cloud base temperature', 'cloud base height', 'liquid water equivalent', 'solar radiation', 'planetary boundary layer height', 'surface winds', 'precipitation amount', 'precipitation rate', 'surface pressure', 'rain', 'cloud optical depth/thickness', 'aerosol extinction', 'aerosol optical depth/thickness', 'cirrus cloud systems', 'lidar depolarization ratio', 'radar backscatter', 'radar cross-section', 'return power', 'mean radial velocity', 'radiance', 'air quality', 'climate advisories', 'atmospheric emitted radiation', 'optical depth/thickness', 'surface temperature', 'ultraviolet flux', 'spectrum width', 'microwave imagery', 'lidar backscatter', 'relative humidity', 'u/v wind components', 'wind speed/wind direction', 'radar imagery', 'snow depth', 'land use/land cover classification', 'digital elevation/terrain model (dem)', 'snow', 'droplet size', 'droplet concentration/size', 'drizzle', 'precipitation anomalies', 'snow water equivalent', 'solid precipitation', 'total surface precipitation rate', 'particle size distribution', 'skin temperature', 'attitude characteristics', 'land surface temperature', 'hail', 'reflectance', 'soil moisture/water content', 'soil temperature', 'soil bulk density', 'surface roughness', 'present weather', 'snow density', 'ambient temperature', 'aerosol forward scatter', 'floods', 'snow cover', 'sigma naught', 'precipitable water', 'stage height', 'rivers/streams', 'shortwave radiation', 'photosynthetically active radiation', 'longwave radiation', 'net radiation', 'hourly precipitation amount', '24 hour precipitation amount', 'soil moisture', 'satellite orbits/revolution', 'sea surface temperature', 'heat flux', 'latent heat flux', 'cloud fraction', '3 and 6 hour precipitation amount', 'geopotential height', 'particulate matter', 'particle images', 'water vapor indices', 'horizontal wind velocity/speed', 'electrical conductivity', 'dissolved carbon dioxide', 'hurricanes', 'tropical cyclone track', 'convective clouds/systems (observed/analyzed)', 'cloud top height', 'viewing geometry', 'temperature profiles', 'vertical wind shear', 'wind shear', 'carbon monoxide', 'sea level pressure', 'water vapor tendency', 'potential temperature', 'angstrom exponent', 'ultraviolet radiation', 'solar irradiance', 'scattering', 'absorption', 'water vapor mixing ratio profiles', 'sea surface temperature indices', 'extreme eastern tropical pacific sst', 'sedimentation', 'erosion', 'sediment transport', 'sediments', 'tropopause', 'ocean chemistry', 'ocean optics', 'ocean temperature', 'salinity/density', 'pigments', 'ocean color', 'attenuation/transmission', 'inorganic carbon', 'organic carbon', 'photosynthetically available radiation', 'chlorophyll', 'optical depth', 'fluorescence', 'vegetation index', 'gelbstoff', 'phytoplankton', 'vegetation index2', 'cloud precipitable water', 'landscape ecology', 'ultraviolet radiance', 'cloud ceiling', 'aerosol radiance', 'carbonaceous aerosols', 'dust/ash/smoke', 'nitrate particles', 'organic particles', 'sulfate particles', 'radiative flux', 'transmittance', 'atmospheric stability', 'cloud asymmetry', 'cloud frequency', 'cloud top pressure', 'cloud top temperature', 'cloud vertical distribution', 'cloud emissivity', 'cloud radiative forcing', 'cloud reflectance', 'rain storms', 'reflected infrared', 'thermal infrared', 'incoming solar radiation', 'clouds', 'cloud properties', 'cloud types', 'orbital characteristics', 'sensor characteristics', 'maximum/minimum temperature', 'condensation', 'platform characteristics', 'geolocation', 'geodetics', 'coordinate reference system', 'aerosols', 'topographical relief maps', 'terrain elevation', 'normalized difference vegetation index (ndvi)', 'infrared flux', 'visible flux', 'albedo', 'land use/land cover', 'topography', 'lidar', 'lidar waveform', 'plant phenology', 'vegetation cover', 'crop/plant yields', 'land use classes', 'landscape patterns', 'forest harvesting and engineering', 'forest management', 'total surface water', 'agricultural plant science', 'photosynthesis', 'primary production', 'leaf characteristics', 'evapotranspiration', 'fire occurrence', 'surface thermal properties', 'canopy characteristics', 'evergreen vegetation', 'crown', 'deciduous vegetation', 'anisotropy', 'fire ecology', 'biomass burning', 'wildfires', 'topographical relief', 'burned area', 'surface radiative properties', 'environmental sustainability', 'boundaries', 'anthropogenic/human influenced ecosystems', 'emissions', 'sulfur dioxide', 'population', 'infrastructure', 'environmental assessments', 'public health', 'conservation', 'agriculture production', 'administrative divisions', 'economic resources', 'socioeconomics', 'lake/pond', 'rivers/stream', 'political divisions', 'environmental vulnerability index (evi)', 'ecosystems', 'urban areas', 'sustainability', 'treaty agreements/results', 'human settlements', 'population estimates', 'nitrogen dioxide', 'cropland', 'pasture', 'particulates', 'cyclones', 'mortality', 'environmental impacts', 'droughts', 'earthquakes', 'population distribution', 'fertilizers', 'animal manure and waste', 'urbanization/urban sprawl', 'landslides', 'avalanche', 'urban lands', 'mangroves', 'volcanic eruptions', 'pesticides', 'population size', 'population density', 'lakes/reservoirs', 'surface water', 'rural areas', 'infant mortality rates', 'amphibians', 'mammals', 'carbon', 'sulfur oxides', 'methane', 'non-methane hydrocarbons/volatile organic compounds', 'nitrogen oxides', 'natural gas', 'coal', 'coastal elevation', 'biodiversity functions', 'nuclear radiation exposure', 'radiation exposure', 'poverty levels', 'malnutrition', 'wetlands', 'sea level rise', 'vulnerability levels/index', 'ground water', 'snow/ice', 'electricity', 'energy production/use', 'sustainable development', 'deforestation', 'household income', 'discharge/flow', 'hydropattern', 'nitrogen', 'phosphorus', 'carbon dioxide', 'alpine/tundra', 'forests', 'vegetation', 'permafrost', 'nutrients', 'plant characteristics', 'leaf area index (lai)', 'soil gas/air', 'ammonia', 'nitrous oxide', 'ecosystem functions', 'litter characteristics', 'soil chemistry', 'soil respiration', 'active layer', 'soil depth', 'cation exchange capacity', 'organic matter', 'soil porosity', 'soil texture', 'permafrost melt', 'land subsidence', 'freeze/thaw', 'surface water features', 'chlorinated hydrocarbons', 'methyl bromide', 'methyl chloride', 'molecular hydrogen', 'sulfur compounds', 'fire models', 'biomass', 'dominant species', 'vegetation species', 'sulfur', 'tree rings', 'soil classification', 'heat index', 'sea ice concentration', 'ocean heat budget', 'reforestation', 'even-toed ungulates', 'species recruitment', 'population dynamics', 'range changes', 'topographic effects', 'land resources', 'river ice depth/extent', 'snow melt', 'river ice', 'animal commodities', 'animal ecology and behavior', 'phenological changes', 'water depth', 'inundation', 'forest fire science', 'biogeochemical cycles', 'radiative forcing', 'soil heat budget', 'drainage', 'respiration rate', 'river/lake ice breakup', 'river/lake ice freeze', 'reclamation/revegetation/restoration', 'permafrost temperature', 'indigenous/native species', 'fire dynamics', 'lichens', 'plants', 'plant succession', 'carbon flux', 'coastal', 'salt marsh', 'degradation', 'altitude', 'carbon and hydrocarbon compounds', 'halocarbons and halogens', 'forest composition/vegetation structure', 'water vapor indicators', 'barometric altitude', 'atmospheric water vapor', 'terrestrial ecosystems', 'volatile organic compounds', 'boundary layer winds', 'forest fire danger index', 'periglacial processes', 'landscape processes', 'evaporation', 'soil horizons/profile', 'shrubland/scrub', 'soil ph', 'soils', 'soil water holding capacity', 'community structure', 'pingo', 'soil color', 'virtual temperature', 'formaldehyde', 'hydroxyl', 'photolysis rates', 'cloud dynamics', 'nitric oxide', 'molecular oxygen', 'smog', 'peroxyacyl nitrate', 'hydrogen compounds', 'nitrogen compounds', 'oxygen compounds', 'stable isotopes', 'chemical composition', 'actinic flux', 'tropospheric ozone', 'fossil fuel burning', 'industrial emissions', 'denitrification rate', 'sunshine', 'runoff', 'soil structure', 'mosses/hornworts/liverworts', 'peatlands', 'hydraulic conductivity', 'snow/ice temperature', 'vegetation water content', 'discharge', 'chlorophyll concentrations', 'outgoing longwave radiation', 'geomorphic landforms/processes', 'soil compaction', 'soil impedance', 'canopy transmittance', 'water table', 'decomposition', 'water temperature', 'dissolved gases', 'total dissolved solids', 'agricultural expansion', 'forest science', 'pressure tendency', 'visibility', 'biomass dynamics', 'agricultural lands', 'grasslands', 'savannas', 'grazing dynamics/plant herbivory', 'herbivory', 'paleoclimate reconstructions', 'drought indices', 'fire weather index', 'animal yields', 'multivariate enso index', 'dissolved solids', 'ocean currents', 'salinity', 'coastal processes', 'atmospheric pressure', 'afforestation/reforestation', 'fresh water river discharge', 'surface water chemistry', 'drainage basins', 'resource development site', 'dunes', 'flood plain', 'endangered species', 'precipitation indices', 'temperature indices', 'forest yields', 'stratigraphic sequence', 'freeze/frost', 'frost', 'hydrogen cyanide', 'land management', 'nutrient cycling', 'industrialization', 'suspended solids', 'deserts', 'weathering', 'gas flaring', 'atmospheric temperature', 'ice extent', 'fraction of absorbed photosynthetically active radiation (fapar)', 'marshes', 'swamps', 'lake ice', 'atmospheric winds', 'watershed characteristics', 'transportation', 'soil rooting depth', 'isotopes', 'cultural features', 'consumer behavior', 'boundary surveys', 'aquifers', 'land productivity', 'water quality/water chemistry', 'sediment composition', 'dissolved oxygen', 'surface water processes/measurements', 'turbidity', 'conductivity', 'ph', 'calcium', 'magnesium', 'potassium', 'micronutrients/trace elements', 'social behavior', 'sulfate', 'sediment chemistry', 'biogeochemical processes', 'water ion concentrations', 'cropping systems', 'percolation', 'groundwater chemistry', 'reforestation/revegetation', 'species/population interactions', 'soil infiltration', 'alkalinity', 'soil fertility', 'phosphorous compounds', 'radioisotopes', 'cooling degree days', 'angiosperms (flowering plants)', 'glacial landforms', 'glacial processes', 'contour maps', 'estuaries', 'methane production/use', 'natural gas production/use', 'petroleum production/use', 'visualization/image processing', 'subsetting/supersetting', 'transformation/conversion', 'forest mensuration', 'acid deposition', 'differential pressure', 'precipitation', 'marine ecosystems', 'consumption rates', 'radio wave', 'soil organic carbon (soc)', 'soil erosion', 'halocarbons', 'trace elements/trace metals', 'biomass energy production/use', 'riparian wetlands', 'soil consistence', 'snow stratigraphy', 'thermal conductivity', 'estuary', 'tidal height', 'plant diseases/disorders/pests', 'layered precipitable water', 'atmospheric chemistry', 'water vapor concentration profiles', 'specific humidity', 'total runoff', 'pressure thickness', 'wind stress', 'atmospheric heating', 'conduction', 'hydrogen chloride', 'nitric acid', 'radar', 'land surface/agriculture indicators', 'satellite soil moisture index', 'chlorine nitrate', 'chlorofluorocarbons', 'dinitrogen pentoxide', 'antenna temperature', 'glaciers', 'ice sheets', 'dimethyl sulfide', 'potential vorticity', 'ice fraction', 'atmospheric radiation', 'runoff rate', 'temperature tendency', 'wind dynamics', 'wind direction tendency', 'base flow', 'bromine monoxide', 'chlorine monoxide', 'methyl cyanide', 'hypochlorous acid', 'methanol', 'hydroperoxy', 'cloud base pressure', 'temperature anomalies', 'nitrate', 'ocean mixed layer', 'precipitation trends', 'temperature trends', 'convection', 'ground ice', 'oxygen', 'phosphate', 'solar induced fluorescence', 'chlorine dioxide', 'sun-earth interactions', 'uv aerosol index', 'volcanic activity', 'potential evapotranspiration', 'ultraviolet wavelengths', 'ice temperature', 'sea surface skin temperature', 'sea surface height', 'sublimation', 'convective surface precipitation rate', 'hydrogen fluoride', 'airglow', 'energy deposition', 'x-ray flux', 'electron flux', 'proton flux', 'magnetic fields/magnetic currents']\n else:\n return ['platform characteristics', 'atmospheric winds','radio wave', 'weather events', 'geomagnetism','atmospheric electricity', 'microwave', 'atmospheric temperature','atmospheric water vapor', 'atmospheric pressure', 'aerosols','atmospheric radiation', 'atmospheric chemistry', 'precipitation','sensor characteristics', 'radar', 'infrared wavelengths','visible wavelengths', 'weather/climate advisories', 'clouds','lidar', 'ocean optics', 'ultraviolet wavelengths','cryospheric indicators', 'land use/land cover', 'topography','surface thermal properties', 'spectral/engineering', 'soils','snow/ice', 'geothermal dynamics', 'natural hazards','surface water', 'vegetation','land surface/agriculture indicators','gravity/gravitational field', 'marine advisories', 'altitude','water quality/water chemistry', 'ocean temperature','ocean winds', 'atmospheric/ocean indicators', 'coastal processes','erosion/sedimentation', 'marine sediments', 'ocean chemistry','salinity/density', 'ocean color', 'aquatic ecosystems','vegetation2', 'landscape', 'cloud properties','surface radiative properties', 'geodetics','agricultural plant science', 'forest science','ecological dynamics', 'environmental impacts', 'sustainability','boundaries', 'ecosystems', 'air quality', 'population','infrastructure', 'environmental governance/management','public health', 'economic resources', 'socioeconomics','environmental vulnerability index (evi)', 'human settlements','agricultural chemicals', 'animal science','habitat conversion/fragmentation', 'animals/vertebrates','earth gases/liquids', 'rocks/minerals/crystals','social behavior', 'ground water', 'frozen ground','terrestrial hydrosphere indicators', 'ocean heat budget','biospheric indicators', 'animal commodities', 'fungi', 'plants','carbon flux', 'geomorphic landforms/processes','paleoclimate indicators', 'ocean circulation', 'sea ice','geochemistry', 'visualization/image processing','subsetting/supersetting', 'transformation/conversion','ocean pressure', 'glaciers/ice sheets', 'protists','solar activity', 'sun-earth interactions','sea surface topography', 'solar energetic particle properties','solar energetic particle flux','ionosphere/magnetosphere dynamics','flight data logs','wind dynamics', 'radio wave flux', 'lightning', 'magnetic field','atmospheric conductivity', 'electric field','data synchronization time', 'brightness temperature','upper air temperature', 'water vapor profiles','surface temperature', 'upper level winds','atmospheric pressure measurements', 'water vapor indicators','aerosol particle properties', 'emissivity','trace gases/trace species', 'liquid precipitation','cloud microphysics', 'microwave radiance', 'sensor counts','total pressure', 'airspeed/ground speed', 'total temperature','static pressure', 'humidity', 'radar reflectivity','doppler velocity', 'infrared imagery', 'visible imagery','aerosol backscatter', 'weather forecast', 'tropical cyclones','visible radiance', 'infrared radiance','atmospheric temperature indices', 'cloud droplet distribution','cloud condensation nuclei', 'hydrometeors', 'oxygen compounds','wind profiles', 'liquid water equivalent', 'solar radiation','planetary boundary layer height', 'surface winds','precipitation amount', 'precipitation rate', 'surface pressure','aerosol extinction', 'aerosol optical depth/thickness','tropospheric/high-level clouds (observed/analyzed)','lidar depolarization ratio', 'radar backscatter','radar cross-section', 'return power', 'radial velocity','radiance', 'climate advisories', 'atmospheric emitted radiation','optical depth/thickness', 'ultraviolet flux', 'spectrum width','microwave imagery', 'lidar backscatter', 'radar imagery','snow depth', 'land use/land cover classification','terrain elevation', 'solid precipitation', 'droplet size','droplet concentration/size', 'precipitation anomalies','snow water equivalent', 'total surface precipitation rate','skin temperature', 'water vapor', 'attitude characteristics','land surface temperature', 'reflectance','soil moisture/water content', 'soil temperature','soil bulk density', 'surface roughness', 'present weather','snow density', 'geothermal temperature','aerosol forward scatter', 'floods', 'snow cover', 'sigma naught','precipitable water', 'surface water processes/measurements','surface water features', 'shortwave radiation','photosynthetically active radiation', 'longwave radiation','net radiation', 'flight level winds', 'soil moisture','satellite orbits/revolution', 'heat flux','precipitation profiles', 'geopotential height','particulate matter', 'particle images', 'water vapor indices','electrical conductivity', 'gases', 'sea surface temperature','convective clouds/systems (observed/analyzed)','viewing geometry', 'wind shear','carbon and hydrocarbon compounds', 'sea level pressure','water vapor processes', 'ultraviolet radiation','solar irradiance', 'scattering', 'absorption','sea surface temperature indices', 'sedimentation', 'erosion','sediment transport', 'sediments', 'tropopause', 'nan', 'pigments','attenuation/transmission', 'inorganic carbon', 'organic carbon','photosynthetically available radiation', 'chlorophyll','optical depth', 'fluorescence', 'vegetation index', 'gelbstoff','plankton', 'vegetation index2', 'landscape ecology','ultraviolet radiance', 'aerosol radiance','carbonaceous aerosols', 'dust/ash/smoke', 'nitrate particles','organic particles', 'sulfate particles', 'radiative flux','transmittance', 'atmospheric stability','cloud radiative transfer', 'rain storms', 'reflected infrared','thermal infrared', 'incoming solar radiation', 'cloud types','orbital characteristics', 'geolocation','coordinate reference system', 'infrared flux', 'visible flux','albedo', 'lidar waveform', 'plant phenology', 'vegetation cover','crop/plant yields', 'land use classes', 'landscape patterns','forest harvesting and engineering', 'forest management','ecosystem functions', 'leaf characteristics', 'fire ecology','total surface water', 'primary production', 'photosynthesis','canopy characteristics', 'evergreen vegetation', 'crown','deciduous vegetation', 'anisotropy', 'biomass burning','wildfires', 'topographical relief','environmental sustainability','anthropogenic/human influenced ecosystems', 'emissions','sulfur compounds', 'environmental assessments', 'conservation','agriculture production', 'administrative divisions','freshwater ecosystems', 'political divisions', 'urban areas','treaty agreements/results', 'population estimates','nitrogen compounds', 'particulates', 'mortality', 'droughts','earthquakes', 'population distribution', 'fertilizers','animal manure and waste', 'urbanization/urban sprawl','landslides', 'avalanche', 'mangroves', 'volcanic eruptions','pesticides', 'population size', 'population density','rural areas', 'amphibians', 'mammals', 'carbon', 'sulfur oxides','land management', 'natural gas', 'sedimentary rocks','coastal elevation', 'community dynamics','nuclear radiation exposure', 'radiation exposure','poverty levels', 'malnutrition', 'sea level rise','vulnerability levels/index', 'electricity','energy production/use', 'sustainable development','deforestation', 'household income', 'nitrogen', 'phosphorus','terrestrial ecosystems', 'permafrost', 'nutrients','plant characteristics', 'soil gas/air', 'litter characteristics','soil chemistry', 'soil respiration', 'active layer', 'soil depth','cation exchange capacity', 'organic matter', 'soil porosity','soil texture', 'permafrost melt','ground water processes/measurements', 'freeze/thaw','halocarbons and halogens', 'hydrogen compounds', 'biomass','dominant species', 'vegetation species', 'sulfur', 'tree rings','soil classification', 'sea ice concentration', 'reforestation','species/population interactions', 'range changes','topographic effects', 'land resources', 'river ice depth/extent','snow melt', 'river ice', 'animal ecology and behavior','phenological changes', 'forest fire science', 'radiative forcing','soil heat budget', 'river/lake ice breakup','river/lake ice freeze', 'reclamation/revegetation/restoration','lichens', 'marine ecosystems', 'coastal landforms', 'degradation','forest composition/vegetation structure', 'barometric altitude','volatile organic compounds', 'forest fire danger index','periglacial processes', 'landscape processes','soil horizons/profile', 'soil ph', 'soil water holding capacity','fluvial landforms', 'soil color', 'glacial processes','photochemistry', 'cloud dynamics', 'nitrogen oxides', 'smog','chemical composition', 'actinic flux', 'tropospheric ozone','fossil fuel burning', 'industrial emissions','denitrification rate', 'sunshine', 'soil structure','mosses/hornworts/liverworts', 'hydraulic conductivity','snow/ice temperature', 'water characteristics','outgoing longwave radiation', 'soil compaction', 'soil impedance','canopy transmittance', 'ground water features', 'solids','agricultural expansion', 'pressure tendency', 'visibility','herbivory', 'paleoclimate reconstructions', 'drought indices','fire weather index', 'animal yields', 'teleconnections','carbon dioxide', 'dissolved solids', 'ocean currents', 'salinity','afforestation/reforestation', 'fresh water river discharge','surface water chemistry', 'aeolian landforms','precipitation indices', 'temperature indices', 'forest yields','stratigraphic sequence', 'freeze/frost', 'frost','industrialization', 'ice core records', 'suspended solids','weathering', 'gas flaring', 'ice extent', 'biogeochemical cycles','lake ice', 'isotopes', 'watershed characteristics','transportation', 'soil rooting depth', 'geochemical properties','carbon monoxide', 'cultural features', 'consumer behavior','boundary surveys', 'land productivity', 'sediment composition','calcium', 'magnesium', 'potassium','micronutrients/trace elements', 'sediment chemistry','biogeochemical processes', 'cropping systems','groundwater chemistry', 'reforestation/revegetation','soil infiltration', 'soil fertility','angiosperms (flowering plants)', 'glacial landforms','forest mensuration', 'acid deposition', 'differential pressure','soil erosion', 'trace elements/trace metals', 'soil consistence','snow stratigraphy', 'thermal conductivity', 'estuaries','tidal height', 'plant diseases/disorders/pests','pressure thickness', 'atmospheric heating', 'conduction','evaporation', 'turbulence', 'wind stress','satellite soil moisture index', 'antenna temperature', 'glaciers','ice sheets', 'nitrate', 'ocean mixed layer','precipitation indicators', 'temperature indicators', 'ground ice','alkalinity', 'dissolved gases', 'oxygen', 'ph', 'phosphate','solar induced fluorescence', 'volcanic activity','ice temperature', 'sea surface height', 'airglow','energy deposition', 'x-ray flux', 'electron flux', 'proton flux','magnetic fields/magnetic currents', 'vertical profiles','air temperature', 'dew point temperature','cloud liquid water/ice', 'wind speed', 'wind direction','vertical wind velocity/speed', 'total precipitable water','boundary layer temperature', 'cloud height','cloud droplet concentration/size', 'ozone','cloud base temperature', 'cloud base height', 'rain','cloud optical depth/thickness', 'cirrus/systems','mean radial velocity', 'relative humidity', 'u/v wind components','wind speed/wind direction','digital elevation/terrain model (dem)', 'snow', 'drizzle','particle size distribution', 'hail', 'ambient temperature','stage height', 'rivers/streams', 'hourly precipitation amount','24 hour precipitation amount', 'latent heat flux','cloud fraction', '3 and 6 hour precipitation amount','horizontal wind velocity/speed', 'dissolved carbon dioxide','hurricanes', 'tropical cyclone track', 'cloud top height','temperature profiles', 'vertical wind shear','water vapor tendency', 'potential temperature','angstrom exponent', 'water vapor mixing ratio profiles','extreme eastern tropical pacific sst', 'phytoplankton','cloud precipitable water', 'cloud asymmetry', 'cloud ceiling','cloud frequency', 'cloud top pressure', 'cloud top temperature','cloud vertical distribution', 'cloud emissivity','cloud radiative forcing', 'cloud reflectance','maximum/minimum temperature', 'condensation','topographical relief maps', 'evapotranspiration','fire occurrence', 'burned area', 'sulfur dioxide', 'lake/pond','rivers/stream', 'nitrogen dioxide', 'agricultural lands','cyclones', 'urban lands', 'lakes/reservoirs','infant mortality rates', 'methane','non-methane hydrocarbons/volatile organic compounds', 'coal','biodiversity functions', 'wetlands', 'discharge/flow','hydropattern', 'alpine/tundra', 'forests','leaf area index (lai)', 'ammonia', 'nitrous oxide','land subsidence', 'normalized difference vegetation index (ndvi)','chlorinated hydrocarbons', 'methyl bromide', 'methyl chloride','molecular hydrogen', 'fire models', 'heat index','even-toed ungulates', 'species recruitment','population dynamics', 'water depth', 'inundation', 'drainage','respiration rate', 'permafrost temperature','indigenous/native species', 'fire dynamics', 'plant succession','coastal', 'salt marsh', 'boundary layer winds', 'shrubland/scrub','community structure', 'pingo', 'virtual temperature','formaldehyde', 'hydroxyl', 'photolysis rates', 'nitric oxide','molecular oxygen', 'peroxyacyl nitrate', 'stable isotopes','runoff', 'vegetation water content', 'discharge','chlorophyll concentrations', 'water table', 'decomposition','water temperature', 'total dissolved solids', 'biomass dynamics','grasslands', 'savannas', 'grazing dynamics/plant herbivory','multivariate enso index', 'drainage basins','resource development site', 'dunes', 'flood plain','endangered species', 'hydrogen cyanide', 'nutrient cycling','deserts','fraction of absorbed photosynthetically active radiation (fapar)','aquifers', 'dissolved oxygen', 'turbidity', 'conductivity','sulfate', 'water ion concentrations', 'percolation','phosphorous compounds', 'radioisotopes', 'cooling degree days','contour maps', 'methane production/use','natural gas production/use', 'petroleum production/use','consumption rates', 'soil organic carbon (soc)', 'halocarbons','biomass energy production/use', 'estuary','layered precipitable water', 'water vapor concentration profiles','hydrogen chloride', 'nitric acid', 'chlorine nitrate','chlorofluorocarbons', 'dinitrogen pentoxide', 'dimethyl sulfide','vorticity', 'ice fraction', 'temperature tendency','wind direction tendency', 'bromine monoxide', 'chlorine monoxide','methyl cyanide', 'hypochlorous acid', 'methanol', 'hydroperoxy','cloud base pressure', 'temperature anomalies','precipitation trends', 'temperature trends', 'convection','chlorine dioxide', 'uv aerosol index','sea surface skin temperature', 'sublimation','convective surface precipitation rate', 'hydrogen fluoride']","def eval_final_label(args):\n cfg, lbl = util.get_label_cfg_by_args(args)\n uid = cfg['uniqueid']\n print('We are playing with %s' % uid)\n outdir='models/%s/gate_expert' % uid\n outname='gate_expert_model.pt'\n if KLLOSS:\n outname = 'gate_expert_kldiv_model.pt'\n if args.warm:\n outname = outname.replace('.pt', '_warm.pt')\n mdl_path = os.path.join(outdir, outname)\n gate_expert = GateExpertNet(mdl_path, False)\n eval_fun = gate_expert.get_p_y\n\n data = npload(cfg['file_path'], uid)\n datax = data[cfg['x_name']]\n p, v = eval_fun(datax)\n\n label = np.argmax(p, axis=1)\n\n if args.draw:\n fig, ax = plt.subplots()\n n_expert = np.amax(label) + 1\n for i in range(n_expert):\n mask = label == i\n ax.scatter(datax[mask, 0], datax[mask, 1])\n plt.show()\n\n label_name = 'data/pen/gate_expert_label.npy'\n if KLLOSS:\n label_name = label_name.replace('_label', '_kldiv_label')\n if args.warm:\n label_name = label_name.replace('.npy', '_warm.npy')\n np.save(label_name, label)","def main():\r\n if len(sys.argv) == 2:\r\n if sys.argv[1] == 'branch_name':\r\n print branch_name()\r\n elif sys.argv[1] == 'plat_id':\r\n print plat_id()\r\n else:\r\n print plat_id()\r\n print branch_name()\r\n return","def step_name(self):\n return \"main\"","def setup_protocol(self):\n self.ctx.inputs = {\n 'codename': self.inputs.codename,\n 'parameters': {},\n 'settings': {},\n 'options': ParameterData(dict={\n 'resources': {\n 'num_machines': 1\n },\n 'max_wallclock_seconds': 1800,\n }),\n }\n\n if self.inputs.protocol == 'standard':\n self.report('running the workchain in the \"{}\" protocol'.format(self.inputs.protocol.value))\n self.ctx.protocol = {\n 'kpoints_mesh_offset': [0., 0., 0.],\n 'kpoints_mesh_density': 0.2,\n 'convergence_threshold': 2.E-06,\n 'smearing': 'marzari-vanderbilt',\n 'degauss': 0.02,\n 'occupations': 'smearing',\n 'tstress': True,\n 'pseudo_familyname': 'SSSP',\n 'pseudo_data': {\n 'H': {'cutoff': 55, 'dual': 8, 'pseudo': '031US'},\n 'He': {'cutoff': 55, 'dual': 4, 'pseudo': 'SG15'},\n 'Li': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.4'},\n 'Be': {'cutoff': 40, 'dual': 8, 'pseudo': 'GBRV-1.4'},\n 'B': {'cutoff': 40, 'dual': 8, 'pseudo': '031PAW'},\n 'C': {'cutoff': 50, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'N': {'cutoff': 55, 'dual': 8, 'pseudo': 'THEOS'},\n 'O': {'cutoff': 45, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'F': {'cutoff': 50, 'dual': 8, 'pseudo': 'GBRV-1.4'},\n 'Ne': {'cutoff': 200, 'dual': 8, 'pseudo': '100PAW'},\n 'Na': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'Mg': {'cutoff': 35, 'dual': 8, 'pseudo': 'GBRV-1.4'},\n 'Al': {'cutoff': 30, 'dual': 8, 'pseudo': '100PAW'},\n 'Si': {'cutoff': 30, 'dual': 8, 'pseudo': '100US'},\n 'P': {'cutoff': 30, 'dual': 8, 'pseudo': '100US'},\n 'S': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'Cl': {'cutoff': 35, 'dual': 8, 'pseudo': 'GBRV-1.4'},\n 'Ar': {'cutoff': 120, 'dual': 8, 'pseudo': '100US'},\n 'K': {'cutoff': 50, 'dual': 8, 'pseudo': '100US'},\n 'Ca': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'Sc': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'Ti': {'cutoff': 35, 'dual': 8, 'pseudo': 'GBRV-1.4'},\n 'V': {'cutoff': 40, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'Cr': {'cutoff': 40, 'dual': 8, 'pseudo': 'GBRV-1.5'},\n 'Mn': {'cutoff': 70, 'dual': 12, 'pseudo': '031PAW'},\n 'Fe': {'cutoff': 90, 'dual': 12, 'pseudo': '031PAW'},\n 'Co': {'cutoff': 55, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'Ni': {'cutoff': 45, 'dual': 8, 'pseudo': 'GBRV-1.4'},\n 'Cu': {'cutoff': 40, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'Zn': {'cutoff': 40, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'Ga': {'cutoff': 35, 'dual': 8, 'pseudo': '031US'},\n 'Ge': {'cutoff': 40, 'dual': 8, 'pseudo': '100PAW'},\n 'As': {'cutoff': 30, 'dual': 8, 'pseudo': '031US'},\n 'Se': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'Br': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.4'},\n 'Kr': {'cutoff': 100, 'dual': 8, 'pseudo': '031US'},\n 'Rb': {'cutoff': 50, 'dual': 4, 'pseudo': 'SG15'},\n 'Sr': {'cutoff': 35, 'dual': 8, 'pseudo': '100US'},\n 'Y': {'cutoff': 35, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'Zr': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'Nb': {'cutoff': 35, 'dual': 8, 'pseudo': '031PAW'},\n 'Mo': {'cutoff': 35, 'dual': 4, 'pseudo': 'SG15'},\n 'Tc': {'cutoff': 30, 'dual': 4, 'pseudo': 'SG15'},\n 'Ru': {'cutoff': 40, 'dual': 4, 'pseudo': 'SG15'},\n 'Rh': {'cutoff': 45, 'dual': 8, 'pseudo': '100PAW'},\n 'Pd': {'cutoff': 55, 'dual': 8, 'pseudo': '100PAW'},\n 'Ag': {'cutoff': 35, 'dual': 8, 'pseudo': 'GBRV-1.4'},\n 'Cd': {'cutoff': 40, 'dual': 8, 'pseudo': '031US'},\n 'In': {'cutoff': 35, 'dual': 8, 'pseudo': '031US'},\n 'Sn': {'cutoff': 35, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'Sb': {'cutoff': 40, 'dual': 8, 'pseudo': 'GBRV-1.4'},\n 'Te': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'I': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'Xe': {'cutoff': 120, 'dual': 8, 'pseudo': '100US'},\n 'Cs': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'Ba': {'cutoff': 40, 'dual': 4, 'pseudo': 'SG15'},\n 'Hf': {'cutoff': 35, 'dual': 8, 'pseudo': '031US'},\n 'Ta': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'W': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'Re': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'Os': {'cutoff': 35, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'Ir': {'cutoff': 40, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'Pt': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.4'},\n 'Au': {'cutoff': 45, 'dual': 4, 'pseudo': 'SG15'},\n 'Hg': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'Tl': {'cutoff': 30, 'dual': 8, 'pseudo': '031US'},\n 'Pb': {'cutoff': 40, 'dual': 8, 'pseudo': '031PAW'},\n 'Bi': {'cutoff': 35, 'dual': 8, 'pseudo': '031PAW'},\n 'Po': {'cutoff': 45, 'dual': 8, 'pseudo': '100US'},\n 'Rn': {'cutoff': 45, 'dual': 8, 'pseudo': '100US'},\n 'La': {'cutoff': 55, 'dual': 8, 'pseudo': 'Wentzcovitch'},\n 'Ce': {'cutoff': 45, 'dual': 8, 'pseudo': 'Wentzcovitch'},\n 'Pr': {'cutoff': 50, 'dual': 8, 'pseudo': 'Wentzcovitch'},\n 'Nd': {'cutoff': 40, 'dual': 8, 'pseudo': 'Wentzcovitch'},\n 'Sm': {'cutoff': 40, 'dual': 8, 'pseudo': 'Wentzcovitch'},\n 'Eu': {'cutoff': 55, 'dual': 8, 'pseudo': 'Wentzcovitch'},\n 'Tb': {'cutoff': 40, 'dual': 8, 'pseudo': 'Wentzcovitch'},\n 'Dy': {'cutoff': 40, 'dual': 8, 'pseudo': 'Wentzcovitch'},\n 'Ho': {'cutoff': 40, 'dual': 8, 'pseudo': 'Wentzcovitch'},\n 'Er': {'cutoff': 40, 'dual': 8, 'pseudo': 'Wentzcovitch'},\n 'Tm': {'cutoff': 40, 'dual': 8, 'pseudo': 'Wentzcovitch'},\n 'Yb': {'cutoff': 40, 'dual': 8, 'pseudo': 'Wentzcovitch'},\n 'Lu': {'cutoff': 45, 'dual': 8, 'pseudo': 'Wentzcovitch'},\n }\n }","def test_get_label_line(self):\r\n\r\n sample_id = \"Sample1\"\r\n fasta_label = \"ABCD1234 region=1 length=254\"\r\n bc = \"AAAA\"\r\n corrected_bc = \"AAAT\"\r\n num_errors = 1\r\n actual_label = get_label_line(sample_id, fasta_label, bc, corrected_bc,\r\n num_errors)\r\n\r\n expected_label = \"Sample1 ABCD1234 orig_bc=AAAA new_bc=AAAT bc_diffs=1\"\r\n self.assertEqual(actual_label, expected_label)","def Label(self) -> str:","def set_label(termtype, timeperiod):\n label = 'Graph these comma-separated noun phrases (yearly frequencies):' if termtype == 'Noun phrases' and timeperiod == 'Yearly' \\\n else 'Graph these comma-separated noun phrases (monthly frequencies):' if termtype == 'Noun phrases' and timeperiod == 'Monthly' \\\n else 'Graph these comma-separated entity mentions (yearly frequencies):' if termtype == 'Entity mentions' and timeperiod == 'Yearly' \\\n else 'Graph these comma-separated entity mentions (monthly frequencies):' if termtype == 'entity mentions' and timeperiod == 'Monthly' \\\n else 'Enter a phrase and get similar terms and the distribution of its \"cluster\"'\n return label","def label(tree):\n return tree[0]","def housepredict(intent_request):\r\n \r\n \r\n location_zip = get_slots(intent_request)[\"location\"]\r\n housetype_zip = get_slots(intent_request)[\"housetype\"]\r\n source = intent_request['invocationSource']\r\n \r\n print('received request: ' + str(intent_request))\r\n print (\"housetype\",housetype_zip)\r\n print (\"location1\",location_zip)\r\n\r\n if source == 'DialogCodeHook':\r\n # Perform basic validation on the supplied input slots.\r\n # Use the elicitSlot dialog action to re-prompt for the first violation detected.\r\n slots = get_slots(intent_request)\r\n print('slots are' ,str(slots)) \r\n validation_result = validate_housepred(location_zip)\r\n if not validation_result['isValid']:\r\n slots[validation_result['violatedSlot']] = None\r\n return elicit_slot(intent_request['sessionAttributes'],\r\n intent_request['currentIntent']['name'],\r\n slots,\r\n validation_result['violatedSlot'],\r\n validation_result['message'])\r\n\t\t\r\n validation_result2 = validate_housepred_hstyp(housetype_zip)\r\n if not validation_result2['isValid']:\r\n slots[validation_result2['violatedSlot']] = None\r\n return elicit_slot(intent_request['sessionAttributes'],\r\n intent_request['currentIntent']['name'],\r\n slots,\r\n validation_result2['violatedSlot'],\r\n validation_result2['message'])\r\n\r\n # Pass the price of the flowers back through session attributes to be used in various prompts defined\r\n # on the bot model.\r\n output_session_attributes = intent_request['sessionAttributes'] if intent_request['sessionAttributes'] is not None else {}\r\n if location_zip is not None and housetype_zip is not None:\r\n output_session_attributes['Price'] = house_price_pred(location_zip,housetype_zip)#len(location_zip)*5#house_price_pred(location_zip,housetype_zip) \r\n #price = house_price_pred(location_zip,housetype_zip)# Elegant pricing model\r\n\t\t\t\r\n return delegate(output_session_attributes, get_slots(intent_request))\r\n\r\n # Order the flowers, and rely on the goodbye message of the bot to define the message to the end user.\r\n # In a real bot, this would likely involve a call to a backend service.\r\n print(intent_request['sessionAttributes']['Price']) \r\n return close(intent_request['sessionAttributes'],\r\n 'Fulfilled',\r\n {'contentType': 'PlainText',\r\n 'content': 'Approx. next year growth prediction for {hstyp} in {loc} is {prc}%'.format(hstyp=housetype_zip,loc=location_zip,prc=intent_request['sessionAttributes']['Price'])})","def test_get_prior_string_dict(self):\n categories = {\"asdfa\": 0.1, 2: 0.2, 3: 0.3, \"lalala\": 0.4}\n dim = Categorical(\n \"yolo\", categories, shape=2, default_value=[\"asdfa\", \"lalala\"]\n )\n assert dim.get_prior_string() == (\n \"choices({'asdfa': 0.10, 2: 0.20, 3: 0.30, 'lalala': 0.40}, \"\n \"shape=2, default_value=['asdfa', 'lalala'])\"\n )","def getLabel(*args):","def getLabel(*args):","def getLabel(*args):","def __rechaindict__(c):\n from TriggerMenu.menu.DictFromChainName import DictFromChainName\n dfcn = DictFromChainName()\n\n pl1 = []\n for pch in c['chainParts']:\n pl1.append(pch['L1item'])\n\n newname = c['chainName'].replace('dv_','').replace('TestChain','j')\n nchlist = [ newname ,c['chainCounter'],c['L1item'],pl1,c['stream'],\n c['groups'],c['EBstep'] ]\n \n return dfcn.getChainDict(nchlist)","def plot_hypnogram(stages, labeldict=None, title=None, epochlen=30, ax=None,\n verbose=True, xlabel=True, ylabel=True, **kwargs,):\n\n if labeldict is None:\n labeldict = {}\n _defaultdict = {-1: 'A', 0:'Wake', 4:'REM', 1:'S1', 2:'S2', 3:'SWS', 5:'Artefact'}\n if set(stages) == set([0, 1]):\n labeldict = {0:'Wake', 1:'Sleep'}\n elif set(stages) == set([0, 1, 2]):\n labeldict = {0:'Wake', 2:'REM', 1:'NREM'}\n else:\n for stage in _defaultdict:\n if stage in stages:\n labeldict[stage] = _defaultdict[stage]\n if verbose: print('Assuming {}'.format(labeldict))\n\n # check if all stages that are in the hypnogram have a corresponding label in the dict\n for stage in np.unique(stages):\n if not stage in labeldict:\n print('WARNING: {} is in stages, but not in labeldict, stage will be ??'.format(stage))\n\n # create the label order\n labels = [labeldict[l] for l in labeldict]\n labels = sorted(set(labels), key=labels.index)\n\n # we iterate through the stages and fetch the label for this stage\n # then we append the position on the plot of this stage via the labels-dict\n x = []\n y = []\n rem_start = []\n rem_end = []\n for i in np.arange(len(stages)):\n s = stages[i]\n label = labeldict.get(s)\n if label is None:\n p = 99\n if '??' not in labels: labels.append('??')\n else :\n p = -labels.index(label)\n \n # make some red line markers for REM, mark beginning and end of REM\n if 'REM' in labels:\n if label=='REM' and len(rem_start)==len(rem_end):\n rem_start.append(i-2)\n elif label!='REM' and len(rem_start)>len(rem_end):\n rem_end.append(i-1)\n if label=='REM' and i==len(stages)-1:\n rem_end.append(i+1)\n \n if i!=0:\n y.append(p)\n x.append(i-1)\n y.append(p)\n x.append(i)\n \n assert len(rem_start)==len(rem_end), 'Something went wrong in REM length calculation'\n\n x = np.array(x)*epochlen\n y = np.array(y)\n y[y==99] = y.min()-1 # make sure Unknown stage is plotted below all else\n\n if ax is None:\n plt.figure()\n ax = plt.gca()\n formatter = matplotlib.ticker.FuncFormatter(lambda s, x: time.strftime('%H:%M', time.gmtime(s)))\n \n ax.plot(x,y, **kwargs)\n ax.set_xlim(0, x[-1])\n ax.xaxis.set_major_formatter(formatter)\n \n ax.set_yticks(np.arange(len(np.unique(labels)))*-1)\n ax.set_yticklabels(labels)\n ax.set_xticks(np.arange(0,x[-1],3600))\n if xlabel: plt.xlabel('Time after recording start')\n if ylabel: plt.ylabel('Sleep Stage')\n if title is not None:\n plt.title(title)\n\n try:\n warnings.filterwarnings(\"ignore\", message='This figure includes Axes that are not compatible')\n plt.tight_layout()\n except Exception: pass\n\n # plot REM in RED here\n for start, end in zip(rem_start, rem_end):\n height = -labels.index('REM')\n ax.hlines(height, start*epochlen, end*epochlen, color='r',\n linewidth=4, zorder=99)","def final_result(self, hyp, confidence):\n print(\"Final:\"+hyp)","def handle(self, *args, **options):\n chains = sorted(plugin.BY_REQUIREMENTS.keys())\n for chain in chains:\n print(chain, \"chain:\")\n reqs = sorted(\"{} -> {}\".format(\", \".join(sorted(k)) or 'START',\n \", \".join(sorted(v))) for k, v in\n plugin.BY_REQUIREMENTS[chain].iteritems())\n for req in reqs:\n print(\"-\", req)","def get_kit_string(currentStep):\n kit_string = currentStep.udf.get(\"ONT prep kit\")\n\n if currentStep.udf.get(\"ONT expansion kit\") != \"None\":\n kit_string += f\" {currentStep.udf.get('ONT expansion kit')}\"\n\n return kit_string","def name(self):\n return self.viztrail.name","def processSystematic(observable, xsecType, xsecLevel, systematic, histNominal):\n varHists = []\n linkStr = \"\"\n singlePointSystematics = [\"ERDON\", \"ERDONRETUNE\", \"GLUONMOVETUNE\", \"BFRAG_PETERSON\"]\n\n sPS = 0\n\n if any(singlePointSystematic in systematic for singlePointSystematic in singlePointSystematics):\n sPS = 1\n\n linkStr = \"_\"\n variations = [\"\"]\n for variation in variations:\n path = directory_base + xsec_type + \"_\" + xsec_level + directory_tail + systematic + linkStr + variation + \"/combinedUnfolded/Hyp\" + observable + \"Results.txt\"\n inputfile = open(path, 'r').readlines()\n bins = []\n for line in inputfile:\n bins.append(float(line.split( )[3]))\n bins.append(float(line.split( )[5]))\n bins = sorted(bins)\n binsArray = array('f',bins)\n histNameUp = systematic + \"_UP\" \n histNameDown = systematic + \"_DOWN\" \n histUp = TH1F(histNameUp, histNameUp, len(bins)-1, binsArray)\n histDown = TH1F(histNameDown, histNameDown, len(bins)-1, binsArray)\n histUpFinal = TH1F(\"\", \"\", len(bins)-1, binsArray)\n histDownFinal = TH1F(\"\", \"\", len(bins)-1, binsArray)\n \n ibin = 0\n\n for line in inputfile:\n nomBin = histNominal.GetBinContent(ibin+1)\n nomBinCenter = histNominal.GetBinCenter(ibin+1)\n unc = float(line.split( )[7])\n if systematic == \"DY\":\n print \"DY UP = \" + str(1.0 + unc)\n print \"DY DOWN = \" + str(1.0 - unc)\n\n\n histUp.SetBinContent(ibin+1, 1.0 + unc)\n histDown.SetBinContent(ibin+1,1.0 - unc)\n ibin = ibin + 1 \n\n histUpVis = histUp.Clone()\n histDownVis = histDown.Clone()\n histUpFinal = histUp.Clone()\n histDownFinal = histDown.Clone()\n\n if systematic == \"PDF\":\n histUpFinal, histDownFinal = reNormalise(histNominal, histUpVis, histDownVis)\n\n return (histUpFinal, histDownFinal)","def get_labels(rf_pipeline):\n return rf_pipeline.stages[0].labels","def _repr_(self):\n return \"Category of hyperbolic models of {}\".format(self.base())","def label(cmd):\r\n cmd = cmd.replace('make][.DP', 'make1][.NP')\r\n cmd = cmd.replace('make][.SC', 'make2][.SC')\r\n cmd = re.sub('(draw.*)one','\\\\1one1',cmd)\r\n cmd = re.sub('(make1.*)one','\\\\1one1',cmd)\r\n cmd = re.sub('(make2.*)one','\\\\1one2',cmd)\r\n cmd = re.sub('(move.*)one','\\\\1one2',cmd)\r\n cmd = re.sub('(hide.*)one','\\\\1one2',cmd)\r\n cmd = '[result ' + cmd + ']' #dummy function for plop\r\n return cmd","def get_match_label(match):\n # Define variables\n home_goals = match['home_team_goal']\n away_goals = match['away_team_goal']\n\n label = pd.Series()\n label['match_api_id'] = match['match_api_id']\n\n # Identify match label\n if home_goals > away_goals:\n label['label'] = \"Win\"\n if home_goals == away_goals:\n label['label'] = \"Draw\"\n if home_goals < away_goals:\n label['label'] = \"Defeat\"\n\n # Return label (match_api_id; label)\n return label","def main(_):\n hps = LM.get_default_hparams().parse(FLAGS.hpconfig)\n hps._set(\"num_gpus\", FLAGS.num_gpus)\n print ('*****HYPER PARAMETERS*****')\n print (hps)\n print ('**************************')\n\n vocab = Vocabulary.from_file(os.path.join(FLAGS.datadir, \"vocabulary.txt\"))\n\n if FLAGS.mode == \"train\":\n #hps.batch_size = 256\n dataset = Dataset(vocab, os.path.join(FLAGS.datadir, \"train.txt\"))\n run_train(dataset, hps, os.path.join(FLAGS.logdir, \"train\"), ps_device=\"/gpu:0\")\n elif FLAGS.mode.startswith(\"eval\"):\n data_dir = os.path.join(FLAGS.datadir, \"eval.txt\")\n #predict_model = prediction.Model('/dir/ckpt',os.path.join(FLAGS.datadir, \"vocabulary.txt\"), hps)\n\n dataset = Dataset(vocab, data_dir, deterministic=True)\n prefix_words = \"<brk>\".split()\n predict_model = predict.Model(hps, FLAGS.logdir, FLAGS.datadir)\n print ('start input')\n out = predict_model.predictnextkwords(prefix_words, FLAGS.num_sen)\n for row in out:\n print(' '.join(row) + \"\\n\")\n print(\"len_out: \" + str(len(out)))\n #prediction.topkwords(prefix_words, dataset, hps, FLAGS.logdir, FLAGS.mode)\n #sentence_ppl(prefix_words,dataset, hps, FLAGS.logdir, FLAGS.mode)\n #print vocab\n #dataset = Dataset(vocab, os.path.join(FLAGS.datadir, \"eval.txt\"))\n #run_eval(dataset, hps, FLAGS.logdir, FLAGS.mode, FLAGS.eval_steps)","def get_new_word(key, chains):\n values = chains[key]\n return choice(values)","def parse_logic(self, logic):\n if 'xxx' in logic.conf:\n # self.function(logic['name'])\n pass","def forward(self, waveforms: Tensor) -> str:\n logits, _ = self.model(waveforms) # [batch, num_seq, num_label]\n best_path = torch.argmax(logits[0], dim=-1) # [num_seq,]\n prev = ''\n hypothesis = ''\n for i in best_path:\n char = self.labels[i]\n if char == prev:\n continue\n if char == '<s>':\n prev = ''\n continue\n hypothesis += char\n prev = char\n return hypothesis.replace('|', ' ')","def make_text(chains):\n\n key = random.choice(chains.keys())\n return_string = key[0] + \" \" + key[1]\n\n while chains[key] != None: #chains.get(key[-1]) != None: \n next_word = random.choice(chains[key])\n return_string = return_string + \" \" + next_word\n key = (key[1],next_word)\n\n return return_string","def get_chain_name (chain):\n if \"-\" in chain.id:\n id_chain=chain.id[-1]\n else:\n id_chain=chain.id\n return id_chain","def _get_label(self):\n return self.label","def get_clarifications_socialiqa(ex, nlp, comet_model):\n context = ex['context']\n question = ex['question']\n\n question_to_comet_relation = {\n \"What will [NAME] want to do next?\": \"xWant\",\n \"What will [NAME] want to do after?\": \"xWant\",\n \"How would [NAME] feel afterwards?\": \"xReact\",\n \"How would [NAME] feel as a result?\": \"xReact\",\n \"What will [NAME] do next?\": \"xReact\",\n \"How would [NAME] feel after?\": \"xReact\",\n \"How would you describe [NAME]?\": \"xAttr\",\n \"What kind of person is [NAME]?\": \"xAttr\",\n \"How would you describe [NAME] as a person?\": \"xAttr\",\n \"Why did [NAME] do that?\": \"xIntent\",\n \"Why did [NAME] do this?\": \"xIntent\",\n \"Why did [NAME] want to do this?\": \"xIntent\",\n \"What does [NAME] need to do beforehand?\": \"xNeed\",\n \"What does [NAME] need to do before?\": \"xNeed\",\n \"What does [NAME] need to do before this?\": \"xNeed\",\n \"What did [NAME] need to do before this?\": \"xNeed\",\n \"What will happen to [NAME]?\": \"xEffect\",\n \"What will happen to [NAME] next?\": \"xEffect\"\n }\n\n clarifications = []\n personx, _ = get_personx(nlp, context)\n relation = question_to_comet_relation.get(re.sub(personx, \"[NAME]\", question, flags=re.I), None)\n\n if relation is not None:\n outputs = {relation: comet_model.predict(context, relation, num_beams=5)}\n\n prefix = CATEGORY_TO_PREFIX[relation]\n for out_event in outputs[relation]:\n if out_event != \"none\" and out_event != \"\":\n if not out_event.lower().startswith(\"person\") and not out_event.lower().startswith(\"other\"):\n out_event = \" \".join((prefix, out_event))\n\n out_event = re.sub(\"personx\", personx, out_event, flags=re.I)\n out_event = re.sub(\"person x\", personx, out_event, flags=re.I)\n out_event = re.sub(\"persony\", \"others\", out_event, flags=re.I)\n out_event = re.sub(\"person y\", \"others\", out_event, flags=re.I)\n\n clarifications.append((question, out_event))\n\n return clarifications","def label(efo):\n url = 'https://www.ebi.ac.uk/ols/api/ontologies/efo/terms?iri=http://www.ebi.ac.uk/efo/'+efo\n try:\n response = requests.get(url).json()\n except:\n return \"\"\n if 'error' in response.keys():\n return \"\"\n return response['_embedded']['terms'][0]['label']","def chain_run(ctx, chain_name, mine, verbosity):\n logger = logging.getLogger('populus.cli.chain.run')\n project = ctx.obj['PROJECT']\n\n chain = project.get_chain(chain_name)\n\n if isinstance(chain, BaseGethChain):\n chain.geth.register_stdout_callback(logger.info)\n chain.geth.register_stderr_callback(logger.error)\n\n with chain:\n try:\n while True:\n time.sleep(0.2)\n except KeyboardInterrupt:\n pass","def getRaceLabel(x,binary=False):\r\n ID = x.split(\"/\")[-1].split(\"_\")[0]\r\n label = truth[truth.DummyID == int(ID)]['Medview_Race'].values[0]\r\n\r\n if label == 'African American':\r\n return 0\r\n elif label == \"White\":\r\n return 1\r\n else:\r\n return 2","def pipeline(self):\n predicted, real = self.surface_segmentation()\n # print(predicted[0:10])\n # print(len(predicted))\n test_file = \"../morphology/\" + self.language + \"/\" + self.language + \".clean.test.conll\"\n input_file = open(os.path.join(sys.path[0], test_file), 'r')\n segmented_words = []\n\n # Only one entry per word for dictionary\n\n words = []\n labels = []\n for line in input_file.readlines():\n tmp = line.rstrip('\\n').split(\" | \")[0]\n label_arr = line.rstrip('\\n').split(\" | \")[2]\n label_arr = get_labels(label_arr)\n if tmp not in words:\n words.append(tmp)\n labels.append(label_arr)\n\n segmented_words = []\n for word, label in zip(words, predicted):\n tmp = []\n for i in range(len(label)):\n if label[i] == \"S\" or label[i] == \"E\":\n tmp.append(word[i])\n tmp.append(\"-\")\n else:\n tmp.append(word[i])\n tmp = \"\".join(tmp).rstrip(\"-\")\n segmented_words.append(tmp)\n\n features = surface_labelled_data_preparation_pipeline(segmented_words)\n predicted, test = self.__surface_labelled_segmentation_pipeline(features)\n return predicted, labels","def get_clarifications_piqa(ex, nlp, comet_model):\n # Questions are usually like \"how would you do something?\"\n personx = \"you\"\n\n input_event = ex[\"goal\"].replace(\"?\", \"\")\n outputs = {category: comet_model.predict(input_event, category, num_beams=5) for category in comet_model.categories}\n\n # We only care about preconditions and postconditions for X\n relevant_categories = [\"xIntent\", \"xNeed\", \"xEffect\", \"xWant\"]\n curr_events = []\n for category in relevant_categories:\n prefix = CATEGORY_TO_PREFIX[category]\n for out_event in outputs[category]:\n if out_event != \"none\" and out_event != \"\":\n if not out_event.lower().startswith(\"person\") and not out_event.lower().startswith(\"other\"):\n out_event = \" \".join((prefix, out_event))\n\n out_event = re.sub(\"personx\", personx, out_event, flags=re.I)\n out_event = re.sub(\"person x\", personx, out_event, flags=re.I)\n out_event = re.sub(\"persony\", \"others\", out_event, flags=re.I)\n out_event = re.sub(\"person y\", \"others\", out_event, flags=re.I)\n\n question = CATEGORY_TO_QUESTION[category].replace(\"PersonX\", personx)\n curr_events.append((question, out_event))\n\n return curr_events","def get_label(self):\n return self.job[self.label_key]","def lhco_line(self):\n if not self.check_def(['eta','phi','pt','mass','pid']): \n sys.exit('Particle error: some attribute not defined')\n\n jet=[1,2,3,4,5,6,21]\n inv_list=[12,14,16,18,1000022,1000023,1000024,1000025,1000035]\n\n #define pid-> type\n pid_to_type={11:1,-11:1,13:2,-13:2,15:3,-15:3,22:0}\n for data in jet:\n pid_to_type[data]=4\n pid_to_type[-data]=4\n for data in inv_list:\n pid_to_type[data]=6\n pid_to_type[-data]=6\n\n\n \n type=''\n for key in pid_to_type.keys():\n if self.pid==key:\n type=pid_to_type[key]\n break\n \n if type=='':\n print 'Warning unknown type'\n return ''\n\n text =' '+str(type) #type LHCO\n text+=' '+str(self.eta) #ETA\n text+=' '+str(self.phi) #PHI\n text+=' '+str(self.pt) #PT\n text+=' '+str(self.mass) #JMASS\n if self.pid in [11,13]: #NTRK\n text+=' -1' \n else:\n text+=' 1'\n if self.pid in [-5,5]: #BTAG\n text+=' 2'\n else:\n text+=' 0'\n text+=' 0' #HAD/EM\n text+=' 0' #DUMMY 1\n text+=' 0' #DUMMY 2\n \n return text","def get_chain(self, chain_id):\n if self.chain_dict.has_key(chain_id):\n return self.chain_dict[chain_id]\n return None","def label(self) -> str:\n return self[\"label\"]","def label(cmd):\n cmd = cmd.replace('make][.DP', 'make1][.NP')\n cmd = cmd.replace('make][.SC', 'make2][.SC')\n cmd = re.sub('(draw.*)one','\\\\1one1',cmd)\n cmd = re.sub('(make1.*)one','\\\\1one1',cmd)\n cmd = re.sub('(make2.*)one','\\\\1one2',cmd)\n cmd = re.sub('(move.*)one','\\\\1one2',cmd)\n cmd = re.sub('(hide.*)one','\\\\1one2',cmd)\n cmd = '[result ' + cmd + ']' #dummy function for plop\n return cmd","def SetupFcn(self):\n return _hypre.HypreParaSails_SetupFcn(self)","def generate_HLD(component, output):\n component.delete_none_attrs()\n yaml.indent(mapping=2, sequence=4, offset=2)\n d = component.asdict()\n\n yaml.dump(d, output)"],"string":"[\n \"def _make_ht_label(chain_parts):\\n\\n assert len(chain_parts) == 1, '_make_ht_label, no. of chain parts != 1'\\n scenario = chain_parts[0]['hypoScenario']\\n \\n assert scenario.startswith('HT'), '_make_ht_label(): scenario does not start with HT'\\n\\n arg_res = [\\n re.compile(r'^(?P<lo>\\\\d*)(?P<key>ht)(?P<hi>\\\\d*)$'),\\n re.compile(r'^(?P<lo>\\\\d*)(?P<key>et)(?P<hi>\\\\d*)$'),\\n re.compile(r'^(?P<lo>\\\\d*)(?P<key>eta)(?P<hi>\\\\d*)$'),\\n ]\\n\\n defaults = {\\n 'ht': ('0', 'inf'),\\n 'et': ('0', 'inf'),\\n 'eta': ('0', 'inf'),\\n }\\n\\n\\n args = _args_from_scenario(scenario)\\n argvals = {}\\n nargs = len(args)\\n assert len(args) <= len(arg_res), 'bad num of args %d, expected < %d' % (len(args),\\n len(arg_res))\\n\\n # obtain argument values frrom scenario\\n while args:\\n arg = args.pop()\\n for r in arg_res:\\n m = r.match(arg)\\n if m is not None:\\n arg_res.remove(r)\\n gd = m.groupdict()\\n key = gd['key']\\n\\n try:\\n lo = float(gd['lo'])\\n except ValueError:\\n lo = float(defaults[key][0])\\n argvals[key+'lo'] = lo \\n try:\\n hi = float(gd['hi'])\\n except ValueError:\\n hi = float(defaults[key][1])\\n argvals[key+'hi'] = hi\\n\\n print (argvals)\\n assert len(argvals) == 2*nargs, 'no of args: %d, expected %d' % (len(argvals), 2*nargs)\\n\\n print ('sent 100')\\n result = \\\"\\\"\\\"\\n ht([(%(htlo).0fht) \\n (%(etlo).0fet)\\n (%(etalo).0feta%(etahi).0f)\\n ])\\\"\\\"\\\" % argvals\\n print (result)\\n return result\",\n \"def _make_combinationsTest_label(chain_parts):\\n\\n assert len(chain_parts) == 1\\n scenario = chain_parts[0]['hypoScenario']\\n \\n assert scenario == 'combinationsTest'\\n\\n \\n\\n return \\\"\\\"\\\"\\n combgen(\\n [(2)(20et, 0eta320)]\\n \\n simple([(40et, 0eta320) (50et, 0eta320)])\\n simple([(35et, 0eta240) (55et, 0eta240)])\\n )\\\"\\\"\\\"\",\n \"def _make_simple_comb_label(chain_dict):\\n\\n cps = chain_dict['chainParts']\\n if not (_select_simple_chainparts(cps)):\\n raise NotImplementedError(\\n 'chain fails substring selection: not \\\"simple\\\": %s' % (\\n chain_dict['chainName']))\\n \\n simple_strs = []\\n\\n for cp in cps:\\n print(cp)\\n simple_strs.append(_make_simple_label([cp]))\\n\\n label = 'combgen([(%d)]' % len(cps)\\n for s in simple_strs:\\n label += ' %s ' % s\\n label += ')'\\n return label\",\n \"def _make_simple_label(chain_parts):\\n \\n if not _select_simple_chainparts(chain_parts):\\n msg = 'Jet Configuration error: '\\\\\\n 'chain fails substring selection: not \\\"simple\\\" '\\n\\n raise NotImplementedError(msg)\\n \\n label = 'simple(['\\n for cp in chain_parts:\\n smcstr = str(cp['smc'])\\n jvtstr = str(cp['jvt'])\\n if smcstr == 'nosmc':\\n smcstr = ''\\n for i in range(int(cp['multiplicity'])):\\n # condition_str = '(%set,%s,%s)' % (str(cp['threshold']),\\n # str(cp['etaRange']),\\n # smcstr,)\\n condition_str = '(%set,%s' % (str(cp['threshold']),\\n str(cp['etaRange']),)\\n if smcstr: # Run 2 chains have \\\"INF\\\" in the SMC substring\\n condition_str += ',%s)' % smcstr.replace('INF','')\\n elif jvtstr:\\n condition_str += ',%s)' % jvtstr\\n else:\\n condition_str += ')'\\n label += condition_str\\n label += '])'\\n return label\",\n \"def _make_simple_partition_label(chain_dict):\\n\\n cps = chain_dict['chainParts']\\n if not (_select_simple_chainparts(cps)):\\n raise NotImplementedError(\\n 'chain fails substring selection: not \\\"simple\\\": %s' % (\\n chain_dict['chainName']))\\n \\n label = 'simplepartition(['\\n for cp in cps:\\n smcstr = str(cp['smc'])\\n if smcstr == 'nosmc':\\n smcstr = ''\\n for i in range(int(cp['multiplicity'])):\\n # condition_str = '(%set,%s,%s)' % (str(cp['threshold']),\\n # str(cp['etaRange']),\\n # smcstr,)\\n condition_str = '(%set,%s' % (str(cp['threshold']),\\n str(cp['etaRange']),)\\n if smcstr:\\n condition_str += ',%s)'\\n else:\\n condition_str += ')'\\n label += condition_str\\n label += '])'\\n return label\",\n \"def _make_partitionsTest_label(chain_parts):\\n\\n assert len(chain_parts) == 1\\n scenario = chain_parts[0]['hypoScenario']\\n \\n assert scenario == 'partitionsTest'\\n\\n \\n\\n return \\\"\\\"\\\"\\n partgen(\\n [(20et, 0eta320)]\\n \\n simple([(40et, 0eta320) (50et, 0eta320)])\\n simple([(35et, 0eta240) (55et, 0eta240)])\\n )\\\"\\\"\\\"\",\n \"def _make_dijet_label(chain_parts):\\n\\n assert len(chain_parts) == 1\\n scenario = chain_parts[0]['hypoScenario']\\n \\n assert scenario.startswith('dijet')\\n\\n arg_res = [\\n re.compile(r'^(?P<lo>\\\\d*)(?P<key>djmass)(?P<hi>\\\\d*)$'),\\n re.compile(r'^(?P<lo>\\\\d*)(?P<key>j1et)(?P<hi>\\\\d*)$'),\\n re.compile(r'^(?P<lo>\\\\d*)(?P<key>j1eta)(?P<hi>\\\\d*)$'),\\n re.compile(r'^(?P<lo>\\\\d*)(?P<key>j2et)(?P<hi>\\\\d*)$'),\\n re.compile(r'^(?P<lo>\\\\d*)(?P<key>j2eta)(?P<hi>\\\\d*)$'),\\n ]\\n\\n defaults = {\\n 'j1et': ('100', 'inf'),\\n 'j2et': ('100', 'inf'),\\n 'j1eta': ('0', '320'),\\n 'j2eta': ('0', '320'),\\n 'djmass': ('1000', 'inf'),\\n }\\n\\n\\n args = _args_from_scenario(scenario)\\n argvals = {}\\n while args:\\n assert len(args) == len(arg_res)\\n arg = args.pop()\\n for r in arg_res:\\n m = r.match(arg)\\n if m is not None:\\n arg_res.remove(r)\\n gd = m.groupdict()\\n key = gd['key']\\n\\n try:\\n lo = float(gd['lo'])\\n except ValueError:\\n lo = defaults[key][0]\\n argvals[key+'lo'] = lo \\n try:\\n hi = float(gd['hi'])\\n except ValueError:\\n hi = defaults[key][1]\\n argvals[key+'hi'] = hi\\n\\n assert len(args) == len(arg_res)\\n assert len(args) == 0\\n\\n return \\\"\\\"\\\"\\n combgen(\\n [(2)(%(j1etlo).0fet, %(j1etalo).0feta%(j1etahi).0f)\\n (%(j1etlo).0fet, %(j1etalo).0feta%(j1etahi).0f)\\n ]\\n \\n dijet(\\n [(%(djmasslo).0fdjmass)])\\n simple([(%(j1etlo).0fet, %(j1etalo).0feta%(j1etahi).0f)\\n (%(j2etlo).0fet, %(j2etalo).0feta%(j2etahi).0f)])\\n )\\\"\\\"\\\" % argvals\",\n \"def get_label(self, hierarchy: List[str]) -> Any:\",\n \"def _make_vbenf_label(chain_parts):\\n\\n # toy label for development: run simple and dijet independently.\\n # simple makes Et cuts on two jets. Independently (sharing possible)\\n # of jets choosean by simple, the dijet\\n # scenario requires a dijet of mass > 900, and opening angle in phi > 2.6\\n\\n assert len(chain_parts) == 1\\n scenario = chain_parts[0]['hypoScenario']\\n assert scenario.startswith('vbenf')\\n args = _args_from_scenario(scenario)\\n if not args:\\n return 'and([]simple([(50et)(70et)])combgen([(2)] dijet([(900djmass, 26djdphi)])))' \\n arg_res = [\\n re.compile(r'(?P<lo>\\\\d*)(?P<key>fbet)(?P<hi>\\\\d*)'),\\n re.compile(r'(?P<lo>\\\\d*)(?P<key>mass)(?P<hi>\\\\d*)'),\\n re.compile(r'(?P<lo>\\\\d*)(?P<key>et)(?P<hi>\\\\d*)'),\\n ]\\n\\n defaults = {\\n 'et': ('101', 'inf'),\\n 'mass': ('800', 'inf'),\\n 'fbet': ('501', 'inf'),\\n }\\n\\n argvals = {}\\n while args:\\n assert len(args) == len(arg_res)\\n arg = args.pop()\\n for r in arg_res:\\n m = r.match(arg)\\n if m is not None:\\n arg_res.remove(r)\\n gd = m.groupdict()\\n key = gd['key']\\n try:\\n lo = float(gd['lo'])\\n except ValueError:\\n lo = defaults[key][0]\\n argvals[key+'lo'] = lo \\n try:\\n hi = float(gd['hi'])\\n except ValueError:\\n hi = defaults[key][1]\\n argvals[key+'hi'] = hi\\n\\n assert len(args) == len(arg_res)\\n assert len(args) == 0\\n\\n return \\\"\\\"\\\"\\n and\\n (\\n []\\n simple\\n (\\n [(%(etlo).0fet, 500neta)(%(etlo).0fet, peta500)]\\n )\\n combgen\\n (\\n [(10et, 0eta320)]\\n dijet\\n (\\n [(%(masslo).0fdjmass, 26djdphi)]\\n ) \\n simple\\n (\\n [(10et, 0eta320)(20et, 0eta320)]\\n )\\n )\\n )\\\"\\\"\\\" % argvals\",\n \"def chain():\\n chain_identifier, url = get_vars(request, [\\\"id\\\", \\\"data\\\"])\\n info('chain=%s' % chain_identifier)\\n chain = LAPPS_SERVICE_CHAINS.get_chain(chain_identifier)\\n info('source-url=%s' % url)\\n data = requests.get(url).text\\n result = chain.run({\\n \\\"discriminator\\\": \\\"http://vocab.lappsgrid.org/ns/media/text\\\", \\n \\\"payload\\\": data})\\n info(\\\"discriminator=%s\\\" % result.get('discriminator'))\\n return render_template(\\\"chain.html\\\",\\n chain=chain,\\n fname=url,\\n result=result,\\n builder=HtmlBuilder())\",\n \"def chain_name(self) -> str:\\n return pulumi.get(self, \\\"chain_name\\\")\",\n \"def _get_label(self):\\n if self.model.name == '':\\n return \\\"KPI\\\"\\n return \\\"KPI: {} ({})\\\".format(self.model.name, self.model.objective)\",\n \"def get_extra_label(self, label_name: str, hierarchy: List[str]) -> Any:\",\n \"def chainLabel(self,i):\\n assert(i >= 0 and i < self.nAtoms())\\n assert(self._c_structure is not NULL)\\n cdef char label[2]\\n label[0] = freesasa_structure_atom_chain(self._c_structure,i)\\n label[1] = '\\\\0'\\n return label\",\n \"def __init__(self, **kwargs):\\n\\n polymer_type = \\\"PE\\\"\\n helice = Helice()\\n num_monomers = 30\\n tacticity = \\\"\\\"\\n chiriality = \\\"\\\"\\n head_tail_defect_ratio = 0\\n configs = 30\\n infinite = False\\n\\n for key in kwargs:\\n if key == \\\"polymer_type\\\":\\n polymer_type = kwargs[\\\"polymer_type\\\"]\\n elif key == \\\"helice\\\":\\n helice = kwargs[\\\"helice\\\"]\\n elif key == \\\"num_monomers\\\":\\n num_monomers = kwargs[\\\"num_monomers\\\"]\\n if is_integer_num(num_monomers):\\n if num_monomers < 1:\\n raise ValueError(\\n \\\"Number of monomers should be equal or larger than 1\\\"\\n )\\n else:\\n raise ValueError(\\\"Number of monomers should be an integer\\\")\\n elif key == \\\"tacticity\\\":\\n tacticity = kwargs[\\\"tacticity\\\"]\\n elif key == \\\"chiriality\\\":\\n chiriality = kwargs[\\\"chiriality\\\"]\\n elif key == \\\"head_tail_defect_ratio\\\":\\n head_tail_defect_ratio = kwargs[\\\"head_tail_defect_ratio\\\"]\\n elif key == \\\"configs\\\":\\n configs = kwargs[\\\"configs\\\"]\\n elif key == \\\"infinite\\\":\\n infinite = kwargs[\\\"infinite\\\"]\\n else:\\n raise KeyError(\\n \\\"Unknown input %s for Chain class\\\\n Please see help for more information\\\"\\n % key\\n )\\n\\n if polymer_type not in polymer_types:\\n raise ValueError(\\n polymer_type\\n + \\\" do not exist in our library, please consider using custom feature\\\"\\n )\\n self.polymer_type = polymer_types[polymer_type]\\n\\n if self.polymer_type.helicity:\\n self.custom = 0\\n else:\\n self.custom = 1\\n\\n if self.custom:\\n print(\\\"Warning: Custom type, only read helice motifs and turns info\\\")\\n self.helice = helice\\n\\n if not 0 <= (head_tail_defect_ratio) <= 1:\\n raise ValueError(\\n \\\"Defect ratio of head to head and tail to tail connections is\\\",\\n head_tail_defect_ratio,\\n \\\"and should be in the range of [0,1]\\\",\\n )\\n self.head_tail_defect_ratio = head_tail_defect_ratio\\n\\n self.unit_num_monomers = 1\\n if \\\"num_monomers\\\" not in kwargs:\\n if infinite:\\n num_monomers = 2\\n else:\\n num_monomers = 1\\n\\n self.num_monomers = num_monomers\\n\\n self.tacticity = tacticity\\n if self.tacticity:\\n if self.tacticity == \\\"N/A\\\":\\n self.tacticity = \\\"\\\"\\n else:\\n print(\\\"Warning: Custom type does not have tacticity\\\")\\n self.tacticity = \\\"\\\"\\n\\n self.chiriality = chiriality\\n if self.chiriality:\\n if self.chiriality == \\\"N/A\\\":\\n self.chiriality = \\\"\\\"\\n else:\\n print(\\\"Warning: Custom type does not have chiriality\\\")\\n self.chiriality = \\\"\\\"\\n\\n self.infinite = infinite\\n\\n else:\\n monomer_backbone_atoms = len(self.polymer_type.backbone_atoms)\\n\\n if helice.atoms % monomer_backbone_atoms:\\n raise Exception(\\n \\\"Number of backbone atoms in a motif must be multiple of number of monomer backbone atoms %d\\\\n\\\"\\n % monomer_backbone_atoms\\n )\\n if tacticity == \\\"syndiotactic\\\":\\n multiple = int(monomer_backbone_atoms * 2 / helice.atoms)\\n if (multiple * helice.atoms) % (monomer_backbone_atoms * 2):\\n raise Exception(\\n \\\"Number of backbone atoms in a motif for syndiotactic configuration must be multiple of twice of \\\\\\n the number of monomer backbone atoms %d\\\\n\\\"\\n % monomer_backbone_atoms\\n * 2\\n )\\n elif multiple != 1:\\n print(\\n \\\"Number of backbone atoms in a motif for syndiotactic configuration should be multiple of twice \\\\\\n of the number of monomer backbone atoms %d\\\\n\\\"\\n % (monomer_backbone_atoms * 2)\\n )\\n print(\\n \\\"Trying Helice_%d_%d_%d...\\\"\\n % (\\n helice.atoms * multiple,\\n helice.motifs,\\n helice.turns * multiple,\\n )\\n )\\n helice = Helice(\\n helice.atoms * multiple, helice.motifs, helice.turns * multiple\\n )\\n # else:\\n # if monomer_backbone_atoms != helice.atoms:\\n # raise ValueError(\\\"Number of backbone atoms in a motif must be %d\\\" % helice.atoms)\\n helice_backbone_atoms = helice.atoms * helice.motifs\\n self.helice = helice\\n\\n if not 0 <= (head_tail_defect_ratio) <= 1:\\n raise ValueError(\\n \\\"Defect ratio of head to head and tail to tail connections is\\\",\\n head_tail_defect_ratio,\\n \\\"and should be in the range of [0,1]\\\",\\n )\\n self.head_tail_defect_ratio = head_tail_defect_ratio\\n\\n self.unit_num_monomers = int(helice_backbone_atoms / monomer_backbone_atoms)\\n if \\\"num_monomers\\\" not in kwargs:\\n if infinite:\\n if tacticity == \\\"atactic\\\" or head_tail_defect_ratio:\\n num_monomers = 10 * self.unit_num_monomers\\n elif helice_backbone_atoms > 2:\\n num_monomers = self.unit_num_monomers\\n else:\\n num_monomers = 2\\n\\n if num_monomers < self.unit_num_monomers:\\n raise ValueError(\\n \\\"Number of monomers should be equal or larger than %d in order to generate Helice_%s chain.\\\\nCurrent \\\\\\n number of monomers is %d\\\"\\n % (self.unit_num_monomers, helice, num_monomers)\\n )\\n\\n if infinite:\\n if num_monomers % self.unit_num_monomers:\\n raise ValueError(\\n \\\"Number of monomers should be multiple of %d in order to generate infinite periodic Helice_%s \\\\\\n chain.\\\\nCurrent number of monomers is %d\\\"\\n % (self.unit_num_monomers, helice, num_monomers)\\n )\\n elif num_monomers * monomer_backbone_atoms < 3:\\n raise ValueError(\\n \\\"Number of backbone atoms should be more than 2 in order to create infinite periodic \\\\\\n chain.\\\\nCurrent number of backbone atoms along the periodic chain is %d\\\\nPlease increate \\\\\\n number of monomers.\\\"\\n % (num_monomers * monomer_backbone_atoms)\\n )\\n self.num_monomers = num_monomers + 2 if infinite else num_monomers\\n\\n self.tacticity = tacticity\\n if self.tacticity:\\n if self.tacticity == \\\"N/A\\\":\\n self.tacticity = \\\"\\\"\\n elif self.tacticity not in [\\\"isotactic\\\", \\\"atactic\\\", \\\"syndiotactic\\\"]:\\n raise TypeError(\\n \\\"Unknown tacticity, please specify one of the following: isotactic, atactic and syndiotactic\\\"\\n )\\n elif not self.polymer_type.side_atom:\\n raise ValueError(\\\"Please specify side_atom\\\")\\n\\n self.chiriality = chiriality\\n if str(self.helice) in [\\\"2_1_1\\\", \\\"4_1_2\\\"]:\\n self.torsion_seq = [180, 180, 180, 180]\\n if self.chiriality:\\n self.chiriality = \\\"\\\"\\n print(\\\"Zig-zag conformation does not have chiriality\\\")\\n elif str(self.helice) in [\\\"2_2_1\\\", \\\"4_2_2\\\"]:\\n if self.chiriality == \\\"left\\\":\\n self.torsion_seq = [300, 300, 300, 300]\\n elif self.chiriality == \\\"right\\\":\\n self.torsion_seq = [60, 60, 60, 60]\\n else:\\n raise ValueError(\\\"Please specify chiriality: left or right\\\")\\n elif str(self.helice) in [\\\"2_3_1\\\", \\\"4_3_2\\\"]:\\n if self.chiriality == \\\"left\\\":\\n self.torsion_seq = [180, 300, 180, 300]\\n elif self.chiriality == \\\"right\\\":\\n self.torsion_seq = [60, 180, 60, 180]\\n else:\\n raise ValueError(\\\"Please specify chiriality: left or right\\\")\\n elif str(self.helice) == \\\"4_1_1\\\":\\n self.torsion_seq = [60, 180, 300, 180]\\n if self.chiriality:\\n self.chiriality = \\\"\\\"\\n print(\\\"Helice_4_1_1 conformation does not have chiriality\\\")\\n elif str(self.helice) == \\\"4_2_1\\\":\\n if self.chiriality == \\\"left\\\":\\n self.torsion_seq = [180, 180, 300, 300]\\n elif self.chiriality == \\\"right\\\":\\n self.torsion_seq = [60, 60, 180, 180]\\n else:\\n raise ValueError(\\\"Please specify chiriality: left or right\\\")\\n elif str(self.helice) == \\\"4_3_1\\\":\\n if self.chiriality == \\\"left\\\":\\n if self.helice.sub_type:\\n self.torsion_seq = [180, 300, 300, 300]\\n else:\\n self.torsion_seq = [180, 180, 180, 300]\\n elif self.chiriality == \\\"right\\\":\\n if self.helice.sub_type:\\n self.torsion_seq = [60, 60, 60, 180]\\n else:\\n self.torsion_seq = [60, 180, 180, 180]\\n else:\\n raise ValueError(\\\"Please specify chiriality: left or right\\\")\\n else:\\n raise Exception(\\\"Helice_%s is currently not supported\\\" % self.helice)\\n\\n self.configs = configs\\n self.infinite = infinite\\n # self.pattern = 0\\n self.monomers = []\\n self.weights = {}\",\n \"def describe(self):\\n branch = randint(0,62)\\n \\n if 0 <= branch <= 29: \\n if self.casteOrder[0] == 'soldiers':\\n if self.genesis == 'escape persecution': \\n self.description = '{2}: A full service {3} for retired {1}'.format(choice(self.__class__.badjectives), choice(self.__class__.soldierSynonyms), self.name, choice(self.__class__.settlements[self.tech])) \\n elif self.genesis == 'maintain control': \\n self.description = 'The penal mining colony for {0} {1} on {2}'.format(choice(self.__class__.badjectives), choice(self.__class__.casteSynonyms[self.casteOrder[5]]), self.name, choice(self.__class__.settlements[self.tech])) \\n elif self.genesis == 'explore the unknown':\\n self.description = 'The frontier garrison and {2} {0} recently conquered {1}'.format(choice(self.__class__.techPreps[self.tech]), self.name, choice(self.__class__.settlements[self.tech]))\\n elif self.genesis == 'seed the galaxy with life':\\n self.description = 'The militarized {3} and bonsai garden for the mandatory contemplation of {0} {1} {2}'.format(choice(self.__class__.seedIdeals), choice(self.__class__.techPreps[self.tech]), self.name, choice(self.__class__.settlements[self.tech]))\\n elif self.genesis == 'spread the gospel':\\n self.description = 'An outpost for crusaders who took up arms to defend {2} {3} on {0} {1}'.format(choice(self.__class__.techAdjectives[self.tech]), self.name, choice(self.__class__.badjectives), choice(self.__class__.priestSynonyms)) \\n elif self.casteOrder[0] == 'scientists':\\n if self.genesis == 'escape persecution': \\n self.description = 'A sanctuary for {0} who challenged the dogma of powerful {1} {2} {3}'.format(choice(self.__class__.scientistSynonyms), choice(self.__class__.priestSynonyms), choice(self.__class__.techPreps[self.tech]), self.name) \\n elif self.genesis == 'maintain control': \\n self.description = '{0}, home to a coalition of {1} eugenicists and their {2} servants'.format(self.name, choice(self.__class__.scientistAdjectives), choice(self.__class__.casteAdjectives[self.casteOrder[5]]))\\n elif self.genesis == 'explore the unknown':\\n self.description = 'An Extremely Large Hadron Collider {0} {1} {2}'.format(choice(self.__class__.techPreps[self.tech]), choice(self.__class__.techAdjectives[self.tech]), self.name)\\n elif self.genesis == 'seed the galaxy with life':\\n self.description = 'The research institute and {2} for abiogenesis on {0} {1}'.format(choice(self.__class__.techAdjectives[self.tech]), self.name, choice(self.__class__.settlements[self.tech]))\\n elif self.genesis == 'spread the gospel':\\n self.description = 'The Galactic Academy of Sciences founded by {0} {1} {2} {3}'.format(choice(self.__class__.scientistAdjectives), choice(self.__class__.scientistSynonyms), choice(self.__class__.techPreps[self.tech]), self.name)\\n elif self.casteOrder[0] == 'laborers':\\n if self.genesis == 'escape persecution':\\n self.description = 'The {0} for unionized {1} {2} {3}'.format(choice(self.__class__.settlements[self.tech]), choice(self.__class__.laborerSynonyms), choice(self.__class__.techPreps[self.tech]), self.name)\\n elif self.genesis == 'maintain control':\\n self.description = '{0} {1}: divisional headquarters for the communist party in this region of the galaxy (where evidence of {2} has been redacted)'.format(choice(self.__class__.techAdjectives[self.tech]).capitalize(), self.name, choice(self.__class__.controlIdeals))\\n elif self.genesis == 'explore the unknown':\\n self.description = 'A team of robot {0} sent to survey {1} {2}'.format(choice(self.__class__.laborerSynonyms), choice(self.__class__.techAdjectives[self.tech]), self.name)\\n elif self.genesis == 'seed the galaxy with life':\\n self.description = 'Drones sent to terraform {0} {1} and build {2}'.format(choice(self.__class__.techAdjectives[self.tech]), self.name, choice(self.__class__.seedPlaces))\\n elif self.genesis == 'spread the gospel':\\n self.description = 'The {0} {1} {2} where a hard day\\\\'s work is highly valued'.format(choice(self.__class__.settlements[self.tech]), choice(self.__class__.techPreps[self.tech]), self.name)\\n elif self.casteOrder[0] == 'merchants':\\n if self.genesis == 'escape persecution':\\n self.description = '{0} {1}: a refuge for {2} who fled a communist revolution on their home planet'.format(choice(self.__class__.techAdjectives[self.tech]).capitalize(), self.name, choice(self.__class__.merchantSynonyms))\\n elif self.genesis == 'maintain control':\\n self.description = 'The monopolistic conglomerate of {0} {1} {2} {3}'.format(choice(self.__class__.merchantAdjectives), choice(self.__class__.merchantSynonyms), choice(self.__class__.techPreps[self.tech]), self.name)\\n elif self.genesis == 'explore the unknown':\\n self.description = '{3} {0}, home to a consortium of {1} seeking to monetize {2}'.format(self.name, choice(self.__class__.merchantSynonyms), choice(self.__class__.genesisIdeals[choice(self.__class__.genesisReasons)]), choice(self.__class__.techAdjectives[self.tech]).capitalize())\\n elif self.genesis == 'seed the galaxy with life':\\n self.description = 'An oligarchy of wealthy {0} who recently opened a for-profit {1} on {2}'.format(choice(self.__class__.merchantSynonyms), choice(self.__class__.settlements[self.tech]), self.name)\\n elif self.genesis == 'spread the gospel':\\n self.description = 'An orbital printing press that rains down copies of {0} onto {1} {2}'.format(choice(self.__class__.merchantBooks), choice(self.__class__.techAdjectives[self.tech]), self.name)\\n elif self.casteOrder[0] == 'artists':\\n if self.genesis == 'escape persecution':\\n self.description = 'The {0}\\\\' commune for the free and naked expression of {1} {2} {3}'.format(choice(self.__class__.artistSynonyms), choice(self.__class__.escapeIdeals), choice(self.__class__.techPreps[self.tech]), self.name)\\n elif self.genesis == 'maintain control':\\n self.description = 'The {0} with mandatory art classes on {1} {2}'.format(choice(self.__class__.settlements[self.tech]), choice(self.__class__.techAdjectives[self.tech]), self.name)\\n elif self.genesis == 'explore the unknown':\\n self.description = '{0} {1}, an observation deck where {2} observe naked and confined {3} to better understand the mysteries of {4}'.format(choice(self.__class__.techPreps[self.tech]).capitalize(), self.name, choice(self.__class__.artistSynonyms), choice(self.__class__.casteSynonyms[self.casteOrder[5]]), choice(self.__class__.genesisIdeals[choice(self.__class__.genesisReasons)]))\\n elif self.genesis == 'seed the galaxy with life':\\n self.description = 'The {0} for {1} {2} who choose to better understand their craft through lovemaking on {3}'.format(choice(self.__class__.settlements[self.tech]), choice(self.__class__.seedAdjectives), choice(self.__class__.artistSynonyms), self.name)\\n elif self.genesis == 'spread the gospel':\\n self.description = 'A {0} on {1} that hosts an annual conference for pop {2}'.format(choice(self.__class__.settlements[self.tech]), self.name, choice(self.__class__.artistSynonyms))\\n elif self.casteOrder[0] == 'priests':\\n if self.genesis == 'escape persecution':\\n self.description = '{3} {0}, home to an order of heretical {1} who reject the {2} doctrine of their people'.format(self.name, choice(self.__class__.priestSynonyms), choice(self.__class__.gospelAdjectives), choice(self.__class__.techAdjectives[self.tech]).capitalize())\\n elif self.genesis == 'maintain control':\\n self.description = 'The orthodox {0} for {1} {2} {3} {4}'.format(choice(self.__class__.gospelPlaces), choice(self.__class__.gospelAdjectives), choice(self.__class__.priestSynonyms), choice(self.__class__.techPreps[self.tech]), self.name)\\n elif self.genesis == 'explore the unknown':\\n self.description = '{0} {1}, a seminary for the metaphysical contemplation of {2}'.format(choice(self.__class__.techPreps[self.tech]).capitalize(), self.name, choice(self.__class__.gospelIdeals))\\n elif self.genesis == 'seed the galaxy with life':\\n self.description = 'The marriage counseling clinic and devotional {2} {0} {1}'.format(choice(self.__class__.techPreps[self.tech]), self.name, choice(self.__class__.settlements[self.tech])) \\n elif self.genesis == 'spread the gospel':\\n self.description = 'A {0} mission on {1} {2} for converting {3} natives'.format(choice(self.__class__.gospelAdjectives), choice(self.__class__.techAdjectives[self.tech]), self.name, choice(self.__class__.badjectives))\\n \\n elif 30 <= branch <= 44:\\n if self.tech == 'pre-industrial technology':\\n if self.genesis == 'explore the unknown':\\n self.description = '{0}, home to a historical reenactment society of {2} {1}'.format(self.name, choice(self.__class__.casteSynonyms[self.casteOrder[0]]), choice(self.__class__.badjectives))\\n elif self.genesis == 'escape persecution':\\n self.description = '{1}: a {2} of {0} Luddites'.format(choice(self.__class__.casteAdjectives[self.casteOrder[0]]), self.name, choice(self.__class__.preindustrialSettlements))\\n elif self.genesis == 'maintain control':\\n self.description = 'The {0} fiefdoms of {1}, where {2} serve their {3} liege lord'.format(choice(self.__class__.preindustrialAdjectives), self.name, choice(self.__class__.casteSynonyms[self.casteOrder[5]]), choice(self.__class__.casteAdjectives[self.casteOrder[0]]))\\n elif self.genesis == 'seed the galaxy with life':\\n self.description = 'A harem of {0} {1} on medieval {2}'.format(choice(self.__class__.seedAdjectives), choice(self.__class__.casteSynonyms[self.casteOrder[0]]), self.name)\\n elif self.genesis == 'spread the gospel':\\n self.description = 'The Puritan {0} for evangelical {1} on {2}'.format(choice(self.__class__.preindustrialSettlements), choice(self.__class__.casteSynonyms[self.casteOrder[0]]), self.name)\\n elif self.tech == 'machine technology':\\n if self.genesis == 'explore the unknown':\\n self.description = 'An array of radio telescopes outside the {0} on {1} {2}'.format(choice(self.__class__.machineSettlements), choice(self.__class__.machineAdjectives), self.name)\\n elif self.genesis == 'escape persecution':\\n self.description = 'Public housing for {0} {1} gentrified {2}'.format(choice(self.__class__.casteSynonyms[self.casteOrder[0]]), choice(self.__class__.machinePreps), self.name) \\n elif self.genesis == 'maintain control':\\n self.description = 'The juvenile detention center for {0} children who obsess over {1} on {2}'.format(choice(self.__class__.badjectives), choice(self.__class__.genesisIdeals[choice(self.__class__.genesisReasons)]), self.name)\\n elif self.genesis == 'seed the galaxy with life':\\n self.description = 'Just a giant cruise ship full of {0} {1} on {2}'.format(choice(self.__class__.seedAdjectives), choice(self.__class__.casteSynonyms[self.casteOrder[0]]), self.name)\\n elif self.genesis == 'spread the gospel':\\n self.description = 'A megachurch run by {0} {1}, broadcasting live from {2}'.format(choice(self.__class__.priestAdjectives), choice(self.__class__.casteSynonyms[self.casteOrder[0]]), self.name)\\n elif self.tech == 'ubiquitous technology':\\n if self.genesis == 'explore the unknown':\\n self.description = 'A quantum data center for simulating the lives of {0} {1} {2} {3}'.format(choice(self.__class__.casteAdjectives[self.casteOrder[0]]), choice(self.__class__.casteSynonyms[choice(self.__class__.castes)]), choice(self.__class__.techPreps[self.tech]), self.name)\\n elif self.genesis == 'escape persecution':\\n self.description = 'The cryogenics facility for the preservation of {0} {1} {2} {3}'.format(choice(self.__class__.badjectives), choice(self.__class__.casteSynonyms[self.casteOrder[0]]), choice(self.__class__.techPreps[self.tech]), self.name)\\n elif self.genesis == 'maintain control':\\n self.description = 'Orbiting {0}: a socially stratified {1} governed by {2}'.format(self.name, choice(self.__class__.ubiqitousSettlements), choice(self.__class__.casteSynonyms[self.casteOrder[0]]))\\n elif self.genesis == 'seed the galaxy with life':\\n self.description = '{0} {1}, home to an assembly plant for android {2}'.format(choice(self.__class__.ubiqitousAdjectives).capitalize(), self.name, choice(self.__class__.casteSynonyms[self.casteOrder[0]]))\\n elif self.genesis == 'spread the gospel':\\n self.description = '{0}, home to an anthropological society of {1} who covertly inject the theme of {2} into the folklore of other civilizations'.format(self.name, choice(self.__class__.casteSynonyms[self.casteOrder[0]]), choice(self.__class__.genesisIdeals[choice(self.__class__.genesisReasons)]))\\n \\n elif 45 <= branch <= 62:\\n if self.casteOrder[0] == 'laborers':\\n if self.tech == 'pre-industrial technology':\\n self.description = 'A kibbutz for {0} {1} on {2}'.format(choice(self.__class__.genesisAdjectives[self.genesis]), choice(self.laborerSynonyms), self.name)\\n elif self.tech == 'machine technology':\\n self.description = 'The worker-owned and operated {1} of {2} {0}'.format(self.name, choice(self.__class__.genesisPlaces[self.genesis]), choice(self.__class__.machineAdjectives))\\n elif self.tech == 'ubiquitous technology':\\n self.description = '{0}, host to a psychic hivemind of {1} {2}'.format(self.name, choice(self.__class__.genesisAdjectives[self.genesis]), choice(self.__class__.laborerSynonyms))\\n elif self.casteOrder[0] == 'artists':\\n if self.tech == 'pre-industrial technology':\\n self.description = 'The conservatory for neoclassical {0} who explore the theme of {1} on {2}'.format(choice(self.__class__.artistSynonyms), choice(self.__class__.genesisIdeals[self.genesis]), self.name)\\n elif self.tech == 'machine technology':\\n self.description = 'A series of art installations conceived by {1} at various {0} on {2}'.format(choice(self.__class__.genesisPlaces[self.genesis]), choice(self.__class__.artistSynonyms), self.name)\\n elif self.tech == 'ubiquitous technology':\\n self.description = '{0}: a collective of AI {1} who parody the human theme of {2}'.format(self.name, choice(self.__class__.artistSynonyms), choice(self.__class__.genesisIdeals[self.genesis]))\\n elif self.casteOrder[0] == 'priests':\\n if self.tech == 'pre-industrial technology':\\n self.description = '{0} {1}, home to a scriptorium dedicated to the penning of meditations on {2}'.format(choice(self.__class__.preindustrialAdjectives).capitalize(), self.name, choice(self.__class__.genesisIdeals[self.genesis]))\\n elif self.tech == 'machine technology':\\n self.description = 'Polygamous cultists who live among the {0} of {1} {2}'.format(choice(self.__class__.genesisPlaces[self.genesis]), choice(self.__class__.machineAdjectives), self.name)\\n elif self.tech == 'ubiquitous technology':\\n self.description = 'A pyramidic burial chamber and monument to {0} {1} {2}'.format(choice(self.__class__.genesisIdeals[self.genesis]), choice(self.__class__.ubiquitousPreps), self.name)\\n elif self.casteOrder[0] == 'scientists':\\n if self.tech == 'pre-industrial technology':\\n self.description = '{0}, home to a collective of {1} {2} who reproduce scientific experiments from pre-industrial Earth'.format(self.name, choice(self.genesisAdjectives[self.genesis]), choice(self.__class__.scientistSynonyms))\\n elif self.tech == 'machine technology':\\n self.description = 'A society of {0} who work simulated jobs at {1} on {3} to better understand {2}'.format(choice(self.__class__.scientistSynonyms), choice(self.__class__.genesisPlaces[self.genesis]), choice(self.__class__.genesisIdeals[self.genesis]), self.name)\\n elif self.tech == 'ubiquitous technology':\\n self.description = 'The postdoctoral program for {0} tenure-track {1} {2} {3}'.format(choice(self.__class__.genesisAdjectives[self.genesis]), choice(self.__class__.scientistSynonyms), choice(self.__class__.ubiquitousPreps), self.name)\\n elif self.casteOrder[0] == 'soldiers':\\n if self.tech == 'pre-industrial technology':\\n self.description = '{0}, where {1} {2} study their martial arts in the quiet isolation of a {3}'.format(self.name, choice(self.__class__.genesisAdjectives[self.genesis]), choice(self.__class__.soldierSynonyms), choice(self.__class__.preindustrialSettlements))\\n elif self.tech == 'machine technology':\\n self.description = '{0}, where {1} {2} spar each other to overcome their frustrations surrounding {3}'.format(self.name, choice(self.__class__.badjectives), choice(self.__class__.soldierSynonyms), choice(self.__class__.genesisIdeals[self.genesis]))\\n elif self.tech == 'ubiquitous technology':\\n self.description = 'The highly militarized {0} {1} {2}'.format(choice(self.__class__.genesisPlaces[self.genesis]), choice(self.__class__.ubiquitousPreps), self.name)\\n elif self.casteOrder[0] == 'merchants':\\n if self.tech == 'pre-industrial technology':\\n self.description = 'An antique fair on {0} where 1% of the proceeds are donated to the study of {1}'.format(self.name, choice(self.__class__.genesisIdeals[self.genesis]))\\n elif self.tech == 'machine technology':\\n self.description = 'A chain of retail {0} near the {1} on {2}'.format(choice(self.__class__.genesisPlaces[self.genesis]), choice(self.__class__.machineSettlements), self.name)\\n elif self.tech == 'ubiquitous technology':\\n self.description = 'A pay-by-the-hour computer simulation {0} {1} where patrons can experience {2}'.format(choice(self.__class__.ubiquitousPreps), self.name, choice(self.__class__.genesisIdeals[self.genesis]))\",\n \"def main(codelabel):\\n try:\\n code = Code.get_from_string(codelabel)\\n except NotExistent:\\n print(\\\"The code '{}' does not exist\\\".format(codelabel))\\n sys.exit(1)\\n\\n print(\\\"Testing CP2K ENERGY on H2 (DFT) without StructureData...\\\")\\n\\n # parameters\\n parameters = Dict(\\n dict={\\n 'FORCE_EVAL': {\\n 'METHOD': 'Quickstep',\\n 'DFT': {\\n 'BASIS_SET_FILE_NAME': 'BASIS_MOLOPT',\\n 'QS': {\\n 'EPS_DEFAULT': 1.0e-12,\\n 'WF_INTERPOLATION': 'ps',\\n 'EXTRAPOLATION_ORDER': 3,\\n },\\n 'MGRID': {\\n 'NGRIDS': 4,\\n 'CUTOFF': 280,\\n 'REL_CUTOFF': 30,\\n },\\n 'XC': {\\n 'XC_FUNCTIONAL': {\\n '_': 'LDA',\\n },\\n },\\n 'POISSON': {\\n 'PERIODIC': 'none',\\n 'PSOLVER': 'MT',\\n },\\n },\\n 'SUBSYS': {\\n # structure directly included in parameters\\n 'CELL': {\\n 'ABC': '4.0 4.0 4.75'\\n },\\n 'COORD': {\\n ' ': ['H 2.0 2.0 2.737166', 'H 2.0 2.0 2.000000']\\n },\\n 'KIND': [\\n {\\n '_': 'O',\\n 'BASIS_SET': 'DZVP-MOLOPT-SR-GTH',\\n 'POTENTIAL': 'GTH-LDA-q6'\\n },\\n {\\n '_': 'H',\\n 'BASIS_SET': 'DZVP-MOLOPT-SR-GTH',\\n 'POTENTIAL': 'GTH-LDA-q1'\\n },\\n ],\\n },\\n }\\n })\\n\\n # resources\\n options = {\\n \\\"resources\\\": {\\n \\\"num_machines\\\": 1,\\n \\\"num_mpiprocs_per_machine\\\": 1,\\n },\\n \\\"max_wallclock_seconds\\\": 1 * 3 * 60,\\n }\\n\\n inputs = {'parameters': parameters, 'code': code, 'metadata': {'options': options,}}\\n\\n print(\\\"submitted calculation...\\\")\\n calc = run(Cp2kCalculation, **inputs)\\n\\n # check energy\\n expected_energy = -1.14005678487\\n if abs(calc['output_parameters'].dict.energy - expected_energy) < 1e-10:\\n print(\\\"OK, energy has the expected value\\\")\\n else:\\n print(\\\"ERROR!\\\")\\n print(\\\"Expected energy value: {}\\\".format(expected_energy))\\n print(\\\"Actual energy value: {}\\\".format(calc['output_parameters'].dict.energy))\\n sys.exit(3)\\n\\n sys.exit(0)\",\n \"def load_label(self, pr):\\n return\",\n \"def get_step_label_at_index(self, index):\\n return self[index][1]\",\n \"def get_label(genotype_type):\\n if genotype_type == \\\"Hom\\\":\\n return 0\\n elif genotype_type == \\\"Het\\\":\\n return 1\\n elif genotype_type == \\\"Hom_alt\\\":\\n return 2\",\n \"def label(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"label\\\")\",\n \"def label(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"label\\\")\",\n \"def label(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"label\\\")\",\n \"def t_labeling_cohort(**kargs): \\n def read_ids(fname): \\n assert fname.find('.id') > 0\\n fp = os.path.join(basedir, fname)\\n assert os.path.exists(fp), 'Invalid input: %s' % fp\\n df_id = pd.read_csv(fp, sep=sep, header=0, index_col=False, error_bad_lines=True)\\n return df_id['person_id'].values\\n def seq_to_str(seqx, sep=','): \\n return [sep.join(str(s) for s in seq) for seq in seqx] \\n def str_to_seq(df, col='sequence', sep=','):\\n seqx = []\\n for seqstr in df[col].values: \\n s = seqstr.split(sep)\\n seqx.append(s)\\n return seqx\\n def to_str(tokens, sep='+'): \\n return sep.join([str(tok) for tok in tokens])\\n\\n # import labeling\\n import seqReader as sr\\n\\n ### CKD cohort \\n # basedir = sys_config.read('DataIn') # data-in simlink to data ... 10.17 \\n # 'data-in' is reserved for input data not generated from within the system \\n basedir = sys_config.read('DataExpRoot')\\n \\n # cohort attributes\\n cohort_name = 'CKD'\\n fname = 'eMerge_NKF_Stage_20170818.csv' \\n header = ['patientId', 'Case_Control_Unknown_Status', 'NKF_Stage', ]\\n sep = ','\\n\\n fpath = os.path.join(basedir, fname)\\n df = pd.read_csv(fpath, sep=sep, header=0, index_col=False, error_bad_lines=True)\\n\\n # use stages as labels \\n labelset = list(df['NKF_Stage'].unique())\\n print('info> cohort: %s | labels (n=%d):\\\\n%s\\\\n' % (cohort_name, len(labelset), labelset))\\n # [log] 7 labels\\n\\n labels = df['NKF_Stage']\\n\\n # only read documents with data \\n idx = person_ids = getPersonIDs(cohort=cohort_name, inputdir=basedir, sep=sep) # cohort, inputdir, sep, sep_compo\\n seqparams.TDoc.verifyIDs(idx) # ascending order? duplicates? \\n\\n n_persons = len(idx)\\n print('info> n_persons: %d' % n_persons)\\n\\n ### find labels\\n # don't use the data source's ordering of IDs, which when made via seqMaker2.py was sorted\\n # ERROR: labels = df.loc[df['patientId'].isin(idx)]['NKF_Stage'].values\\n \\n sort_keys = ['patientId', ]\\n # df_test1 = df.sort_values(sort_keys, ascending=True)\\n # l = df['patientId'].values\\n # assert all(l[i] <= l[i+1] for i in xrange(len(l)-1)) # passed\\n # assert all(l == idx) # passed\\n\\n # filter > sort > extract (good!)\\n # output np.array\\n # labels = labels_ref = labelDocByDataFrame(, person_ids=idx, id_field='patientId', label_field='NKF_Stage')\\n labels = labels_ref = labelDocByFile(fpath, person_ids=idx, id_field='patientId', label_field='NKF_Stage')\\n\\n # n_labels = len(labels)\\n # print('info> Got %d labels' % n_labels)\\n\\n # [test] verify the ID and labels\\n # print('status> verifying the match between IDs and labels')\\n # for i, (r, row) in enumerate(df_test1.iterrows()): # sorted entries\\n # pid, label = row['patientId'], row['NKF_Stage']\\n # if pid in idx: \\n # assert label == labels[i], \\\"%d-th label: %s <> %s\\\" % (i, label, labels[i])\\n ## [conclusion] the label ordering via df_test1 does not agree!!! \\n\\n # extract labels according to the ID ordering\\n # sampleIDs = random.sample(range(n_persons), 50)\\n # labels = []\\n # for pid in idx: \\n # row = df.loc[df['patientId']==pid] # row is a dataframe\\n # assert row.shape[0] == 1, 'Found dups: id=%s => %s' % (pid, row)\\n # l = list(row['NKF_Stage'].values)\\n # labels.extend(l)\\n # assert len(labels) == len(labels_ref) == len(idx) # passed\\n # assert all(labels_ref == labels), \\\"ordering inconsistency:\\\\n%s\\\\n VS \\\\n%s\\\\n\\\" % (labels_ref[:50], labels[:50]) # passed\\n\\n n_labels = len(labels)\\n print('info> verified %d labels' % n_labels)\\n\\n # double check with structured version of the sequences produced by seqMaker2 (header: person_id, sequence, timestamp)\\n # tfile = 'condition_drug_timed_seq-%s.csv' % cohort_name # test file\\n # fpath2 = os.path.join(basedir, tfile)\\n # # if os.path.exists(fpath2): \\n # dft = pd.read_csv(fpath2, sep='|', header=0, index_col=False, error_bad_lines=True)\\n # print('info> from timed_seq .csv | n_persons: %d =?= n_labels: %d' % (dft.shape[0], n_labels)) # n_persons: 2833 =?= n_labels: 2833\\n\\n ### Read Sequences\\n\\n print('info> 1. CSeq from .csv')\\n ret = readDocFromCSV(cohort=cohort_name, inputdir=basedir)\\n print('info> making structured format of the coding sequences (cohort:%s, n_labels:%d)' % (cohort_name, n_labels))\\n # df = readToCSV(cohort=cohort_name, labels=labels)\\n \\n seqx = ret['sequence'] # list(dft['sequence'].values)\\n tseqx = ret.get('timestamp', []) # list(dft['timestamp'].values)\\n if tseqx: \\n assert len(seqx) == len(tseqx), \\\"len(seqx)=%d, len(times)=%d\\\" % (len(seqx), len(tseqx))\\n\\n print('info> 2. CSeq from .dat')\\n seqx2, tseqx2 = readDoc(cohort=cohort_name, inputdir=basedir, include_timestamps=True) # ifiles\\n\\n # can then create .csv via readDocToCSV() # [params] cohort, basedir, ifiles, labels\\n\\n if tseqx2: \\n assert len(seqx2) == len(tseqx2), \\\"len(seqx)=%d, len(times)=%d\\\" % (len(seqx2), len(tseqx2))\\n n_docs, n_docs2 = len(seqx), len(seqx2)\\n \\n # print('info> read %d from .dat =?= %d from .csv' % (n_docs2, n_docs))\\n assert n_docs == n_docs2, \\\".dat and .csv formats are not consistent n_doc: %d (csv) <> %d (dat)\\\" % (n_docs, n_docs2)\\n\\n # when did they diverge? \\n # n_matched = 0\\n # for i, seq in enumerate(seqx): \\n # s1 = seq # list of tokens\\n\\n # try: \\n # s2 = seqx2[i] # list of tokens\\n # except: \\n # s2 = []\\n\\n # if s1 == s2: \\n # n_matched += 1 \\n # else: \\n # msg = \\\".csv not consistent with .dat (n_matched=%d)=>\\\\n%s\\\\nVS\\\\n%s\\\\n\\\" % (n_matched, s1, s2)\\n # raise ValueError, msg \\n\\n n_docs_src = df.shape[0]\\n assert n_docs == n_labels, \\\"n_labels: %d <> n_docs: %d ...\\\" % (n_labels, n_docs)\\n\\n print('input> n_doc_src (cohort source document): %d, n_doc (parsed, has data in DB): %d' % (n_docs_src, n_docs))\\n\\n print('info> writing labels to .csv')\\n df2 = sr.readDocToCSV(cohort=cohort_name, labels=labels)\\n print('info> created .csv format with columns:\\\\n%s\\\\n' % df2.columns.values)\\n n_docs3 = df2.shape[0]\\n assert n_docs3 == n_docs\\n\\n return\",\n \"def print_common_hub_words(rem_stop_words):\\n results = {'_removing stop-words':rem_stop_words}\\n\\n print '------ CLASSIFICATION EVALUATION --------'\\n print '> Reading cases..'\\n descriptions_path = '../data/tasa/TASA900_dependencies'\\n texts, labels = data.read_files(descriptions_path)\\n\\n print '> Creating representations..'\\n fd = nltk.probability.FreqDist()\\n for i, text in enumerate(texts):\\n if i%100==0: print ' ',str(i)+'/'+str(len(texts))\\n g = graph_representation.construct_dependency_network(text, remove_stop_words=rem_stop_words)\\n hubs = graph.get_hubs(g, 10)\\n for h in hubs:\\n fd.inc(h[0])\\n g = None # just to make sure..\\n\\n results['tasa'] = fd.keys()\\n\\n print '------ RETRIEVAL EVALUATION --------'\\n print '> Reading cases..'\\n descriptions_path = '../data/air/problem_descriptions_dependencies'\\n description_texts, labels = data.read_files(descriptions_path)\\n\\n print '> Creating representations..'\\n fd = nltk.probability.FreqDist()\\n for i, text in enumerate(description_texts):\\n if i%100==0: print ' ',str(i)+'/'+str(len(description_texts))\\n g = graph_representation.construct_dependency_network(text, remove_stop_words=rem_stop_words)\\n hubs = graph.get_hubs(g, 10)\\n for h in hubs:\\n fd.inc(h[0])\\n g = None # just to make sure..\\n\\n results['air'] = fd.keys()\\n\\n if rem_stop_words:\\n modifier = 'without'\\n else:\\n modifier = 'with'\\n data.pickle_to_file(results, 'output/dependencies/common_hubs_'+modifier+'stop_words')\\n\\n pp.pprint(results)\\n return results\",\n \"def get_parent_struc (chain, added_chains_dict):\\n if \\\"-\\\" in chain.id:\\n structure = added_chains_dict[chain.id]\\n else:\\n structure = chain.get_parent().get_parent()\\n return structure\",\n \"def get_label(settings):\",\n \"def _generate_pipeline_labels(self, job):\\n jobname = self._get_jobname(job)\\n labels = {\\\"name\\\": jobname, \\\"app\\\": \\\"snakemake\\\"}\\n return labels\",\n \"def plugin_second_label():\\n return \\\"second\\\"\",\n \"def main(structure, label, return_type):\\n sequence = get_sequence(structure=structure, label=label,\\n return_type=return_type)\\n if sequence is not None:\\n click.echo(sequence)\",\n \"def __init__(self):\\n self.label = \\\"Grand WOFE\\\"\\n self.description = \\\"From list of Evidence layers generate weights tables and output rasters from Calculate Respons and Logistic Regression.\\\"\\n self.canRunInBackground = False\\n self.category = \\\"Weights of Evidence\\\"\",\n \"def get_chain(self, chain_id):\\n if self.default_model is None:\\n return None\\n if self.default_model.chain_dict.has_key(chain_id):\\n return self.default_model.chain_dict[chain_id]\\n return None\",\n \"def pred_wine_type():\\n \\n Alcohol\\t=request.args.get('Alcohol')\\n Malic=request.args.get('Malic')\\n Ash=request.args.get('Ash')\\n Alcalinity=request.args.get('Alcalinity')\\n Magnesium=request.args.get('Magnesium')\\n Phenols=request.args.get('Phenols')\\n Flavanoids=request.args.get('Flavanoids')\\n Nonflavanoids=request.args.get('Nonflavanoids')\\n Proanthocyanins=request.args.get('Proanthocyanins')\\n Color=request.args.get('Color')\\n Hue=request.args.get('Hue')\\n Dilution=request.args.get('Dilution')\\n Proline=request.args.get('Proline')\\n prediction=classifier.predict([[Alcohol,Malic,Ash,Alcalinity,Magnesium,Phenols,Flavanoids,Nonflavanoids,Proanthocyanins,Color,Hue,Dilution,Proline]])\\n return 'The predicted value is'+str(prediction)\",\n \"def chain(self, chain_id, model_num = 0):\\n return self.struct[model_num][chain_id]\",\n \"def default_chain(self):\\n self.name = \\\"Default Chain Mail Armor\\\"\\n self.rarity = \\\"Common\\\"\\n self.pdef_value = 15\\n self.mdef_value = 2\\n self.increase_crit = 0\\n self.desc = \\\"A rusty piece of chain mail, old and discoloured\\\"\",\n \"def get_step_label_at_index(self, index):\\n return self.routine_template.get_step_label_at_index(index)\",\n \"def get_clarifications_winogrande(ex, nlp, comet_model):\\n personx, persony = ex['option1'], ex['option2']\\n\\n # Only extract relations for people\\n if personx[0] != personx[0].upper() or persony[0] != persony[0].upper():\\n return []\\n\\n input_event = ex[\\\"sentence\\\"]\\n outputs = {category: comet_model.predict(input_event, category, num_beams=5) for category in comet_model.categories}\\n\\n curr_events = []\\n for category, prefix in CATEGORY_TO_PREFIX.items():\\n for out_event in outputs[category]:\\n if out_event != \\\"none\\\" and out_event != \\\"\\\":\\n if not out_event.lower().startswith(\\\"person\\\") and not out_event.lower().startswith(\\\"other\\\"):\\n out_event = \\\" \\\".join((prefix, out_event))\\n\\n out_event = re.sub(\\\"personx\\\", personx, out_event, flags=re.I)\\n out_event = re.sub(\\\"person x\\\", personx, out_event, flags=re.I)\\n out_event = re.sub(\\\"persony\\\", persony, out_event, flags=re.I)\\n out_event = re.sub(\\\"person y\\\", persony, out_event, flags=re.I)\\n\\n question = CATEGORY_TO_QUESTION[category].replace(\\\"PersonX\\\", personx)\\n curr_events.append((question, out_event))\\n\\n return curr_events\",\n \"def test_get_nested_attribute(self):\\n result = self.runner.invoke(\\n cli,\\n [\\n *CLI_LOG_OPTION,\\n \\\"config\\\",\\n \\\"get\\\",\\n \\\"skills.dummy.behaviours.dummy.class_name\\\",\\n ],\\n standalone_mode=False,\\n )\\n assert result.exit_code == 0\\n assert result.output == \\\"DummyBehaviour\\\\n\\\"\",\n \"def q_getdifficulty(abe, page, chain):\\n if chain is None:\\n return 'Shows the difficulty of the last block in CHAIN.\\\\n' \\\\\\n '/chain/CHAIN/q/getdifficulty\\\\n'\\n target = abe.store.get_target(chain.id)\\n return \\\"\\\" if target is None else util.target_to_difficulty(target)\",\n \"def label_rule_for_company(text: str) -> str:\\n match = re.search(LABEL_SPECIFICATION[\\\"RE_COMPANY_PRIMARY\\\"], text)\\n if not match:\\n match = re.search(LABEL_SPECIFICATION[\\\"RE_COMPANY_SECONDARY\\\"], text)\\n if match:\\n text = match.group(\\\"label\\\").strip()\\n if len(text) > 1:\\n return text\\n else:\\n return \\\"\\\"\\n return \\\"\\\"\",\n \"def get_label(name):\\n lower = name.lower()\\n vals = lower.split('_')\\n if 'ho' in vals:\\n name = 'Independent Estimate'\\n elif 'alldata' in vals:\\n name = 'Extra-Data Estimate'\\n elif 'ris' in vals[0]:\\n name = 'RIS'\\n if 'w' in vals[0]:\\n name += ' WIS'\\n if 'pd' in vals[0]:\\n name += ' PDIS'\\n elif 'is' in vals[0]:\\n name = 'OIS'\\n if 'w' in vals[0]:\\n name += ' WIS'\\n if 'pd' in vals[0]:\\n name += ' PDIS'\\n if 'dr' in vals:\\n name += ' DR'\\n if 'wdr' in vals:\\n name += ' WDR'\\n return name\",\n \"def label(self, cfg):\\n rep = \\\"\\\"\\n nl = \\\"\\\"\\n for node in cfg.nodes:\\n rep += nl + \\\"{}\\\\tgen={}\\\\tkill={}\\\\tout={}\\\".format(\\n node, \\n set(self.gen.get(node)),\\n set(self.kill.get(node)),\\n set(self.out.get(node)))\\n nl = \\\"\\\\n\\\"\\n return rep\",\n \"def test_get_skill_name(self):\\n result = self.runner.invoke(\\n cli,\\n [*CLI_LOG_OPTION, \\\"config\\\", \\\"get\\\", \\\"skills.dummy.name\\\"],\\n standalone_mode=False,\\n )\\n assert result.exit_code == 0\\n assert result.output == \\\"dummy\\\\n\\\"\",\n \"def test_label_callback():\\n release_numbers = dict(a='123')\\n data = dict(revision='a', attributes=dict(b='c'))\\n data2 = dict(revision='b', attributes=dict(d='e'))\\n\\n assert _label_callback(data, release_numbers) == u'a\\\\n- Release: 123\\\\n- b: c'\\n assert _label_callback(data2) == u'b\\\\n- Release: Unknown\\\\n- d: e'\",\n \"def get_label():\\n inp = option_text('Input label name (leave blank for no label):')\\n add_to_collected('label', inp)\\n OPTIONS['label'] = inp\\n return\",\n \"def _GenerateConfLine(self, term, precedence=None):\\n if term.term.qos in self.qos_value_map:\\n target = []\\n qos_value = self.qos_value_map[term.term.qos]\\n target.append('match protocol ip src-ip any src-port any')\\n target.append('dst-ip any dst-port any application')\\n target.append(term.term.name)\\n if precedence:\\n target.append('dscp %s set traffic-class 1' %\\n self.precedence_value_map[precedence])\\n else:\\n target.append('dscp any set traffic-class 1')\\n target.append('lan-qos-dscp %s wan-qos-dscp %s\\\\n\\\\n' %\\n (qos_value, qos_value))\\n return ' '.join(target)\\n return ''\",\n \"def get_clarifications_copa(ex, nlp, comet_model):\\n category_to_prefix_causes = {\\\"xIntent\\\": CATEGORY_TO_PREFIX[\\\"xIntent\\\"],\\n \\\"xNeed\\\": CATEGORY_TO_PREFIX[\\\"xNeed\\\"]}\\n\\n category_to_prefix_effects = CATEGORY_TO_PREFIX.copy()\\n category_to_prefix_effects.pop(\\\"xIntent\\\")\\n category_to_prefix_effects.pop(\\\"xNeed\\\")\\n category_to_prefix_effects.pop(\\\"xAttr\\\")\\n\\n input_event = ex[\\\"premise\\\"]\\n personx, is_named_entity = get_personx(nlp, input_event)\\n\\n if personx == \\\"\\\":\\n return []\\n\\n personx = personx if (is_named_entity or personx == \\\"I\\\") else personx.lower()\\n outputs = {category: comet_model.predict(input_event, category, num_beams=5) for category in comet_model.categories}\\n\\n if ex[\\\"question\\\"] == \\\"cause\\\":\\n category_to_prefix = category_to_prefix_causes\\n else:\\n category_to_prefix = category_to_prefix_effects\\n\\n curr_events = []\\n for category, prefix in category_to_prefix.items():\\n for out_event in outputs[category]:\\n if out_event != \\\"none\\\" and out_event != \\\"\\\":\\n if not out_event.lower().startswith(\\\"person\\\") and not out_event.lower().startswith(\\\"other\\\"):\\n out_event = \\\" \\\".join((prefix, out_event))\\n\\n out_event = re.sub(\\\"personx\\\", personx, out_event, flags=re.I)\\n out_event = re.sub(\\\"person x\\\", personx, out_event, flags=re.I)\\n out_event = re.sub(\\\"persony\\\", \\\"others\\\", out_event, flags=re.I)\\n out_event = re.sub(\\\"person y\\\", \\\"others\\\", out_event, flags=re.I)\\n\\n question = CATEGORY_TO_QUESTION[category].replace(\\\"PersonX\\\", personx)\\n curr_events.append((question, out_event))\\n\\n return curr_events\",\n \"def make_text(chain_dict):\\n\\n# This selects the first random key to begin the chain.\\n \\n random_key = random.choice(chain_dict.keys())\\n\\n# This creates a random text list to append a random value from the original random key.\\n# The random key is then reassigned to a tuple containing the second key in the random keys tuple,\\n# and adds the randomly generated value of the earlier random key tuple as the second tuple value. \\n# Convert tuples in random_key to strings, then added all strings together, then added to empty list\\n\\n first_words = ' '.join(map(str,random_key)) \\n random_text_list = [first_words]\\n \\n for i in range(1,100):\\n #while random_key in chain_dict: \\n next = random.choice(chain_dict[random_key]) \\n random_text_list.append(next)\\n random_key = (random_key[1],next)\\n\\n pretty_text = []\\n pretty_text = ' '.join(map(str, random_text_list)) \\n return pretty_text\",\n \"def label_rule_for_others(text: str, label_type: str) -> str:\\n match = re.search(LABEL_SPECIFICATION[f\\\"RE_{label_type.upper()}\\\"], text)\\n if match:\\n return match.group(\\\"label\\\").strip()\\n return \\\"\\\"\",\n \"def main(argv):\\n global fileName, hyp, run_type, rep_type, n_processor, output_dir # Used by both master and slave processes\\n fileName = args.outPrefix\\n hyp_default = args.default\\n hyp_adjust = args.hyperparam\\n output_dir = args.outPrefix\\n n_processor = args.num_worker\\n run_type = args.type1\\n rep_type = args.type2\\n\\n hyp = loadHyp(pFileName=hyp_default)\\n updateHyp(hyp,hyp_adjust)\\n print(hyp)\\n\\n master()\",\n \"def get_label(urs):\\n return assign_term(urs)[1]\",\n \"def gen_hts_lab_mono(self):\\n chosen_fields_lst = ['start', 'stop', 'phone']\\n\\n self._hts_lab_mono_ttpl = \\\\\\n lst.transp_ttpl(\\n tuple(\\n tuple(self._proc_ldic[field]) for field in chosen_fields_lst\\n )\\n )\\n\\n self._hts_lab_mono_ttpl = tuple(tuple([\\\"{:>10}\\\".format(row[0]), \\\"{:>10}\\\".format(row[1]), row[2]])\\n for row in self._hts_lab_mono_ttpl)\\n\\n self.hts_lab_mono_prn = tuple(' '.join(l) for l in self._hts_lab_mono_ttpl)\",\n \"def get_label_from_analysis_model(analysis_model, id_hash):\\n\\n root = os.path.basename(os.path.dirname(analysis_model.compilation)).replace(\\\"_\\\", \\\" \\\")\\n output = analysis_model.output_directory.replace(\\\"_\\\", \\\" \\\") if analysis_model.output_directory else \\\"analysis\\\"\\n return \\\"{0} -> {1}, ({2})\\\".format(root, output, id_hash[-6:])\",\n \"def main( argv = None ):\\n\\n if argv == None: argv = sys.argv\\n\\n # setup command line parser\\n parser = E.OptionParser( version = \\\"%prog version: $Id$\\\", \\n usage = globals()[\\\"__doc__\\\"] )\\n\\n parser.add_option(\\\"--category\\\", dest=\\\"category\\\", type=\\\"choice\\\",\\n choices = (\\\"B\\\", \\\"C\\\"), help=\\\"supply help\\\" )\\n\\n ## add common options (-h/--help, ...) and parse command line \\n (options, args) = E.Start( parser, argv = argv )\\n\\n data = getData(options.stdin)\\n if options.category == \\\"B\\\":\\n options.stdout.write(\\\"Category B pathway\\\\tKO\\\\tGenes\\\\tDescriptions\\\\n\\\")\\n for pathway, descriptions in b2ko(data).iteritems():\\n options.stdout.write(\\\"\\\\t\\\".join([pathway, \\\"; \\\".join(descriptions[0]), \\\"; \\\".join(descriptions[1]), \\\"; \\\".join(descriptions[2])]) + \\\"\\\\n\\\")\\n\\n elif options.category == \\\"C\\\":\\n options.stdout.write(\\\"Category C pathway\\\\tKO\\\\tGenes\\\\tDescriptions\\\\n\\\")\\n for pathway, descriptions in c2ko(data).iteritems():\\n options.stdout.write(\\\"\\\\t\\\".join([pathway, \\\"; \\\".join(descriptions[0]), \\\"; \\\".join(descriptions[1]), \\\"; \\\".join(descriptions[2])]) + \\\"\\\\n\\\")\\n else:\\n raise ValueError(\\\"must specify the category of pathway\\\")\\n\\n\\n ## write footer and output benchmark information.\\n E.Stop()\",\n \"def __str__(self):\\n return self.piece_behavior.summary\",\n \"def get_labels(self):\\n if self.option == \\\"term\\\":\\n return ['platform characteristics', 'atmospheric winds', 'radio wave','weather events', 'geomagnetism', 'atmospheric electricity','microwave', 'atmospheric temperature', 'atmospheric water vapor','atmospheric pressure', 'aerosols', 'atmospheric radiation','atmospheric chemistry', 'precipitation', 'sensor characteristics','radar', 'infrared wavelengths', 'visible wavelengths','weather/climate advisories', 'clouds', 'lidar', 'ocean optics','ultraviolet wavelengths', 'cryospheric indicators','land use/land cover', 'topography', 'surface thermal properties','spectral/engineering', 'soils', 'snow/ice', 'geothermal dynamics','natural hazards', 'surface water', 'vegetation','land surface/agriculture indicators','gravity/gravitational field', 'marine advisories', 'altitude','water quality/water chemistry', 'ocean temperature','ocean winds', 'atmospheric/ocean indicators', 'coastal processes','erosion/sedimentation', 'marine sediments', 'ocean chemistry','salinity/density', 'ocean color', 'aquatic ecosystems','vegetation2', 'landscape', 'cloud properties','surface radiative properties', 'geodetics','agricultural plant science', 'forest science','ecological dynamics', 'environmental impacts', 'sustainability','boundaries', 'ecosystems', 'air quality', 'population','infrastructure', 'environmental governance/management','public health', 'economic resources', 'socioeconomics','environmental vulnerability index (evi)', 'human settlements','agricultural chemicals', 'animal science','habitat conversion/fragmentation', 'animals/vertebrates','earth gases/liquids', 'rocks/minerals/crystals','social behavior', 'ground water', 'frozen ground','terrestrial hydrosphere indicators', 'ocean heat budget','biospheric indicators', 'animal commodities', 'fungi', 'plants','carbon flux', 'geomorphic landforms/processes','paleoclimate indicators', 'ocean circulation', 'sea ice','geochemistry', 'visualization/image processing','subsetting/supersetting', 'transformation/conversion','ocean pressure', 'glaciers/ice sheets', 'protists','solar activity', 'sun-earth interactions','sea surface topography', 'solar energetic particle properties','solar energetic particle flux','ionosphere/magnetosphere dynamics']\\n elif self.option == \\\"mostdepth\\\":\\n return ['flight data logs', 'turbulence', 'radio wave flux', 'lightning', 'magnetic field', 'atmospheric conductivity', 'electric field', 'data synchronization time', 'brightness temperature', 'vertical profiles', 'water vapor profiles', 'air temperature', 'upper level winds', 'atmospheric pressure measurements', 'upper air temperature', 'humidity', 'dew point temperature', 'aerosol particle properties', 'emissivity', 'trace gases/trace species', 'liquid precipitation', 'cloud liquid water/ice', 'microwave radiance', 'sensor counts', 'total pressure', 'airspeed/ground speed', 'total temperature', 'static pressure', 'wind speed', 'wind direction', 'radar reflectivity', 'doppler velocity', 'infrared imagery', 'visible imagery', 'water vapor', 'vertical wind velocity/speed', 'aerosol backscatter', 'weather forecast', 'tropical cyclones', 'visible radiance', 'infrared radiance', 'total precipitable water', 'boundary layer temperature', 'atmospheric temperature indices', 'cloud height', 'flight level winds', 'cloud droplet distribution', 'cloud droplet concentration/size', 'cloud condensation nuclei', 'cloud microphysics', 'hydrometeors', 'ozone', 'wind profiles', 'cloud base temperature', 'cloud base height', 'liquid water equivalent', 'solar radiation', 'planetary boundary layer height', 'surface winds', 'precipitation amount', 'precipitation rate', 'surface pressure', 'rain', 'cloud optical depth/thickness', 'aerosol extinction', 'aerosol optical depth/thickness', 'cirrus cloud systems', 'lidar depolarization ratio', 'radar backscatter', 'radar cross-section', 'return power', 'mean radial velocity', 'radiance', 'air quality', 'climate advisories', 'atmospheric emitted radiation', 'optical depth/thickness', 'surface temperature', 'ultraviolet flux', 'spectrum width', 'microwave imagery', 'lidar backscatter', 'relative humidity', 'u/v wind components', 'wind speed/wind direction', 'radar imagery', 'snow depth', 'land use/land cover classification', 'digital elevation/terrain model (dem)', 'snow', 'droplet size', 'droplet concentration/size', 'drizzle', 'precipitation anomalies', 'snow water equivalent', 'solid precipitation', 'total surface precipitation rate', 'particle size distribution', 'skin temperature', 'attitude characteristics', 'land surface temperature', 'hail', 'reflectance', 'soil moisture/water content', 'soil temperature', 'soil bulk density', 'surface roughness', 'present weather', 'snow density', 'ambient temperature', 'aerosol forward scatter', 'floods', 'snow cover', 'sigma naught', 'precipitable water', 'stage height', 'rivers/streams', 'shortwave radiation', 'photosynthetically active radiation', 'longwave radiation', 'net radiation', 'hourly precipitation amount', '24 hour precipitation amount', 'soil moisture', 'satellite orbits/revolution', 'sea surface temperature', 'heat flux', 'latent heat flux', 'cloud fraction', '3 and 6 hour precipitation amount', 'geopotential height', 'particulate matter', 'particle images', 'water vapor indices', 'horizontal wind velocity/speed', 'electrical conductivity', 'dissolved carbon dioxide', 'hurricanes', 'tropical cyclone track', 'convective clouds/systems (observed/analyzed)', 'cloud top height', 'viewing geometry', 'temperature profiles', 'vertical wind shear', 'wind shear', 'carbon monoxide', 'sea level pressure', 'water vapor tendency', 'potential temperature', 'angstrom exponent', 'ultraviolet radiation', 'solar irradiance', 'scattering', 'absorption', 'water vapor mixing ratio profiles', 'sea surface temperature indices', 'extreme eastern tropical pacific sst', 'sedimentation', 'erosion', 'sediment transport', 'sediments', 'tropopause', 'ocean chemistry', 'ocean optics', 'ocean temperature', 'salinity/density', 'pigments', 'ocean color', 'attenuation/transmission', 'inorganic carbon', 'organic carbon', 'photosynthetically available radiation', 'chlorophyll', 'optical depth', 'fluorescence', 'vegetation index', 'gelbstoff', 'phytoplankton', 'vegetation index2', 'cloud precipitable water', 'landscape ecology', 'ultraviolet radiance', 'cloud ceiling', 'aerosol radiance', 'carbonaceous aerosols', 'dust/ash/smoke', 'nitrate particles', 'organic particles', 'sulfate particles', 'radiative flux', 'transmittance', 'atmospheric stability', 'cloud asymmetry', 'cloud frequency', 'cloud top pressure', 'cloud top temperature', 'cloud vertical distribution', 'cloud emissivity', 'cloud radiative forcing', 'cloud reflectance', 'rain storms', 'reflected infrared', 'thermal infrared', 'incoming solar radiation', 'clouds', 'cloud properties', 'cloud types', 'orbital characteristics', 'sensor characteristics', 'maximum/minimum temperature', 'condensation', 'platform characteristics', 'geolocation', 'geodetics', 'coordinate reference system', 'aerosols', 'topographical relief maps', 'terrain elevation', 'normalized difference vegetation index (ndvi)', 'infrared flux', 'visible flux', 'albedo', 'land use/land cover', 'topography', 'lidar', 'lidar waveform', 'plant phenology', 'vegetation cover', 'crop/plant yields', 'land use classes', 'landscape patterns', 'forest harvesting and engineering', 'forest management', 'total surface water', 'agricultural plant science', 'photosynthesis', 'primary production', 'leaf characteristics', 'evapotranspiration', 'fire occurrence', 'surface thermal properties', 'canopy characteristics', 'evergreen vegetation', 'crown', 'deciduous vegetation', 'anisotropy', 'fire ecology', 'biomass burning', 'wildfires', 'topographical relief', 'burned area', 'surface radiative properties', 'environmental sustainability', 'boundaries', 'anthropogenic/human influenced ecosystems', 'emissions', 'sulfur dioxide', 'population', 'infrastructure', 'environmental assessments', 'public health', 'conservation', 'agriculture production', 'administrative divisions', 'economic resources', 'socioeconomics', 'lake/pond', 'rivers/stream', 'political divisions', 'environmental vulnerability index (evi)', 'ecosystems', 'urban areas', 'sustainability', 'treaty agreements/results', 'human settlements', 'population estimates', 'nitrogen dioxide', 'cropland', 'pasture', 'particulates', 'cyclones', 'mortality', 'environmental impacts', 'droughts', 'earthquakes', 'population distribution', 'fertilizers', 'animal manure and waste', 'urbanization/urban sprawl', 'landslides', 'avalanche', 'urban lands', 'mangroves', 'volcanic eruptions', 'pesticides', 'population size', 'population density', 'lakes/reservoirs', 'surface water', 'rural areas', 'infant mortality rates', 'amphibians', 'mammals', 'carbon', 'sulfur oxides', 'methane', 'non-methane hydrocarbons/volatile organic compounds', 'nitrogen oxides', 'natural gas', 'coal', 'coastal elevation', 'biodiversity functions', 'nuclear radiation exposure', 'radiation exposure', 'poverty levels', 'malnutrition', 'wetlands', 'sea level rise', 'vulnerability levels/index', 'ground water', 'snow/ice', 'electricity', 'energy production/use', 'sustainable development', 'deforestation', 'household income', 'discharge/flow', 'hydropattern', 'nitrogen', 'phosphorus', 'carbon dioxide', 'alpine/tundra', 'forests', 'vegetation', 'permafrost', 'nutrients', 'plant characteristics', 'leaf area index (lai)', 'soil gas/air', 'ammonia', 'nitrous oxide', 'ecosystem functions', 'litter characteristics', 'soil chemistry', 'soil respiration', 'active layer', 'soil depth', 'cation exchange capacity', 'organic matter', 'soil porosity', 'soil texture', 'permafrost melt', 'land subsidence', 'freeze/thaw', 'surface water features', 'chlorinated hydrocarbons', 'methyl bromide', 'methyl chloride', 'molecular hydrogen', 'sulfur compounds', 'fire models', 'biomass', 'dominant species', 'vegetation species', 'sulfur', 'tree rings', 'soil classification', 'heat index', 'sea ice concentration', 'ocean heat budget', 'reforestation', 'even-toed ungulates', 'species recruitment', 'population dynamics', 'range changes', 'topographic effects', 'land resources', 'river ice depth/extent', 'snow melt', 'river ice', 'animal commodities', 'animal ecology and behavior', 'phenological changes', 'water depth', 'inundation', 'forest fire science', 'biogeochemical cycles', 'radiative forcing', 'soil heat budget', 'drainage', 'respiration rate', 'river/lake ice breakup', 'river/lake ice freeze', 'reclamation/revegetation/restoration', 'permafrost temperature', 'indigenous/native species', 'fire dynamics', 'lichens', 'plants', 'plant succession', 'carbon flux', 'coastal', 'salt marsh', 'degradation', 'altitude', 'carbon and hydrocarbon compounds', 'halocarbons and halogens', 'forest composition/vegetation structure', 'water vapor indicators', 'barometric altitude', 'atmospheric water vapor', 'terrestrial ecosystems', 'volatile organic compounds', 'boundary layer winds', 'forest fire danger index', 'periglacial processes', 'landscape processes', 'evaporation', 'soil horizons/profile', 'shrubland/scrub', 'soil ph', 'soils', 'soil water holding capacity', 'community structure', 'pingo', 'soil color', 'virtual temperature', 'formaldehyde', 'hydroxyl', 'photolysis rates', 'cloud dynamics', 'nitric oxide', 'molecular oxygen', 'smog', 'peroxyacyl nitrate', 'hydrogen compounds', 'nitrogen compounds', 'oxygen compounds', 'stable isotopes', 'chemical composition', 'actinic flux', 'tropospheric ozone', 'fossil fuel burning', 'industrial emissions', 'denitrification rate', 'sunshine', 'runoff', 'soil structure', 'mosses/hornworts/liverworts', 'peatlands', 'hydraulic conductivity', 'snow/ice temperature', 'vegetation water content', 'discharge', 'chlorophyll concentrations', 'outgoing longwave radiation', 'geomorphic landforms/processes', 'soil compaction', 'soil impedance', 'canopy transmittance', 'water table', 'decomposition', 'water temperature', 'dissolved gases', 'total dissolved solids', 'agricultural expansion', 'forest science', 'pressure tendency', 'visibility', 'biomass dynamics', 'agricultural lands', 'grasslands', 'savannas', 'grazing dynamics/plant herbivory', 'herbivory', 'paleoclimate reconstructions', 'drought indices', 'fire weather index', 'animal yields', 'multivariate enso index', 'dissolved solids', 'ocean currents', 'salinity', 'coastal processes', 'atmospheric pressure', 'afforestation/reforestation', 'fresh water river discharge', 'surface water chemistry', 'drainage basins', 'resource development site', 'dunes', 'flood plain', 'endangered species', 'precipitation indices', 'temperature indices', 'forest yields', 'stratigraphic sequence', 'freeze/frost', 'frost', 'hydrogen cyanide', 'land management', 'nutrient cycling', 'industrialization', 'suspended solids', 'deserts', 'weathering', 'gas flaring', 'atmospheric temperature', 'ice extent', 'fraction of absorbed photosynthetically active radiation (fapar)', 'marshes', 'swamps', 'lake ice', 'atmospheric winds', 'watershed characteristics', 'transportation', 'soil rooting depth', 'isotopes', 'cultural features', 'consumer behavior', 'boundary surveys', 'aquifers', 'land productivity', 'water quality/water chemistry', 'sediment composition', 'dissolved oxygen', 'surface water processes/measurements', 'turbidity', 'conductivity', 'ph', 'calcium', 'magnesium', 'potassium', 'micronutrients/trace elements', 'social behavior', 'sulfate', 'sediment chemistry', 'biogeochemical processes', 'water ion concentrations', 'cropping systems', 'percolation', 'groundwater chemistry', 'reforestation/revegetation', 'species/population interactions', 'soil infiltration', 'alkalinity', 'soil fertility', 'phosphorous compounds', 'radioisotopes', 'cooling degree days', 'angiosperms (flowering plants)', 'glacial landforms', 'glacial processes', 'contour maps', 'estuaries', 'methane production/use', 'natural gas production/use', 'petroleum production/use', 'visualization/image processing', 'subsetting/supersetting', 'transformation/conversion', 'forest mensuration', 'acid deposition', 'differential pressure', 'precipitation', 'marine ecosystems', 'consumption rates', 'radio wave', 'soil organic carbon (soc)', 'soil erosion', 'halocarbons', 'trace elements/trace metals', 'biomass energy production/use', 'riparian wetlands', 'soil consistence', 'snow stratigraphy', 'thermal conductivity', 'estuary', 'tidal height', 'plant diseases/disorders/pests', 'layered precipitable water', 'atmospheric chemistry', 'water vapor concentration profiles', 'specific humidity', 'total runoff', 'pressure thickness', 'wind stress', 'atmospheric heating', 'conduction', 'hydrogen chloride', 'nitric acid', 'radar', 'land surface/agriculture indicators', 'satellite soil moisture index', 'chlorine nitrate', 'chlorofluorocarbons', 'dinitrogen pentoxide', 'antenna temperature', 'glaciers', 'ice sheets', 'dimethyl sulfide', 'potential vorticity', 'ice fraction', 'atmospheric radiation', 'runoff rate', 'temperature tendency', 'wind dynamics', 'wind direction tendency', 'base flow', 'bromine monoxide', 'chlorine monoxide', 'methyl cyanide', 'hypochlorous acid', 'methanol', 'hydroperoxy', 'cloud base pressure', 'temperature anomalies', 'nitrate', 'ocean mixed layer', 'precipitation trends', 'temperature trends', 'convection', 'ground ice', 'oxygen', 'phosphate', 'solar induced fluorescence', 'chlorine dioxide', 'sun-earth interactions', 'uv aerosol index', 'volcanic activity', 'potential evapotranspiration', 'ultraviolet wavelengths', 'ice temperature', 'sea surface skin temperature', 'sea surface height', 'sublimation', 'convective surface precipitation rate', 'hydrogen fluoride', 'airglow', 'energy deposition', 'x-ray flux', 'electron flux', 'proton flux', 'magnetic fields/magnetic currents']\\n else:\\n return ['platform characteristics', 'atmospheric winds','radio wave', 'weather events', 'geomagnetism','atmospheric electricity', 'microwave', 'atmospheric temperature','atmospheric water vapor', 'atmospheric pressure', 'aerosols','atmospheric radiation', 'atmospheric chemistry', 'precipitation','sensor characteristics', 'radar', 'infrared wavelengths','visible wavelengths', 'weather/climate advisories', 'clouds','lidar', 'ocean optics', 'ultraviolet wavelengths','cryospheric indicators', 'land use/land cover', 'topography','surface thermal properties', 'spectral/engineering', 'soils','snow/ice', 'geothermal dynamics', 'natural hazards','surface water', 'vegetation','land surface/agriculture indicators','gravity/gravitational field', 'marine advisories', 'altitude','water quality/water chemistry', 'ocean temperature','ocean winds', 'atmospheric/ocean indicators', 'coastal processes','erosion/sedimentation', 'marine sediments', 'ocean chemistry','salinity/density', 'ocean color', 'aquatic ecosystems','vegetation2', 'landscape', 'cloud properties','surface radiative properties', 'geodetics','agricultural plant science', 'forest science','ecological dynamics', 'environmental impacts', 'sustainability','boundaries', 'ecosystems', 'air quality', 'population','infrastructure', 'environmental governance/management','public health', 'economic resources', 'socioeconomics','environmental vulnerability index (evi)', 'human settlements','agricultural chemicals', 'animal science','habitat conversion/fragmentation', 'animals/vertebrates','earth gases/liquids', 'rocks/minerals/crystals','social behavior', 'ground water', 'frozen ground','terrestrial hydrosphere indicators', 'ocean heat budget','biospheric indicators', 'animal commodities', 'fungi', 'plants','carbon flux', 'geomorphic landforms/processes','paleoclimate indicators', 'ocean circulation', 'sea ice','geochemistry', 'visualization/image processing','subsetting/supersetting', 'transformation/conversion','ocean pressure', 'glaciers/ice sheets', 'protists','solar activity', 'sun-earth interactions','sea surface topography', 'solar energetic particle properties','solar energetic particle flux','ionosphere/magnetosphere dynamics','flight data logs','wind dynamics', 'radio wave flux', 'lightning', 'magnetic field','atmospheric conductivity', 'electric field','data synchronization time', 'brightness temperature','upper air temperature', 'water vapor profiles','surface temperature', 'upper level winds','atmospheric pressure measurements', 'water vapor indicators','aerosol particle properties', 'emissivity','trace gases/trace species', 'liquid precipitation','cloud microphysics', 'microwave radiance', 'sensor counts','total pressure', 'airspeed/ground speed', 'total temperature','static pressure', 'humidity', 'radar reflectivity','doppler velocity', 'infrared imagery', 'visible imagery','aerosol backscatter', 'weather forecast', 'tropical cyclones','visible radiance', 'infrared radiance','atmospheric temperature indices', 'cloud droplet distribution','cloud condensation nuclei', 'hydrometeors', 'oxygen compounds','wind profiles', 'liquid water equivalent', 'solar radiation','planetary boundary layer height', 'surface winds','precipitation amount', 'precipitation rate', 'surface pressure','aerosol extinction', 'aerosol optical depth/thickness','tropospheric/high-level clouds (observed/analyzed)','lidar depolarization ratio', 'radar backscatter','radar cross-section', 'return power', 'radial velocity','radiance', 'climate advisories', 'atmospheric emitted radiation','optical depth/thickness', 'ultraviolet flux', 'spectrum width','microwave imagery', 'lidar backscatter', 'radar imagery','snow depth', 'land use/land cover classification','terrain elevation', 'solid precipitation', 'droplet size','droplet concentration/size', 'precipitation anomalies','snow water equivalent', 'total surface precipitation rate','skin temperature', 'water vapor', 'attitude characteristics','land surface temperature', 'reflectance','soil moisture/water content', 'soil temperature','soil bulk density', 'surface roughness', 'present weather','snow density', 'geothermal temperature','aerosol forward scatter', 'floods', 'snow cover', 'sigma naught','precipitable water', 'surface water processes/measurements','surface water features', 'shortwave radiation','photosynthetically active radiation', 'longwave radiation','net radiation', 'flight level winds', 'soil moisture','satellite orbits/revolution', 'heat flux','precipitation profiles', 'geopotential height','particulate matter', 'particle images', 'water vapor indices','electrical conductivity', 'gases', 'sea surface temperature','convective clouds/systems (observed/analyzed)','viewing geometry', 'wind shear','carbon and hydrocarbon compounds', 'sea level pressure','water vapor processes', 'ultraviolet radiation','solar irradiance', 'scattering', 'absorption','sea surface temperature indices', 'sedimentation', 'erosion','sediment transport', 'sediments', 'tropopause', 'nan', 'pigments','attenuation/transmission', 'inorganic carbon', 'organic carbon','photosynthetically available radiation', 'chlorophyll','optical depth', 'fluorescence', 'vegetation index', 'gelbstoff','plankton', 'vegetation index2', 'landscape ecology','ultraviolet radiance', 'aerosol radiance','carbonaceous aerosols', 'dust/ash/smoke', 'nitrate particles','organic particles', 'sulfate particles', 'radiative flux','transmittance', 'atmospheric stability','cloud radiative transfer', 'rain storms', 'reflected infrared','thermal infrared', 'incoming solar radiation', 'cloud types','orbital characteristics', 'geolocation','coordinate reference system', 'infrared flux', 'visible flux','albedo', 'lidar waveform', 'plant phenology', 'vegetation cover','crop/plant yields', 'land use classes', 'landscape patterns','forest harvesting and engineering', 'forest management','ecosystem functions', 'leaf characteristics', 'fire ecology','total surface water', 'primary production', 'photosynthesis','canopy characteristics', 'evergreen vegetation', 'crown','deciduous vegetation', 'anisotropy', 'biomass burning','wildfires', 'topographical relief','environmental sustainability','anthropogenic/human influenced ecosystems', 'emissions','sulfur compounds', 'environmental assessments', 'conservation','agriculture production', 'administrative divisions','freshwater ecosystems', 'political divisions', 'urban areas','treaty agreements/results', 'population estimates','nitrogen compounds', 'particulates', 'mortality', 'droughts','earthquakes', 'population distribution', 'fertilizers','animal manure and waste', 'urbanization/urban sprawl','landslides', 'avalanche', 'mangroves', 'volcanic eruptions','pesticides', 'population size', 'population density','rural areas', 'amphibians', 'mammals', 'carbon', 'sulfur oxides','land management', 'natural gas', 'sedimentary rocks','coastal elevation', 'community dynamics','nuclear radiation exposure', 'radiation exposure','poverty levels', 'malnutrition', 'sea level rise','vulnerability levels/index', 'electricity','energy production/use', 'sustainable development','deforestation', 'household income', 'nitrogen', 'phosphorus','terrestrial ecosystems', 'permafrost', 'nutrients','plant characteristics', 'soil gas/air', 'litter characteristics','soil chemistry', 'soil respiration', 'active layer', 'soil depth','cation exchange capacity', 'organic matter', 'soil porosity','soil texture', 'permafrost melt','ground water processes/measurements', 'freeze/thaw','halocarbons and halogens', 'hydrogen compounds', 'biomass','dominant species', 'vegetation species', 'sulfur', 'tree rings','soil classification', 'sea ice concentration', 'reforestation','species/population interactions', 'range changes','topographic effects', 'land resources', 'river ice depth/extent','snow melt', 'river ice', 'animal ecology and behavior','phenological changes', 'forest fire science', 'radiative forcing','soil heat budget', 'river/lake ice breakup','river/lake ice freeze', 'reclamation/revegetation/restoration','lichens', 'marine ecosystems', 'coastal landforms', 'degradation','forest composition/vegetation structure', 'barometric altitude','volatile organic compounds', 'forest fire danger index','periglacial processes', 'landscape processes','soil horizons/profile', 'soil ph', 'soil water holding capacity','fluvial landforms', 'soil color', 'glacial processes','photochemistry', 'cloud dynamics', 'nitrogen oxides', 'smog','chemical composition', 'actinic flux', 'tropospheric ozone','fossil fuel burning', 'industrial emissions','denitrification rate', 'sunshine', 'soil structure','mosses/hornworts/liverworts', 'hydraulic conductivity','snow/ice temperature', 'water characteristics','outgoing longwave radiation', 'soil compaction', 'soil impedance','canopy transmittance', 'ground water features', 'solids','agricultural expansion', 'pressure tendency', 'visibility','herbivory', 'paleoclimate reconstructions', 'drought indices','fire weather index', 'animal yields', 'teleconnections','carbon dioxide', 'dissolved solids', 'ocean currents', 'salinity','afforestation/reforestation', 'fresh water river discharge','surface water chemistry', 'aeolian landforms','precipitation indices', 'temperature indices', 'forest yields','stratigraphic sequence', 'freeze/frost', 'frost','industrialization', 'ice core records', 'suspended solids','weathering', 'gas flaring', 'ice extent', 'biogeochemical cycles','lake ice', 'isotopes', 'watershed characteristics','transportation', 'soil rooting depth', 'geochemical properties','carbon monoxide', 'cultural features', 'consumer behavior','boundary surveys', 'land productivity', 'sediment composition','calcium', 'magnesium', 'potassium','micronutrients/trace elements', 'sediment chemistry','biogeochemical processes', 'cropping systems','groundwater chemistry', 'reforestation/revegetation','soil infiltration', 'soil fertility','angiosperms (flowering plants)', 'glacial landforms','forest mensuration', 'acid deposition', 'differential pressure','soil erosion', 'trace elements/trace metals', 'soil consistence','snow stratigraphy', 'thermal conductivity', 'estuaries','tidal height', 'plant diseases/disorders/pests','pressure thickness', 'atmospheric heating', 'conduction','evaporation', 'turbulence', 'wind stress','satellite soil moisture index', 'antenna temperature', 'glaciers','ice sheets', 'nitrate', 'ocean mixed layer','precipitation indicators', 'temperature indicators', 'ground ice','alkalinity', 'dissolved gases', 'oxygen', 'ph', 'phosphate','solar induced fluorescence', 'volcanic activity','ice temperature', 'sea surface height', 'airglow','energy deposition', 'x-ray flux', 'electron flux', 'proton flux','magnetic fields/magnetic currents', 'vertical profiles','air temperature', 'dew point temperature','cloud liquid water/ice', 'wind speed', 'wind direction','vertical wind velocity/speed', 'total precipitable water','boundary layer temperature', 'cloud height','cloud droplet concentration/size', 'ozone','cloud base temperature', 'cloud base height', 'rain','cloud optical depth/thickness', 'cirrus/systems','mean radial velocity', 'relative humidity', 'u/v wind components','wind speed/wind direction','digital elevation/terrain model (dem)', 'snow', 'drizzle','particle size distribution', 'hail', 'ambient temperature','stage height', 'rivers/streams', 'hourly precipitation amount','24 hour precipitation amount', 'latent heat flux','cloud fraction', '3 and 6 hour precipitation amount','horizontal wind velocity/speed', 'dissolved carbon dioxide','hurricanes', 'tropical cyclone track', 'cloud top height','temperature profiles', 'vertical wind shear','water vapor tendency', 'potential temperature','angstrom exponent', 'water vapor mixing ratio profiles','extreme eastern tropical pacific sst', 'phytoplankton','cloud precipitable water', 'cloud asymmetry', 'cloud ceiling','cloud frequency', 'cloud top pressure', 'cloud top temperature','cloud vertical distribution', 'cloud emissivity','cloud radiative forcing', 'cloud reflectance','maximum/minimum temperature', 'condensation','topographical relief maps', 'evapotranspiration','fire occurrence', 'burned area', 'sulfur dioxide', 'lake/pond','rivers/stream', 'nitrogen dioxide', 'agricultural lands','cyclones', 'urban lands', 'lakes/reservoirs','infant mortality rates', 'methane','non-methane hydrocarbons/volatile organic compounds', 'coal','biodiversity functions', 'wetlands', 'discharge/flow','hydropattern', 'alpine/tundra', 'forests','leaf area index (lai)', 'ammonia', 'nitrous oxide','land subsidence', 'normalized difference vegetation index (ndvi)','chlorinated hydrocarbons', 'methyl bromide', 'methyl chloride','molecular hydrogen', 'fire models', 'heat index','even-toed ungulates', 'species recruitment','population dynamics', 'water depth', 'inundation', 'drainage','respiration rate', 'permafrost temperature','indigenous/native species', 'fire dynamics', 'plant succession','coastal', 'salt marsh', 'boundary layer winds', 'shrubland/scrub','community structure', 'pingo', 'virtual temperature','formaldehyde', 'hydroxyl', 'photolysis rates', 'nitric oxide','molecular oxygen', 'peroxyacyl nitrate', 'stable isotopes','runoff', 'vegetation water content', 'discharge','chlorophyll concentrations', 'water table', 'decomposition','water temperature', 'total dissolved solids', 'biomass dynamics','grasslands', 'savannas', 'grazing dynamics/plant herbivory','multivariate enso index', 'drainage basins','resource development site', 'dunes', 'flood plain','endangered species', 'hydrogen cyanide', 'nutrient cycling','deserts','fraction of absorbed photosynthetically active radiation (fapar)','aquifers', 'dissolved oxygen', 'turbidity', 'conductivity','sulfate', 'water ion concentrations', 'percolation','phosphorous compounds', 'radioisotopes', 'cooling degree days','contour maps', 'methane production/use','natural gas production/use', 'petroleum production/use','consumption rates', 'soil organic carbon (soc)', 'halocarbons','biomass energy production/use', 'estuary','layered precipitable water', 'water vapor concentration profiles','hydrogen chloride', 'nitric acid', 'chlorine nitrate','chlorofluorocarbons', 'dinitrogen pentoxide', 'dimethyl sulfide','vorticity', 'ice fraction', 'temperature tendency','wind direction tendency', 'bromine monoxide', 'chlorine monoxide','methyl cyanide', 'hypochlorous acid', 'methanol', 'hydroperoxy','cloud base pressure', 'temperature anomalies','precipitation trends', 'temperature trends', 'convection','chlorine dioxide', 'uv aerosol index','sea surface skin temperature', 'sublimation','convective surface precipitation rate', 'hydrogen fluoride']\",\n \"def eval_final_label(args):\\n cfg, lbl = util.get_label_cfg_by_args(args)\\n uid = cfg['uniqueid']\\n print('We are playing with %s' % uid)\\n outdir='models/%s/gate_expert' % uid\\n outname='gate_expert_model.pt'\\n if KLLOSS:\\n outname = 'gate_expert_kldiv_model.pt'\\n if args.warm:\\n outname = outname.replace('.pt', '_warm.pt')\\n mdl_path = os.path.join(outdir, outname)\\n gate_expert = GateExpertNet(mdl_path, False)\\n eval_fun = gate_expert.get_p_y\\n\\n data = npload(cfg['file_path'], uid)\\n datax = data[cfg['x_name']]\\n p, v = eval_fun(datax)\\n\\n label = np.argmax(p, axis=1)\\n\\n if args.draw:\\n fig, ax = plt.subplots()\\n n_expert = np.amax(label) + 1\\n for i in range(n_expert):\\n mask = label == i\\n ax.scatter(datax[mask, 0], datax[mask, 1])\\n plt.show()\\n\\n label_name = 'data/pen/gate_expert_label.npy'\\n if KLLOSS:\\n label_name = label_name.replace('_label', '_kldiv_label')\\n if args.warm:\\n label_name = label_name.replace('.npy', '_warm.npy')\\n np.save(label_name, label)\",\n \"def main():\\r\\n if len(sys.argv) == 2:\\r\\n if sys.argv[1] == 'branch_name':\\r\\n print branch_name()\\r\\n elif sys.argv[1] == 'plat_id':\\r\\n print plat_id()\\r\\n else:\\r\\n print plat_id()\\r\\n print branch_name()\\r\\n return\",\n \"def step_name(self):\\n return \\\"main\\\"\",\n \"def setup_protocol(self):\\n self.ctx.inputs = {\\n 'codename': self.inputs.codename,\\n 'parameters': {},\\n 'settings': {},\\n 'options': ParameterData(dict={\\n 'resources': {\\n 'num_machines': 1\\n },\\n 'max_wallclock_seconds': 1800,\\n }),\\n }\\n\\n if self.inputs.protocol == 'standard':\\n self.report('running the workchain in the \\\"{}\\\" protocol'.format(self.inputs.protocol.value))\\n self.ctx.protocol = {\\n 'kpoints_mesh_offset': [0., 0., 0.],\\n 'kpoints_mesh_density': 0.2,\\n 'convergence_threshold': 2.E-06,\\n 'smearing': 'marzari-vanderbilt',\\n 'degauss': 0.02,\\n 'occupations': 'smearing',\\n 'tstress': True,\\n 'pseudo_familyname': 'SSSP',\\n 'pseudo_data': {\\n 'H': {'cutoff': 55, 'dual': 8, 'pseudo': '031US'},\\n 'He': {'cutoff': 55, 'dual': 4, 'pseudo': 'SG15'},\\n 'Li': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.4'},\\n 'Be': {'cutoff': 40, 'dual': 8, 'pseudo': 'GBRV-1.4'},\\n 'B': {'cutoff': 40, 'dual': 8, 'pseudo': '031PAW'},\\n 'C': {'cutoff': 50, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'N': {'cutoff': 55, 'dual': 8, 'pseudo': 'THEOS'},\\n 'O': {'cutoff': 45, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'F': {'cutoff': 50, 'dual': 8, 'pseudo': 'GBRV-1.4'},\\n 'Ne': {'cutoff': 200, 'dual': 8, 'pseudo': '100PAW'},\\n 'Na': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'Mg': {'cutoff': 35, 'dual': 8, 'pseudo': 'GBRV-1.4'},\\n 'Al': {'cutoff': 30, 'dual': 8, 'pseudo': '100PAW'},\\n 'Si': {'cutoff': 30, 'dual': 8, 'pseudo': '100US'},\\n 'P': {'cutoff': 30, 'dual': 8, 'pseudo': '100US'},\\n 'S': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'Cl': {'cutoff': 35, 'dual': 8, 'pseudo': 'GBRV-1.4'},\\n 'Ar': {'cutoff': 120, 'dual': 8, 'pseudo': '100US'},\\n 'K': {'cutoff': 50, 'dual': 8, 'pseudo': '100US'},\\n 'Ca': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'Sc': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'Ti': {'cutoff': 35, 'dual': 8, 'pseudo': 'GBRV-1.4'},\\n 'V': {'cutoff': 40, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'Cr': {'cutoff': 40, 'dual': 8, 'pseudo': 'GBRV-1.5'},\\n 'Mn': {'cutoff': 70, 'dual': 12, 'pseudo': '031PAW'},\\n 'Fe': {'cutoff': 90, 'dual': 12, 'pseudo': '031PAW'},\\n 'Co': {'cutoff': 55, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'Ni': {'cutoff': 45, 'dual': 8, 'pseudo': 'GBRV-1.4'},\\n 'Cu': {'cutoff': 40, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'Zn': {'cutoff': 40, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'Ga': {'cutoff': 35, 'dual': 8, 'pseudo': '031US'},\\n 'Ge': {'cutoff': 40, 'dual': 8, 'pseudo': '100PAW'},\\n 'As': {'cutoff': 30, 'dual': 8, 'pseudo': '031US'},\\n 'Se': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'Br': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.4'},\\n 'Kr': {'cutoff': 100, 'dual': 8, 'pseudo': '031US'},\\n 'Rb': {'cutoff': 50, 'dual': 4, 'pseudo': 'SG15'},\\n 'Sr': {'cutoff': 35, 'dual': 8, 'pseudo': '100US'},\\n 'Y': {'cutoff': 35, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'Zr': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'Nb': {'cutoff': 35, 'dual': 8, 'pseudo': '031PAW'},\\n 'Mo': {'cutoff': 35, 'dual': 4, 'pseudo': 'SG15'},\\n 'Tc': {'cutoff': 30, 'dual': 4, 'pseudo': 'SG15'},\\n 'Ru': {'cutoff': 40, 'dual': 4, 'pseudo': 'SG15'},\\n 'Rh': {'cutoff': 45, 'dual': 8, 'pseudo': '100PAW'},\\n 'Pd': {'cutoff': 55, 'dual': 8, 'pseudo': '100PAW'},\\n 'Ag': {'cutoff': 35, 'dual': 8, 'pseudo': 'GBRV-1.4'},\\n 'Cd': {'cutoff': 40, 'dual': 8, 'pseudo': '031US'},\\n 'In': {'cutoff': 35, 'dual': 8, 'pseudo': '031US'},\\n 'Sn': {'cutoff': 35, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'Sb': {'cutoff': 40, 'dual': 8, 'pseudo': 'GBRV-1.4'},\\n 'Te': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'I': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'Xe': {'cutoff': 120, 'dual': 8, 'pseudo': '100US'},\\n 'Cs': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'Ba': {'cutoff': 40, 'dual': 4, 'pseudo': 'SG15'},\\n 'Hf': {'cutoff': 35, 'dual': 8, 'pseudo': '031US'},\\n 'Ta': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'W': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'Re': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'Os': {'cutoff': 35, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'Ir': {'cutoff': 40, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'Pt': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.4'},\\n 'Au': {'cutoff': 45, 'dual': 4, 'pseudo': 'SG15'},\\n 'Hg': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'Tl': {'cutoff': 30, 'dual': 8, 'pseudo': '031US'},\\n 'Pb': {'cutoff': 40, 'dual': 8, 'pseudo': '031PAW'},\\n 'Bi': {'cutoff': 35, 'dual': 8, 'pseudo': '031PAW'},\\n 'Po': {'cutoff': 45, 'dual': 8, 'pseudo': '100US'},\\n 'Rn': {'cutoff': 45, 'dual': 8, 'pseudo': '100US'},\\n 'La': {'cutoff': 55, 'dual': 8, 'pseudo': 'Wentzcovitch'},\\n 'Ce': {'cutoff': 45, 'dual': 8, 'pseudo': 'Wentzcovitch'},\\n 'Pr': {'cutoff': 50, 'dual': 8, 'pseudo': 'Wentzcovitch'},\\n 'Nd': {'cutoff': 40, 'dual': 8, 'pseudo': 'Wentzcovitch'},\\n 'Sm': {'cutoff': 40, 'dual': 8, 'pseudo': 'Wentzcovitch'},\\n 'Eu': {'cutoff': 55, 'dual': 8, 'pseudo': 'Wentzcovitch'},\\n 'Tb': {'cutoff': 40, 'dual': 8, 'pseudo': 'Wentzcovitch'},\\n 'Dy': {'cutoff': 40, 'dual': 8, 'pseudo': 'Wentzcovitch'},\\n 'Ho': {'cutoff': 40, 'dual': 8, 'pseudo': 'Wentzcovitch'},\\n 'Er': {'cutoff': 40, 'dual': 8, 'pseudo': 'Wentzcovitch'},\\n 'Tm': {'cutoff': 40, 'dual': 8, 'pseudo': 'Wentzcovitch'},\\n 'Yb': {'cutoff': 40, 'dual': 8, 'pseudo': 'Wentzcovitch'},\\n 'Lu': {'cutoff': 45, 'dual': 8, 'pseudo': 'Wentzcovitch'},\\n }\\n }\",\n \"def test_get_label_line(self):\\r\\n\\r\\n sample_id = \\\"Sample1\\\"\\r\\n fasta_label = \\\"ABCD1234 region=1 length=254\\\"\\r\\n bc = \\\"AAAA\\\"\\r\\n corrected_bc = \\\"AAAT\\\"\\r\\n num_errors = 1\\r\\n actual_label = get_label_line(sample_id, fasta_label, bc, corrected_bc,\\r\\n num_errors)\\r\\n\\r\\n expected_label = \\\"Sample1 ABCD1234 orig_bc=AAAA new_bc=AAAT bc_diffs=1\\\"\\r\\n self.assertEqual(actual_label, expected_label)\",\n \"def Label(self) -> str:\",\n \"def set_label(termtype, timeperiod):\\n label = 'Graph these comma-separated noun phrases (yearly frequencies):' if termtype == 'Noun phrases' and timeperiod == 'Yearly' \\\\\\n else 'Graph these comma-separated noun phrases (monthly frequencies):' if termtype == 'Noun phrases' and timeperiod == 'Monthly' \\\\\\n else 'Graph these comma-separated entity mentions (yearly frequencies):' if termtype == 'Entity mentions' and timeperiod == 'Yearly' \\\\\\n else 'Graph these comma-separated entity mentions (monthly frequencies):' if termtype == 'entity mentions' and timeperiod == 'Monthly' \\\\\\n else 'Enter a phrase and get similar terms and the distribution of its \\\"cluster\\\"'\\n return label\",\n \"def label(tree):\\n return tree[0]\",\n \"def housepredict(intent_request):\\r\\n \\r\\n \\r\\n location_zip = get_slots(intent_request)[\\\"location\\\"]\\r\\n housetype_zip = get_slots(intent_request)[\\\"housetype\\\"]\\r\\n source = intent_request['invocationSource']\\r\\n \\r\\n print('received request: ' + str(intent_request))\\r\\n print (\\\"housetype\\\",housetype_zip)\\r\\n print (\\\"location1\\\",location_zip)\\r\\n\\r\\n if source == 'DialogCodeHook':\\r\\n # Perform basic validation on the supplied input slots.\\r\\n # Use the elicitSlot dialog action to re-prompt for the first violation detected.\\r\\n slots = get_slots(intent_request)\\r\\n print('slots are' ,str(slots)) \\r\\n validation_result = validate_housepred(location_zip)\\r\\n if not validation_result['isValid']:\\r\\n slots[validation_result['violatedSlot']] = None\\r\\n return elicit_slot(intent_request['sessionAttributes'],\\r\\n intent_request['currentIntent']['name'],\\r\\n slots,\\r\\n validation_result['violatedSlot'],\\r\\n validation_result['message'])\\r\\n\\t\\t\\r\\n validation_result2 = validate_housepred_hstyp(housetype_zip)\\r\\n if not validation_result2['isValid']:\\r\\n slots[validation_result2['violatedSlot']] = None\\r\\n return elicit_slot(intent_request['sessionAttributes'],\\r\\n intent_request['currentIntent']['name'],\\r\\n slots,\\r\\n validation_result2['violatedSlot'],\\r\\n validation_result2['message'])\\r\\n\\r\\n # Pass the price of the flowers back through session attributes to be used in various prompts defined\\r\\n # on the bot model.\\r\\n output_session_attributes = intent_request['sessionAttributes'] if intent_request['sessionAttributes'] is not None else {}\\r\\n if location_zip is not None and housetype_zip is not None:\\r\\n output_session_attributes['Price'] = house_price_pred(location_zip,housetype_zip)#len(location_zip)*5#house_price_pred(location_zip,housetype_zip) \\r\\n #price = house_price_pred(location_zip,housetype_zip)# Elegant pricing model\\r\\n\\t\\t\\t\\r\\n return delegate(output_session_attributes, get_slots(intent_request))\\r\\n\\r\\n # Order the flowers, and rely on the goodbye message of the bot to define the message to the end user.\\r\\n # In a real bot, this would likely involve a call to a backend service.\\r\\n print(intent_request['sessionAttributes']['Price']) \\r\\n return close(intent_request['sessionAttributes'],\\r\\n 'Fulfilled',\\r\\n {'contentType': 'PlainText',\\r\\n 'content': 'Approx. next year growth prediction for {hstyp} in {loc} is {prc}%'.format(hstyp=housetype_zip,loc=location_zip,prc=intent_request['sessionAttributes']['Price'])})\",\n \"def test_get_prior_string_dict(self):\\n categories = {\\\"asdfa\\\": 0.1, 2: 0.2, 3: 0.3, \\\"lalala\\\": 0.4}\\n dim = Categorical(\\n \\\"yolo\\\", categories, shape=2, default_value=[\\\"asdfa\\\", \\\"lalala\\\"]\\n )\\n assert dim.get_prior_string() == (\\n \\\"choices({'asdfa': 0.10, 2: 0.20, 3: 0.30, 'lalala': 0.40}, \\\"\\n \\\"shape=2, default_value=['asdfa', 'lalala'])\\\"\\n )\",\n \"def getLabel(*args):\",\n \"def getLabel(*args):\",\n \"def getLabel(*args):\",\n \"def __rechaindict__(c):\\n from TriggerMenu.menu.DictFromChainName import DictFromChainName\\n dfcn = DictFromChainName()\\n\\n pl1 = []\\n for pch in c['chainParts']:\\n pl1.append(pch['L1item'])\\n\\n newname = c['chainName'].replace('dv_','').replace('TestChain','j')\\n nchlist = [ newname ,c['chainCounter'],c['L1item'],pl1,c['stream'],\\n c['groups'],c['EBstep'] ]\\n \\n return dfcn.getChainDict(nchlist)\",\n \"def plot_hypnogram(stages, labeldict=None, title=None, epochlen=30, ax=None,\\n verbose=True, xlabel=True, ylabel=True, **kwargs,):\\n\\n if labeldict is None:\\n labeldict = {}\\n _defaultdict = {-1: 'A', 0:'Wake', 4:'REM', 1:'S1', 2:'S2', 3:'SWS', 5:'Artefact'}\\n if set(stages) == set([0, 1]):\\n labeldict = {0:'Wake', 1:'Sleep'}\\n elif set(stages) == set([0, 1, 2]):\\n labeldict = {0:'Wake', 2:'REM', 1:'NREM'}\\n else:\\n for stage in _defaultdict:\\n if stage in stages:\\n labeldict[stage] = _defaultdict[stage]\\n if verbose: print('Assuming {}'.format(labeldict))\\n\\n # check if all stages that are in the hypnogram have a corresponding label in the dict\\n for stage in np.unique(stages):\\n if not stage in labeldict:\\n print('WARNING: {} is in stages, but not in labeldict, stage will be ??'.format(stage))\\n\\n # create the label order\\n labels = [labeldict[l] for l in labeldict]\\n labels = sorted(set(labels), key=labels.index)\\n\\n # we iterate through the stages and fetch the label for this stage\\n # then we append the position on the plot of this stage via the labels-dict\\n x = []\\n y = []\\n rem_start = []\\n rem_end = []\\n for i in np.arange(len(stages)):\\n s = stages[i]\\n label = labeldict.get(s)\\n if label is None:\\n p = 99\\n if '??' not in labels: labels.append('??')\\n else :\\n p = -labels.index(label)\\n \\n # make some red line markers for REM, mark beginning and end of REM\\n if 'REM' in labels:\\n if label=='REM' and len(rem_start)==len(rem_end):\\n rem_start.append(i-2)\\n elif label!='REM' and len(rem_start)>len(rem_end):\\n rem_end.append(i-1)\\n if label=='REM' and i==len(stages)-1:\\n rem_end.append(i+1)\\n \\n if i!=0:\\n y.append(p)\\n x.append(i-1)\\n y.append(p)\\n x.append(i)\\n \\n assert len(rem_start)==len(rem_end), 'Something went wrong in REM length calculation'\\n\\n x = np.array(x)*epochlen\\n y = np.array(y)\\n y[y==99] = y.min()-1 # make sure Unknown stage is plotted below all else\\n\\n if ax is None:\\n plt.figure()\\n ax = plt.gca()\\n formatter = matplotlib.ticker.FuncFormatter(lambda s, x: time.strftime('%H:%M', time.gmtime(s)))\\n \\n ax.plot(x,y, **kwargs)\\n ax.set_xlim(0, x[-1])\\n ax.xaxis.set_major_formatter(formatter)\\n \\n ax.set_yticks(np.arange(len(np.unique(labels)))*-1)\\n ax.set_yticklabels(labels)\\n ax.set_xticks(np.arange(0,x[-1],3600))\\n if xlabel: plt.xlabel('Time after recording start')\\n if ylabel: plt.ylabel('Sleep Stage')\\n if title is not None:\\n plt.title(title)\\n\\n try:\\n warnings.filterwarnings(\\\"ignore\\\", message='This figure includes Axes that are not compatible')\\n plt.tight_layout()\\n except Exception: pass\\n\\n # plot REM in RED here\\n for start, end in zip(rem_start, rem_end):\\n height = -labels.index('REM')\\n ax.hlines(height, start*epochlen, end*epochlen, color='r',\\n linewidth=4, zorder=99)\",\n \"def final_result(self, hyp, confidence):\\n print(\\\"Final:\\\"+hyp)\",\n \"def handle(self, *args, **options):\\n chains = sorted(plugin.BY_REQUIREMENTS.keys())\\n for chain in chains:\\n print(chain, \\\"chain:\\\")\\n reqs = sorted(\\\"{} -> {}\\\".format(\\\", \\\".join(sorted(k)) or 'START',\\n \\\", \\\".join(sorted(v))) for k, v in\\n plugin.BY_REQUIREMENTS[chain].iteritems())\\n for req in reqs:\\n print(\\\"-\\\", req)\",\n \"def get_kit_string(currentStep):\\n kit_string = currentStep.udf.get(\\\"ONT prep kit\\\")\\n\\n if currentStep.udf.get(\\\"ONT expansion kit\\\") != \\\"None\\\":\\n kit_string += f\\\" {currentStep.udf.get('ONT expansion kit')}\\\"\\n\\n return kit_string\",\n \"def name(self):\\n return self.viztrail.name\",\n \"def processSystematic(observable, xsecType, xsecLevel, systematic, histNominal):\\n varHists = []\\n linkStr = \\\"\\\"\\n singlePointSystematics = [\\\"ERDON\\\", \\\"ERDONRETUNE\\\", \\\"GLUONMOVETUNE\\\", \\\"BFRAG_PETERSON\\\"]\\n\\n sPS = 0\\n\\n if any(singlePointSystematic in systematic for singlePointSystematic in singlePointSystematics):\\n sPS = 1\\n\\n linkStr = \\\"_\\\"\\n variations = [\\\"\\\"]\\n for variation in variations:\\n path = directory_base + xsec_type + \\\"_\\\" + xsec_level + directory_tail + systematic + linkStr + variation + \\\"/combinedUnfolded/Hyp\\\" + observable + \\\"Results.txt\\\"\\n inputfile = open(path, 'r').readlines()\\n bins = []\\n for line in inputfile:\\n bins.append(float(line.split( )[3]))\\n bins.append(float(line.split( )[5]))\\n bins = sorted(bins)\\n binsArray = array('f',bins)\\n histNameUp = systematic + \\\"_UP\\\" \\n histNameDown = systematic + \\\"_DOWN\\\" \\n histUp = TH1F(histNameUp, histNameUp, len(bins)-1, binsArray)\\n histDown = TH1F(histNameDown, histNameDown, len(bins)-1, binsArray)\\n histUpFinal = TH1F(\\\"\\\", \\\"\\\", len(bins)-1, binsArray)\\n histDownFinal = TH1F(\\\"\\\", \\\"\\\", len(bins)-1, binsArray)\\n \\n ibin = 0\\n\\n for line in inputfile:\\n nomBin = histNominal.GetBinContent(ibin+1)\\n nomBinCenter = histNominal.GetBinCenter(ibin+1)\\n unc = float(line.split( )[7])\\n if systematic == \\\"DY\\\":\\n print \\\"DY UP = \\\" + str(1.0 + unc)\\n print \\\"DY DOWN = \\\" + str(1.0 - unc)\\n\\n\\n histUp.SetBinContent(ibin+1, 1.0 + unc)\\n histDown.SetBinContent(ibin+1,1.0 - unc)\\n ibin = ibin + 1 \\n\\n histUpVis = histUp.Clone()\\n histDownVis = histDown.Clone()\\n histUpFinal = histUp.Clone()\\n histDownFinal = histDown.Clone()\\n\\n if systematic == \\\"PDF\\\":\\n histUpFinal, histDownFinal = reNormalise(histNominal, histUpVis, histDownVis)\\n\\n return (histUpFinal, histDownFinal)\",\n \"def get_labels(rf_pipeline):\\n return rf_pipeline.stages[0].labels\",\n \"def _repr_(self):\\n return \\\"Category of hyperbolic models of {}\\\".format(self.base())\",\n \"def label(cmd):\\r\\n cmd = cmd.replace('make][.DP', 'make1][.NP')\\r\\n cmd = cmd.replace('make][.SC', 'make2][.SC')\\r\\n cmd = re.sub('(draw.*)one','\\\\\\\\1one1',cmd)\\r\\n cmd = re.sub('(make1.*)one','\\\\\\\\1one1',cmd)\\r\\n cmd = re.sub('(make2.*)one','\\\\\\\\1one2',cmd)\\r\\n cmd = re.sub('(move.*)one','\\\\\\\\1one2',cmd)\\r\\n cmd = re.sub('(hide.*)one','\\\\\\\\1one2',cmd)\\r\\n cmd = '[result ' + cmd + ']' #dummy function for plop\\r\\n return cmd\",\n \"def get_match_label(match):\\n # Define variables\\n home_goals = match['home_team_goal']\\n away_goals = match['away_team_goal']\\n\\n label = pd.Series()\\n label['match_api_id'] = match['match_api_id']\\n\\n # Identify match label\\n if home_goals > away_goals:\\n label['label'] = \\\"Win\\\"\\n if home_goals == away_goals:\\n label['label'] = \\\"Draw\\\"\\n if home_goals < away_goals:\\n label['label'] = \\\"Defeat\\\"\\n\\n # Return label (match_api_id; label)\\n return label\",\n \"def main(_):\\n hps = LM.get_default_hparams().parse(FLAGS.hpconfig)\\n hps._set(\\\"num_gpus\\\", FLAGS.num_gpus)\\n print ('*****HYPER PARAMETERS*****')\\n print (hps)\\n print ('**************************')\\n\\n vocab = Vocabulary.from_file(os.path.join(FLAGS.datadir, \\\"vocabulary.txt\\\"))\\n\\n if FLAGS.mode == \\\"train\\\":\\n #hps.batch_size = 256\\n dataset = Dataset(vocab, os.path.join(FLAGS.datadir, \\\"train.txt\\\"))\\n run_train(dataset, hps, os.path.join(FLAGS.logdir, \\\"train\\\"), ps_device=\\\"/gpu:0\\\")\\n elif FLAGS.mode.startswith(\\\"eval\\\"):\\n data_dir = os.path.join(FLAGS.datadir, \\\"eval.txt\\\")\\n #predict_model = prediction.Model('/dir/ckpt',os.path.join(FLAGS.datadir, \\\"vocabulary.txt\\\"), hps)\\n\\n dataset = Dataset(vocab, data_dir, deterministic=True)\\n prefix_words = \\\"<brk>\\\".split()\\n predict_model = predict.Model(hps, FLAGS.logdir, FLAGS.datadir)\\n print ('start input')\\n out = predict_model.predictnextkwords(prefix_words, FLAGS.num_sen)\\n for row in out:\\n print(' '.join(row) + \\\"\\\\n\\\")\\n print(\\\"len_out: \\\" + str(len(out)))\\n #prediction.topkwords(prefix_words, dataset, hps, FLAGS.logdir, FLAGS.mode)\\n #sentence_ppl(prefix_words,dataset, hps, FLAGS.logdir, FLAGS.mode)\\n #print vocab\\n #dataset = Dataset(vocab, os.path.join(FLAGS.datadir, \\\"eval.txt\\\"))\\n #run_eval(dataset, hps, FLAGS.logdir, FLAGS.mode, FLAGS.eval_steps)\",\n \"def get_new_word(key, chains):\\n values = chains[key]\\n return choice(values)\",\n \"def parse_logic(self, logic):\\n if 'xxx' in logic.conf:\\n # self.function(logic['name'])\\n pass\",\n \"def forward(self, waveforms: Tensor) -> str:\\n logits, _ = self.model(waveforms) # [batch, num_seq, num_label]\\n best_path = torch.argmax(logits[0], dim=-1) # [num_seq,]\\n prev = ''\\n hypothesis = ''\\n for i in best_path:\\n char = self.labels[i]\\n if char == prev:\\n continue\\n if char == '<s>':\\n prev = ''\\n continue\\n hypothesis += char\\n prev = char\\n return hypothesis.replace('|', ' ')\",\n \"def make_text(chains):\\n\\n key = random.choice(chains.keys())\\n return_string = key[0] + \\\" \\\" + key[1]\\n\\n while chains[key] != None: #chains.get(key[-1]) != None: \\n next_word = random.choice(chains[key])\\n return_string = return_string + \\\" \\\" + next_word\\n key = (key[1],next_word)\\n\\n return return_string\",\n \"def get_chain_name (chain):\\n if \\\"-\\\" in chain.id:\\n id_chain=chain.id[-1]\\n else:\\n id_chain=chain.id\\n return id_chain\",\n \"def _get_label(self):\\n return self.label\",\n \"def get_clarifications_socialiqa(ex, nlp, comet_model):\\n context = ex['context']\\n question = ex['question']\\n\\n question_to_comet_relation = {\\n \\\"What will [NAME] want to do next?\\\": \\\"xWant\\\",\\n \\\"What will [NAME] want to do after?\\\": \\\"xWant\\\",\\n \\\"How would [NAME] feel afterwards?\\\": \\\"xReact\\\",\\n \\\"How would [NAME] feel as a result?\\\": \\\"xReact\\\",\\n \\\"What will [NAME] do next?\\\": \\\"xReact\\\",\\n \\\"How would [NAME] feel after?\\\": \\\"xReact\\\",\\n \\\"How would you describe [NAME]?\\\": \\\"xAttr\\\",\\n \\\"What kind of person is [NAME]?\\\": \\\"xAttr\\\",\\n \\\"How would you describe [NAME] as a person?\\\": \\\"xAttr\\\",\\n \\\"Why did [NAME] do that?\\\": \\\"xIntent\\\",\\n \\\"Why did [NAME] do this?\\\": \\\"xIntent\\\",\\n \\\"Why did [NAME] want to do this?\\\": \\\"xIntent\\\",\\n \\\"What does [NAME] need to do beforehand?\\\": \\\"xNeed\\\",\\n \\\"What does [NAME] need to do before?\\\": \\\"xNeed\\\",\\n \\\"What does [NAME] need to do before this?\\\": \\\"xNeed\\\",\\n \\\"What did [NAME] need to do before this?\\\": \\\"xNeed\\\",\\n \\\"What will happen to [NAME]?\\\": \\\"xEffect\\\",\\n \\\"What will happen to [NAME] next?\\\": \\\"xEffect\\\"\\n }\\n\\n clarifications = []\\n personx, _ = get_personx(nlp, context)\\n relation = question_to_comet_relation.get(re.sub(personx, \\\"[NAME]\\\", question, flags=re.I), None)\\n\\n if relation is not None:\\n outputs = {relation: comet_model.predict(context, relation, num_beams=5)}\\n\\n prefix = CATEGORY_TO_PREFIX[relation]\\n for out_event in outputs[relation]:\\n if out_event != \\\"none\\\" and out_event != \\\"\\\":\\n if not out_event.lower().startswith(\\\"person\\\") and not out_event.lower().startswith(\\\"other\\\"):\\n out_event = \\\" \\\".join((prefix, out_event))\\n\\n out_event = re.sub(\\\"personx\\\", personx, out_event, flags=re.I)\\n out_event = re.sub(\\\"person x\\\", personx, out_event, flags=re.I)\\n out_event = re.sub(\\\"persony\\\", \\\"others\\\", out_event, flags=re.I)\\n out_event = re.sub(\\\"person y\\\", \\\"others\\\", out_event, flags=re.I)\\n\\n clarifications.append((question, out_event))\\n\\n return clarifications\",\n \"def label(efo):\\n url = 'https://www.ebi.ac.uk/ols/api/ontologies/efo/terms?iri=http://www.ebi.ac.uk/efo/'+efo\\n try:\\n response = requests.get(url).json()\\n except:\\n return \\\"\\\"\\n if 'error' in response.keys():\\n return \\\"\\\"\\n return response['_embedded']['terms'][0]['label']\",\n \"def chain_run(ctx, chain_name, mine, verbosity):\\n logger = logging.getLogger('populus.cli.chain.run')\\n project = ctx.obj['PROJECT']\\n\\n chain = project.get_chain(chain_name)\\n\\n if isinstance(chain, BaseGethChain):\\n chain.geth.register_stdout_callback(logger.info)\\n chain.geth.register_stderr_callback(logger.error)\\n\\n with chain:\\n try:\\n while True:\\n time.sleep(0.2)\\n except KeyboardInterrupt:\\n pass\",\n \"def getRaceLabel(x,binary=False):\\r\\n ID = x.split(\\\"/\\\")[-1].split(\\\"_\\\")[0]\\r\\n label = truth[truth.DummyID == int(ID)]['Medview_Race'].values[0]\\r\\n\\r\\n if label == 'African American':\\r\\n return 0\\r\\n elif label == \\\"White\\\":\\r\\n return 1\\r\\n else:\\r\\n return 2\",\n \"def pipeline(self):\\n predicted, real = self.surface_segmentation()\\n # print(predicted[0:10])\\n # print(len(predicted))\\n test_file = \\\"../morphology/\\\" + self.language + \\\"/\\\" + self.language + \\\".clean.test.conll\\\"\\n input_file = open(os.path.join(sys.path[0], test_file), 'r')\\n segmented_words = []\\n\\n # Only one entry per word for dictionary\\n\\n words = []\\n labels = []\\n for line in input_file.readlines():\\n tmp = line.rstrip('\\\\n').split(\\\" | \\\")[0]\\n label_arr = line.rstrip('\\\\n').split(\\\" | \\\")[2]\\n label_arr = get_labels(label_arr)\\n if tmp not in words:\\n words.append(tmp)\\n labels.append(label_arr)\\n\\n segmented_words = []\\n for word, label in zip(words, predicted):\\n tmp = []\\n for i in range(len(label)):\\n if label[i] == \\\"S\\\" or label[i] == \\\"E\\\":\\n tmp.append(word[i])\\n tmp.append(\\\"-\\\")\\n else:\\n tmp.append(word[i])\\n tmp = \\\"\\\".join(tmp).rstrip(\\\"-\\\")\\n segmented_words.append(tmp)\\n\\n features = surface_labelled_data_preparation_pipeline(segmented_words)\\n predicted, test = self.__surface_labelled_segmentation_pipeline(features)\\n return predicted, labels\",\n \"def get_clarifications_piqa(ex, nlp, comet_model):\\n # Questions are usually like \\\"how would you do something?\\\"\\n personx = \\\"you\\\"\\n\\n input_event = ex[\\\"goal\\\"].replace(\\\"?\\\", \\\"\\\")\\n outputs = {category: comet_model.predict(input_event, category, num_beams=5) for category in comet_model.categories}\\n\\n # We only care about preconditions and postconditions for X\\n relevant_categories = [\\\"xIntent\\\", \\\"xNeed\\\", \\\"xEffect\\\", \\\"xWant\\\"]\\n curr_events = []\\n for category in relevant_categories:\\n prefix = CATEGORY_TO_PREFIX[category]\\n for out_event in outputs[category]:\\n if out_event != \\\"none\\\" and out_event != \\\"\\\":\\n if not out_event.lower().startswith(\\\"person\\\") and not out_event.lower().startswith(\\\"other\\\"):\\n out_event = \\\" \\\".join((prefix, out_event))\\n\\n out_event = re.sub(\\\"personx\\\", personx, out_event, flags=re.I)\\n out_event = re.sub(\\\"person x\\\", personx, out_event, flags=re.I)\\n out_event = re.sub(\\\"persony\\\", \\\"others\\\", out_event, flags=re.I)\\n out_event = re.sub(\\\"person y\\\", \\\"others\\\", out_event, flags=re.I)\\n\\n question = CATEGORY_TO_QUESTION[category].replace(\\\"PersonX\\\", personx)\\n curr_events.append((question, out_event))\\n\\n return curr_events\",\n \"def get_label(self):\\n return self.job[self.label_key]\",\n \"def lhco_line(self):\\n if not self.check_def(['eta','phi','pt','mass','pid']): \\n sys.exit('Particle error: some attribute not defined')\\n\\n jet=[1,2,3,4,5,6,21]\\n inv_list=[12,14,16,18,1000022,1000023,1000024,1000025,1000035]\\n\\n #define pid-> type\\n pid_to_type={11:1,-11:1,13:2,-13:2,15:3,-15:3,22:0}\\n for data in jet:\\n pid_to_type[data]=4\\n pid_to_type[-data]=4\\n for data in inv_list:\\n pid_to_type[data]=6\\n pid_to_type[-data]=6\\n\\n\\n \\n type=''\\n for key in pid_to_type.keys():\\n if self.pid==key:\\n type=pid_to_type[key]\\n break\\n \\n if type=='':\\n print 'Warning unknown type'\\n return ''\\n\\n text =' '+str(type) #type LHCO\\n text+=' '+str(self.eta) #ETA\\n text+=' '+str(self.phi) #PHI\\n text+=' '+str(self.pt) #PT\\n text+=' '+str(self.mass) #JMASS\\n if self.pid in [11,13]: #NTRK\\n text+=' -1' \\n else:\\n text+=' 1'\\n if self.pid in [-5,5]: #BTAG\\n text+=' 2'\\n else:\\n text+=' 0'\\n text+=' 0' #HAD/EM\\n text+=' 0' #DUMMY 1\\n text+=' 0' #DUMMY 2\\n \\n return text\",\n \"def get_chain(self, chain_id):\\n if self.chain_dict.has_key(chain_id):\\n return self.chain_dict[chain_id]\\n return None\",\n \"def label(self) -> str:\\n return self[\\\"label\\\"]\",\n \"def label(cmd):\\n cmd = cmd.replace('make][.DP', 'make1][.NP')\\n cmd = cmd.replace('make][.SC', 'make2][.SC')\\n cmd = re.sub('(draw.*)one','\\\\\\\\1one1',cmd)\\n cmd = re.sub('(make1.*)one','\\\\\\\\1one1',cmd)\\n cmd = re.sub('(make2.*)one','\\\\\\\\1one2',cmd)\\n cmd = re.sub('(move.*)one','\\\\\\\\1one2',cmd)\\n cmd = re.sub('(hide.*)one','\\\\\\\\1one2',cmd)\\n cmd = '[result ' + cmd + ']' #dummy function for plop\\n return cmd\",\n \"def SetupFcn(self):\\n return _hypre.HypreParaSails_SetupFcn(self)\",\n \"def generate_HLD(component, output):\\n component.delete_none_attrs()\\n yaml.indent(mapping=2, sequence=4, offset=2)\\n d = component.asdict()\\n\\n yaml.dump(d, output)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67336076","0.6324823","0.5675857","0.56554145","0.5556557","0.54489195","0.5372017","0.53109175","0.5194049","0.509463","0.50940394","0.49333954","0.49087635","0.4816282","0.47896782","0.47874323","0.4760651","0.47558823","0.47320828","0.47163337","0.4697964","0.4697964","0.4697964","0.46477467","0.46188495","0.4604326","0.45948538","0.45567554","0.4532131","0.4518247","0.45069382","0.4505159","0.4496154","0.4493104","0.44868314","0.4484499","0.44842538","0.44788465","0.4477625","0.4468817","0.4454167","0.44472125","0.44438758","0.44295356","0.4416616","0.44085002","0.4408289","0.4407519","0.4402998","0.43985268","0.43980908","0.43762022","0.43733582","0.4373203","0.43682143","0.43631634","0.43624112","0.43573672","0.43348658","0.433402","0.4316019","0.4310848","0.4306008","0.42983785","0.42978182","0.42926103","0.42795235","0.42795235","0.42795235","0.42770424","0.4275674","0.42737427","0.42713505","0.42654365","0.42651907","0.42640334","0.42553523","0.42533186","0.42526105","0.4250961","0.42506745","0.42496133","0.42416823","0.42362565","0.42317078","0.42307195","0.42296165","0.42284736","0.42284212","0.42218295","0.4220016","0.42185876","0.42176226","0.4216664","0.42116132","0.42020443","0.42009687","0.42005658","0.42001638","0.418759"],"string":"[\n \"0.67336076\",\n \"0.6324823\",\n \"0.5675857\",\n \"0.56554145\",\n \"0.5556557\",\n \"0.54489195\",\n \"0.5372017\",\n \"0.53109175\",\n \"0.5194049\",\n \"0.509463\",\n \"0.50940394\",\n \"0.49333954\",\n \"0.49087635\",\n \"0.4816282\",\n \"0.47896782\",\n \"0.47874323\",\n \"0.4760651\",\n \"0.47558823\",\n \"0.47320828\",\n \"0.47163337\",\n \"0.4697964\",\n \"0.4697964\",\n \"0.4697964\",\n \"0.46477467\",\n \"0.46188495\",\n \"0.4604326\",\n \"0.45948538\",\n \"0.45567554\",\n \"0.4532131\",\n \"0.4518247\",\n \"0.45069382\",\n \"0.4505159\",\n \"0.4496154\",\n \"0.4493104\",\n \"0.44868314\",\n \"0.4484499\",\n \"0.44842538\",\n \"0.44788465\",\n \"0.4477625\",\n \"0.4468817\",\n \"0.4454167\",\n \"0.44472125\",\n \"0.44438758\",\n \"0.44295356\",\n \"0.4416616\",\n \"0.44085002\",\n \"0.4408289\",\n \"0.4407519\",\n \"0.4402998\",\n \"0.43985268\",\n \"0.43980908\",\n \"0.43762022\",\n \"0.43733582\",\n \"0.4373203\",\n \"0.43682143\",\n \"0.43631634\",\n \"0.43624112\",\n \"0.43573672\",\n \"0.43348658\",\n \"0.433402\",\n \"0.4316019\",\n \"0.4310848\",\n \"0.4306008\",\n \"0.42983785\",\n \"0.42978182\",\n \"0.42926103\",\n \"0.42795235\",\n \"0.42795235\",\n \"0.42795235\",\n \"0.42770424\",\n \"0.4275674\",\n \"0.42737427\",\n \"0.42713505\",\n \"0.42654365\",\n \"0.42651907\",\n \"0.42640334\",\n \"0.42553523\",\n \"0.42533186\",\n \"0.42526105\",\n \"0.4250961\",\n \"0.42506745\",\n \"0.42496133\",\n \"0.42416823\",\n \"0.42362565\",\n \"0.42317078\",\n \"0.42307195\",\n \"0.42296165\",\n \"0.42284736\",\n \"0.42284212\",\n \"0.42218295\",\n \"0.4220016\",\n \"0.42185876\",\n \"0.42176226\",\n \"0.4216664\",\n \"0.42116132\",\n \"0.42020443\",\n \"0.42009687\",\n \"0.42005658\",\n \"0.42001638\",\n \"0.418759\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6201193"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":8793,"cells":{"query":{"kind":"string","value":"(Set, float, float, int, str) > list Filters a set of Products according to the parameters. This function is responsible to determine if filtering with tags should be applied or not."},"document":{"kind":"string","value":"def get_matching_products(products, lat, lng, radius, tags):\n if tags:\n tag_list = tags.split(',')\n return list([\n product for product in products\n if is_matching_product_with_tags(\n product,\n lat,\n lng,\n radius,\n tag_list\n )\n ])\n else:\n return list([\n product for product in products\n if is_matching_product(\n product,\n lat,\n lng,\n radius\n )\n ])"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def filter_generic(products, listings, result=None):\n print \"Apply Generic Filtering \"\n if result == None:\n result = {}\n matched_listings = []\n for alist in listings:\n manufacturer, renamed_manufacturer = find_manufacturer(products, alist)\n if manufacturer == False:\n continue\n for product in products[manufacturer]:\n product = product[0] # get product information all in lower case\n if not does_list_contains_model(\\\n alist, product['model'], manufacturer):\n continue\n if product['product_name'] not in result:\n result[product['product_name']] = []\n for matched_list in listings[alist]:\n matched_manufacturer =\\\n matched_list['manufacturer'].lower()\n if manufacturer not in matched_manufacturer and\\\n matched_manufacturer not in renamed_manufacturer:\n continue\n result[product['product_name']].append(matched_list)\n matched_listings.append(alist)\n remove_matched_list(listings, matched_listings)\n length_listings(listings)\n return result","def filter_queryset(self, queryset):\n query_params = self.request.query_params\n # validate query parameters\n exception_response = ParamsCheck.validate(\n query_params, APIParams.products_list_params\n )\n if exception_response:\n return exception_response\n\n products_qs = self.get_queryset() # all\n\n category = query_params.get(\"category\", None)\n exclude_ingredients = query_params.get(\"exclude_ingredient\", None)\n exclude_ingredients = self._clean_string(exclude_ingredients)\n include_ingredients = query_params.get(\"include_ingredient\", None)\n include_ingredients = self._clean_string(include_ingredients)\n\n # filtering part\n if category is not None:\n products_qs = products_qs.filter(category=category)\n for each in include_ingredients:\n products_qs = products_qs.filter(ingredients__name=each)\n for each in exclude_ingredients:\n products_qs = products_qs.exclude(ingredients__name=each)\n\n return products_qs","def filter_products(self, products, mrp_only=False, extension=None, **filters):\n\n filterMask = np.full(len(products), True, dtype=bool)\n\n # Applying the special filters (mrp_only and extension)\n if mrp_only:\n filterMask &= (products['productGroupDescription'] == \"Minimum Recommended Products\")\n\n if extension:\n mask = np.full(len(products), False, dtype=bool)\n for elt in extension:\n mask |= [False if isinstance(x, np.ma.core.MaskedConstant) else x.endswith(elt)\n for x in products[\"productFilename\"]]\n filterMask &= mask\n\n # Applying the rest of the filters\n for colname, vals in filters.items():\n\n if type(vals) == str:\n vals = [vals]\n\n mask = np.full(len(products), False, dtype=bool)\n for elt in vals:\n mask |= (products[colname] == elt)\n\n filterMask &= mask\n\n return products[np.where(filterMask)]","def filter(self, filters):","def test_tag_filter(self):\n request = RequestFactory().get('/?tags=foo&tags=bar')\n qs = MockQuerySet()\n filter = TestFilterSet(request.GET, qs)\n self.assertEquals(filter.qs.filters['tags__slug__in'], ['foo', 'bar'])","def filter_queryset(self, queryset):\n tags = self.request.GET.getlist(\"tag\")\n if tags:\n for tag in tags:\n queryset = queryset.filter(tag__tag=tag)\n return super().filter_queryset(queryset)","def filter_by_tag(self, tags):\n\n if isinstance(tags, string_types):\n message = \"tags should be a list or None, got tags={}\".format(tags)\n raise TypeError(message)\n\n data_collection = DataCollection()\n for item in self.iteritems():\n if tags == [] or tags == None or all([tag in item.tags for tag in tags]):\n data_collection.add_data(item)\n return data_collection","def filter_queryset(self, request, queryset, view):\n # filter by tags if available.\n tags = request.query_params.get(\"tags\", None)\n\n if tags and isinstance(tags, six.string_types):\n tags = tags.split(\",\")\n return queryset.filter(tags__name__in=tags)\n\n return queryset","def test_filter_remove_only_bad_products(self):\n list_of_products = [self.good_product, self.bad_product]\n self.assertEqual(\n ProductValidator().filter(list_of_products),\n [self.good_product])","def apply(self, catalog):\n out = []\n for product in catalog:\n valid = True\n for key, filtr in self.filters.items():\n valid = valid and filtr(product[key])\n if valid:\n out.append(product)\n out = sorted(out, key=lambda x: x['onDemandUsdPrice'])\n return self.limit_size(out)","def check_intersection(product_list, product):\n best_products = []\n if len(product_list) > 0:\n\n for current_product in product_list:\n intersection_product = set(current_product.categories.all()) & set(\n product.categories.all())\n\n if len(intersection_product) >= 1:\n best_products.append(current_product)\n\n return best_products","def filter_category_products(products, searchterm='', for_sale=None, **kwargs):\n\n searchterm = searchterm.lower()\n filtered_products = []\n for product in products:\n if searchterm not in product['name'].lower():\n continue\n if for_sale and not product['records']:\n continue\n filtered_products.append(product)\n return filtered_products","def test_set_tag_filters(self):\n filters = QueryFilterCollection()\n\n url = \"?\"\n query_params = self.mocked_query_params(url, OCPTagView)\n handler = OCPTagQueryHandler(query_params)\n tag_keys = handler.get_tag_keys(filters=False)\n\n filter_key = tag_keys[0]\n\n filter_value = \"filter\"\n group_by_key = tag_keys[1]\n\n group_by_value = \"group_By\"\n\n url = f\"?filter[tag:{filter_key}]={filter_value}&group_by[tag:{group_by_key}]={group_by_value}\"\n query_params = self.mocked_query_params(url, OCPCpuView)\n handler = OCPReportQueryHandler(query_params)\n filters = handler._set_tag_filters(filters)\n\n expected = f\"\"\"<class 'api.query_filter.QueryFilterCollection'>: (AND: ('pod_labels__{filter_key}__icontains', '{filter_value}')), (AND: ('pod_labels__{group_by_key}__icontains', '{group_by_value}')), \"\"\" # noqa: E501\n\n self.assertEqual(repr(filters), expected)","def clean(self, products):\n clean_products = []\n clean_categories = set()\n for product in products:\n if self.is_valid(product):\n product[\"categories\"] = [\n cat.strip().lower().capitalize()\n for cat in product[\"categories\"].split(\",\")\n ]\n clean_products.append(product)\n clean_categories |= set(product[\"categories\"])\n return clean_categories, clean_products","def test_tag_filter(self):\n request = RequestFactory().get('/?search=foobar')\n qs = MockQuerySet()\n filter = TestFilterSet(request.GET, qs)\n self.assertEquals(filter.qs.filters['name__icontains'], 'foobar')\n self.assertEquals(filter.qs.filters['status__startswith'], 'foobar')","def filter(\n self, items: Iterable[Product], spec: Specification\n ) -> Generator[Product, None, None]:\n return (item for item in items if spec.is_satisfied(item))","def _fuzzy_products(self, package: ImagePackage) -> typing.List[str]:\n\n products = {package.name}\n # TODO: add the generic product generation code (including nomatch exclusions here)\n return list(products)","def call(self):\r\n clean_products = []\r\n\r\n for category in CATEGORIES:\r\n print(f\"Chargement des produits de type {category}\")\r\n api_url = SEARCH_API_URL + \\\r\n (f\"?search_terms={category}\"\r\n \"&search_tag=category&sort_by=unique_scans_n\"\r\n \"&page_size=1000&json=1\")\r\n json_response = requests.get(api_url).json()\r\n products = json_response[\"products\"]\r\n\r\n for product in products:\r\n clean_product = {\r\n k: v for k, v in product.items()\r\n if k in FIELD_NEEDED and v != ''}\r\n clean_products.append(clean_product)\r\n\r\n return clean_products","def filter(self, filters:list)->list:\n for item in self.list:\n use_item = True\n for filter in filters:\n filter_key, filter_value, filter_type = filter\n if filter_type == \"<\" and item[filter_key] >= filter_value:\n use_item = False\n break\n elif filter_type == \">\" and item[filter_key] <= filter_value:\n use_item = False\n break\n elif filter_type == \"<=\" and item[filter_key] > filter_value:\n use_item = False\n break\n elif filter_type == \">=\" and item[filter_key] < filter_value:\n use_item = False\n break\n elif filter_type == \"=\" and not item[filter_key] == filter_value:\n use_item = False\n break\n if use_item:\n yield item","def filter(self, artifacts: ArtifactsList) -> ArtifactsList:\n print(self.my_param)\n return artifacts","def filter_products(self, products: list):\n # Get all products that has no parent\n independent = [product for product in products if product[\"parent_id\"] is None]\n # Get all products that has parent\n dependent = [\n product for product in products if product[\"parent_id\"] is not None\n ]\n # Sort dependent products by parent_id, so that a child will be always\n # inserted after the parent\n dependent = sorted(dependent, key=lambda item: item[\"parent_id\"])\n # Saves the total of objects\n self.total = len(independent) + len(dependent)\n return independent, dependent","def filter_by_color(self, products, color):\n for p in products:\n # Selects products of the specified color\n if p.color == color:\n yield p","def get_all_products(request, *args, query_str=''):\n\n active_filters = []\n products = Product.objects.all()\n product_fields = (\n (\"size\", \"options\"),\n (\"price\", \"range\"),\n (\"colours\", \"options\"),\n (\"year\", \"range\"),\n (\"collection\", \"equals\")\n )\n field_ranges = []\n for field, filter_type in product_fields:\n if filter_type == \"range\":\n (min_val) = products.filter().values_list(field).order_by(field)[0]\n (max_val) = products.filter().values_list(field).order_by\\\n (f'-{field}')[0]\n obj = {}\n obj['min_val'] = int(min_val[0])\n obj['max_val'] = int(max_val[0])\n obj['field'] = field\n field_ranges.append(obj)\n\n # if filter_type == \"options\":\n\n\n\n if request.GET:\n for key in request.GET:\n if \"__range\" in key:\n val = request.GET.getlist(key)\n val[:] = [int(x) for x in val]\n active_filters.append(\n [key.split(\"__\")[0], key.split(\"__\")[1], val]\n )\n obj = {}\n obj[key] = val\n query = Q(**obj)\n products = products.filter(query)\n\n\n if 'collection' in request.GET:\n collection_pk = request.GET['collection']\n if not collection_pk or not collection_pk.isnumeric():\n if query:\n return redirect(\n reverse('products'),\n kwargs={'query_str': query}\n )\n else:\n return redirect(reverse('products'))\n\n products = products.filter(collection=collection_pk)\n\n if 'q' in request.GET:\n query = request.GET['q']\n query_str = query\n if not query:\n return redirect(reverse('products'))\n\n queries = Q(display_name__icontains=query) | \\\n Q(name__icontains=query)\n products = products.filter(queries)\n\n\n context = {\n 'products': products,\n 'MEDIA_URL': settings.MEDIA_URL,\n 'search_term': query_str,\n 'filters': product_fields,\n 'field_ranges': field_ranges,\n 'active_filters': active_filters\n }\n\n return render(request, 'products/products.html', context)","def _apply_filters(self, metadata):\n if \"keywords\" in self.filters:\n if not metadata.keywords:\n return False\n if not all(keyword in metadata.keywords for keyword in self.filters[\"keywords\"]):\n return False\n if \"features\" in self.filters:\n if not metadata.features:\n return False\n if not all(feature in metadata.features for feature in self.filters[\"features\"]):\n return False\n if \"authors\" in self.filters:\n if not metadata.authors:\n return False\n if not all(author in metadata.authors for author in self.filters[\"authors\"]):\n return False\n if \"version\" in self.filters:\n if not metadata.pylith_version:\n return False\n for verMeta in metadata.pylith_version:\n if not eval(\"{ver} {verMeta}\".format(ver=self.filters[\"version\"], verMeta=verMeta)):\n return False\n return True","def filter(self, *args, **kwargs):","def filterPick(list, filter, classification):\n y = []\n for job in list:\n x = [(job, classification) for l in job for m in (filter(l),) if m]\n y.append(x)\n return y","def type_filter(self, items, types=None):","def extract(self, filter_by='relevance', all_pages=False, limit=None):\r\n\r\n page = 1\r\n total_of_pages = 1\r\n products_list = []\r\n\r\n while page <= total_of_pages:\r\n\r\n products_code = None\r\n while products_code is None:\r\n soup = self.__olx_requests(filter_by, page)\r\n products_code = soup.find('div', {'class': \"sc-1fcmfeb-0 WQhDk\"})\r\n\r\n if page == 1 and all_pages is True and limit is None:\r\n max_pages = self.__number_of_pages(soup)\r\n if max_pages is not None:\r\n total_of_pages = max_pages\r\n\r\n elif page == 1 and all_pages is False and isinstance(limit, int):\r\n max_pages = self.__number_of_pages(soup)\r\n if max_pages is not None and limit <= max_pages:\r\n total_of_pages = limit\r\n else:\r\n total_of_pages = 1\r\n\r\n # Individual product - TAG\r\n for tags_products in [\"sc-1fcmfeb-2 ggOGTJ\", \"sc-1fcmfeb-2 hFOgZc\"]:\r\n for each_product in products_code.findAll('li', {'class': tags_products}):\r\n\r\n # Each product dictionary\r\n product_dict = {}\r\n\r\n # Name\r\n PRODUCT_NAME_TAG = 'fnmrjs-8 kRlFBv'\r\n if each_product.find('div', {'class': PRODUCT_NAME_TAG}) is not None:\r\n product_name = each_product.find('div', {'class': PRODUCT_NAME_TAG}).text\r\n if 'Anunciante online' in product_name:\r\n product_name = product_name.replace('Anunciante online', '')\r\n product_dict['Name'] = product_name\r\n else:\r\n continue\r\n\r\n # ID\r\n product_id = each_product.find('a', {'data-lurker-detail': 'list_id'})['data-lurker_list_id']\r\n product_dict['ID'] = product_id\r\n\r\n # Image\r\n PRODUCT_IMAGE_TAG = 'fnmrjs-5 jksoiN'\r\n product_img = each_product.find('div', {'class': PRODUCT_IMAGE_TAG}).find('img')['src']\r\n product_dict['Image'] = product_img\r\n\r\n # Price\r\n PRODUCT_PRICE_TAG = 'fnmrjs-15 clbSMi'\r\n if each_product.find('div', {'class': PRODUCT_PRICE_TAG}).text:\r\n product_price = each_product.find('div', {'class': PRODUCT_PRICE_TAG}).text\r\n product_dict['Price'] = re.findall('R\\$ (\\d*,?\\.?\\d*)|$', product_price)[0].replace('.', '')\r\n else:\r\n product_dict['Price'] = '-'\r\n\r\n # Date\r\n PRODUCT_DATE_TAG = 'fnmrjs-18 gMKELN'\r\n product_date = each_product.find('div', {'class': PRODUCT_DATE_TAG}).text\r\n if 'Hoje' in product_date:\r\n product_date = product_date.replace('Hoje', datetime.date.today().strftime(\"%d/%m \"))\r\n product_dict['Date'] = product_date\r\n\r\n elif 'Ontem' in product_date:\r\n product_date = product_date.replace('Ontem', (datetime.date.today() - datetime.timedelta(days=1)).strftime(\"%d/%m \"))\r\n product_dict['Date'] = product_date\r\n\r\n else:\r\n product_date = product_date.replace(re.findall(' ([a-z]*)\\d*', product_date)[0], months[re.findall(' ([a-z]*)\\d*', product_date)[0]]).replace(' ', r'/', 1)\r\n product_dict['Date'] = product_date\r\n\r\n # Location\r\n PRODUCT_LOCATION_PARENT_TAG = 'fnmrjs-21 bktOWr'\r\n PRODUCT_LOCATION_CHILD_TAG = 'fnmrjs-13 hdwqVC'\r\n product_location = each_product.find('div', {'class': PRODUCT_LOCATION_PARENT_TAG}).find('p', {'class': PRODUCT_LOCATION_CHILD_TAG}).text\r\n product_dict['City'] = re.findall('(.*\\w*),|$', product_location)[0]\r\n product_dict['Neighborhood'] = re.findall(r',(.*\\w*) - |$', product_location)[0].strip()\r\n product_dict['State'] = states_ddd[re.findall(r'DDD (\\d*)|$', product_location)[0]]\r\n\r\n # Link\r\n product_link = each_product.find('a', {'data-lurker-detail': 'list_id'})['href']\r\n product_dict['Link'] = product_link\r\n\r\n # List of Products\r\n products_list.append(product_dict)\r\n\r\n # Next page\r\n page += 1\r\n\r\n return products_list","def order_filter(self,elements):","def get_queryset(self):\n tags = self.request.query_params.get('tags')\n ingredient = self.request.query_params.get('ingredient')\n queryset = self.queryset\n if tags:\n tags_id = self._params_to_int(tags)\n queryset = queryset.filter(tags__id__in =tags_id)\n if ingredient:\n ingredient_id = self._params_to_int(ingredient)\n queryset = queryset.filter(ingredient__id__in = ingredient_id)\n\n return queryset.filter(user = self.request.user)","def get_queryset(self):\n tags = self.request.query_params.get('tags')\n categories = self.request.query_params.get('categories')\n user = self.request.query_params.get('user')\n queryset = self.queryset\n\n if tags:\n tags_title = self._params(tags)\n queryset = queryset.filter(tags__title__in=tags_title)\n\n if categories:\n categories_title = self._params(categories)\n queryset = queryset.filter(categories__title__in=categories_title)\n\n if user:\n user_id = self._params_to_ints(user)\n queryset = queryset.filter(user__id__in=user_id)\n return queryset","def testFiltrerTag(self):\n\t\ttags = (\n\t\t\t \t('in,', 'in'),\n\t\t\t \t('casse-tete', 'casse-tete'),\n\t\t\t \t)\n\t\t\n\t\tf = Flickr()\n\t\tfor tag, tag_filter in tags:\n\t\t\tresult = f.filtrer_tag(tag)\n\t\t\tself.assertEqual(result, tag_filter)","def FilterToKnownTags(self, tags: Iterable[str]) -> Set[str]:\n return self._GetKnownTags() & set(tags)","def filter_for_tags(cls, image: np.ndarray, tags: Set[Tag]) -> np.ndarray:\n masks = []\n for tag in tags:\n color = tag.color;\n red_mask = image[:, :, 0] == color[0]\n green_mask = image[:, :, 1] == color[1]\n blue_mask = image[:, :, 2] == color[2]\n masks.append(np.logical_and(red_mask, green_mask, blue_mask))\n\n final_mask = np.logical_not(np.logical_or.reduce(masks))\n image[final_mask] = 255\n return image","def filter_by_size(self, products, size):\n for p in products:\n # Selects products of the specified size\n if p.size == size:\n yield p","def queryset(self, request, queryset):\n for tag in get_resource_tags():\n if self.value() == tag[0]:\n return queryset.filter(tags__slug__iexact=tag[0])","def filtered(self, func):\n return PSetList(list(filter(func, self.sets)))","def sort_products(param: str, querySet: QuerySet):\n products_list = list(querySet)\n products_list.sort(\n key=lambda product: (-product.calculate_score(param), product.price)\n )\n return products_list","def filter_all(_):\n return True","def is_matching_product_with_tags(product, lat, lng, radius, tags):\n return vincenty(\n (lat, lng),\n (product.shop.lat, product.shop.lng)\n ).meters <= radius and any(tag in product.shop.tags for tag in tags)","def test_filter_recipe_by_tags(self):\n recipe1 = sample_recipe(user=self.user,title='chicken curry')\n recipe2 = sample_recipe(user=self.user,title='mutton curry')\n recipe3 = sample_recipe(user=self.user,title='milk dish')\n tag1 = sample_tag(user=self.user,name='chicken')\n tag2 = sample_tag(user=self.user,name='mutton')\n recipe1.tag.add(tag1)\n recipe2.tag.add(tag2)\n\n res = self.client.get(RECIPE_URL,{'tag':f'{tag1.id},{tag2.id}'})\n s1 = RecipeSerializer(recipe1)\n s2 = RecipeSerializer(recipe2)\n s3 = RecipeSerializer(recipe3)\n self.assertIn(s1.data,res.data)\n self.assertIn(s2.data,res.data)\n self.assertNotIn(s3.data,res.data)","def get_all_products(self):\n\t\tpass","def test_filter_reecipe_by_tag(self):\n recipe1 = sample_recipe(user=self.user, title=\"fish curry\")\n recipe2 = sample_recipe(user=self.user, title='mutton curry')\n\n tag1 = sample_tag(user=self.user, name='fish')\n tag2 = sample_tag(user=self.user, name='mutton')\n\n recipe1.tags.add(tag1)\n recipe2.tags.add(tag2)\n recipe3 = sample_recipe(user = self.user, title = 'Chicken curry')\n\n res = self.client.get(RECIPE_URL,\n {'tags' : f'{tag1.id},{tag2.id}'})\n seralizer1 = Recipeserializer(recipe1)\n seralizer2 = Recipeserializer(recipe2)\n seralizer3 = Recipeserializer(recipe3)\n self.assertIn(seralizer1.data, res.data)\n self.assertIn(seralizer2.data, res.data)\n self.assertNotIn(seralizer3.data, res.data)","def filter_stacks(stacks) -> dict:\n if not app_config.TAGS:\n return stacks\n keep = list()\n for stack in stacks[\"Stacks\"]:\n for tag in stack[\"Tags\"]:\n for filter_tag in app_config.TAGS:\n if filter_tag in tag.values():\n keep.append(stack)\n stacks[\"Stacks\"] = keep\n return stacks","def test_no_op(self):\n request = RequestFactory().get('/?tags=')\n qs = MockQuerySet()\n filter = TestFilterSet(request.GET, qs)\n self.assertNotIn('tags__slug__in', filter.qs.filters)","def search_by_product(self, **query):\n for product, datasets in self._do_search_by_product(query):\n yield product, self._make_many(datasets, product)","def filter(self, *args):\n return _libsbml.ElementFilter_filter(self, *args)","def by_tags(self, tags):\n if tags:\n self._filters.append(\n models.Note.tags.any(models.Tag.id.in_(tags)),\n )\n return self","def get_filters(self):","def doFiltering(self, searchfunc, filters=None):\n F=[]\n for f in self.filters:\n F.append(f.getFilter())\n #print F\n sets = []\n for f in F:\n col, val, op, boolean = f\n names = searchfunc(col, val, op)\n sets.append((set(names), boolean))\n names = sets[0][0]\n for s in sets[1:]:\n b=s[1]\n if b == 'AND':\n names = names & s[0]\n elif b == 'OR':\n names = names | s[0]\n elif b == 'NOT':\n names = names - s[0]\n names = list(names)\n self.updateResults(len(names))\n return names","def test_list_products_filtered_by_category(self):\n self._require_login(self.user1)\n response = self.client.get('/api/1.0/products/?category=1')\n self.assertEqual(response.status_code, status.HTTP_200_OK)\n self.assertEqual(response.data.__len__(), 1)\n self.assertEqual(response.data[0]['name'], 'Producto 2')\n self.assertEqual(response.data[0]['description'], 'Descripcion producto 2')","def filter_scalings(scaling_list, scaling_type):\n return filter(\n lambda _f: True if scaling_type in _f[\"runname\"] else False,\n scaling_list)","def filter_and(filters):\n def filt(item):\n for f in filters:\n if not f(item):\n return False\n return True\n return filt","def filter_by_param(self, pars):\n\n assert(type(pars) == dict)\n for par, vals in pars.items():\n vals = [type(self.sim_confs[0][par])(v) for v in vals]\n self.sim_confs = [conf for conf in self.sim_confs if conf[par] in vals]\n groups = []\n for group in self.sim_groups:\n filt_group = [conf for conf in group if conf[par] in vals]\n groups.append(filt_group)\n self.sim_groups = groups\n assert(len(self.sim_confs) >= 1)\n return self.sim_confs, self.sim_groups","def filter_element_and(mt_list, elem_list):\r\n return [mt for mt in mt_list if all(e in mt['pretty_formula'] for e in elem_list)]","def FilterItems(self):\r\n\t\treturn self._get_attribute('filterItems')","def itemFilter(*args, byBin: Union[AnyStr, List[AnyStr], bool]=\"\", byName: Union[AnyStr,\n bool]=\"\", byScript: Union[AnyStr, bool]=\"\", byType: Union[AnyStr, List[AnyStr],\n bool]=\"\", category: Union[AnyStr, List[AnyStr], bool]=\"\", classification:\n Union[AnyStr, bool]=\"\", clearByBin: bool=True, clearByType: bool=True,\n difference: Union[List[AnyStr, AnyStr], bool]=None, exists: bool=True,\n intersect: Union[List[AnyStr, AnyStr], bool]=None, listBuiltInFilters: bool=True,\n listOtherFilters: bool=True, listUserFilters: bool=True, negate: bool=True,\n parent: Union[AnyStr, bool]=\"\", pythonModule: Union[AnyStr, bool]=\"\",\n secondScript: Union[AnyStr, bool]=\"\", text: Union[AnyStr, bool]=\"\", union:\n Union[List[AnyStr, AnyStr], bool]=None, uniqueNodeNames: bool=True, q=True,\n query=True, e=True, edit=True, **kwargs)->Union[AnyStr, Any]:\n pass","def filter(self, included_suites=None, included_tests=None,\n included_tags=None, excluded_tags=None):\n self.visit(Filter(included_suites, included_tests,\n included_tags, excluded_tags))","def tag_filters(self) -> typing.Optional[typing.Mapping[str,typing.Any]]:\n return self._values.get('tag_filters')","def tag_filters(self) -> typing.Optional[typing.Mapping[str,typing.Any]]:\n return self._values.get('tag_filters')","def test_list_products_filtered_by_keyword(self):\n self._require_login(self.user1)\n response = self.client.get('/api/1.0/products/?name=1')\n self.assertEqual(response.status_code, status.HTTP_200_OK)\n self.assertEqual(response.data.__len__(), 1)\n self.assertEqual(response.data[0]['name'], 'Producto 1')\n self.assertEqual(response.data[0]['description'], 'Descripcion producto 1')","def filter(self, filter_dict):\n pass","def test_filter_recipes_by_tags(self):\n recipe1 = sample_recipe(user=self.user, title='Vegetable Curry')\n recipe2 = sample_recipe(user=self.user, title='blaaaa')\n tag1 = sample_tag(user=self.user, name='Vegan')\n tag2 = sample_tag(user=self.user, name='Vegetarian')\n recipe1.tags.add(tag1)\n recipe2.tags.add(tag2)\n recipe3 = sample_recipe(user=self.user, title='fish & chips')\n\n res = self.client.get(\n RECIPE_URL,\n {'tags': f'{tag1.id}, {tag2.id}'} # the way we designed our function in views.py to filter by tags is by passing a get parameter with comma separated string of the tags ids we wanna filter by\n )\n\n serializer1 = RecipeSerializer(recipe1)\n serializer2 = RecipeSerializer(recipe2)\n serializer3 = RecipeSerializer(recipe3)\n\n self.assertIn(serializer1.data, res.data)\n self.assertIn(serializer2.data, res.data)\n self.assertNotIn(serializer3.data, res.data) # since recipe3 has no tag","def filter_tag(tags=None):\n tagdict = defaultdict(list)\n Besarkecil = lambda f: ' '.join(re.findall('[A-Z][^A-Z]*', f))\n for obj in list(tags):\n if len(obj.split(':')) == 2:\n k, v = obj.split(':')\n # filtering key Besarkecil, lowercase\n k = str(Besarkecil(k)).lower()\n # print(k)\n if k in ['cari', 'jadwal', 'keberangkatan', 'maskapai', 'type', 'ibadah', 'jumlah hari', 'rute', 'tour']:\n res = re.findall(r\"(^[A-Z][^A-Z]+)|([^\\W\\d_]+|[\\d+]+)\", v)\n arres = []\n for resple in res:\n arres.append(filter(None, resple)[0])\n # print([e for e in resple])\n # print(' '.join(arres))\n tagdict[k].append(' '.join(arres))\n return tagdict","def get_tags_for_tags_and_malware_family_fields(tags: Optional[list], is_malware_family=False):\n if not tags:\n return None\n results = []\n for item in tags:\n results.append(item.get('tag_name'))\n results.append(item.get('public_tag_name'))\n for alias in item.get('aliases', []):\n results.append(alias)\n if not is_malware_family:\n for group in item.get('tagGroups', [{}]):\n results.append(group.get('tag_group_name'))\n # Returns a list without duplicates and empty elements\n return list(set(filter(None, results)))","def filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:\n return pulumi.get(self, \"filters\")","def filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:\n return pulumi.get(self, \"filters\")","def post_process(klass, results, unsafe_filters):\n logging.info(u'DatastoreModel.post_process() handled unsafe filters:')\n logging.info(u'{}'.format(unsafe_filters))\n all_matching_sets = []\n for k, v in unsafe_filters.items():\n matches = set([e for e in results if getattr(e, k) in v])\n all_matching_sets.append(matches)\n return set.intersection(*all_matching_sets)","def dgfilter(*args, attribute: AnyStr=\"\", list: bool=True, logicalAnd: List[AnyStr,\n AnyStr]=None, logicalNot: AnyStr=\"\", logicalOr: List[AnyStr, AnyStr]=None, name:\n AnyStr=\"\", node: AnyStr=\"\", nodeType: AnyStr=\"\", plug: AnyStr=\"\",\n **kwargs)->AnyStr:\n pass","def compute_filtered_features(self, features):\n return [\n feature\n for feature in features\n if \"\".join(feature.qualifiers.get(\"is_edit\", \"false\")) != \"true\"\n ]","def test_filter_mixed_function(self):\n for none_type in (False, True):\n for all_type in (False, True):\n for any_type in (False, True, None):\n result = none_type is False and all_type is True \\\n and (any_type is None or any_type is True)\n self._test_filter(none_type, all_type, any_type, result)","def test_filter_recipes_by_tags(self):\n recipe1 = sample_reteta(user=self.user, title='Thai vegetable curry')\n recipe2 = sample_reteta(user=self.user, title='Aubergine with tahini')\n tag1 = sample_tag(user=self.user, name='Vegan')\n tag2 = sample_tag(user=self.user, name='Vegetarian')\n recipe1.tags.add(tag1)\n recipe2.tags.add(tag2)\n # recipe3 = sample_reteta(user=self.user, title='Fasole si carnati')\n\n res = self.client.get(\n RETETA_URL,\n {'tags': f'{tag1.id},{tag2.id}'}\n )\n\n serializer1 = RetetaSerializer(recipe1)\n serializer2 = RetetaSerializer(recipe2)\n # serializer3 = RetetaSerializer(recipe3)\n self.assertIn(serializer1.data, res.data)\n self.assertIn(serializer2.data, res.data)\n # self.assertNotIn(serializer3.data, res.data)","def filter_tag(tags=None):\n tagdict = defaultdict(list)\n Besarkecil = lambda f: ' '.join(re.findall('[A-Z][^A-Z]*', f))\n for obj in list(tags):\n if len(obj.split(':')) == 2:\n k, v = obj.split(':')\n # filtering key Besarkecil, lowercase\n k = str(Besarkecil(k)).lower()\n # print(k)\n if k in ['cari', 'jadwal', 'keberangkatan', 'maskapai', 'type', 'ibadah', 'jumlah hari', 'rute',\n 'tour']:\n res = re.findall(r\"(^[A-Z][^A-Z]+)|([^\\W\\d_]+|[\\d+]+)\", v)\n arres = []\n for resple in res:\n arres.append(filter(None, resple)[0])\n # print([e for e in resple])\n # print(' '.join(arres))\n tagdict[k].append(' '.join(arres))\n return tagdict","def test_filter_services_by_tag(self):\n\n service1 = sample_services(user=self.user, title='Mechanical Work 1')\n service2 = sample_services(user=self.user, title='Mechanical Work 2')\n service3 = sample_services(user=self.user, title='Mechanical Work 3')\n\n tag1 = sample_tag(user=self.user, name='Mech1')\n tag2 = sample_tag(user=self.user, name='Mech2')\n tag3 = sample_tag(user=self.user, name='mech3')\n\n service1.tags.add(tag1)\n service2.tags.add(tag2)\n service3.tags.add(tag3)\n\n res = self.client.get(\n SERVICES_URL,\n {'tags': f'{tag1.id},{tag2.id},{tag3.id}'}\n )\n\n serializer1 = ServiceSerializer(service1)\n serializer2 = ServiceSerializer(service2)\n serializer3 = ServiceSerializer(service3)\n\n self.assertIn(serializer1.data, res.data)\n self.assertIn(serializer2.data, res.data)\n self.assertNotIn(serializer3.data, res.data)","def filter_queryset(self, queryset):\n \n queryset = super().filter_queryset(queryset)\n\n # List of StockItem objects to match against\n items = self.get_items()\n\n # We wish to filter by stock items\n if len(items) > 0:\n \"\"\"\n At this point, we are basically forced to be inefficient,\n as we need to compare the 'filters' string of each label,\n and see if it matches against each of the requested items.\n\n TODO: In the future, if this becomes excessively slow, it\n will need to be readdressed.\n \"\"\"\n\n # Keep track of which labels match every specified stockitem\n valid_label_ids = set()\n \n for label in queryset.all():\n\n matches = True\n\n # Filter string defined for the StockItemLabel object\n try:\n filters = InvenTree.helpers.validateFilterString(label.filters)\n except ValidationError:\n continue\n\n for item in items:\n\n item_query = StockItem.objects.filter(pk=item.pk)\n\n try:\n if not item_query.filter(**filters).exists():\n matches = False\n break\n except FieldError:\n matches = False\n break\n\n # Matched all items\n if matches:\n valid_label_ids.add(label.pk)\n else:\n continue\n\n # Reduce queryset to only valid matches\n queryset = queryset.filter(pk__in=[pk for pk in valid_label_ids])\n\n return queryset","def apply_feature_filter(self):\n self.features = set()\n for language in self.data.values():\n features_in_data = set(language.keys())\n features_to_keep = features_in_data & self.feature_filter\n self.features |= features_to_keep\n features_to_remove = features_in_data - features_to_keep\n for feat in features_to_remove:\n language.pop(feat)\n self.features = sorted(list(self.features))","def set_filter():\n try:\n #=======================================================================\n # isofilter=[arg.partition('=')[-1] for arg in argv if 'atomfilter=' in arg][0][1:-1].split(',')\n #=======================================================================\n isofilter = config.arg('atomfilter')[1:-1].split(',')\n isofilter = [f.split(':') for f in isofilter]\n for f in isofilter:\n if len(f) < 2:\n f.append('True')\n if len(f) < 3:\n f.append('True')\n if len(f) < 4:\n f.append('None')\n except:\n isofilter = [['element', 'H', 'True', 'None']]\n try:\n #=======================================================================\n # isopartnerfilter=[arg.partition('=')[-1] for arg in argv if 'partnerfilter=' in arg][0][1:-1].split(',')\n #=======================================================================\n isopartnerfilter = config.arg('partnerfilter')[1:-1].split(',')\n isopartnerfilter = [f.split(':') for f in isopartnerfilter]\n for f in isopartnerfilter:\n if len(f) < 2:\n f.append('True')\n if len(f) < 3:\n f.append('True')\n if len(f) < 4:\n f.append('None')\n except:\n isopartnerfilter = [['None', 'None', 'None', 'None']]\n return isofilter, isopartnerfilter\n isofilterlist = []\n isopartnerfilterlist = []\n for i in xrange(len(isofilter) / 2):\n isofilterlist.append(tuple(isofilter[2 * i:2 * i + 2]))\n for i in xrange(len(isopartnerfilter) / 2):\n isopartnerfilterlist.append(tuple(isopartnerfilter[2 * i:2 * i + 2]))\n\n return [isofilterlist, isopartnerfilterlist]","def filter_entries_by_tag(search, entry) -> bool:\n tags = entry.tags\n search_words = search.strip().translate(str.maketrans(\"&|\", \" \")).split()\n\n if \"&\" in search:\n search_type = \"AND\"\n else:\n search_type = \"OR\"\n\n for word in search_words:\n if word.lower() in tags:\n if search_type == \"OR\":\n return True\n\n elif search_type == \"AND\":\n return False\n\n if search_type == \"OR\":\n return False\n\n else:\n return True","def test_filter_multiple(self):\n self.es.register_filter(foo=False, bar='baz')\n self.assertFalse(self.es.streamfilter(self.data))\n self.es.filter = {'all': [], 'any': [], 'none': []}\n self.es.register_filter(foo=True, bar='baz')\n self.assertTrue(self.es.streamfilter(self.data))\n # check whether filter functions are different\n f, g = self.es.filter['all']\n c = {'foo': True}\n self.assertNotEqual(f(c), g(c))\n c = {'bar': 'baz'}\n self.assertNotEqual(f(c), g(c))","def filter(\n self,\n surfaces: Union[list, int] = None,\n volumes: Union[list, int] = None,\n fields: Union[list, str] = None,\n instances: DerivedQuantity = None,\n ):\n # ensure arguments are list\n if surfaces is not None and not isinstance(surfaces, list):\n surfaces = [surfaces]\n if volumes is not None and not isinstance(volumes, list):\n volumes = [volumes]\n if fields is not None and not isinstance(fields, list):\n fields = [fields]\n if instances is not None and not isinstance(instances, list):\n instances = [instances]\n\n quantities = []\n\n # iterate through derived_quantities\n for quantity in self.derived_quantities:\n # initialise flags to False\n match_surface, match_volume, match_field, match_instance = (\n False,\n False,\n False,\n False,\n )\n\n # check if matches surface\n if surfaces is not None:\n if hasattr(quantity, \"surface\") and quantity.surface in surfaces:\n match_surface = True\n else:\n match_surface = True\n\n # check if matches volume\n if volumes is not None:\n if hasattr(quantity, \"volume\") and quantity.volume in volumes:\n match_volume = True\n else:\n match_volume = True\n\n # check if matches field\n if fields is not None:\n if quantity.field in fields:\n match_field = True\n else:\n match_field = True\n\n # check if matches instance\n if instances is not None:\n if isinstance(quantity, tuple(instances)):\n match_instance = True\n else:\n match_instance = True\n\n # if all flags are True, append to the list\n if match_surface and match_volume and match_field and match_instance:\n quantities.append(quantity)\n\n if len(quantities) == 1:\n quantities = quantities[0]\n return quantities","def filter(self, *args, **kwargs):\n self._not_support_combined_queries(\"filter\")\n return self._filter_or_exclude(False, args, kwargs)","def add_products(self, products):\n return [self.add_product(product) for product in set(products)]","def filter_queryset(self, queryset, view=None):\n queryset = super().filter_queryset(queryset.only(\"id\", \"shared\"))\n form_pk = self.kwargs.get(self.lookup_field)\n\n if form_pk:\n try:\n int(form_pk)\n except ValueError as e:\n if form_pk == self.public_data_endpoint:\n queryset = self._get_public_forms_queryset()\n else:\n raise ParseError(_(f\"Invalid pk {form_pk}\")) from e\n else:\n queryset = self._filtered_or_shared_queryset(queryset, form_pk)\n else:\n tags = self.request.query_params.get(\"tags\")\n not_tagged = self.request.query_params.get(\"not_tagged\")\n\n if tags and isinstance(tags, six.string_types):\n tags = tags.split(\",\")\n queryset = queryset.filter(tags__name__in=tags)\n if not_tagged and isinstance(not_tagged, six.string_types):\n not_tagged = not_tagged.split(\",\")\n queryset = queryset.exclude(tags__name__in=not_tagged)\n\n return queryset","def test_filter_recipe_by_tag(self):\n tag1 = sample_tag(self.user, name='Indian')\n tag2 = sample_tag(self.user, name='Breakfast')\n recipe1 = sample_recipe(self.user, title='Curry')\n recipe2 = sample_recipe(self.user, title=\"bacon pie\")\n recipe1.tags.add(tag1)\n recipe2.tags.add(tag2)\n recipe3 = sample_recipe(self.user)\n\n res = self.client.get(\n RECIPE_URL,\n {'tags': f'{tag1.id},{tag2.id}'}\n )\n serializer1 = RecipeSerializer(recipe1)\n serializer2 = RecipeSerializer(recipe2)\n serializer3 = RecipeSerializer(recipe3)\n self.assertIn(serializer1.data, res.data)\n self.assertIn(serializer2.data, res.data)\n self.assertNotIn(serializer3.data, res.data)","def test_get_project_list_with_tag_filter(self):\n # Add test projects.\n tag = 'tag1'\n projects_with_tag = [\n add_project(title='1', description='1', tags=[tag]),\n add_project(title='2', description='2', tags=[tag]),\n ]\n project_without_tag = add_project(title='3', description='3', tags=[])\n\n result = get_project_list(tag=tag)\n result_projects = result['projects'].object_list\n\n # Make sure only projects with tag are retrieved.\n for project_with_tag in projects_with_tag:\n self.assertTrue(project_with_tag in result_projects)\n self.assertFalse(project_without_tag in result_projects)\n self.assertEqual(len(result_projects), len(projects_with_tag))\n self.assertTrue(result['filtered'])\n self.assertEqual(result['tag'], tag)","def filter_queryset(self, queryset):\n\n queryset = super().filter_queryset(queryset)\n\n items = self.get_items()\n\n if len(items) > 0:\n \"\"\"At this point, we are basically forced to be inefficient:\n\n We need to compare the 'filters' string of each report template,\n and see if it matches against each of the requested items.\n\n In practice, this is not too bad.\n \"\"\"\n\n valid_report_ids = set()\n\n for report in queryset.all():\n matches = True\n\n try:\n filters = InvenTree.helpers.validateFilterString(report.filters)\n except ValidationError:\n continue\n\n for item in items:\n item_query = self.ITEM_MODEL.objects.filter(pk=item.pk)\n\n try:\n if not item_query.filter(**filters).exists():\n matches = False\n break\n except FieldError:\n matches = False\n break\n\n # Matched all items\n if matches:\n valid_report_ids.add(report.pk)\n\n # Reduce queryset to only valid matches\n queryset = queryset.filter(pk__in=list(valid_report_ids))\n\n return queryset","def filter(request):\n product = Product.objects.filter(name__icontains=request.GET['q']).filter(brand__icontains=request.GET['brand']).filter(year__icontains=request.GET['year'])\n return render(request, \"search_results.html\", {\"products\": product})","def _getWhereClause(self, tagIDs):\n objectIDs = self._criteria.get('objectIDs')\n where = [TagValue.tagID == Tag.id]\n if objectIDs:\n where.append(TagValue.objectID.is_in(objectIDs))\n if tagIDs:\n where.append(Tag.id.is_in(tagIDs))\n createdBeforeTime = self._criteria.get('createdBeforeTime')\n if createdBeforeTime:\n where.append(TagValue.creationTime < createdBeforeTime)\n return where","def filter_or(filters):\n def filt(item):\n for f in filters:\n if f(item):\n return True\n return False\n return filt","def tags(catalog,lista,tag):\n final=lt.newList(datastructure='ARRAY_LIST')\n i=it.newIterator(lista)\n while it.hasNext(i):\n vid=it.next(i)\n if tag in vid['tags']:\n lt.addLast(final,vid)\n return final","def filter_queryset(self, queryset):\n for name, value in self.form.cleaned_data.items():\n queryset = self.filters[name].filter(queryset, value)\n # assert isinstance(queryset, models.QuerySet), \\\n # \"Expected '%s.%s' to return a QuerySet, but got a %s instead.\" \\\n # % (type(self).__name__, name, type(queryset).__name__)\n return queryset","def filter(self, **args ):\n query = TXLOG.select('*')\n for key, value in args.items():\n if '__' in key:\n key, op = key.split('__')\n else:\n op = 'eq'\n\n if not key in self.schema:\n raise BadArgument(\"Key %s not a valid argument\" % key )\n\n if not isinstance(value, basestring ):\n value = str(value)\n\n query = query.where({key:value}, self.operators[op])\n\n items = query.list()\n return items","def filter_queryset(self, queryset):\n params = self.request.query_params\n\n queryset = super().filter_queryset(queryset)\n\n # Filter by 'build'\n build = params.get('build', None)\n\n if build is not None:\n\n try:\n build = Build.objects.get(pk=build)\n\n queryset = queryset.filter(stock_item__build=build)\n\n except (ValueError, Build.DoesNotExist):\n pass\n\n # Filter by stock item\n item = params.get('stock_item', None)\n\n if item is not None:\n try:\n item = StockItem.objects.get(pk=item)\n\n items = [item]\n\n # Do we wish to also include test results for 'installed' items?\n include_installed = str2bool(params.get('include_installed', False))\n\n if include_installed:\n # Include items which are installed \"underneath\" this item\n # Note that this function is recursive!\n installed_items = item.get_installed_items(cascade=True)\n\n items += list(installed_items)\n\n queryset = queryset.filter(stock_item__in=items)\n\n except (ValueError, StockItem.DoesNotExist):\n pass\n\n return queryset","def _filter(self, probs: Tensor, ids: Tensor) -> Tuple[Tensor, List[int]]:\n raise NotImplementedError","def test_filtering_recipes_with_tags(self):\n recipe1 = create_sample_recipe(user=self.user, title=\"Chicken tikka\")\n recipe2 = create_sample_recipe(user=self.user, title=\"Italian pasta\")\n recipe3 = create_sample_recipe(user=self.user, title=\"Vegan dessert\")\n\n tag1 = create_sample_tag(user=self.user, name=\"Grill\")\n tag2 = create_sample_tag(user=self.user, name=\"Light food\")\n\n recipe1.tags.add(tag1)\n recipe2.tags.add(tag2)\n\n res = self.client.get( RECIPE_URL, {\"tags\": f\"{tag1.id}, {tag2.id}\"})\n\n serializer1 = RecipeSerializer(recipe1)\n serializer2 = RecipeSerializer(recipe2)\n serializer3 = RecipeSerializer(recipe3)\n\n self.assertEqual(res.status_code, status.HTTP_200_OK)\n self.assertIn(serializer1.data, res.data)\n self.assertIn(serializer2.data, res.data)\n self.assertNotIn(serializer3.data, res.data)","def get_visible_products(self):\r\n all_products = billing.loading.get_products(hidden=True)\r\n public_products = billing.loading.get_products()\r\n subscribed_product_types = ProductType.objects \\\r\n .filter(subscriptions__billing_account=self) \\\r\n .distinct()\r\n subscribed_products = set(pt.get_product_class() for pt in subscribed_product_types)\r\n visible_products = set(public_products).union(subscribed_products)\r\n return [p for p in all_products if p in visible_products]","def search(self, cr, user, args, offset=0, limit=None, order=None,\n context=None, count=False):\n prod_obj = self.pool['product.product']\n op_map = {'=': 'in', '!=': 'not in', '<>': 'not in',\n 'in': 'in', 'not in': 'not in'}\n #TODO - support between combination of <,<= and >, >=\n args2 = args[:]\n arg_offset = 0\n res = False\n for idx, arg in enumerate(args2):\n if arg[0] == 'product_id':\n product_ids = prod_obj.search(cr, user,\n [('id', arg[1], arg[2]),\n ('is_multi_variants', '=', True)],\n context=context)\n tmpl_ids = [prod.product_tmpl_id.id for prod in\n prod_obj.browse(cr, user, product_ids,\n context=context)]\n if tmpl_ids:\n prod_ids = prod_obj.search(cr, user,\n [('product_tmpl_id', 'in',\n tmpl_ids)])\n operator = op_map.get(arg[1], 'in')\n if idx > 0 and args2[idx - 1] == '!':\n operator = operator == 'in' and 'not in' or 'in'\n extra_args = ['|', '&',\n ('bom_template', '=', True),\n ('product_id', operator, prod_ids)]\n args = (args[:idx + arg_offset] + extra_args +\n args[idx + arg_offset:])\n arg_offset += len(extra_args)\n try:\n res = super(BomTemplate, self).search(cr, user, args, offset=offset,\n limit=limit, order=order,\n context=context, count=count)\n except:\n _logger.exception('Extended search failed for MRP BoM with domain '\n '%s. Performing standard search with %s' %\n (args, args2))\n if not res:\n res = super(BomTemplate, self).search(cr, user, args2, offset=offset,\n limit=limit, order=order,\n context=context, count=count)\n return res","def _filter(\n self,\n data: List[dict],\n filters: List[Tuple[str, SupportedFilterType]],\n state_dataclass: StateSchema,\n detail: bool,\n ) -> List[dict]:\n filters = _convert_filters_type(filters, state_dataclass)\n result = []\n for datum in data:\n match = True\n for filter_column, filter_predicate, filter_value in filters:\n filterable_columns = state_dataclass.filterable_columns()\n filter_column = filter_column.lower()\n if filter_column not in filterable_columns:\n raise ValueError(\n f\"The given filter column {filter_column} is not supported. \"\n f\"Supported filter columns: {filterable_columns}\"\n )\n\n if filter_column not in datum:\n match = False\n elif filter_predicate == \"=\":\n if isinstance(filter_value, str) and isinstance(\n datum[filter_column], str\n ):\n # Case insensitive match for string filter values.\n match = datum[filter_column].lower() == filter_value.lower()\n else:\n match = datum[filter_column] == filter_value\n elif filter_predicate == \"!=\":\n if isinstance(filter_value, str) and isinstance(\n datum[filter_column], str\n ):\n match = datum[filter_column].lower() != filter_value.lower()\n else:\n match = datum[filter_column] != filter_value\n else:\n raise ValueError(\n f\"Unsupported filter predicate {filter_predicate} is given. \"\n \"Available predicates: =, !=.\"\n )\n\n if not match:\n break\n\n if match:\n result.append(filter_fields(datum, state_dataclass, detail))\n return result","def test_list_products_filtered_by_selling_status(self):\n self._require_login(self.user1)\n response = self.client.get('/api/1.0/products/?selling=3')\n self.assertEqual(response.status_code, status.HTTP_200_OK)\n self.assertEqual(response.data.__len__(), 1)\n self.assertEqual(response.data[0]['name'], 'Producto 2')\n self.assertEqual(response.data[0]['description'], 'Descripcion producto 2')","def check_products(self, adi):\r\n results = []\r\n products = self.get_products(adi)\r\n for product in products[\"data\"][\"products\"]:\r\n print(\"Checking product '{}'... \".format(product[\"name\"]), end='')\r\n detail = self.get_product_detail(adi, product_id=product[\"productId\"], product_name=product[\"name\"])\r\n if self.rf.valid_product_detail(detail):\r\n print(\"Valid.\")\r\n result = \"Available\"\r\n else:\r\n print(\"INVALID.\")\r\n result = \"Not available\"\r\n results.append([product[\"name\"], result])\r\n return results"],"string":"[\n \"def filter_generic(products, listings, result=None):\\n print \\\"Apply Generic Filtering \\\"\\n if result == None:\\n result = {}\\n matched_listings = []\\n for alist in listings:\\n manufacturer, renamed_manufacturer = find_manufacturer(products, alist)\\n if manufacturer == False:\\n continue\\n for product in products[manufacturer]:\\n product = product[0] # get product information all in lower case\\n if not does_list_contains_model(\\\\\\n alist, product['model'], manufacturer):\\n continue\\n if product['product_name'] not in result:\\n result[product['product_name']] = []\\n for matched_list in listings[alist]:\\n matched_manufacturer =\\\\\\n matched_list['manufacturer'].lower()\\n if manufacturer not in matched_manufacturer and\\\\\\n matched_manufacturer not in renamed_manufacturer:\\n continue\\n result[product['product_name']].append(matched_list)\\n matched_listings.append(alist)\\n remove_matched_list(listings, matched_listings)\\n length_listings(listings)\\n return result\",\n \"def filter_queryset(self, queryset):\\n query_params = self.request.query_params\\n # validate query parameters\\n exception_response = ParamsCheck.validate(\\n query_params, APIParams.products_list_params\\n )\\n if exception_response:\\n return exception_response\\n\\n products_qs = self.get_queryset() # all\\n\\n category = query_params.get(\\\"category\\\", None)\\n exclude_ingredients = query_params.get(\\\"exclude_ingredient\\\", None)\\n exclude_ingredients = self._clean_string(exclude_ingredients)\\n include_ingredients = query_params.get(\\\"include_ingredient\\\", None)\\n include_ingredients = self._clean_string(include_ingredients)\\n\\n # filtering part\\n if category is not None:\\n products_qs = products_qs.filter(category=category)\\n for each in include_ingredients:\\n products_qs = products_qs.filter(ingredients__name=each)\\n for each in exclude_ingredients:\\n products_qs = products_qs.exclude(ingredients__name=each)\\n\\n return products_qs\",\n \"def filter_products(self, products, mrp_only=False, extension=None, **filters):\\n\\n filterMask = np.full(len(products), True, dtype=bool)\\n\\n # Applying the special filters (mrp_only and extension)\\n if mrp_only:\\n filterMask &= (products['productGroupDescription'] == \\\"Minimum Recommended Products\\\")\\n\\n if extension:\\n mask = np.full(len(products), False, dtype=bool)\\n for elt in extension:\\n mask |= [False if isinstance(x, np.ma.core.MaskedConstant) else x.endswith(elt)\\n for x in products[\\\"productFilename\\\"]]\\n filterMask &= mask\\n\\n # Applying the rest of the filters\\n for colname, vals in filters.items():\\n\\n if type(vals) == str:\\n vals = [vals]\\n\\n mask = np.full(len(products), False, dtype=bool)\\n for elt in vals:\\n mask |= (products[colname] == elt)\\n\\n filterMask &= mask\\n\\n return products[np.where(filterMask)]\",\n \"def filter(self, filters):\",\n \"def test_tag_filter(self):\\n request = RequestFactory().get('/?tags=foo&tags=bar')\\n qs = MockQuerySet()\\n filter = TestFilterSet(request.GET, qs)\\n self.assertEquals(filter.qs.filters['tags__slug__in'], ['foo', 'bar'])\",\n \"def filter_queryset(self, queryset):\\n tags = self.request.GET.getlist(\\\"tag\\\")\\n if tags:\\n for tag in tags:\\n queryset = queryset.filter(tag__tag=tag)\\n return super().filter_queryset(queryset)\",\n \"def filter_by_tag(self, tags):\\n\\n if isinstance(tags, string_types):\\n message = \\\"tags should be a list or None, got tags={}\\\".format(tags)\\n raise TypeError(message)\\n\\n data_collection = DataCollection()\\n for item in self.iteritems():\\n if tags == [] or tags == None or all([tag in item.tags for tag in tags]):\\n data_collection.add_data(item)\\n return data_collection\",\n \"def filter_queryset(self, request, queryset, view):\\n # filter by tags if available.\\n tags = request.query_params.get(\\\"tags\\\", None)\\n\\n if tags and isinstance(tags, six.string_types):\\n tags = tags.split(\\\",\\\")\\n return queryset.filter(tags__name__in=tags)\\n\\n return queryset\",\n \"def test_filter_remove_only_bad_products(self):\\n list_of_products = [self.good_product, self.bad_product]\\n self.assertEqual(\\n ProductValidator().filter(list_of_products),\\n [self.good_product])\",\n \"def apply(self, catalog):\\n out = []\\n for product in catalog:\\n valid = True\\n for key, filtr in self.filters.items():\\n valid = valid and filtr(product[key])\\n if valid:\\n out.append(product)\\n out = sorted(out, key=lambda x: x['onDemandUsdPrice'])\\n return self.limit_size(out)\",\n \"def check_intersection(product_list, product):\\n best_products = []\\n if len(product_list) > 0:\\n\\n for current_product in product_list:\\n intersection_product = set(current_product.categories.all()) & set(\\n product.categories.all())\\n\\n if len(intersection_product) >= 1:\\n best_products.append(current_product)\\n\\n return best_products\",\n \"def filter_category_products(products, searchterm='', for_sale=None, **kwargs):\\n\\n searchterm = searchterm.lower()\\n filtered_products = []\\n for product in products:\\n if searchterm not in product['name'].lower():\\n continue\\n if for_sale and not product['records']:\\n continue\\n filtered_products.append(product)\\n return filtered_products\",\n \"def test_set_tag_filters(self):\\n filters = QueryFilterCollection()\\n\\n url = \\\"?\\\"\\n query_params = self.mocked_query_params(url, OCPTagView)\\n handler = OCPTagQueryHandler(query_params)\\n tag_keys = handler.get_tag_keys(filters=False)\\n\\n filter_key = tag_keys[0]\\n\\n filter_value = \\\"filter\\\"\\n group_by_key = tag_keys[1]\\n\\n group_by_value = \\\"group_By\\\"\\n\\n url = f\\\"?filter[tag:{filter_key}]={filter_value}&group_by[tag:{group_by_key}]={group_by_value}\\\"\\n query_params = self.mocked_query_params(url, OCPCpuView)\\n handler = OCPReportQueryHandler(query_params)\\n filters = handler._set_tag_filters(filters)\\n\\n expected = f\\\"\\\"\\\"<class 'api.query_filter.QueryFilterCollection'>: (AND: ('pod_labels__{filter_key}__icontains', '{filter_value}')), (AND: ('pod_labels__{group_by_key}__icontains', '{group_by_value}')), \\\"\\\"\\\" # noqa: E501\\n\\n self.assertEqual(repr(filters), expected)\",\n \"def clean(self, products):\\n clean_products = []\\n clean_categories = set()\\n for product in products:\\n if self.is_valid(product):\\n product[\\\"categories\\\"] = [\\n cat.strip().lower().capitalize()\\n for cat in product[\\\"categories\\\"].split(\\\",\\\")\\n ]\\n clean_products.append(product)\\n clean_categories |= set(product[\\\"categories\\\"])\\n return clean_categories, clean_products\",\n \"def test_tag_filter(self):\\n request = RequestFactory().get('/?search=foobar')\\n qs = MockQuerySet()\\n filter = TestFilterSet(request.GET, qs)\\n self.assertEquals(filter.qs.filters['name__icontains'], 'foobar')\\n self.assertEquals(filter.qs.filters['status__startswith'], 'foobar')\",\n \"def filter(\\n self, items: Iterable[Product], spec: Specification\\n ) -> Generator[Product, None, None]:\\n return (item for item in items if spec.is_satisfied(item))\",\n \"def _fuzzy_products(self, package: ImagePackage) -> typing.List[str]:\\n\\n products = {package.name}\\n # TODO: add the generic product generation code (including nomatch exclusions here)\\n return list(products)\",\n \"def call(self):\\r\\n clean_products = []\\r\\n\\r\\n for category in CATEGORIES:\\r\\n print(f\\\"Chargement des produits de type {category}\\\")\\r\\n api_url = SEARCH_API_URL + \\\\\\r\\n (f\\\"?search_terms={category}\\\"\\r\\n \\\"&search_tag=category&sort_by=unique_scans_n\\\"\\r\\n \\\"&page_size=1000&json=1\\\")\\r\\n json_response = requests.get(api_url).json()\\r\\n products = json_response[\\\"products\\\"]\\r\\n\\r\\n for product in products:\\r\\n clean_product = {\\r\\n k: v for k, v in product.items()\\r\\n if k in FIELD_NEEDED and v != ''}\\r\\n clean_products.append(clean_product)\\r\\n\\r\\n return clean_products\",\n \"def filter(self, filters:list)->list:\\n for item in self.list:\\n use_item = True\\n for filter in filters:\\n filter_key, filter_value, filter_type = filter\\n if filter_type == \\\"<\\\" and item[filter_key] >= filter_value:\\n use_item = False\\n break\\n elif filter_type == \\\">\\\" and item[filter_key] <= filter_value:\\n use_item = False\\n break\\n elif filter_type == \\\"<=\\\" and item[filter_key] > filter_value:\\n use_item = False\\n break\\n elif filter_type == \\\">=\\\" and item[filter_key] < filter_value:\\n use_item = False\\n break\\n elif filter_type == \\\"=\\\" and not item[filter_key] == filter_value:\\n use_item = False\\n break\\n if use_item:\\n yield item\",\n \"def filter(self, artifacts: ArtifactsList) -> ArtifactsList:\\n print(self.my_param)\\n return artifacts\",\n \"def filter_products(self, products: list):\\n # Get all products that has no parent\\n independent = [product for product in products if product[\\\"parent_id\\\"] is None]\\n # Get all products that has parent\\n dependent = [\\n product for product in products if product[\\\"parent_id\\\"] is not None\\n ]\\n # Sort dependent products by parent_id, so that a child will be always\\n # inserted after the parent\\n dependent = sorted(dependent, key=lambda item: item[\\\"parent_id\\\"])\\n # Saves the total of objects\\n self.total = len(independent) + len(dependent)\\n return independent, dependent\",\n \"def filter_by_color(self, products, color):\\n for p in products:\\n # Selects products of the specified color\\n if p.color == color:\\n yield p\",\n \"def get_all_products(request, *args, query_str=''):\\n\\n active_filters = []\\n products = Product.objects.all()\\n product_fields = (\\n (\\\"size\\\", \\\"options\\\"),\\n (\\\"price\\\", \\\"range\\\"),\\n (\\\"colours\\\", \\\"options\\\"),\\n (\\\"year\\\", \\\"range\\\"),\\n (\\\"collection\\\", \\\"equals\\\")\\n )\\n field_ranges = []\\n for field, filter_type in product_fields:\\n if filter_type == \\\"range\\\":\\n (min_val) = products.filter().values_list(field).order_by(field)[0]\\n (max_val) = products.filter().values_list(field).order_by\\\\\\n (f'-{field}')[0]\\n obj = {}\\n obj['min_val'] = int(min_val[0])\\n obj['max_val'] = int(max_val[0])\\n obj['field'] = field\\n field_ranges.append(obj)\\n\\n # if filter_type == \\\"options\\\":\\n\\n\\n\\n if request.GET:\\n for key in request.GET:\\n if \\\"__range\\\" in key:\\n val = request.GET.getlist(key)\\n val[:] = [int(x) for x in val]\\n active_filters.append(\\n [key.split(\\\"__\\\")[0], key.split(\\\"__\\\")[1], val]\\n )\\n obj = {}\\n obj[key] = val\\n query = Q(**obj)\\n products = products.filter(query)\\n\\n\\n if 'collection' in request.GET:\\n collection_pk = request.GET['collection']\\n if not collection_pk or not collection_pk.isnumeric():\\n if query:\\n return redirect(\\n reverse('products'),\\n kwargs={'query_str': query}\\n )\\n else:\\n return redirect(reverse('products'))\\n\\n products = products.filter(collection=collection_pk)\\n\\n if 'q' in request.GET:\\n query = request.GET['q']\\n query_str = query\\n if not query:\\n return redirect(reverse('products'))\\n\\n queries = Q(display_name__icontains=query) | \\\\\\n Q(name__icontains=query)\\n products = products.filter(queries)\\n\\n\\n context = {\\n 'products': products,\\n 'MEDIA_URL': settings.MEDIA_URL,\\n 'search_term': query_str,\\n 'filters': product_fields,\\n 'field_ranges': field_ranges,\\n 'active_filters': active_filters\\n }\\n\\n return render(request, 'products/products.html', context)\",\n \"def _apply_filters(self, metadata):\\n if \\\"keywords\\\" in self.filters:\\n if not metadata.keywords:\\n return False\\n if not all(keyword in metadata.keywords for keyword in self.filters[\\\"keywords\\\"]):\\n return False\\n if \\\"features\\\" in self.filters:\\n if not metadata.features:\\n return False\\n if not all(feature in metadata.features for feature in self.filters[\\\"features\\\"]):\\n return False\\n if \\\"authors\\\" in self.filters:\\n if not metadata.authors:\\n return False\\n if not all(author in metadata.authors for author in self.filters[\\\"authors\\\"]):\\n return False\\n if \\\"version\\\" in self.filters:\\n if not metadata.pylith_version:\\n return False\\n for verMeta in metadata.pylith_version:\\n if not eval(\\\"{ver} {verMeta}\\\".format(ver=self.filters[\\\"version\\\"], verMeta=verMeta)):\\n return False\\n return True\",\n \"def filter(self, *args, **kwargs):\",\n \"def filterPick(list, filter, classification):\\n y = []\\n for job in list:\\n x = [(job, classification) for l in job for m in (filter(l),) if m]\\n y.append(x)\\n return y\",\n \"def type_filter(self, items, types=None):\",\n \"def extract(self, filter_by='relevance', all_pages=False, limit=None):\\r\\n\\r\\n page = 1\\r\\n total_of_pages = 1\\r\\n products_list = []\\r\\n\\r\\n while page <= total_of_pages:\\r\\n\\r\\n products_code = None\\r\\n while products_code is None:\\r\\n soup = self.__olx_requests(filter_by, page)\\r\\n products_code = soup.find('div', {'class': \\\"sc-1fcmfeb-0 WQhDk\\\"})\\r\\n\\r\\n if page == 1 and all_pages is True and limit is None:\\r\\n max_pages = self.__number_of_pages(soup)\\r\\n if max_pages is not None:\\r\\n total_of_pages = max_pages\\r\\n\\r\\n elif page == 1 and all_pages is False and isinstance(limit, int):\\r\\n max_pages = self.__number_of_pages(soup)\\r\\n if max_pages is not None and limit <= max_pages:\\r\\n total_of_pages = limit\\r\\n else:\\r\\n total_of_pages = 1\\r\\n\\r\\n # Individual product - TAG\\r\\n for tags_products in [\\\"sc-1fcmfeb-2 ggOGTJ\\\", \\\"sc-1fcmfeb-2 hFOgZc\\\"]:\\r\\n for each_product in products_code.findAll('li', {'class': tags_products}):\\r\\n\\r\\n # Each product dictionary\\r\\n product_dict = {}\\r\\n\\r\\n # Name\\r\\n PRODUCT_NAME_TAG = 'fnmrjs-8 kRlFBv'\\r\\n if each_product.find('div', {'class': PRODUCT_NAME_TAG}) is not None:\\r\\n product_name = each_product.find('div', {'class': PRODUCT_NAME_TAG}).text\\r\\n if 'Anunciante online' in product_name:\\r\\n product_name = product_name.replace('Anunciante online', '')\\r\\n product_dict['Name'] = product_name\\r\\n else:\\r\\n continue\\r\\n\\r\\n # ID\\r\\n product_id = each_product.find('a', {'data-lurker-detail': 'list_id'})['data-lurker_list_id']\\r\\n product_dict['ID'] = product_id\\r\\n\\r\\n # Image\\r\\n PRODUCT_IMAGE_TAG = 'fnmrjs-5 jksoiN'\\r\\n product_img = each_product.find('div', {'class': PRODUCT_IMAGE_TAG}).find('img')['src']\\r\\n product_dict['Image'] = product_img\\r\\n\\r\\n # Price\\r\\n PRODUCT_PRICE_TAG = 'fnmrjs-15 clbSMi'\\r\\n if each_product.find('div', {'class': PRODUCT_PRICE_TAG}).text:\\r\\n product_price = each_product.find('div', {'class': PRODUCT_PRICE_TAG}).text\\r\\n product_dict['Price'] = re.findall('R\\\\$ (\\\\d*,?\\\\.?\\\\d*)|$', product_price)[0].replace('.', '')\\r\\n else:\\r\\n product_dict['Price'] = '-'\\r\\n\\r\\n # Date\\r\\n PRODUCT_DATE_TAG = 'fnmrjs-18 gMKELN'\\r\\n product_date = each_product.find('div', {'class': PRODUCT_DATE_TAG}).text\\r\\n if 'Hoje' in product_date:\\r\\n product_date = product_date.replace('Hoje', datetime.date.today().strftime(\\\"%d/%m \\\"))\\r\\n product_dict['Date'] = product_date\\r\\n\\r\\n elif 'Ontem' in product_date:\\r\\n product_date = product_date.replace('Ontem', (datetime.date.today() - datetime.timedelta(days=1)).strftime(\\\"%d/%m \\\"))\\r\\n product_dict['Date'] = product_date\\r\\n\\r\\n else:\\r\\n product_date = product_date.replace(re.findall(' ([a-z]*)\\\\d*', product_date)[0], months[re.findall(' ([a-z]*)\\\\d*', product_date)[0]]).replace(' ', r'/', 1)\\r\\n product_dict['Date'] = product_date\\r\\n\\r\\n # Location\\r\\n PRODUCT_LOCATION_PARENT_TAG = 'fnmrjs-21 bktOWr'\\r\\n PRODUCT_LOCATION_CHILD_TAG = 'fnmrjs-13 hdwqVC'\\r\\n product_location = each_product.find('div', {'class': PRODUCT_LOCATION_PARENT_TAG}).find('p', {'class': PRODUCT_LOCATION_CHILD_TAG}).text\\r\\n product_dict['City'] = re.findall('(.*\\\\w*),|$', product_location)[0]\\r\\n product_dict['Neighborhood'] = re.findall(r',(.*\\\\w*) - |$', product_location)[0].strip()\\r\\n product_dict['State'] = states_ddd[re.findall(r'DDD (\\\\d*)|$', product_location)[0]]\\r\\n\\r\\n # Link\\r\\n product_link = each_product.find('a', {'data-lurker-detail': 'list_id'})['href']\\r\\n product_dict['Link'] = product_link\\r\\n\\r\\n # List of Products\\r\\n products_list.append(product_dict)\\r\\n\\r\\n # Next page\\r\\n page += 1\\r\\n\\r\\n return products_list\",\n \"def order_filter(self,elements):\",\n \"def get_queryset(self):\\n tags = self.request.query_params.get('tags')\\n ingredient = self.request.query_params.get('ingredient')\\n queryset = self.queryset\\n if tags:\\n tags_id = self._params_to_int(tags)\\n queryset = queryset.filter(tags__id__in =tags_id)\\n if ingredient:\\n ingredient_id = self._params_to_int(ingredient)\\n queryset = queryset.filter(ingredient__id__in = ingredient_id)\\n\\n return queryset.filter(user = self.request.user)\",\n \"def get_queryset(self):\\n tags = self.request.query_params.get('tags')\\n categories = self.request.query_params.get('categories')\\n user = self.request.query_params.get('user')\\n queryset = self.queryset\\n\\n if tags:\\n tags_title = self._params(tags)\\n queryset = queryset.filter(tags__title__in=tags_title)\\n\\n if categories:\\n categories_title = self._params(categories)\\n queryset = queryset.filter(categories__title__in=categories_title)\\n\\n if user:\\n user_id = self._params_to_ints(user)\\n queryset = queryset.filter(user__id__in=user_id)\\n return queryset\",\n \"def testFiltrerTag(self):\\n\\t\\ttags = (\\n\\t\\t\\t \\t('in,', 'in'),\\n\\t\\t\\t \\t('casse-tete', 'casse-tete'),\\n\\t\\t\\t \\t)\\n\\t\\t\\n\\t\\tf = Flickr()\\n\\t\\tfor tag, tag_filter in tags:\\n\\t\\t\\tresult = f.filtrer_tag(tag)\\n\\t\\t\\tself.assertEqual(result, tag_filter)\",\n \"def FilterToKnownTags(self, tags: Iterable[str]) -> Set[str]:\\n return self._GetKnownTags() & set(tags)\",\n \"def filter_for_tags(cls, image: np.ndarray, tags: Set[Tag]) -> np.ndarray:\\n masks = []\\n for tag in tags:\\n color = tag.color;\\n red_mask = image[:, :, 0] == color[0]\\n green_mask = image[:, :, 1] == color[1]\\n blue_mask = image[:, :, 2] == color[2]\\n masks.append(np.logical_and(red_mask, green_mask, blue_mask))\\n\\n final_mask = np.logical_not(np.logical_or.reduce(masks))\\n image[final_mask] = 255\\n return image\",\n \"def filter_by_size(self, products, size):\\n for p in products:\\n # Selects products of the specified size\\n if p.size == size:\\n yield p\",\n \"def queryset(self, request, queryset):\\n for tag in get_resource_tags():\\n if self.value() == tag[0]:\\n return queryset.filter(tags__slug__iexact=tag[0])\",\n \"def filtered(self, func):\\n return PSetList(list(filter(func, self.sets)))\",\n \"def sort_products(param: str, querySet: QuerySet):\\n products_list = list(querySet)\\n products_list.sort(\\n key=lambda product: (-product.calculate_score(param), product.price)\\n )\\n return products_list\",\n \"def filter_all(_):\\n return True\",\n \"def is_matching_product_with_tags(product, lat, lng, radius, tags):\\n return vincenty(\\n (lat, lng),\\n (product.shop.lat, product.shop.lng)\\n ).meters <= radius and any(tag in product.shop.tags for tag in tags)\",\n \"def test_filter_recipe_by_tags(self):\\n recipe1 = sample_recipe(user=self.user,title='chicken curry')\\n recipe2 = sample_recipe(user=self.user,title='mutton curry')\\n recipe3 = sample_recipe(user=self.user,title='milk dish')\\n tag1 = sample_tag(user=self.user,name='chicken')\\n tag2 = sample_tag(user=self.user,name='mutton')\\n recipe1.tag.add(tag1)\\n recipe2.tag.add(tag2)\\n\\n res = self.client.get(RECIPE_URL,{'tag':f'{tag1.id},{tag2.id}'})\\n s1 = RecipeSerializer(recipe1)\\n s2 = RecipeSerializer(recipe2)\\n s3 = RecipeSerializer(recipe3)\\n self.assertIn(s1.data,res.data)\\n self.assertIn(s2.data,res.data)\\n self.assertNotIn(s3.data,res.data)\",\n \"def get_all_products(self):\\n\\t\\tpass\",\n \"def test_filter_reecipe_by_tag(self):\\n recipe1 = sample_recipe(user=self.user, title=\\\"fish curry\\\")\\n recipe2 = sample_recipe(user=self.user, title='mutton curry')\\n\\n tag1 = sample_tag(user=self.user, name='fish')\\n tag2 = sample_tag(user=self.user, name='mutton')\\n\\n recipe1.tags.add(tag1)\\n recipe2.tags.add(tag2)\\n recipe3 = sample_recipe(user = self.user, title = 'Chicken curry')\\n\\n res = self.client.get(RECIPE_URL,\\n {'tags' : f'{tag1.id},{tag2.id}'})\\n seralizer1 = Recipeserializer(recipe1)\\n seralizer2 = Recipeserializer(recipe2)\\n seralizer3 = Recipeserializer(recipe3)\\n self.assertIn(seralizer1.data, res.data)\\n self.assertIn(seralizer2.data, res.data)\\n self.assertNotIn(seralizer3.data, res.data)\",\n \"def filter_stacks(stacks) -> dict:\\n if not app_config.TAGS:\\n return stacks\\n keep = list()\\n for stack in stacks[\\\"Stacks\\\"]:\\n for tag in stack[\\\"Tags\\\"]:\\n for filter_tag in app_config.TAGS:\\n if filter_tag in tag.values():\\n keep.append(stack)\\n stacks[\\\"Stacks\\\"] = keep\\n return stacks\",\n \"def test_no_op(self):\\n request = RequestFactory().get('/?tags=')\\n qs = MockQuerySet()\\n filter = TestFilterSet(request.GET, qs)\\n self.assertNotIn('tags__slug__in', filter.qs.filters)\",\n \"def search_by_product(self, **query):\\n for product, datasets in self._do_search_by_product(query):\\n yield product, self._make_many(datasets, product)\",\n \"def filter(self, *args):\\n return _libsbml.ElementFilter_filter(self, *args)\",\n \"def by_tags(self, tags):\\n if tags:\\n self._filters.append(\\n models.Note.tags.any(models.Tag.id.in_(tags)),\\n )\\n return self\",\n \"def get_filters(self):\",\n \"def doFiltering(self, searchfunc, filters=None):\\n F=[]\\n for f in self.filters:\\n F.append(f.getFilter())\\n #print F\\n sets = []\\n for f in F:\\n col, val, op, boolean = f\\n names = searchfunc(col, val, op)\\n sets.append((set(names), boolean))\\n names = sets[0][0]\\n for s in sets[1:]:\\n b=s[1]\\n if b == 'AND':\\n names = names & s[0]\\n elif b == 'OR':\\n names = names | s[0]\\n elif b == 'NOT':\\n names = names - s[0]\\n names = list(names)\\n self.updateResults(len(names))\\n return names\",\n \"def test_list_products_filtered_by_category(self):\\n self._require_login(self.user1)\\n response = self.client.get('/api/1.0/products/?category=1')\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\\n self.assertEqual(response.data.__len__(), 1)\\n self.assertEqual(response.data[0]['name'], 'Producto 2')\\n self.assertEqual(response.data[0]['description'], 'Descripcion producto 2')\",\n \"def filter_scalings(scaling_list, scaling_type):\\n return filter(\\n lambda _f: True if scaling_type in _f[\\\"runname\\\"] else False,\\n scaling_list)\",\n \"def filter_and(filters):\\n def filt(item):\\n for f in filters:\\n if not f(item):\\n return False\\n return True\\n return filt\",\n \"def filter_by_param(self, pars):\\n\\n assert(type(pars) == dict)\\n for par, vals in pars.items():\\n vals = [type(self.sim_confs[0][par])(v) for v in vals]\\n self.sim_confs = [conf for conf in self.sim_confs if conf[par] in vals]\\n groups = []\\n for group in self.sim_groups:\\n filt_group = [conf for conf in group if conf[par] in vals]\\n groups.append(filt_group)\\n self.sim_groups = groups\\n assert(len(self.sim_confs) >= 1)\\n return self.sim_confs, self.sim_groups\",\n \"def filter_element_and(mt_list, elem_list):\\r\\n return [mt for mt in mt_list if all(e in mt['pretty_formula'] for e in elem_list)]\",\n \"def FilterItems(self):\\r\\n\\t\\treturn self._get_attribute('filterItems')\",\n \"def itemFilter(*args, byBin: Union[AnyStr, List[AnyStr], bool]=\\\"\\\", byName: Union[AnyStr,\\n bool]=\\\"\\\", byScript: Union[AnyStr, bool]=\\\"\\\", byType: Union[AnyStr, List[AnyStr],\\n bool]=\\\"\\\", category: Union[AnyStr, List[AnyStr], bool]=\\\"\\\", classification:\\n Union[AnyStr, bool]=\\\"\\\", clearByBin: bool=True, clearByType: bool=True,\\n difference: Union[List[AnyStr, AnyStr], bool]=None, exists: bool=True,\\n intersect: Union[List[AnyStr, AnyStr], bool]=None, listBuiltInFilters: bool=True,\\n listOtherFilters: bool=True, listUserFilters: bool=True, negate: bool=True,\\n parent: Union[AnyStr, bool]=\\\"\\\", pythonModule: Union[AnyStr, bool]=\\\"\\\",\\n secondScript: Union[AnyStr, bool]=\\\"\\\", text: Union[AnyStr, bool]=\\\"\\\", union:\\n Union[List[AnyStr, AnyStr], bool]=None, uniqueNodeNames: bool=True, q=True,\\n query=True, e=True, edit=True, **kwargs)->Union[AnyStr, Any]:\\n pass\",\n \"def filter(self, included_suites=None, included_tests=None,\\n included_tags=None, excluded_tags=None):\\n self.visit(Filter(included_suites, included_tests,\\n included_tags, excluded_tags))\",\n \"def tag_filters(self) -> typing.Optional[typing.Mapping[str,typing.Any]]:\\n return self._values.get('tag_filters')\",\n \"def tag_filters(self) -> typing.Optional[typing.Mapping[str,typing.Any]]:\\n return self._values.get('tag_filters')\",\n \"def test_list_products_filtered_by_keyword(self):\\n self._require_login(self.user1)\\n response = self.client.get('/api/1.0/products/?name=1')\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\\n self.assertEqual(response.data.__len__(), 1)\\n self.assertEqual(response.data[0]['name'], 'Producto 1')\\n self.assertEqual(response.data[0]['description'], 'Descripcion producto 1')\",\n \"def filter(self, filter_dict):\\n pass\",\n \"def test_filter_recipes_by_tags(self):\\n recipe1 = sample_recipe(user=self.user, title='Vegetable Curry')\\n recipe2 = sample_recipe(user=self.user, title='blaaaa')\\n tag1 = sample_tag(user=self.user, name='Vegan')\\n tag2 = sample_tag(user=self.user, name='Vegetarian')\\n recipe1.tags.add(tag1)\\n recipe2.tags.add(tag2)\\n recipe3 = sample_recipe(user=self.user, title='fish & chips')\\n\\n res = self.client.get(\\n RECIPE_URL,\\n {'tags': f'{tag1.id}, {tag2.id}'} # the way we designed our function in views.py to filter by tags is by passing a get parameter with comma separated string of the tags ids we wanna filter by\\n )\\n\\n serializer1 = RecipeSerializer(recipe1)\\n serializer2 = RecipeSerializer(recipe2)\\n serializer3 = RecipeSerializer(recipe3)\\n\\n self.assertIn(serializer1.data, res.data)\\n self.assertIn(serializer2.data, res.data)\\n self.assertNotIn(serializer3.data, res.data) # since recipe3 has no tag\",\n \"def filter_tag(tags=None):\\n tagdict = defaultdict(list)\\n Besarkecil = lambda f: ' '.join(re.findall('[A-Z][^A-Z]*', f))\\n for obj in list(tags):\\n if len(obj.split(':')) == 2:\\n k, v = obj.split(':')\\n # filtering key Besarkecil, lowercase\\n k = str(Besarkecil(k)).lower()\\n # print(k)\\n if k in ['cari', 'jadwal', 'keberangkatan', 'maskapai', 'type', 'ibadah', 'jumlah hari', 'rute', 'tour']:\\n res = re.findall(r\\\"(^[A-Z][^A-Z]+)|([^\\\\W\\\\d_]+|[\\\\d+]+)\\\", v)\\n arres = []\\n for resple in res:\\n arres.append(filter(None, resple)[0])\\n # print([e for e in resple])\\n # print(' '.join(arres))\\n tagdict[k].append(' '.join(arres))\\n return tagdict\",\n \"def get_tags_for_tags_and_malware_family_fields(tags: Optional[list], is_malware_family=False):\\n if not tags:\\n return None\\n results = []\\n for item in tags:\\n results.append(item.get('tag_name'))\\n results.append(item.get('public_tag_name'))\\n for alias in item.get('aliases', []):\\n results.append(alias)\\n if not is_malware_family:\\n for group in item.get('tagGroups', [{}]):\\n results.append(group.get('tag_group_name'))\\n # Returns a list without duplicates and empty elements\\n return list(set(filter(None, results)))\",\n \"def filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:\\n return pulumi.get(self, \\\"filters\\\")\",\n \"def filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:\\n return pulumi.get(self, \\\"filters\\\")\",\n \"def post_process(klass, results, unsafe_filters):\\n logging.info(u'DatastoreModel.post_process() handled unsafe filters:')\\n logging.info(u'{}'.format(unsafe_filters))\\n all_matching_sets = []\\n for k, v in unsafe_filters.items():\\n matches = set([e for e in results if getattr(e, k) in v])\\n all_matching_sets.append(matches)\\n return set.intersection(*all_matching_sets)\",\n \"def dgfilter(*args, attribute: AnyStr=\\\"\\\", list: bool=True, logicalAnd: List[AnyStr,\\n AnyStr]=None, logicalNot: AnyStr=\\\"\\\", logicalOr: List[AnyStr, AnyStr]=None, name:\\n AnyStr=\\\"\\\", node: AnyStr=\\\"\\\", nodeType: AnyStr=\\\"\\\", plug: AnyStr=\\\"\\\",\\n **kwargs)->AnyStr:\\n pass\",\n \"def compute_filtered_features(self, features):\\n return [\\n feature\\n for feature in features\\n if \\\"\\\".join(feature.qualifiers.get(\\\"is_edit\\\", \\\"false\\\")) != \\\"true\\\"\\n ]\",\n \"def test_filter_mixed_function(self):\\n for none_type in (False, True):\\n for all_type in (False, True):\\n for any_type in (False, True, None):\\n result = none_type is False and all_type is True \\\\\\n and (any_type is None or any_type is True)\\n self._test_filter(none_type, all_type, any_type, result)\",\n \"def test_filter_recipes_by_tags(self):\\n recipe1 = sample_reteta(user=self.user, title='Thai vegetable curry')\\n recipe2 = sample_reteta(user=self.user, title='Aubergine with tahini')\\n tag1 = sample_tag(user=self.user, name='Vegan')\\n tag2 = sample_tag(user=self.user, name='Vegetarian')\\n recipe1.tags.add(tag1)\\n recipe2.tags.add(tag2)\\n # recipe3 = sample_reteta(user=self.user, title='Fasole si carnati')\\n\\n res = self.client.get(\\n RETETA_URL,\\n {'tags': f'{tag1.id},{tag2.id}'}\\n )\\n\\n serializer1 = RetetaSerializer(recipe1)\\n serializer2 = RetetaSerializer(recipe2)\\n # serializer3 = RetetaSerializer(recipe3)\\n self.assertIn(serializer1.data, res.data)\\n self.assertIn(serializer2.data, res.data)\\n # self.assertNotIn(serializer3.data, res.data)\",\n \"def filter_tag(tags=None):\\n tagdict = defaultdict(list)\\n Besarkecil = lambda f: ' '.join(re.findall('[A-Z][^A-Z]*', f))\\n for obj in list(tags):\\n if len(obj.split(':')) == 2:\\n k, v = obj.split(':')\\n # filtering key Besarkecil, lowercase\\n k = str(Besarkecil(k)).lower()\\n # print(k)\\n if k in ['cari', 'jadwal', 'keberangkatan', 'maskapai', 'type', 'ibadah', 'jumlah hari', 'rute',\\n 'tour']:\\n res = re.findall(r\\\"(^[A-Z][^A-Z]+)|([^\\\\W\\\\d_]+|[\\\\d+]+)\\\", v)\\n arres = []\\n for resple in res:\\n arres.append(filter(None, resple)[0])\\n # print([e for e in resple])\\n # print(' '.join(arres))\\n tagdict[k].append(' '.join(arres))\\n return tagdict\",\n \"def test_filter_services_by_tag(self):\\n\\n service1 = sample_services(user=self.user, title='Mechanical Work 1')\\n service2 = sample_services(user=self.user, title='Mechanical Work 2')\\n service3 = sample_services(user=self.user, title='Mechanical Work 3')\\n\\n tag1 = sample_tag(user=self.user, name='Mech1')\\n tag2 = sample_tag(user=self.user, name='Mech2')\\n tag3 = sample_tag(user=self.user, name='mech3')\\n\\n service1.tags.add(tag1)\\n service2.tags.add(tag2)\\n service3.tags.add(tag3)\\n\\n res = self.client.get(\\n SERVICES_URL,\\n {'tags': f'{tag1.id},{tag2.id},{tag3.id}'}\\n )\\n\\n serializer1 = ServiceSerializer(service1)\\n serializer2 = ServiceSerializer(service2)\\n serializer3 = ServiceSerializer(service3)\\n\\n self.assertIn(serializer1.data, res.data)\\n self.assertIn(serializer2.data, res.data)\\n self.assertNotIn(serializer3.data, res.data)\",\n \"def filter_queryset(self, queryset):\\n \\n queryset = super().filter_queryset(queryset)\\n\\n # List of StockItem objects to match against\\n items = self.get_items()\\n\\n # We wish to filter by stock items\\n if len(items) > 0:\\n \\\"\\\"\\\"\\n At this point, we are basically forced to be inefficient,\\n as we need to compare the 'filters' string of each label,\\n and see if it matches against each of the requested items.\\n\\n TODO: In the future, if this becomes excessively slow, it\\n will need to be readdressed.\\n \\\"\\\"\\\"\\n\\n # Keep track of which labels match every specified stockitem\\n valid_label_ids = set()\\n \\n for label in queryset.all():\\n\\n matches = True\\n\\n # Filter string defined for the StockItemLabel object\\n try:\\n filters = InvenTree.helpers.validateFilterString(label.filters)\\n except ValidationError:\\n continue\\n\\n for item in items:\\n\\n item_query = StockItem.objects.filter(pk=item.pk)\\n\\n try:\\n if not item_query.filter(**filters).exists():\\n matches = False\\n break\\n except FieldError:\\n matches = False\\n break\\n\\n # Matched all items\\n if matches:\\n valid_label_ids.add(label.pk)\\n else:\\n continue\\n\\n # Reduce queryset to only valid matches\\n queryset = queryset.filter(pk__in=[pk for pk in valid_label_ids])\\n\\n return queryset\",\n \"def apply_feature_filter(self):\\n self.features = set()\\n for language in self.data.values():\\n features_in_data = set(language.keys())\\n features_to_keep = features_in_data & self.feature_filter\\n self.features |= features_to_keep\\n features_to_remove = features_in_data - features_to_keep\\n for feat in features_to_remove:\\n language.pop(feat)\\n self.features = sorted(list(self.features))\",\n \"def set_filter():\\n try:\\n #=======================================================================\\n # isofilter=[arg.partition('=')[-1] for arg in argv if 'atomfilter=' in arg][0][1:-1].split(',')\\n #=======================================================================\\n isofilter = config.arg('atomfilter')[1:-1].split(',')\\n isofilter = [f.split(':') for f in isofilter]\\n for f in isofilter:\\n if len(f) < 2:\\n f.append('True')\\n if len(f) < 3:\\n f.append('True')\\n if len(f) < 4:\\n f.append('None')\\n except:\\n isofilter = [['element', 'H', 'True', 'None']]\\n try:\\n #=======================================================================\\n # isopartnerfilter=[arg.partition('=')[-1] for arg in argv if 'partnerfilter=' in arg][0][1:-1].split(',')\\n #=======================================================================\\n isopartnerfilter = config.arg('partnerfilter')[1:-1].split(',')\\n isopartnerfilter = [f.split(':') for f in isopartnerfilter]\\n for f in isopartnerfilter:\\n if len(f) < 2:\\n f.append('True')\\n if len(f) < 3:\\n f.append('True')\\n if len(f) < 4:\\n f.append('None')\\n except:\\n isopartnerfilter = [['None', 'None', 'None', 'None']]\\n return isofilter, isopartnerfilter\\n isofilterlist = []\\n isopartnerfilterlist = []\\n for i in xrange(len(isofilter) / 2):\\n isofilterlist.append(tuple(isofilter[2 * i:2 * i + 2]))\\n for i in xrange(len(isopartnerfilter) / 2):\\n isopartnerfilterlist.append(tuple(isopartnerfilter[2 * i:2 * i + 2]))\\n\\n return [isofilterlist, isopartnerfilterlist]\",\n \"def filter_entries_by_tag(search, entry) -> bool:\\n tags = entry.tags\\n search_words = search.strip().translate(str.maketrans(\\\"&|\\\", \\\" \\\")).split()\\n\\n if \\\"&\\\" in search:\\n search_type = \\\"AND\\\"\\n else:\\n search_type = \\\"OR\\\"\\n\\n for word in search_words:\\n if word.lower() in tags:\\n if search_type == \\\"OR\\\":\\n return True\\n\\n elif search_type == \\\"AND\\\":\\n return False\\n\\n if search_type == \\\"OR\\\":\\n return False\\n\\n else:\\n return True\",\n \"def test_filter_multiple(self):\\n self.es.register_filter(foo=False, bar='baz')\\n self.assertFalse(self.es.streamfilter(self.data))\\n self.es.filter = {'all': [], 'any': [], 'none': []}\\n self.es.register_filter(foo=True, bar='baz')\\n self.assertTrue(self.es.streamfilter(self.data))\\n # check whether filter functions are different\\n f, g = self.es.filter['all']\\n c = {'foo': True}\\n self.assertNotEqual(f(c), g(c))\\n c = {'bar': 'baz'}\\n self.assertNotEqual(f(c), g(c))\",\n \"def filter(\\n self,\\n surfaces: Union[list, int] = None,\\n volumes: Union[list, int] = None,\\n fields: Union[list, str] = None,\\n instances: DerivedQuantity = None,\\n ):\\n # ensure arguments are list\\n if surfaces is not None and not isinstance(surfaces, list):\\n surfaces = [surfaces]\\n if volumes is not None and not isinstance(volumes, list):\\n volumes = [volumes]\\n if fields is not None and not isinstance(fields, list):\\n fields = [fields]\\n if instances is not None and not isinstance(instances, list):\\n instances = [instances]\\n\\n quantities = []\\n\\n # iterate through derived_quantities\\n for quantity in self.derived_quantities:\\n # initialise flags to False\\n match_surface, match_volume, match_field, match_instance = (\\n False,\\n False,\\n False,\\n False,\\n )\\n\\n # check if matches surface\\n if surfaces is not None:\\n if hasattr(quantity, \\\"surface\\\") and quantity.surface in surfaces:\\n match_surface = True\\n else:\\n match_surface = True\\n\\n # check if matches volume\\n if volumes is not None:\\n if hasattr(quantity, \\\"volume\\\") and quantity.volume in volumes:\\n match_volume = True\\n else:\\n match_volume = True\\n\\n # check if matches field\\n if fields is not None:\\n if quantity.field in fields:\\n match_field = True\\n else:\\n match_field = True\\n\\n # check if matches instance\\n if instances is not None:\\n if isinstance(quantity, tuple(instances)):\\n match_instance = True\\n else:\\n match_instance = True\\n\\n # if all flags are True, append to the list\\n if match_surface and match_volume and match_field and match_instance:\\n quantities.append(quantity)\\n\\n if len(quantities) == 1:\\n quantities = quantities[0]\\n return quantities\",\n \"def filter(self, *args, **kwargs):\\n self._not_support_combined_queries(\\\"filter\\\")\\n return self._filter_or_exclude(False, args, kwargs)\",\n \"def add_products(self, products):\\n return [self.add_product(product) for product in set(products)]\",\n \"def filter_queryset(self, queryset, view=None):\\n queryset = super().filter_queryset(queryset.only(\\\"id\\\", \\\"shared\\\"))\\n form_pk = self.kwargs.get(self.lookup_field)\\n\\n if form_pk:\\n try:\\n int(form_pk)\\n except ValueError as e:\\n if form_pk == self.public_data_endpoint:\\n queryset = self._get_public_forms_queryset()\\n else:\\n raise ParseError(_(f\\\"Invalid pk {form_pk}\\\")) from e\\n else:\\n queryset = self._filtered_or_shared_queryset(queryset, form_pk)\\n else:\\n tags = self.request.query_params.get(\\\"tags\\\")\\n not_tagged = self.request.query_params.get(\\\"not_tagged\\\")\\n\\n if tags and isinstance(tags, six.string_types):\\n tags = tags.split(\\\",\\\")\\n queryset = queryset.filter(tags__name__in=tags)\\n if not_tagged and isinstance(not_tagged, six.string_types):\\n not_tagged = not_tagged.split(\\\",\\\")\\n queryset = queryset.exclude(tags__name__in=not_tagged)\\n\\n return queryset\",\n \"def test_filter_recipe_by_tag(self):\\n tag1 = sample_tag(self.user, name='Indian')\\n tag2 = sample_tag(self.user, name='Breakfast')\\n recipe1 = sample_recipe(self.user, title='Curry')\\n recipe2 = sample_recipe(self.user, title=\\\"bacon pie\\\")\\n recipe1.tags.add(tag1)\\n recipe2.tags.add(tag2)\\n recipe3 = sample_recipe(self.user)\\n\\n res = self.client.get(\\n RECIPE_URL,\\n {'tags': f'{tag1.id},{tag2.id}'}\\n )\\n serializer1 = RecipeSerializer(recipe1)\\n serializer2 = RecipeSerializer(recipe2)\\n serializer3 = RecipeSerializer(recipe3)\\n self.assertIn(serializer1.data, res.data)\\n self.assertIn(serializer2.data, res.data)\\n self.assertNotIn(serializer3.data, res.data)\",\n \"def test_get_project_list_with_tag_filter(self):\\n # Add test projects.\\n tag = 'tag1'\\n projects_with_tag = [\\n add_project(title='1', description='1', tags=[tag]),\\n add_project(title='2', description='2', tags=[tag]),\\n ]\\n project_without_tag = add_project(title='3', description='3', tags=[])\\n\\n result = get_project_list(tag=tag)\\n result_projects = result['projects'].object_list\\n\\n # Make sure only projects with tag are retrieved.\\n for project_with_tag in projects_with_tag:\\n self.assertTrue(project_with_tag in result_projects)\\n self.assertFalse(project_without_tag in result_projects)\\n self.assertEqual(len(result_projects), len(projects_with_tag))\\n self.assertTrue(result['filtered'])\\n self.assertEqual(result['tag'], tag)\",\n \"def filter_queryset(self, queryset):\\n\\n queryset = super().filter_queryset(queryset)\\n\\n items = self.get_items()\\n\\n if len(items) > 0:\\n \\\"\\\"\\\"At this point, we are basically forced to be inefficient:\\n\\n We need to compare the 'filters' string of each report template,\\n and see if it matches against each of the requested items.\\n\\n In practice, this is not too bad.\\n \\\"\\\"\\\"\\n\\n valid_report_ids = set()\\n\\n for report in queryset.all():\\n matches = True\\n\\n try:\\n filters = InvenTree.helpers.validateFilterString(report.filters)\\n except ValidationError:\\n continue\\n\\n for item in items:\\n item_query = self.ITEM_MODEL.objects.filter(pk=item.pk)\\n\\n try:\\n if not item_query.filter(**filters).exists():\\n matches = False\\n break\\n except FieldError:\\n matches = False\\n break\\n\\n # Matched all items\\n if matches:\\n valid_report_ids.add(report.pk)\\n\\n # Reduce queryset to only valid matches\\n queryset = queryset.filter(pk__in=list(valid_report_ids))\\n\\n return queryset\",\n \"def filter(request):\\n product = Product.objects.filter(name__icontains=request.GET['q']).filter(brand__icontains=request.GET['brand']).filter(year__icontains=request.GET['year'])\\n return render(request, \\\"search_results.html\\\", {\\\"products\\\": product})\",\n \"def _getWhereClause(self, tagIDs):\\n objectIDs = self._criteria.get('objectIDs')\\n where = [TagValue.tagID == Tag.id]\\n if objectIDs:\\n where.append(TagValue.objectID.is_in(objectIDs))\\n if tagIDs:\\n where.append(Tag.id.is_in(tagIDs))\\n createdBeforeTime = self._criteria.get('createdBeforeTime')\\n if createdBeforeTime:\\n where.append(TagValue.creationTime < createdBeforeTime)\\n return where\",\n \"def filter_or(filters):\\n def filt(item):\\n for f in filters:\\n if f(item):\\n return True\\n return False\\n return filt\",\n \"def tags(catalog,lista,tag):\\n final=lt.newList(datastructure='ARRAY_LIST')\\n i=it.newIterator(lista)\\n while it.hasNext(i):\\n vid=it.next(i)\\n if tag in vid['tags']:\\n lt.addLast(final,vid)\\n return final\",\n \"def filter_queryset(self, queryset):\\n for name, value in self.form.cleaned_data.items():\\n queryset = self.filters[name].filter(queryset, value)\\n # assert isinstance(queryset, models.QuerySet), \\\\\\n # \\\"Expected '%s.%s' to return a QuerySet, but got a %s instead.\\\" \\\\\\n # % (type(self).__name__, name, type(queryset).__name__)\\n return queryset\",\n \"def filter(self, **args ):\\n query = TXLOG.select('*')\\n for key, value in args.items():\\n if '__' in key:\\n key, op = key.split('__')\\n else:\\n op = 'eq'\\n\\n if not key in self.schema:\\n raise BadArgument(\\\"Key %s not a valid argument\\\" % key )\\n\\n if not isinstance(value, basestring ):\\n value = str(value)\\n\\n query = query.where({key:value}, self.operators[op])\\n\\n items = query.list()\\n return items\",\n \"def filter_queryset(self, queryset):\\n params = self.request.query_params\\n\\n queryset = super().filter_queryset(queryset)\\n\\n # Filter by 'build'\\n build = params.get('build', None)\\n\\n if build is not None:\\n\\n try:\\n build = Build.objects.get(pk=build)\\n\\n queryset = queryset.filter(stock_item__build=build)\\n\\n except (ValueError, Build.DoesNotExist):\\n pass\\n\\n # Filter by stock item\\n item = params.get('stock_item', None)\\n\\n if item is not None:\\n try:\\n item = StockItem.objects.get(pk=item)\\n\\n items = [item]\\n\\n # Do we wish to also include test results for 'installed' items?\\n include_installed = str2bool(params.get('include_installed', False))\\n\\n if include_installed:\\n # Include items which are installed \\\"underneath\\\" this item\\n # Note that this function is recursive!\\n installed_items = item.get_installed_items(cascade=True)\\n\\n items += list(installed_items)\\n\\n queryset = queryset.filter(stock_item__in=items)\\n\\n except (ValueError, StockItem.DoesNotExist):\\n pass\\n\\n return queryset\",\n \"def _filter(self, probs: Tensor, ids: Tensor) -> Tuple[Tensor, List[int]]:\\n raise NotImplementedError\",\n \"def test_filtering_recipes_with_tags(self):\\n recipe1 = create_sample_recipe(user=self.user, title=\\\"Chicken tikka\\\")\\n recipe2 = create_sample_recipe(user=self.user, title=\\\"Italian pasta\\\")\\n recipe3 = create_sample_recipe(user=self.user, title=\\\"Vegan dessert\\\")\\n\\n tag1 = create_sample_tag(user=self.user, name=\\\"Grill\\\")\\n tag2 = create_sample_tag(user=self.user, name=\\\"Light food\\\")\\n\\n recipe1.tags.add(tag1)\\n recipe2.tags.add(tag2)\\n\\n res = self.client.get( RECIPE_URL, {\\\"tags\\\": f\\\"{tag1.id}, {tag2.id}\\\"})\\n\\n serializer1 = RecipeSerializer(recipe1)\\n serializer2 = RecipeSerializer(recipe2)\\n serializer3 = RecipeSerializer(recipe3)\\n\\n self.assertEqual(res.status_code, status.HTTP_200_OK)\\n self.assertIn(serializer1.data, res.data)\\n self.assertIn(serializer2.data, res.data)\\n self.assertNotIn(serializer3.data, res.data)\",\n \"def get_visible_products(self):\\r\\n all_products = billing.loading.get_products(hidden=True)\\r\\n public_products = billing.loading.get_products()\\r\\n subscribed_product_types = ProductType.objects \\\\\\r\\n .filter(subscriptions__billing_account=self) \\\\\\r\\n .distinct()\\r\\n subscribed_products = set(pt.get_product_class() for pt in subscribed_product_types)\\r\\n visible_products = set(public_products).union(subscribed_products)\\r\\n return [p for p in all_products if p in visible_products]\",\n \"def search(self, cr, user, args, offset=0, limit=None, order=None,\\n context=None, count=False):\\n prod_obj = self.pool['product.product']\\n op_map = {'=': 'in', '!=': 'not in', '<>': 'not in',\\n 'in': 'in', 'not in': 'not in'}\\n #TODO - support between combination of <,<= and >, >=\\n args2 = args[:]\\n arg_offset = 0\\n res = False\\n for idx, arg in enumerate(args2):\\n if arg[0] == 'product_id':\\n product_ids = prod_obj.search(cr, user,\\n [('id', arg[1], arg[2]),\\n ('is_multi_variants', '=', True)],\\n context=context)\\n tmpl_ids = [prod.product_tmpl_id.id for prod in\\n prod_obj.browse(cr, user, product_ids,\\n context=context)]\\n if tmpl_ids:\\n prod_ids = prod_obj.search(cr, user,\\n [('product_tmpl_id', 'in',\\n tmpl_ids)])\\n operator = op_map.get(arg[1], 'in')\\n if idx > 0 and args2[idx - 1] == '!':\\n operator = operator == 'in' and 'not in' or 'in'\\n extra_args = ['|', '&',\\n ('bom_template', '=', True),\\n ('product_id', operator, prod_ids)]\\n args = (args[:idx + arg_offset] + extra_args +\\n args[idx + arg_offset:])\\n arg_offset += len(extra_args)\\n try:\\n res = super(BomTemplate, self).search(cr, user, args, offset=offset,\\n limit=limit, order=order,\\n context=context, count=count)\\n except:\\n _logger.exception('Extended search failed for MRP BoM with domain '\\n '%s. Performing standard search with %s' %\\n (args, args2))\\n if not res:\\n res = super(BomTemplate, self).search(cr, user, args2, offset=offset,\\n limit=limit, order=order,\\n context=context, count=count)\\n return res\",\n \"def _filter(\\n self,\\n data: List[dict],\\n filters: List[Tuple[str, SupportedFilterType]],\\n state_dataclass: StateSchema,\\n detail: bool,\\n ) -> List[dict]:\\n filters = _convert_filters_type(filters, state_dataclass)\\n result = []\\n for datum in data:\\n match = True\\n for filter_column, filter_predicate, filter_value in filters:\\n filterable_columns = state_dataclass.filterable_columns()\\n filter_column = filter_column.lower()\\n if filter_column not in filterable_columns:\\n raise ValueError(\\n f\\\"The given filter column {filter_column} is not supported. \\\"\\n f\\\"Supported filter columns: {filterable_columns}\\\"\\n )\\n\\n if filter_column not in datum:\\n match = False\\n elif filter_predicate == \\\"=\\\":\\n if isinstance(filter_value, str) and isinstance(\\n datum[filter_column], str\\n ):\\n # Case insensitive match for string filter values.\\n match = datum[filter_column].lower() == filter_value.lower()\\n else:\\n match = datum[filter_column] == filter_value\\n elif filter_predicate == \\\"!=\\\":\\n if isinstance(filter_value, str) and isinstance(\\n datum[filter_column], str\\n ):\\n match = datum[filter_column].lower() != filter_value.lower()\\n else:\\n match = datum[filter_column] != filter_value\\n else:\\n raise ValueError(\\n f\\\"Unsupported filter predicate {filter_predicate} is given. \\\"\\n \\\"Available predicates: =, !=.\\\"\\n )\\n\\n if not match:\\n break\\n\\n if match:\\n result.append(filter_fields(datum, state_dataclass, detail))\\n return result\",\n \"def test_list_products_filtered_by_selling_status(self):\\n self._require_login(self.user1)\\n response = self.client.get('/api/1.0/products/?selling=3')\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\\n self.assertEqual(response.data.__len__(), 1)\\n self.assertEqual(response.data[0]['name'], 'Producto 2')\\n self.assertEqual(response.data[0]['description'], 'Descripcion producto 2')\",\n \"def check_products(self, adi):\\r\\n results = []\\r\\n products = self.get_products(adi)\\r\\n for product in products[\\\"data\\\"][\\\"products\\\"]:\\r\\n print(\\\"Checking product '{}'... \\\".format(product[\\\"name\\\"]), end='')\\r\\n detail = self.get_product_detail(adi, product_id=product[\\\"productId\\\"], product_name=product[\\\"name\\\"])\\r\\n if self.rf.valid_product_detail(detail):\\r\\n print(\\\"Valid.\\\")\\r\\n result = \\\"Available\\\"\\r\\n else:\\r\\n print(\\\"INVALID.\\\")\\r\\n result = \\\"Not available\\\"\\r\\n results.append([product[\\\"name\\\"], result])\\r\\n return results\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.66341794","0.6542159","0.63417774","0.6290791","0.61444324","0.61051065","0.5993559","0.5917431","0.5875063","0.5852951","0.578841","0.5734029","0.57259727","0.5694228","0.5673258","0.565935","0.5637606","0.56313235","0.5576161","0.5563928","0.5539448","0.552675","0.5516025","0.5515226","0.5494058","0.5465211","0.5446835","0.5442008","0.5441432","0.54033357","0.54023135","0.5377015","0.53703684","0.53654724","0.5352439","0.5351586","0.5349544","0.5341778","0.53317755","0.53189117","0.53069746","0.5306867","0.5302087","0.52998185","0.52819955","0.52810895","0.52605677","0.5250497","0.5245583","0.52449286","0.5241019","0.5229809","0.52260363","0.5207155","0.5202673","0.51941913","0.5168955","0.5166475","0.5162977","0.5162977","0.5141813","0.513734","0.5133896","0.51291704","0.51181054","0.5116665","0.5116665","0.51119196","0.510481","0.5097499","0.50931436","0.5089226","0.50891185","0.5086877","0.50854343","0.5072374","0.50717646","0.5070128","0.5069506","0.5066296","0.5045647","0.50440836","0.50415945","0.50388145","0.5035905","0.5031814","0.50238466","0.5023284","0.50174785","0.5016951","0.5013485","0.5003747","0.5001859","0.5001404","0.49994662","0.49992457","0.4998505","0.49932528","0.49914837","0.49890947"],"string":"[\n \"0.66341794\",\n \"0.6542159\",\n \"0.63417774\",\n \"0.6290791\",\n \"0.61444324\",\n \"0.61051065\",\n \"0.5993559\",\n \"0.5917431\",\n \"0.5875063\",\n \"0.5852951\",\n \"0.578841\",\n \"0.5734029\",\n \"0.57259727\",\n \"0.5694228\",\n \"0.5673258\",\n \"0.565935\",\n \"0.5637606\",\n \"0.56313235\",\n \"0.5576161\",\n \"0.5563928\",\n \"0.5539448\",\n \"0.552675\",\n \"0.5516025\",\n \"0.5515226\",\n \"0.5494058\",\n \"0.5465211\",\n \"0.5446835\",\n \"0.5442008\",\n \"0.5441432\",\n \"0.54033357\",\n \"0.54023135\",\n \"0.5377015\",\n \"0.53703684\",\n \"0.53654724\",\n \"0.5352439\",\n \"0.5351586\",\n \"0.5349544\",\n \"0.5341778\",\n \"0.53317755\",\n \"0.53189117\",\n \"0.53069746\",\n \"0.5306867\",\n \"0.5302087\",\n \"0.52998185\",\n \"0.52819955\",\n \"0.52810895\",\n \"0.52605677\",\n \"0.5250497\",\n \"0.5245583\",\n \"0.52449286\",\n \"0.5241019\",\n \"0.5229809\",\n \"0.52260363\",\n \"0.5207155\",\n \"0.5202673\",\n \"0.51941913\",\n \"0.5168955\",\n \"0.5166475\",\n \"0.5162977\",\n \"0.5162977\",\n \"0.5141813\",\n \"0.513734\",\n \"0.5133896\",\n \"0.51291704\",\n \"0.51181054\",\n \"0.5116665\",\n \"0.5116665\",\n \"0.51119196\",\n \"0.510481\",\n \"0.5097499\",\n \"0.50931436\",\n \"0.5089226\",\n \"0.50891185\",\n \"0.5086877\",\n \"0.50854343\",\n \"0.5072374\",\n \"0.50717646\",\n \"0.5070128\",\n \"0.5069506\",\n \"0.5066296\",\n \"0.5045647\",\n \"0.50440836\",\n \"0.50415945\",\n \"0.50388145\",\n \"0.5035905\",\n \"0.5031814\",\n \"0.50238466\",\n \"0.5023284\",\n \"0.50174785\",\n \"0.5016951\",\n \"0.5013485\",\n \"0.5003747\",\n \"0.5001859\",\n \"0.5001404\",\n \"0.49994662\",\n \"0.49992457\",\n \"0.4998505\",\n \"0.49932528\",\n \"0.49914837\",\n \"0.49890947\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6570375"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":8794,"cells":{"query":{"kind":"string","value":"(Product, float, float, radius) > boolean Check if the coordinates of a shop is within a radius (in meters) using the Vincenty's formulae."},"document":{"kind":"string","value":"def is_matching_product(product, lat, lng, radius):\n return vincenty(\n (lat, lng),\n (product.shop.lat, product.shop.lng)\n ).meters <= radius"},"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 is_matching_product_with_tags(product, lat, lng, radius, tags):\n return vincenty(\n (lat, lng),\n (product.shop.lat, product.shop.lng)\n ).meters <= radius and any(tag in product.shop.tags for tag in tags)","def __contains__(self, position):\n return sum([(c1 - c2) ** 2 for (c1, c2) in zip(self.position, position)]) <= self.radius","def point_inside_circle(x,y,center_x,center_y,radius):\n return (x-center_x)**2 + (y - center_y)**2 < radius**2","def __contains__(self, other):\n x, y = other\n return self.radius >= sqrt((x - self.x) ** 2 + (y - self.y) ** 2)","def contains(self, position):\n return np.linalg.norm(position - self._center) < self._radius","def inside_unit_circle(point):\n distance = math.sqrt(point[0] ** 2 + point[1] ** 2)\n return distance < 1","def isInCircle(self,x1,y1,radius1):\r\n if(distance(self.x,x1,self.y,y1) < (self.radius+radius1)):\r\n return True\r\n return False","def objects_radius(self, centre, radius):","def checkBounds(x,y,z,center,radius):\n r2 = (x-center[0])**2 + (y-center[1])**2# + (z-center[0])**2\n if r2 < radius**2:\n return True\n else:\n return False","def contains(self, loc): \n return loc.distance(self.center) <= self.radius","def isInside(x1, y1, x2, y2, x3, y3, x, y):\n # Calculate area of triangle ABC\n A = area (x1, y1, x2, y2, x3, y3)\n \n # Calculate area of triangle PBC\n A1 = area (x, y, x2, y2, x3, y3)\n \n # Calculate area of triangle PAC\n A2 = area (x1, y1, x, y, x3, y3)\n \n # Calculate area of triangle PAB\n A3 = area (x1, y1, x2, y2, x, y)\n \n # Check if sum of A1, A2 and A3\n # is same as A\n if(A == A1 + A2 + A3):\n return True\n else:\n return False","def is_point_inside_hypersphere(point: np.array, c: List[float], r: float) -> bool:\n return np.linalg.norm(point - c) < r","def inside(x, y, primitive):\n\n # You should implement your inside test here for all shapes\n # for now, it only returns a false test\n\n if primitive[\"shape\"] == \"circle\":\n dist_sqr = ((primitive[\"center\"][0] - x) ** 2 +\n (primitive[\"center\"][1] - y) ** 2)\n\n return dist_sqr <= primitive[\"radius\"] ** 2\n else:\n return winding_number(x, y, primitive)\n\n return False","def test_get_radius():\n center = Coordinates(7, 3)\n radius = 12\n\n returned_rad = get_radius(center, radius, 30)\n\n assert returned_rad == radius\n assert returned_rad != center.get_x()\n assert returned_rad != center.get_y()","def sphere_isclose(c1, c2, *args, **kwargs):\n return np.isclose(c1.radius, c2.radius, *args, **kwargs) and np.allclose(\n c1.center, c2.center, *args, **kwargs\n )","def containsPos(self, obst_pos, aerial_pos):\n dist_to_center = obst_pos.distanceTo(aerial_pos)\n return dist_to_center <= self.sphere_radius","def check_point_in_detector(p, radius=radius, height=height, distance=distance):\r\n if p[0]**2 + p[1]**2 <= radius**2: # Are the x and y coordinates in the circle?\r\n if (p[2] >= distance) and (p[2] <= height+distance): # Is the z coordinate between the distance and the height?\r\n return True\r\n else:\r\n return False\r\n else:\r\n return False","def isinsidepointXY(x,p):\n \n return dist(x,p) < epsilon","def are_close(coord1, coord2, tolerance=10):\n return vincenty(coord1, coord2).meters < tolerance","def incircle(self,xpos,ypos,cellx,celly):\n xcell, ycell = self.getcellcenter(cellx,celly)\n if ((xpos - xcell)**2 + (ypos - ycell)**2) < self.crad2:\n return True\n return False\n\n return cellx, celly","def WhereAreYou(CurLongitude,CurLatitude,LocationLongitude,LocationLatitude,LocationRadius):\n # Calculate the great circle distance between two points\n # on the earth (specified in decimal degrees)\n # 将十进制度数转化为弧度\n CurLongitude,CurLatitude,LocationLongitude,LocationLatitude = map(radians, [float(CurLongitude),float(CurLatitude),float(LocationLongitude),float(LocationLatitude)])\n\n # haversine公式\n dlon = LocationLongitude - CurLongitude\n dlat = LocationLatitude - CurLatitude\n a = sin(dlat / 2) ** 2 + cos(CurLatitude) * cos(LocationLatitude) * sin(dlon / 2) ** 2\n c = 2 * asin(sqrt(a))\n r = 6371 # 地球平均半径，单位为公里\n distance = c * r * 1000\n if(distance < float(LocationRadius)):\n return True\n else:\n return False","def __contains__(self, point): \n corners = self.corners\n\n if isinstance(point, tuple):\n from pyresample.spherical_geometry import Coordinate\n retval = planar_point_inside(Coordinate(*point), corners)\n else:\n retval = planar_point_inside(point, corners)\n\n #print ' retval from FALSE CORNERS contains '+str(retval)\n\n return retval","def get_radius(self):","def within_radius(self, radius=5.0):\n\n return GeoEntry.within_radius(self.primary_geocode, radius, ['all',])","def in_circle(x0, y0, x, y, r):\n return ((x - x0) ** 2 + (y - y0) ** 2) <= (r ** 2)","def is_point_inside_hypermoon(point: np.array, c: Tuple[List[float]], r: Tuple[float]) -> bool:\n return is_point_inside_hypersphere(point, c[0], r[0]) and not is_point_inside_hypersphere(point, c[1], r[1])","def vincenty(p1, p2):\n # Note: GeoPy expects (latitude, longitude) pairs.\n return geopy.distance.vincenty(\n (p1.y, p1.x),\n (p2.y, p2.x)\n ).miles","def check_coordinates(X, Y):\n\n # Accounting for elliptical Jupiter disk\n Y *= 1.071374\n\n return sqrt(X ** 2 + Y ** 2)","def is_clicked(vtx_x, vtx_y, mouse_x, mouse_y, radius):\n return math.sqrt(((mouse_x - vtx_x) ** 2) + ((mouse_y - vtx_y) ** 2)) < radius","def is_point_inside_hypercube(point: List[float], c: List[float], r: float) -> bool:\n diff = np.subtract(point, c)\n return np.all(np.absolute(diff) <= r)","def dans_cercle(self, r, x, y):\r\n self.r_num(r)\r\n valid = (isinstance(x, int) or isinstance(x, float)) and \\\r\n (isinstance(y, int) or isinstance(y, float))\r\n if valid:\r\n if sqrt(x**2+y**2)<self.r:\r\n return True\r\n else:\r\n return False\r\n else:\r\n raise TypeError","def containsPos(self, aerial_pos):\n # Check altitude of position\n aerial_alt = aerial_pos.altitude_msl\n if (aerial_alt < 0 or aerial_alt > self.cylinder_height):\n return False\n # Check lat/lon of position\n dist_to_center = self.gps_position.distanceTo(aerial_pos.gps_position)\n if dist_to_center > self.cylinder_radius:\n return False\n # Both within altitude and radius bounds, inside cylinder\n return True","def check_in(x, y, R=Re):\n r = np.sqrt(x ** 2 + y ** 2)\n return r <= R","def at_loc((x, y), (cx, cy), eps=0.000035):\n\treturn (x - cx)**2 + (y - cy)**2 <= eps**2","def conf_test(self, trial_coords: np.ndarray) -> bool:\n #N = len(trial_coords)\n r2: float = 0\n i =0\n r2 = np.inner(trial_coords, trial_coords)\n if (r2> self.m_radius2):\n return False\n return True","def is_inside(self, mX, mY, point):\n return (math.sqrt((point[0] - mX) * (point[0] - mX)\n + (point[1] - mY) * (point[1] - mY)) <= 2)","def area_of_circle(radius):\n return radius","def main():\n pos_x1 = float(input())\n pos_y1 = float(input())\n rad_1 = float(input())\n pos_x2 = float(input())\n pos_y2 = float(input())\n rad_2 = float(input())\n\n if ((pos_x1 - pos_x2) ** 2 + (pos_y1 - pos_y2) ** 2) ** 0.5 < rad_1 + rad_2:\n print(\"Yes\")\n else:\n print(\"No\")","def __contains__(self, point):\n #### Original \n from pyresample.spherical_geometry import point_inside, Coordinate\n corners = self.corners\n\n if isinstance(point, tuple):\n return point_inside(Coordinate(*point), corners)\n else:\n return point_inside(point, corners)\n #### End Original\n #from .spherical import SphPolygon\n #log.info('RUNNING SPHERICAL in __contains__')\n #sphpoly = SphPolygon(corners)\n #return sphpoly.intersection(SphPolygon(point), sphpoly)","def isInternal(self, aPoint):\n if compute_distance(self.center, aPoint) <= self.radius:\n return True\n else:\n return False","def within(self, right: GeoSpatialValue) -> ir.BooleanValue:\n return ops.GeoWithin(self, right).to_expr()","def shops_within_radius(self, lat, lng, radius, tags=None):\n center_point = geoindex.GeoPoint(lat, lng)\n points = self.geoindex.get_nearest_points(center_point, radius, 'km')\n\n def tags_filter(shops):\n for shop in shops:\n for tag in tags:\n if tag in shop['tags']:\n yield shop\n break\n\n def get_shops():\n for point, distance in points:\n point.ref['distance'] = distance\n yield point.ref\n\n if tags:\n return tags_filter(get_shops())\n else:\n return get_shops()","def isKelvin(self):\n return _libsbml.Unit_isKelvin(self)","def isoutside(coords, shape):\n # Label external pores for trimming below\n if len(shape) == 1: # Spherical\n # Find external points\n r = np.sqrt(np.sum(coords**2, axis=1))\n Ps = r > shape[0]\n elif len(shape) == 2: # Cylindrical\n # Find external pores outside radius\n r = np.sqrt(np.sum(coords[:, [0, 1]]**2, axis=1))\n Ps = r > shape[0]\n # Find external pores above and below cylinder\n if shape[1] > 0:\n Ps = Ps + (coords[:, 2] > shape[1])\n Ps = Ps + (coords[:, 2] < 0)\n else:\n pass\n elif len(shape) == 3: # Rectilinear\n shape = np.array(shape, dtype=float)\n try:\n lo_lim = shape[:, 0]\n hi_lim = shape[:, 1]\n except IndexError:\n lo_lim = np.array([0, 0, 0])\n hi_lim = shape\n Ps1 = np.any(coords > hi_lim, axis=1)\n Ps2 = np.any(coords < lo_lim, axis=1)\n Ps = Ps1 + Ps2\n return Ps","def FindPointsWithinRadius(self, p_float, , vtkIdList):\n ...","def in_area_of_interest (lat, long, min_lat, max_lat, min_long, max_long):\n\n if lat is None or long is None:\n return False\n\n lat = float(lat)\n long = float(long)\n\n if ((lat >= min_lat and lat <= max_lat) and\n (long >= min_long and long <= max_long)):\n return True\n\n return False","def is_inside(self, p):\n s, t = self.get_barycentric_coord(p)\n if 0 <= s <= 1 and 0 <= t <= 1 and s + t <= 1:\n return True\n else:\n return False","def in_square(self, point):\n size = self.size\n centre = self.centre\n # Find the upper and lower bounds for the square in-terms of x and y\n lower_x, upper_x = centre.x - size / 2, centre.x + size / 2\n lower_y, upper_y = centre.y - size / 2, centre.y + size / 2\n # Equals with lower bounds only\n return (lower_x <= point.x < upper_x) and (lower_y < point.y <= upper_y)","def pointPotential(x,y,q,posx,posy):\n k = 8.99e9\n V = (k * q) / (sqrt(x**2 + (y - sqrt((posx**2 + posy**2)))**2))\n return V","def test_circumference_area(self):\n self.assertEqual(9.425, circumference_area(self.values['radius']))","def sphere_area(radius : number) -> number:\n area = 4*pi*radius*radius\n return area","def is_inside(self, points):\n points = np.atleast_2d(points) - self.centroid\n return np.logical_and(\n np.linalg.norm(points, axis=-1) <= self.radius,\n # At present circles are not orientable, so the z position must\n # match exactly.\n np.isclose(points[:, 2], 0),\n )","def brute_force(savedPnts, unitRadius, point):\n for pnt in savedPnts:\n d = distance(pnt, point)\n if d < unitRadius: return False\n return True","def __ge__(self, other):\n return self.x ** 2 + self.y ** 2 >= other.x ** 2 + other.y ** 2","def contains_pt(self, pt):\n x, y = pt\n if not self.x - self.radius < x < self.x + self.radius:\n return False\n if not self.y - self.radius < y < self.y + self.radius:\n return False\n return True","def _intersected(positions, radius):\n P1 = positions[0]\n P2 = positions[1]\n P3 = positions[2]\n temp1 = P2 - P1\n e_x = temp1 / np.linalg.norm(temp1)\n temp2 = P3 - P1\n i = np.dot(e_x, temp2)\n temp3 = temp2 - i * e_x\n e_y = temp3 / np.linalg.norm(temp3)\n e_z = np.cross(e_x, e_y)\n d = np.linalg.norm(P2 - P1)\n j = np.dot(e_y, temp2) \n x = d / 2\n y = (-2*i*x + i*i + j*j) / (2*j)\n temp4 = radius**2 - x*x - y*y\n if temp4 < 0:\n return False\n return True","def is_perfect_square():","def check_me(triplet, list_of_coords):\n c = True\n for element in list_of_coords:\n if (float(triplet[0])*0.99 <= float(element[0]) <= float(triplet[0])*1.01):\n if (float(triplet[1])*0.99 <= float(element[1]) <= float(triplet[1])*1.01):\n if (float(triplet[2])*0.99 <= float(element[2]) <= float(triplet[2])*1.01):\n c = False\n return c","def is_inside(inner_path, outer_path):\r\n if not hasattr(inner_path, 'bounding_box'):\r\n inner_path.bounding_box = CutPlanner.bounding_box(inner_path)\r\n if not hasattr(outer_path, 'bounding_box'):\r\n outer_path.bounding_box = CutPlanner.bounding_box(outer_path)\r\n if outer_path.bounding_box[0] > inner_path.bounding_box[0]:\r\n # outer minx > inner minx (is not contained)\r\n return False\r\n if outer_path.bounding_box[1] > inner_path.bounding_box[1]:\r\n # outer miny > inner miny (is not contained)\r\n return False\r\n if outer_path.bounding_box[2] < inner_path.bounding_box[2]:\r\n # outer maxx < inner maxx (is not contained)\r\n return False\r\n if outer_path.bounding_box[3] < inner_path.bounding_box[3]:\r\n # outer maxy < inner maxy (is not contained)\r\n return False\r\n if outer_path.bounding_box == inner_path.bounding_box:\r\n if outer_path == inner_path: # This is the same object.\r\n return False\r\n if not hasattr(outer_path, 'vm'):\r\n outer_path = Polygon([outer_path.point(i / 100.0, error=1e4) for i in range(101)])\r\n vm = VectorMontonizer()\r\n vm.add_cluster(outer_path)\r\n outer_path.vm = vm\r\n for i in range(101):\r\n p = inner_path.point(i / 100.0, error=1e4)\r\n if not outer_path.vm.is_point_inside(p.x, p.y):\r\n return False\r\n return True","def parallel_radius(self, lat):\n\n return EARTH_RADIUS * lat.cos()","def get_radius(self):\r\n return 1","def inCircleFast(self, tri, p):\n center, radius = self.circles[tri]\n return np.sum(np.square(center - p)) <= radius","def sphereArea(radius):\n area = 4 * math.pi * radius ** 2\n return area","def vincenty(lon0, lat0, a1, s):\n\n lon0 = np.deg2rad(lon0)\n lat0 = np.deg2rad(lat0)\n a1 = np.deg2rad(a1)\n s = np.deg2rad(s)\n\n sina = np.cos(lat0) * np.sin(a1)\n\n num1 = np.sin(lat0) * np.cos(s) + np.cos(lat0) * np.sin(s) * np.cos(a1)\n den1 = np.sqrt(\n sina**2 + (np.sin(lat0) * np.sin(s) - np.cos(lat0) * np.cos(a1)) ** 2\n )\n lat = np.rad2deg(np.arctan2(num1, den1))\n\n num2 = np.sin(s) * np.sin(a1)\n den2 = np.cos(lat0) * np.cos(s) - np.sin(lat0) * np.sin(s) * np.cos(a1)\n L = np.arctan2(num2, den2)\n lon = np.rad2deg(lon0 + L)\n\n return lon, lat","def great_circle(a: Point, b: Point) -> Km:\n\n lat1, lng1, lat2, lng2 = map(radians, [a.latitude, a.longitude, b.latitude, b.longitude])\n sin_lat1, sin_lat2 = map(sin, [lat1, lat2])\n cos_lat1, cos_lat2 = map(cos, [lat1, lat2])\n delta_lng = lng2 - lng1\n cos_delta_lng, sin_delta_lng = cos(delta_lng), sin(delta_lng)\n\n d = atan2(\n sqrt((cos_lat2 * sin_delta_lng) ** 2 + (cos_lat1 * sin_lat2 - sin_lat1 * cos_lat2 * cos_delta_lng) ** 2),\n sin_lat1 * sin_lat2 + cos_lat1 * cos_lat2 * cos_delta_lng,\n )\n\n return Km(6371.009 * d) # Radius of earth in kilometers is 6371","def circles_collide(x1: float, y1: float, r1: float, x2: float, y2: float, r2: float) -> bool:\n return distance_between_sq(x1, y1, x2, y2) <= (r1 + r2)**2","def Distance(VCoords, SCoords):\r\n #Convert to radians\r\n lat1,lon1,lat2,lon2 = map(math.radians, VCoords+SCoords)\r\n #Apply Haversine formula\r\n dlon = lon2-lon1\r\n dlat = lat2-lat1\r\n a = math.sin(dlat/2)**2 + math.cos(lat1) * math.cos(lat2) * math.sin(dlon/2)**2\r\n c = 2 * math.asin(math.sqrt(a))\r\n #Earth radius = 6371km\r\n return 6371 * c","def validate_pos(game: TowerDefenceSolver, position: Tuple[int, int], purchases_list: Purchases) -> bool:\n if (\n position[0] < 0\n or position[1] < 0\n or position[0] >= game.map_height\n or position[1] >= game.map_width\n or position in game.path\n ):\n return False\n\n for purchase in purchases_list:\n if purchase[\"coords\"] == position:\n return False\n\n return True","def _greatCircleDistance(self, long1, lat1, long2, lat2):\n # convert decimal degrees to radians \n long1, lat1, long2, lat2 = map(radians, [float(long1), float(lat1), float(long2), float(lat2)])\n # haversine formula \n dlon = long2 - long1\n #print(long2)\n #print(long1) \n dlat = lat2 - lat1 \n a = sin(dlat/2)**2 + cos(lat1) * cos(lat2) * sin(dlon/2)**2\n c = 2 * asin(sqrt(a)) \n r = 6371 # Radius of earth in kilometers. Use 3956 for miles\n #print(c*r)\n return c * r","def test_update_radius():\n center = Coordinates(1, 1)\n rad1 = 20.3\n speed = 30\n\n i = Intersection(center, rad1, speed)\n\n assert i.get_radius() == 20.3\n\n i.update_radius(56.5)\n\n assert i.get_radius() == 56.5","def test_get_center():\n center = Coordinates(7, 3)\n radius = 12\n\n returned_center = get_center(center, radius, 25)\n\n assert returned_center.get_x() == center.get_x()\n assert returned_center.get_y() == center.get_y()","def isInside(self, position, maxDimLens):\n dim = len(position);\n deltas = [0] * dim;\n distSqr = 0;\n for i in range(0, dim):\n deltas[i] = math.fabs(position[i] - self.mSample[i]);\n if math.fabs(maxDimLens[i] - deltas[i]) < deltas[i]:\n deltas[i] = math.fabs(maxDimLens[i] - deltas[i]);\n distSqr += deltas[i]**2;\n\n if distSqr < ( self.mRadius**2 ):\n return True;\n else:\n return False;","def check_location(location):\r\n if location.latitude > 35 and location.latitude < 39 and location.longitude > -123 and location.longitude < -120:\r\n return True\r\n else:\r\n return False","def get_uvcircle(Grid):\n \n# center of circulation\n loc=-67.5;lac=41.5; \n dx=(Grid['lonc']-loc)*Grid['coslatc']\n dy=(Grid['latc']-lac)\n di=np.sqrt(dx*dx+dy*dy)\n an=np.angle(dx+1j*dy)\n# velocity is linearly increasing with distance \n# 0.1 m/s at 1 deg distance away from center \n# cyclonic gyre \n u=-0.1*di*np.sin(an)\n v= 0.1*di*np.cos(an)\n# adjust the velocity so that the rotation will be perfect \n# on lon-lat plane\n u=u*Grid['coslatc']/np.cos(lac*np.pi/180) \n \n return u,v","def HasPoint(self, vtkAMRBox, , , p_float_6, p_float_7, p_float_8):\n ...","def test_get_neighborhood_radius_consistent():\r\n grid_spacing = random.uniform(1e-6, 10.0)\r\n center = numpy.random.random(random.randint(1, 3))\r\n\r\n # Find points with radius neighborhood\r\n radius = random.uniform(_distance_to_nearest(grid_spacing, center), grid_spacing*5)\r\n points = ill.get_neighborhood_radius(grid_spacing, center, radius)\r\n\r\n # Every points found within this radius, should be in the points of a larger radius\r\n outer_points = ill.get_neighborhood_radius(grid_spacing, center,\r\n radius+random.uniform(0.0, grid_spacing*5))\r\n\r\n for point in points:\r\n assert point in outer_points","def my_constraint_function(candidate):\r\n # In this case, we'll just say that the point has to lie \r\n # within a circle centered at (0, 0) of radius 1.\r\n if candidate[0]**2 + candidate[1]**2 > 1:\r\n return 1\r\n else:\r\n return 0","def point_in_ellipse(point: Vector, center: Vector, angle: float, length: float, width: float) -> bool:\n c, s = np.cos(angle), np.sin(angle)\n r = np.matrix([[c, -s], [s, c]])\n ru = r.dot(point - center)\n return np.sum(np.square(ru / np.array([length, width]))) < 1","def within_radius(latlong, radius=5.0, ctype_fields=None):\n\n radius = float(radius) # may come through as str\n\n if type(latlong) == GeoEntry:\n latlong = [latlong.latitude, latlong.longitude]\n\n # These are our 4 points (N/S/E/W) We use this to build a bounding box\n HEADINGS = enumerate([0, math.pi/2, math.pi, 3*math.pi/2])\n\n try:\n geoentry = GeoEntry.objects.get(latitude=latlong[0], longitude=latlong[1])\n except GeoEntry.DoesNotExist:\n # Maybe handle more gracefully?\n raise Exception('No GeoEntry matching query')\n except GeoEntry.MultipleObjectsReturned:\n # In this case lets use the first one instead for now\n geoentry = GeoEntry.objects.filter(latitude=latlong[0], longitude=latlong[1])[0]\n\n source_lat = GeoEntry.degrees_to_radians(latlong[0])\n source_long = GeoEntry.degrees_to_radians(latlong[1])\n distance = GeoEntry.miles_to_radians(radius)\n\n boundries = []\n\n for (cnt, heading) in HEADINGS:\n target_lat = GeoEntry.calculate_latitude(source_lat, distance, heading)\n target_long = GeoEntry.calculate_longitude(target_lat, source_long, distance, heading)\n\n boundries.append([GeoEntry.radians_to_degrees(target_lat), \\\n GeoEntry.radians_to_degrees(target_long)])\n\n entries = GeoEntry.objects.all().select_related().filter(latitude__lte=str(boundries[0][0]),\n latitude__gte=str(boundries[2][0]), longitude__gte=str(boundries[1][1]),\n longitude__lte=str(boundries[3][1]))\n\n entry_data = list()\n for entry in entries:\n obj = entry.content_object\n ctype_dict = None,\n if obj and ctype_fields:\n if (len(ctype_fields)==1 and ctype_fields[0]=='all'):\n ctype_list = list()\n for field in obj._meta.fields:\n field_data = getattr(obj, field.name)\n if type(field_data) == unicode:\n ctype_list.append([field.name, field_data.encode('utf-8')])\n else:\n ctype_list.append([field.name, str(field_data)])\n ctype_dict = dict(ctype_list)\n else:\n ctype_dict = dict([[field, getattr(obj, field)] for field in ctype_fields])\n entry_data.append(dict(\n distance=entry.distance_to_latlong((latlong[0], latlong[1])),\n content_type=entry.content_type.pk,\n object_id=entry.object_id,\n object_data=ctype_dict,\n latitude=str(entry.latitude),\n longitude=str(entry.longitude),\n )\n )\n entry_data.sort() # return orderd by distance\n # now fix the bounding box SQL to limit within our radius\n sorted_data = [elem for elem in entry_data if elem['distance']<radius]\n return sorted_data","def hitTest( a, b ):\n r = a.radius + b.radius\n x = abs( a.x - b.x )\n y = abs( a.y - b.y )\n if x <= r and y <= r and x*x + y*y <= r*r:\n return 1\n return 0","def lat_lon_box(lat, dist):\n r_earth = 6371.\n d_2r = dist/(2.*r_earth)\n dlat = 2. * (d_2r)\n dlon = 2. * np.arcsin((np.sin(d_2r))/(np.cos(lat)))\n dlat *= 180./np.pi\n dlon *= 180./np.pi\n return abs(dlat), abs(dlon)","def in_box(point, c1, c2):\n c1x, c1y = c1\n c2x, c2y = c2\n x, y = point\n return min(c1x, c2x) <= x <= max(c1x, c2x) and min(c1y, c2y) <= y <= max(c1y, c2y)","def isinsidearcXY(c,p):\n\n x = c[0]\n r = c[1][0]\n if dist(x,p) > r:\n return False\n if iscircle(c):\n return True\n start = c[1][1]%360.0\n end = c[1][2]%360.0\n if end < start:\n end+= 360.0\n p2 = sub(p,x)\n ang = (atan2(p2[1],p2[0]) % pi2)*360/pi2\n\n if end <= 360.0:\n return (ang >= start and ang <= end)\n else:\n return ang >= start or ang <= (end-360.0)","def has_intersection(self, obj):\r\n obj_x, obj_y = obj.get_location()\r\n x = self.__x\r\n y = self.__y\r\n # Distance formula\r\n distance = sqrt((obj_x - x) ** 2 + (obj_y - y) ** 2)\r\n if distance <= obj.get_radius() + self.__radius:\r\n return True\r\n return False","def is_point_in_box(x, y, bbox):\n if x < 200 and y < 200:\n return True\n return False","def intersects( self, sphere, dim ):\n nearest = self.__findFarestPoint__( sphere.center );\n dist = utility.euclideanDistSqr( nearest, sphere.center );\n if( dist < sphere.radius**2 ):\n return True;\n else:\n return False;","def _generate_boxcar_volume(x, radius, center):\n\n # Form cubic position array for x, y, z\n X_cube = x.copy()\n\n\n # Find all points inside boxcar inside the cube\n vol = np.sqrt((X_cube - center) ** 2 / radius ** 2)\n vol = vol <= 1\n\n return vol.astype(float)","def find_channel_neighbors(geom, radius):\n return (squareform(pdist(geom)) <= radius)","def find_channel_neighbors(geom, radius):\n return (squareform(pdist(geom)) <= radius)","def calcul_v_sphere(r):\n volume = 4/3 * math.pi * (r ** 3)\n return volume","def vincenty(lat1, lon1, lat2, lon2,\n r_major=6378.1370, r_minor=6356.752314, r_sphere=None):\n lat1 = m.radians(lat1)\n lat2 = m.radians(lat2)\n lon1 = m.radians(lon1)\n lon2 = m.radians(lon2)\n \n if (r_sphere is not None):\n r_major = r_sphere\n r_minor = r_sphere\n f = 0.0\n else:\n f = (r_major-r_minor)/r_major\n \n U1 = m.atan((1.0-f) * m.tan(lat1))\n U2 = m.atan((1.0-f) * m.tan(lat2))\n L = lon2 - lon1\n \n epsilon = 1E-12 # Accuracy (10E-12 -> ~ 0.06mm)\n max_iter = 500\n lam = L\n \n cU1 = m.cos(U1)\n cU2 = m.cos(U2)\n sU1 = m.sin(U1)\n sU2 = m.sin(U2)\n \n for i in range(max_iter):\n lam_old = lam\n sLam = m.sin(lam)\n cLam = m.cos(lam)\n sin_sig = m.sqrt((cU2*sLam)**2 + (cU1*sU2 - sU1*cU2*cLam)**2)\n cos_sig = sU1*sU2 + cU1*cU2*cLam\n sig = m.atan2(sin_sig,cos_sig)\n sin_alp = (cU1*cU2*sLam) / sin_sig\n cos2_alp = 1.0 - sin_alp**2\n if (cos2_alp == 0.0):\n # equitorial line\n cos_2sigm = 100\n C = 0.0\n else:\n cos_2sigm = cos_sig - (2.0*sU1*sU2)/cos2_alp\n C = f/16.0 * cos2_alp * (4.0 + f*(4.0-3.0*cos2_alp))\n lam = L + (1.0 - C) * f * sin_alp * \\\n (sig + C * sin_sig * (cos_2sigm + C * cos_sig * \\\n (-1.0 + 2.0 * cos_2sigm**2)))\n if ((m.fabs(lam - lam_old)) <= epsilon):\n # Found a solution in i iters...\n break\n elif (i == max_iter):\n # Catch the out of iters case, never seen this.\n raise Exception(\"Failed to solve for distance\")\n \n usq = cos2_alp * ((r_major**2 - r_minor**2) / r_minor**2)\n A = 1 + usq/16384 * (4096 + usq*(-768 + usq*(320 - 175*usq)))\n B = usq/1024 * (256 + usq*(-128 + usq*(74 - 47*usq)))\n del_sig = B * sin_sig * (cos_2sigm + 0.25*B*(cos_sig*( \\\n -1 + 2*cos_2sigm**2) - (1.0/6.0)*B*cos_2sigm * ( \\\n -3 + 4*sin_sig**2) * (-3 + 4 * cos_2sigm**2)))\n s = r_minor * A * (sig - del_sig)\n alp1 = m.atan2(cU2*m.sin(lam),(cU1*sU2-sU1*cU2*m.cos(lam)))\n alp2 = m.atan2(cU1*m.sin(lam),(cU1*sU2*m.cos(lam)-sU1*cU2))\n\n return (s, m.degrees(alp1), m.degrees(alp2))","def in_box(x, y):\n if self.zoom_box and x <= self.zoom_box_max_x and \\\n x >= self.zoom_box_min_x and y >= self.zoom_box_min_y and \\\n y <= self.zoom_box_max_y:\n return True\n else:\n return False","def inside( self, point ):\n for i in range( 0, len(point) ):\n if math.fabs( self.center[i] - point[i] ) > self.dimLens[i]/2.0:\n return False;\n return True;","def is_in_lon_lat(coords):\n\n bounds = make_bounding_box_array(coords)\n xbounds = np.array([bounds[0], bounds[2]])\n ybounds = np.array([bounds[1], bounds[3]])\n return np.all(xbounds) < 180.0 and np.all(xbounds > -180.0) and \\\n np.all(ybounds) < 90.0 and np.all(ybounds > -90)","def hit(bx, by, r, px, py,h):\n if bx >= px:\n distance = bx - px\n else:\n distance = px - bx\n if py<=by and by<=py+h and distance <= r:\n return True\n else:\n return False","def test_get_kilometers() -> None:\n kilometers = location_util.vincenty(COORDINATES_PARIS, COORDINATES_NEW_YORK)\n assert round(kilometers, 2) == DISTANCE_KM","def dist_vincenty(lat1, lon1, lat2, lon2, iterations=20):\r\n if lat1 < -90 or lat1 > 90 or lat2 < -90 or lat2 > 90 or lon1 < -180 or lon1 > 180 or lon2 < -180 or lon2 > 180:\r\n raise ValueError(\r\n \"Latitude values shoulds range from (-90,90) and longitude from (-180,180) but one of the input values is out of bounds. Latitude_1: %f, Logitude_1: %f, Latitude_2: %f, Logitude_2: %f\" %\r\n (lat1, lon1, lat2, lon2))\r\n\r\n major, minor, f = 6378137, 6356752.314245, 1 / 298.257223563\r\n\r\n lat1, lng1, lat2, lng2 = radians(\r\n lat1), radians(lon1), radians(lat2), radians(lon2)\r\n delta_lng = lng2 - lng1\r\n reduced_lat1, reduced_lat2 = atan(\r\n (1 - f) * tan(lat1)), atan((1 - f) * tan(lat2))\r\n\r\n sin_reduced1, cos_reduced1 = sin(reduced_lat1), cos(reduced_lat1)\r\n sin_reduced2, cos_reduced2 = sin(reduced_lat2), cos(reduced_lat2)\r\n\r\n lambda_lng = delta_lng\r\n lambda_prime = 2 * pi\r\n while abs(lambda_lng - lambda_prime) > 10e-12 and iterations > 0:\r\n sin_lambda_lng, cos_lambda_lng = sin(lambda_lng), cos(lambda_lng)\r\n\r\n sin_sigma = sqrt(\r\n (cos_reduced2 * sin_lambda_lng) ** 2 +\r\n (cos_reduced1 * sin_reduced2 -\r\n sin_reduced1 * cos_reduced2 * cos_lambda_lng) ** 2\r\n )\r\n if sin_sigma == 0:\r\n return 0 # Coincident points\r\n\r\n cos_sigma = (\r\n sin_reduced1 * sin_reduced2 +\r\n cos_reduced1 * cos_reduced2 * cos_lambda_lng\r\n )\r\n sigma = atan2(sin_sigma, cos_sigma)\r\n\r\n sin_alpha = (cos_reduced1 * cos_reduced2 * sin_lambda_lng / sin_sigma)\r\n cos_sq_alpha = 1 - sin_alpha ** 2\r\n\r\n if cos_sq_alpha != 0:\r\n cos2_sigma_m = cos_sigma - 2 * \\\r\n (sin_reduced1 * sin_reduced2 / cos_sq_alpha)\r\n else:\r\n cos2_sigma_m = 0.0 # Equatorial line\r\n\r\n C = f / 16. * cos_sq_alpha * (4 + f * (4 - 3 * cos_sq_alpha))\r\n\r\n lambda_prime = lambda_lng\r\n lambda_lng = (\r\n delta_lng + (1 - C) * f * sin_alpha * (\r\n sigma + C * sin_sigma * (\r\n cos2_sigma_m + C * cos_sigma * (-1 + 2 * cos2_sigma_m ** 2)\r\n )\r\n )\r\n )\r\n iterations -= 1\r\n\r\n if iterations == 0:\r\n raise ValueError(\"Vincenty formula failed to converge!\")\r\n\r\n u_sq = cos_sq_alpha * (major ** 2 - minor ** 2) / minor ** 2\r\n A = 1 + u_sq / 16384. * (4096 + u_sq * (-768 + u_sq * (320 - 175 * u_sq)))\r\n B = u_sq / 1024. * (256 + u_sq * (-128 + u_sq * (74 - 47 * u_sq)))\r\n delta_sigma = B * sin_sigma * (\r\n cos2_sigma_m + B / 4. * (cos_sigma * (-1 + 2 * cos2_sigma_m ** 2) -\r\n B / 6. * cos2_sigma_m * (-3 + 4 * sin_sigma ** 2) *\r\n (-3 + 4 * cos2_sigma_m ** 2))\r\n )\r\n s = minor * A * (sigma - delta_sigma)\r\n\r\n return round(s, 3) # round to 1mm precision\r","def is_inside(self, x: int, y: int) -> bool:\n pass","def is_point_within(self, x, y):\n return abs(x - self._x_position) <= self._x_length / 2 and abs(y - self._y_position) <= self._y_length / 2","def in_woolsey_fire_area(lat, long):\n min_lat = 33.856\n max_lat = 34.211\n min_long = -118.7114\n max_long = -118.2511\n\n return in_area_of_interest(lat, long, min_lat, max_lat, min_long, max_long)"],"string":"[\n \"def is_matching_product_with_tags(product, lat, lng, radius, tags):\\n return vincenty(\\n (lat, lng),\\n (product.shop.lat, product.shop.lng)\\n ).meters <= radius and any(tag in product.shop.tags for tag in tags)\",\n \"def __contains__(self, position):\\n return sum([(c1 - c2) ** 2 for (c1, c2) in zip(self.position, position)]) <= self.radius\",\n \"def point_inside_circle(x,y,center_x,center_y,radius):\\n return (x-center_x)**2 + (y - center_y)**2 < radius**2\",\n \"def __contains__(self, other):\\n x, y = other\\n return self.radius >= sqrt((x - self.x) ** 2 + (y - self.y) ** 2)\",\n \"def contains(self, position):\\n return np.linalg.norm(position - self._center) < self._radius\",\n \"def inside_unit_circle(point):\\n distance = math.sqrt(point[0] ** 2 + point[1] ** 2)\\n return distance < 1\",\n \"def isInCircle(self,x1,y1,radius1):\\r\\n if(distance(self.x,x1,self.y,y1) < (self.radius+radius1)):\\r\\n return True\\r\\n return False\",\n \"def objects_radius(self, centre, radius):\",\n \"def checkBounds(x,y,z,center,radius):\\n r2 = (x-center[0])**2 + (y-center[1])**2# + (z-center[0])**2\\n if r2 < radius**2:\\n return True\\n else:\\n return False\",\n \"def contains(self, loc): \\n return loc.distance(self.center) <= self.radius\",\n \"def isInside(x1, y1, x2, y2, x3, y3, x, y):\\n # Calculate area of triangle ABC\\n A = area (x1, y1, x2, y2, x3, y3)\\n \\n # Calculate area of triangle PBC\\n A1 = area (x, y, x2, y2, x3, y3)\\n \\n # Calculate area of triangle PAC\\n A2 = area (x1, y1, x, y, x3, y3)\\n \\n # Calculate area of triangle PAB\\n A3 = area (x1, y1, x2, y2, x, y)\\n \\n # Check if sum of A1, A2 and A3\\n # is same as A\\n if(A == A1 + A2 + A3):\\n return True\\n else:\\n return False\",\n \"def is_point_inside_hypersphere(point: np.array, c: List[float], r: float) -> bool:\\n return np.linalg.norm(point - c) < r\",\n \"def inside(x, y, primitive):\\n\\n # You should implement your inside test here for all shapes\\n # for now, it only returns a false test\\n\\n if primitive[\\\"shape\\\"] == \\\"circle\\\":\\n dist_sqr = ((primitive[\\\"center\\\"][0] - x) ** 2 +\\n (primitive[\\\"center\\\"][1] - y) ** 2)\\n\\n return dist_sqr <= primitive[\\\"radius\\\"] ** 2\\n else:\\n return winding_number(x, y, primitive)\\n\\n return False\",\n \"def test_get_radius():\\n center = Coordinates(7, 3)\\n radius = 12\\n\\n returned_rad = get_radius(center, radius, 30)\\n\\n assert returned_rad == radius\\n assert returned_rad != center.get_x()\\n assert returned_rad != center.get_y()\",\n \"def sphere_isclose(c1, c2, *args, **kwargs):\\n return np.isclose(c1.radius, c2.radius, *args, **kwargs) and np.allclose(\\n c1.center, c2.center, *args, **kwargs\\n )\",\n \"def containsPos(self, obst_pos, aerial_pos):\\n dist_to_center = obst_pos.distanceTo(aerial_pos)\\n return dist_to_center <= self.sphere_radius\",\n \"def check_point_in_detector(p, radius=radius, height=height, distance=distance):\\r\\n if p[0]**2 + p[1]**2 <= radius**2: # Are the x and y coordinates in the circle?\\r\\n if (p[2] >= distance) and (p[2] <= height+distance): # Is the z coordinate between the distance and the height?\\r\\n return True\\r\\n else:\\r\\n return False\\r\\n else:\\r\\n return False\",\n \"def isinsidepointXY(x,p):\\n \\n return dist(x,p) < epsilon\",\n \"def are_close(coord1, coord2, tolerance=10):\\n return vincenty(coord1, coord2).meters < tolerance\",\n \"def incircle(self,xpos,ypos,cellx,celly):\\n xcell, ycell = self.getcellcenter(cellx,celly)\\n if ((xpos - xcell)**2 + (ypos - ycell)**2) < self.crad2:\\n return True\\n return False\\n\\n return cellx, celly\",\n \"def WhereAreYou(CurLongitude,CurLatitude,LocationLongitude,LocationLatitude,LocationRadius):\\n # Calculate the great circle distance between two points\\n # on the earth (specified in decimal degrees)\\n # 将十进制度数转化为弧度\\n CurLongitude,CurLatitude,LocationLongitude,LocationLatitude = map(radians, [float(CurLongitude),float(CurLatitude),float(LocationLongitude),float(LocationLatitude)])\\n\\n # haversine公式\\n dlon = LocationLongitude - CurLongitude\\n dlat = LocationLatitude - CurLatitude\\n a = sin(dlat / 2) ** 2 + cos(CurLatitude) * cos(LocationLatitude) * sin(dlon / 2) ** 2\\n c = 2 * asin(sqrt(a))\\n r = 6371 # 地球平均半径，单位为公里\\n distance = c * r * 1000\\n if(distance < float(LocationRadius)):\\n return True\\n else:\\n return False\",\n \"def __contains__(self, point): \\n corners = self.corners\\n\\n if isinstance(point, tuple):\\n from pyresample.spherical_geometry import Coordinate\\n retval = planar_point_inside(Coordinate(*point), corners)\\n else:\\n retval = planar_point_inside(point, corners)\\n\\n #print ' retval from FALSE CORNERS contains '+str(retval)\\n\\n return retval\",\n \"def get_radius(self):\",\n \"def within_radius(self, radius=5.0):\\n\\n return GeoEntry.within_radius(self.primary_geocode, radius, ['all',])\",\n \"def in_circle(x0, y0, x, y, r):\\n return ((x - x0) ** 2 + (y - y0) ** 2) <= (r ** 2)\",\n \"def is_point_inside_hypermoon(point: np.array, c: Tuple[List[float]], r: Tuple[float]) -> bool:\\n return is_point_inside_hypersphere(point, c[0], r[0]) and not is_point_inside_hypersphere(point, c[1], r[1])\",\n \"def vincenty(p1, p2):\\n # Note: GeoPy expects (latitude, longitude) pairs.\\n return geopy.distance.vincenty(\\n (p1.y, p1.x),\\n (p2.y, p2.x)\\n ).miles\",\n \"def check_coordinates(X, Y):\\n\\n # Accounting for elliptical Jupiter disk\\n Y *= 1.071374\\n\\n return sqrt(X ** 2 + Y ** 2)\",\n \"def is_clicked(vtx_x, vtx_y, mouse_x, mouse_y, radius):\\n return math.sqrt(((mouse_x - vtx_x) ** 2) + ((mouse_y - vtx_y) ** 2)) < radius\",\n \"def is_point_inside_hypercube(point: List[float], c: List[float], r: float) -> bool:\\n diff = np.subtract(point, c)\\n return np.all(np.absolute(diff) <= r)\",\n \"def dans_cercle(self, r, x, y):\\r\\n self.r_num(r)\\r\\n valid = (isinstance(x, int) or isinstance(x, float)) and \\\\\\r\\n (isinstance(y, int) or isinstance(y, float))\\r\\n if valid:\\r\\n if sqrt(x**2+y**2)<self.r:\\r\\n return True\\r\\n else:\\r\\n return False\\r\\n else:\\r\\n raise TypeError\",\n \"def containsPos(self, aerial_pos):\\n # Check altitude of position\\n aerial_alt = aerial_pos.altitude_msl\\n if (aerial_alt < 0 or aerial_alt > self.cylinder_height):\\n return False\\n # Check lat/lon of position\\n dist_to_center = self.gps_position.distanceTo(aerial_pos.gps_position)\\n if dist_to_center > self.cylinder_radius:\\n return False\\n # Both within altitude and radius bounds, inside cylinder\\n return True\",\n \"def check_in(x, y, R=Re):\\n r = np.sqrt(x ** 2 + y ** 2)\\n return r <= R\",\n \"def at_loc((x, y), (cx, cy), eps=0.000035):\\n\\treturn (x - cx)**2 + (y - cy)**2 <= eps**2\",\n \"def conf_test(self, trial_coords: np.ndarray) -> bool:\\n #N = len(trial_coords)\\n r2: float = 0\\n i =0\\n r2 = np.inner(trial_coords, trial_coords)\\n if (r2> self.m_radius2):\\n return False\\n return True\",\n \"def is_inside(self, mX, mY, point):\\n return (math.sqrt((point[0] - mX) * (point[0] - mX)\\n + (point[1] - mY) * (point[1] - mY)) <= 2)\",\n \"def area_of_circle(radius):\\n return radius\",\n \"def main():\\n pos_x1 = float(input())\\n pos_y1 = float(input())\\n rad_1 = float(input())\\n pos_x2 = float(input())\\n pos_y2 = float(input())\\n rad_2 = float(input())\\n\\n if ((pos_x1 - pos_x2) ** 2 + (pos_y1 - pos_y2) ** 2) ** 0.5 < rad_1 + rad_2:\\n print(\\\"Yes\\\")\\n else:\\n print(\\\"No\\\")\",\n \"def __contains__(self, point):\\n #### Original \\n from pyresample.spherical_geometry import point_inside, Coordinate\\n corners = self.corners\\n\\n if isinstance(point, tuple):\\n return point_inside(Coordinate(*point), corners)\\n else:\\n return point_inside(point, corners)\\n #### End Original\\n #from .spherical import SphPolygon\\n #log.info('RUNNING SPHERICAL in __contains__')\\n #sphpoly = SphPolygon(corners)\\n #return sphpoly.intersection(SphPolygon(point), sphpoly)\",\n \"def isInternal(self, aPoint):\\n if compute_distance(self.center, aPoint) <= self.radius:\\n return True\\n else:\\n return False\",\n \"def within(self, right: GeoSpatialValue) -> ir.BooleanValue:\\n return ops.GeoWithin(self, right).to_expr()\",\n \"def shops_within_radius(self, lat, lng, radius, tags=None):\\n center_point = geoindex.GeoPoint(lat, lng)\\n points = self.geoindex.get_nearest_points(center_point, radius, 'km')\\n\\n def tags_filter(shops):\\n for shop in shops:\\n for tag in tags:\\n if tag in shop['tags']:\\n yield shop\\n break\\n\\n def get_shops():\\n for point, distance in points:\\n point.ref['distance'] = distance\\n yield point.ref\\n\\n if tags:\\n return tags_filter(get_shops())\\n else:\\n return get_shops()\",\n \"def isKelvin(self):\\n return _libsbml.Unit_isKelvin(self)\",\n \"def isoutside(coords, shape):\\n # Label external pores for trimming below\\n if len(shape) == 1: # Spherical\\n # Find external points\\n r = np.sqrt(np.sum(coords**2, axis=1))\\n Ps = r > shape[0]\\n elif len(shape) == 2: # Cylindrical\\n # Find external pores outside radius\\n r = np.sqrt(np.sum(coords[:, [0, 1]]**2, axis=1))\\n Ps = r > shape[0]\\n # Find external pores above and below cylinder\\n if shape[1] > 0:\\n Ps = Ps + (coords[:, 2] > shape[1])\\n Ps = Ps + (coords[:, 2] < 0)\\n else:\\n pass\\n elif len(shape) == 3: # Rectilinear\\n shape = np.array(shape, dtype=float)\\n try:\\n lo_lim = shape[:, 0]\\n hi_lim = shape[:, 1]\\n except IndexError:\\n lo_lim = np.array([0, 0, 0])\\n hi_lim = shape\\n Ps1 = np.any(coords > hi_lim, axis=1)\\n Ps2 = np.any(coords < lo_lim, axis=1)\\n Ps = Ps1 + Ps2\\n return Ps\",\n \"def FindPointsWithinRadius(self, p_float, , vtkIdList):\\n ...\",\n \"def in_area_of_interest (lat, long, min_lat, max_lat, min_long, max_long):\\n\\n if lat is None or long is None:\\n return False\\n\\n lat = float(lat)\\n long = float(long)\\n\\n if ((lat >= min_lat and lat <= max_lat) and\\n (long >= min_long and long <= max_long)):\\n return True\\n\\n return False\",\n \"def is_inside(self, p):\\n s, t = self.get_barycentric_coord(p)\\n if 0 <= s <= 1 and 0 <= t <= 1 and s + t <= 1:\\n return True\\n else:\\n return False\",\n \"def in_square(self, point):\\n size = self.size\\n centre = self.centre\\n # Find the upper and lower bounds for the square in-terms of x and y\\n lower_x, upper_x = centre.x - size / 2, centre.x + size / 2\\n lower_y, upper_y = centre.y - size / 2, centre.y + size / 2\\n # Equals with lower bounds only\\n return (lower_x <= point.x < upper_x) and (lower_y < point.y <= upper_y)\",\n \"def pointPotential(x,y,q,posx,posy):\\n k = 8.99e9\\n V = (k * q) / (sqrt(x**2 + (y - sqrt((posx**2 + posy**2)))**2))\\n return V\",\n \"def test_circumference_area(self):\\n self.assertEqual(9.425, circumference_area(self.values['radius']))\",\n \"def sphere_area(radius : number) -> number:\\n area = 4*pi*radius*radius\\n return area\",\n \"def is_inside(self, points):\\n points = np.atleast_2d(points) - self.centroid\\n return np.logical_and(\\n np.linalg.norm(points, axis=-1) <= self.radius,\\n # At present circles are not orientable, so the z position must\\n # match exactly.\\n np.isclose(points[:, 2], 0),\\n )\",\n \"def brute_force(savedPnts, unitRadius, point):\\n for pnt in savedPnts:\\n d = distance(pnt, point)\\n if d < unitRadius: return False\\n return True\",\n \"def __ge__(self, other):\\n return self.x ** 2 + self.y ** 2 >= other.x ** 2 + other.y ** 2\",\n \"def contains_pt(self, pt):\\n x, y = pt\\n if not self.x - self.radius < x < self.x + self.radius:\\n return False\\n if not self.y - self.radius < y < self.y + self.radius:\\n return False\\n return True\",\n \"def _intersected(positions, radius):\\n P1 = positions[0]\\n P2 = positions[1]\\n P3 = positions[2]\\n temp1 = P2 - P1\\n e_x = temp1 / np.linalg.norm(temp1)\\n temp2 = P3 - P1\\n i = np.dot(e_x, temp2)\\n temp3 = temp2 - i * e_x\\n e_y = temp3 / np.linalg.norm(temp3)\\n e_z = np.cross(e_x, e_y)\\n d = np.linalg.norm(P2 - P1)\\n j = np.dot(e_y, temp2) \\n x = d / 2\\n y = (-2*i*x + i*i + j*j) / (2*j)\\n temp4 = radius**2 - x*x - y*y\\n if temp4 < 0:\\n return False\\n return True\",\n \"def is_perfect_square():\",\n \"def check_me(triplet, list_of_coords):\\n c = True\\n for element in list_of_coords:\\n if (float(triplet[0])*0.99 <= float(element[0]) <= float(triplet[0])*1.01):\\n if (float(triplet[1])*0.99 <= float(element[1]) <= float(triplet[1])*1.01):\\n if (float(triplet[2])*0.99 <= float(element[2]) <= float(triplet[2])*1.01):\\n c = False\\n return c\",\n \"def is_inside(inner_path, outer_path):\\r\\n if not hasattr(inner_path, 'bounding_box'):\\r\\n inner_path.bounding_box = CutPlanner.bounding_box(inner_path)\\r\\n if not hasattr(outer_path, 'bounding_box'):\\r\\n outer_path.bounding_box = CutPlanner.bounding_box(outer_path)\\r\\n if outer_path.bounding_box[0] > inner_path.bounding_box[0]:\\r\\n # outer minx > inner minx (is not contained)\\r\\n return False\\r\\n if outer_path.bounding_box[1] > inner_path.bounding_box[1]:\\r\\n # outer miny > inner miny (is not contained)\\r\\n return False\\r\\n if outer_path.bounding_box[2] < inner_path.bounding_box[2]:\\r\\n # outer maxx < inner maxx (is not contained)\\r\\n return False\\r\\n if outer_path.bounding_box[3] < inner_path.bounding_box[3]:\\r\\n # outer maxy < inner maxy (is not contained)\\r\\n return False\\r\\n if outer_path.bounding_box == inner_path.bounding_box:\\r\\n if outer_path == inner_path: # This is the same object.\\r\\n return False\\r\\n if not hasattr(outer_path, 'vm'):\\r\\n outer_path = Polygon([outer_path.point(i / 100.0, error=1e4) for i in range(101)])\\r\\n vm = VectorMontonizer()\\r\\n vm.add_cluster(outer_path)\\r\\n outer_path.vm = vm\\r\\n for i in range(101):\\r\\n p = inner_path.point(i / 100.0, error=1e4)\\r\\n if not outer_path.vm.is_point_inside(p.x, p.y):\\r\\n return False\\r\\n return True\",\n \"def parallel_radius(self, lat):\\n\\n return EARTH_RADIUS * lat.cos()\",\n \"def get_radius(self):\\r\\n return 1\",\n \"def inCircleFast(self, tri, p):\\n center, radius = self.circles[tri]\\n return np.sum(np.square(center - p)) <= radius\",\n \"def sphereArea(radius):\\n area = 4 * math.pi * radius ** 2\\n return area\",\n \"def vincenty(lon0, lat0, a1, s):\\n\\n lon0 = np.deg2rad(lon0)\\n lat0 = np.deg2rad(lat0)\\n a1 = np.deg2rad(a1)\\n s = np.deg2rad(s)\\n\\n sina = np.cos(lat0) * np.sin(a1)\\n\\n num1 = np.sin(lat0) * np.cos(s) + np.cos(lat0) * np.sin(s) * np.cos(a1)\\n den1 = np.sqrt(\\n sina**2 + (np.sin(lat0) * np.sin(s) - np.cos(lat0) * np.cos(a1)) ** 2\\n )\\n lat = np.rad2deg(np.arctan2(num1, den1))\\n\\n num2 = np.sin(s) * np.sin(a1)\\n den2 = np.cos(lat0) * np.cos(s) - np.sin(lat0) * np.sin(s) * np.cos(a1)\\n L = np.arctan2(num2, den2)\\n lon = np.rad2deg(lon0 + L)\\n\\n return lon, lat\",\n \"def great_circle(a: Point, b: Point) -> Km:\\n\\n lat1, lng1, lat2, lng2 = map(radians, [a.latitude, a.longitude, b.latitude, b.longitude])\\n sin_lat1, sin_lat2 = map(sin, [lat1, lat2])\\n cos_lat1, cos_lat2 = map(cos, [lat1, lat2])\\n delta_lng = lng2 - lng1\\n cos_delta_lng, sin_delta_lng = cos(delta_lng), sin(delta_lng)\\n\\n d = atan2(\\n sqrt((cos_lat2 * sin_delta_lng) ** 2 + (cos_lat1 * sin_lat2 - sin_lat1 * cos_lat2 * cos_delta_lng) ** 2),\\n sin_lat1 * sin_lat2 + cos_lat1 * cos_lat2 * cos_delta_lng,\\n )\\n\\n return Km(6371.009 * d) # Radius of earth in kilometers is 6371\",\n \"def circles_collide(x1: float, y1: float, r1: float, x2: float, y2: float, r2: float) -> bool:\\n return distance_between_sq(x1, y1, x2, y2) <= (r1 + r2)**2\",\n \"def Distance(VCoords, SCoords):\\r\\n #Convert to radians\\r\\n lat1,lon1,lat2,lon2 = map(math.radians, VCoords+SCoords)\\r\\n #Apply Haversine formula\\r\\n dlon = lon2-lon1\\r\\n dlat = lat2-lat1\\r\\n a = math.sin(dlat/2)**2 + math.cos(lat1) * math.cos(lat2) * math.sin(dlon/2)**2\\r\\n c = 2 * math.asin(math.sqrt(a))\\r\\n #Earth radius = 6371km\\r\\n return 6371 * c\",\n \"def validate_pos(game: TowerDefenceSolver, position: Tuple[int, int], purchases_list: Purchases) -> bool:\\n if (\\n position[0] < 0\\n or position[1] < 0\\n or position[0] >= game.map_height\\n or position[1] >= game.map_width\\n or position in game.path\\n ):\\n return False\\n\\n for purchase in purchases_list:\\n if purchase[\\\"coords\\\"] == position:\\n return False\\n\\n return True\",\n \"def _greatCircleDistance(self, long1, lat1, long2, lat2):\\n # convert decimal degrees to radians \\n long1, lat1, long2, lat2 = map(radians, [float(long1), float(lat1), float(long2), float(lat2)])\\n # haversine formula \\n dlon = long2 - long1\\n #print(long2)\\n #print(long1) \\n dlat = lat2 - lat1 \\n a = sin(dlat/2)**2 + cos(lat1) * cos(lat2) * sin(dlon/2)**2\\n c = 2 * asin(sqrt(a)) \\n r = 6371 # Radius of earth in kilometers. Use 3956 for miles\\n #print(c*r)\\n return c * r\",\n \"def test_update_radius():\\n center = Coordinates(1, 1)\\n rad1 = 20.3\\n speed = 30\\n\\n i = Intersection(center, rad1, speed)\\n\\n assert i.get_radius() == 20.3\\n\\n i.update_radius(56.5)\\n\\n assert i.get_radius() == 56.5\",\n \"def test_get_center():\\n center = Coordinates(7, 3)\\n radius = 12\\n\\n returned_center = get_center(center, radius, 25)\\n\\n assert returned_center.get_x() == center.get_x()\\n assert returned_center.get_y() == center.get_y()\",\n \"def isInside(self, position, maxDimLens):\\n dim = len(position);\\n deltas = [0] * dim;\\n distSqr = 0;\\n for i in range(0, dim):\\n deltas[i] = math.fabs(position[i] - self.mSample[i]);\\n if math.fabs(maxDimLens[i] - deltas[i]) < deltas[i]:\\n deltas[i] = math.fabs(maxDimLens[i] - deltas[i]);\\n distSqr += deltas[i]**2;\\n\\n if distSqr < ( self.mRadius**2 ):\\n return True;\\n else:\\n return False;\",\n \"def check_location(location):\\r\\n if location.latitude > 35 and location.latitude < 39 and location.longitude > -123 and location.longitude < -120:\\r\\n return True\\r\\n else:\\r\\n return False\",\n \"def get_uvcircle(Grid):\\n \\n# center of circulation\\n loc=-67.5;lac=41.5; \\n dx=(Grid['lonc']-loc)*Grid['coslatc']\\n dy=(Grid['latc']-lac)\\n di=np.sqrt(dx*dx+dy*dy)\\n an=np.angle(dx+1j*dy)\\n# velocity is linearly increasing with distance \\n# 0.1 m/s at 1 deg distance away from center \\n# cyclonic gyre \\n u=-0.1*di*np.sin(an)\\n v= 0.1*di*np.cos(an)\\n# adjust the velocity so that the rotation will be perfect \\n# on lon-lat plane\\n u=u*Grid['coslatc']/np.cos(lac*np.pi/180) \\n \\n return u,v\",\n \"def HasPoint(self, vtkAMRBox, , , p_float_6, p_float_7, p_float_8):\\n ...\",\n \"def test_get_neighborhood_radius_consistent():\\r\\n grid_spacing = random.uniform(1e-6, 10.0)\\r\\n center = numpy.random.random(random.randint(1, 3))\\r\\n\\r\\n # Find points with radius neighborhood\\r\\n radius = random.uniform(_distance_to_nearest(grid_spacing, center), grid_spacing*5)\\r\\n points = ill.get_neighborhood_radius(grid_spacing, center, radius)\\r\\n\\r\\n # Every points found within this radius, should be in the points of a larger radius\\r\\n outer_points = ill.get_neighborhood_radius(grid_spacing, center,\\r\\n radius+random.uniform(0.0, grid_spacing*5))\\r\\n\\r\\n for point in points:\\r\\n assert point in outer_points\",\n \"def my_constraint_function(candidate):\\r\\n # In this case, we'll just say that the point has to lie \\r\\n # within a circle centered at (0, 0) of radius 1.\\r\\n if candidate[0]**2 + candidate[1]**2 > 1:\\r\\n return 1\\r\\n else:\\r\\n return 0\",\n \"def point_in_ellipse(point: Vector, center: Vector, angle: float, length: float, width: float) -> bool:\\n c, s = np.cos(angle), np.sin(angle)\\n r = np.matrix([[c, -s], [s, c]])\\n ru = r.dot(point - center)\\n return np.sum(np.square(ru / np.array([length, width]))) < 1\",\n \"def within_radius(latlong, radius=5.0, ctype_fields=None):\\n\\n radius = float(radius) # may come through as str\\n\\n if type(latlong) == GeoEntry:\\n latlong = [latlong.latitude, latlong.longitude]\\n\\n # These are our 4 points (N/S/E/W) We use this to build a bounding box\\n HEADINGS = enumerate([0, math.pi/2, math.pi, 3*math.pi/2])\\n\\n try:\\n geoentry = GeoEntry.objects.get(latitude=latlong[0], longitude=latlong[1])\\n except GeoEntry.DoesNotExist:\\n # Maybe handle more gracefully?\\n raise Exception('No GeoEntry matching query')\\n except GeoEntry.MultipleObjectsReturned:\\n # In this case lets use the first one instead for now\\n geoentry = GeoEntry.objects.filter(latitude=latlong[0], longitude=latlong[1])[0]\\n\\n source_lat = GeoEntry.degrees_to_radians(latlong[0])\\n source_long = GeoEntry.degrees_to_radians(latlong[1])\\n distance = GeoEntry.miles_to_radians(radius)\\n\\n boundries = []\\n\\n for (cnt, heading) in HEADINGS:\\n target_lat = GeoEntry.calculate_latitude(source_lat, distance, heading)\\n target_long = GeoEntry.calculate_longitude(target_lat, source_long, distance, heading)\\n\\n boundries.append([GeoEntry.radians_to_degrees(target_lat), \\\\\\n GeoEntry.radians_to_degrees(target_long)])\\n\\n entries = GeoEntry.objects.all().select_related().filter(latitude__lte=str(boundries[0][0]),\\n latitude__gte=str(boundries[2][0]), longitude__gte=str(boundries[1][1]),\\n longitude__lte=str(boundries[3][1]))\\n\\n entry_data = list()\\n for entry in entries:\\n obj = entry.content_object\\n ctype_dict = None,\\n if obj and ctype_fields:\\n if (len(ctype_fields)==1 and ctype_fields[0]=='all'):\\n ctype_list = list()\\n for field in obj._meta.fields:\\n field_data = getattr(obj, field.name)\\n if type(field_data) == unicode:\\n ctype_list.append([field.name, field_data.encode('utf-8')])\\n else:\\n ctype_list.append([field.name, str(field_data)])\\n ctype_dict = dict(ctype_list)\\n else:\\n ctype_dict = dict([[field, getattr(obj, field)] for field in ctype_fields])\\n entry_data.append(dict(\\n distance=entry.distance_to_latlong((latlong[0], latlong[1])),\\n content_type=entry.content_type.pk,\\n object_id=entry.object_id,\\n object_data=ctype_dict,\\n latitude=str(entry.latitude),\\n longitude=str(entry.longitude),\\n )\\n )\\n entry_data.sort() # return orderd by distance\\n # now fix the bounding box SQL to limit within our radius\\n sorted_data = [elem for elem in entry_data if elem['distance']<radius]\\n return sorted_data\",\n \"def hitTest( a, b ):\\n r = a.radius + b.radius\\n x = abs( a.x - b.x )\\n y = abs( a.y - b.y )\\n if x <= r and y <= r and x*x + y*y <= r*r:\\n return 1\\n return 0\",\n \"def lat_lon_box(lat, dist):\\n r_earth = 6371.\\n d_2r = dist/(2.*r_earth)\\n dlat = 2. * (d_2r)\\n dlon = 2. * np.arcsin((np.sin(d_2r))/(np.cos(lat)))\\n dlat *= 180./np.pi\\n dlon *= 180./np.pi\\n return abs(dlat), abs(dlon)\",\n \"def in_box(point, c1, c2):\\n c1x, c1y = c1\\n c2x, c2y = c2\\n x, y = point\\n return min(c1x, c2x) <= x <= max(c1x, c2x) and min(c1y, c2y) <= y <= max(c1y, c2y)\",\n \"def isinsidearcXY(c,p):\\n\\n x = c[0]\\n r = c[1][0]\\n if dist(x,p) > r:\\n return False\\n if iscircle(c):\\n return True\\n start = c[1][1]%360.0\\n end = c[1][2]%360.0\\n if end < start:\\n end+= 360.0\\n p2 = sub(p,x)\\n ang = (atan2(p2[1],p2[0]) % pi2)*360/pi2\\n\\n if end <= 360.0:\\n return (ang >= start and ang <= end)\\n else:\\n return ang >= start or ang <= (end-360.0)\",\n \"def has_intersection(self, obj):\\r\\n obj_x, obj_y = obj.get_location()\\r\\n x = self.__x\\r\\n y = self.__y\\r\\n # Distance formula\\r\\n distance = sqrt((obj_x - x) ** 2 + (obj_y - y) ** 2)\\r\\n if distance <= obj.get_radius() + self.__radius:\\r\\n return True\\r\\n return False\",\n \"def is_point_in_box(x, y, bbox):\\n if x < 200 and y < 200:\\n return True\\n return False\",\n \"def intersects( self, sphere, dim ):\\n nearest = self.__findFarestPoint__( sphere.center );\\n dist = utility.euclideanDistSqr( nearest, sphere.center );\\n if( dist < sphere.radius**2 ):\\n return True;\\n else:\\n return False;\",\n \"def _generate_boxcar_volume(x, radius, center):\\n\\n # Form cubic position array for x, y, z\\n X_cube = x.copy()\\n\\n\\n # Find all points inside boxcar inside the cube\\n vol = np.sqrt((X_cube - center) ** 2 / radius ** 2)\\n vol = vol <= 1\\n\\n return vol.astype(float)\",\n \"def find_channel_neighbors(geom, radius):\\n return (squareform(pdist(geom)) <= radius)\",\n \"def find_channel_neighbors(geom, radius):\\n return (squareform(pdist(geom)) <= radius)\",\n \"def calcul_v_sphere(r):\\n volume = 4/3 * math.pi * (r ** 3)\\n return volume\",\n \"def vincenty(lat1, lon1, lat2, lon2,\\n r_major=6378.1370, r_minor=6356.752314, r_sphere=None):\\n lat1 = m.radians(lat1)\\n lat2 = m.radians(lat2)\\n lon1 = m.radians(lon1)\\n lon2 = m.radians(lon2)\\n \\n if (r_sphere is not None):\\n r_major = r_sphere\\n r_minor = r_sphere\\n f = 0.0\\n else:\\n f = (r_major-r_minor)/r_major\\n \\n U1 = m.atan((1.0-f) * m.tan(lat1))\\n U2 = m.atan((1.0-f) * m.tan(lat2))\\n L = lon2 - lon1\\n \\n epsilon = 1E-12 # Accuracy (10E-12 -> ~ 0.06mm)\\n max_iter = 500\\n lam = L\\n \\n cU1 = m.cos(U1)\\n cU2 = m.cos(U2)\\n sU1 = m.sin(U1)\\n sU2 = m.sin(U2)\\n \\n for i in range(max_iter):\\n lam_old = lam\\n sLam = m.sin(lam)\\n cLam = m.cos(lam)\\n sin_sig = m.sqrt((cU2*sLam)**2 + (cU1*sU2 - sU1*cU2*cLam)**2)\\n cos_sig = sU1*sU2 + cU1*cU2*cLam\\n sig = m.atan2(sin_sig,cos_sig)\\n sin_alp = (cU1*cU2*sLam) / sin_sig\\n cos2_alp = 1.0 - sin_alp**2\\n if (cos2_alp == 0.0):\\n # equitorial line\\n cos_2sigm = 100\\n C = 0.0\\n else:\\n cos_2sigm = cos_sig - (2.0*sU1*sU2)/cos2_alp\\n C = f/16.0 * cos2_alp * (4.0 + f*(4.0-3.0*cos2_alp))\\n lam = L + (1.0 - C) * f * sin_alp * \\\\\\n (sig + C * sin_sig * (cos_2sigm + C * cos_sig * \\\\\\n (-1.0 + 2.0 * cos_2sigm**2)))\\n if ((m.fabs(lam - lam_old)) <= epsilon):\\n # Found a solution in i iters...\\n break\\n elif (i == max_iter):\\n # Catch the out of iters case, never seen this.\\n raise Exception(\\\"Failed to solve for distance\\\")\\n \\n usq = cos2_alp * ((r_major**2 - r_minor**2) / r_minor**2)\\n A = 1 + usq/16384 * (4096 + usq*(-768 + usq*(320 - 175*usq)))\\n B = usq/1024 * (256 + usq*(-128 + usq*(74 - 47*usq)))\\n del_sig = B * sin_sig * (cos_2sigm + 0.25*B*(cos_sig*( \\\\\\n -1 + 2*cos_2sigm**2) - (1.0/6.0)*B*cos_2sigm * ( \\\\\\n -3 + 4*sin_sig**2) * (-3 + 4 * cos_2sigm**2)))\\n s = r_minor * A * (sig - del_sig)\\n alp1 = m.atan2(cU2*m.sin(lam),(cU1*sU2-sU1*cU2*m.cos(lam)))\\n alp2 = m.atan2(cU1*m.sin(lam),(cU1*sU2*m.cos(lam)-sU1*cU2))\\n\\n return (s, m.degrees(alp1), m.degrees(alp2))\",\n \"def in_box(x, y):\\n if self.zoom_box and x <= self.zoom_box_max_x and \\\\\\n x >= self.zoom_box_min_x and y >= self.zoom_box_min_y and \\\\\\n y <= self.zoom_box_max_y:\\n return True\\n else:\\n return False\",\n \"def inside( self, point ):\\n for i in range( 0, len(point) ):\\n if math.fabs( self.center[i] - point[i] ) > self.dimLens[i]/2.0:\\n return False;\\n return True;\",\n \"def is_in_lon_lat(coords):\\n\\n bounds = make_bounding_box_array(coords)\\n xbounds = np.array([bounds[0], bounds[2]])\\n ybounds = np.array([bounds[1], bounds[3]])\\n return np.all(xbounds) < 180.0 and np.all(xbounds > -180.0) and \\\\\\n np.all(ybounds) < 90.0 and np.all(ybounds > -90)\",\n \"def hit(bx, by, r, px, py,h):\\n if bx >= px:\\n distance = bx - px\\n else:\\n distance = px - bx\\n if py<=by and by<=py+h and distance <= r:\\n return True\\n else:\\n return False\",\n \"def test_get_kilometers() -> None:\\n kilometers = location_util.vincenty(COORDINATES_PARIS, COORDINATES_NEW_YORK)\\n assert round(kilometers, 2) == DISTANCE_KM\",\n \"def dist_vincenty(lat1, lon1, lat2, lon2, iterations=20):\\r\\n if lat1 < -90 or lat1 > 90 or lat2 < -90 or lat2 > 90 or lon1 < -180 or lon1 > 180 or lon2 < -180 or lon2 > 180:\\r\\n raise ValueError(\\r\\n \\\"Latitude values shoulds range from (-90,90) and longitude from (-180,180) but one of the input values is out of bounds. Latitude_1: %f, Logitude_1: %f, Latitude_2: %f, Logitude_2: %f\\\" %\\r\\n (lat1, lon1, lat2, lon2))\\r\\n\\r\\n major, minor, f = 6378137, 6356752.314245, 1 / 298.257223563\\r\\n\\r\\n lat1, lng1, lat2, lng2 = radians(\\r\\n lat1), radians(lon1), radians(lat2), radians(lon2)\\r\\n delta_lng = lng2 - lng1\\r\\n reduced_lat1, reduced_lat2 = atan(\\r\\n (1 - f) * tan(lat1)), atan((1 - f) * tan(lat2))\\r\\n\\r\\n sin_reduced1, cos_reduced1 = sin(reduced_lat1), cos(reduced_lat1)\\r\\n sin_reduced2, cos_reduced2 = sin(reduced_lat2), cos(reduced_lat2)\\r\\n\\r\\n lambda_lng = delta_lng\\r\\n lambda_prime = 2 * pi\\r\\n while abs(lambda_lng - lambda_prime) > 10e-12 and iterations > 0:\\r\\n sin_lambda_lng, cos_lambda_lng = sin(lambda_lng), cos(lambda_lng)\\r\\n\\r\\n sin_sigma = sqrt(\\r\\n (cos_reduced2 * sin_lambda_lng) ** 2 +\\r\\n (cos_reduced1 * sin_reduced2 -\\r\\n sin_reduced1 * cos_reduced2 * cos_lambda_lng) ** 2\\r\\n )\\r\\n if sin_sigma == 0:\\r\\n return 0 # Coincident points\\r\\n\\r\\n cos_sigma = (\\r\\n sin_reduced1 * sin_reduced2 +\\r\\n cos_reduced1 * cos_reduced2 * cos_lambda_lng\\r\\n )\\r\\n sigma = atan2(sin_sigma, cos_sigma)\\r\\n\\r\\n sin_alpha = (cos_reduced1 * cos_reduced2 * sin_lambda_lng / sin_sigma)\\r\\n cos_sq_alpha = 1 - sin_alpha ** 2\\r\\n\\r\\n if cos_sq_alpha != 0:\\r\\n cos2_sigma_m = cos_sigma - 2 * \\\\\\r\\n (sin_reduced1 * sin_reduced2 / cos_sq_alpha)\\r\\n else:\\r\\n cos2_sigma_m = 0.0 # Equatorial line\\r\\n\\r\\n C = f / 16. * cos_sq_alpha * (4 + f * (4 - 3 * cos_sq_alpha))\\r\\n\\r\\n lambda_prime = lambda_lng\\r\\n lambda_lng = (\\r\\n delta_lng + (1 - C) * f * sin_alpha * (\\r\\n sigma + C * sin_sigma * (\\r\\n cos2_sigma_m + C * cos_sigma * (-1 + 2 * cos2_sigma_m ** 2)\\r\\n )\\r\\n )\\r\\n )\\r\\n iterations -= 1\\r\\n\\r\\n if iterations == 0:\\r\\n raise ValueError(\\\"Vincenty formula failed to converge!\\\")\\r\\n\\r\\n u_sq = cos_sq_alpha * (major ** 2 - minor ** 2) / minor ** 2\\r\\n A = 1 + u_sq / 16384. * (4096 + u_sq * (-768 + u_sq * (320 - 175 * u_sq)))\\r\\n B = u_sq / 1024. * (256 + u_sq * (-128 + u_sq * (74 - 47 * u_sq)))\\r\\n delta_sigma = B * sin_sigma * (\\r\\n cos2_sigma_m + B / 4. * (cos_sigma * (-1 + 2 * cos2_sigma_m ** 2) -\\r\\n B / 6. * cos2_sigma_m * (-3 + 4 * sin_sigma ** 2) *\\r\\n (-3 + 4 * cos2_sigma_m ** 2))\\r\\n )\\r\\n s = minor * A * (sigma - delta_sigma)\\r\\n\\r\\n return round(s, 3) # round to 1mm precision\\r\",\n \"def is_inside(self, x: int, y: int) -> bool:\\n pass\",\n \"def is_point_within(self, x, y):\\n return abs(x - self._x_position) <= self._x_length / 2 and abs(y - self._y_position) <= self._y_length / 2\",\n \"def in_woolsey_fire_area(lat, long):\\n min_lat = 33.856\\n max_lat = 34.211\\n min_long = -118.7114\\n max_long = -118.2511\\n\\n return in_area_of_interest(lat, long, min_lat, max_lat, min_long, max_long)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.64729494","0.59081954","0.5859355","0.58463377","0.5835103","0.5793143","0.5749297","0.5747117","0.571432","0.5694992","0.5625121","0.55783933","0.5532883","0.5531398","0.55265725","0.5519289","0.54891366","0.5458684","0.54542017","0.5451329","0.53815925","0.5368734","0.53533536","0.5344653","0.5337585","0.5330999","0.53292596","0.5327822","0.5281993","0.527632","0.52735966","0.5269682","0.52684206","0.52648","0.5231576","0.52148795","0.5184256","0.51838636","0.5178946","0.5169917","0.5168901","0.5161907","0.5155475","0.5154727","0.51539874","0.51479965","0.5140828","0.51128596","0.5112121","0.5096806","0.5091921","0.5088492","0.5076165","0.50644964","0.5055583","0.5042755","0.5042422","0.5030619","0.5025518","0.5024839","0.50214154","0.501631","0.50141555","0.50037056","0.50034815","0.5001366","0.49843","0.49586815","0.49437466","0.49362272","0.49278477","0.4926819","0.49258405","0.4924768","0.49194354","0.49169534","0.4915518","0.49011132","0.48934844","0.48847508","0.4884049","0.48769063","0.4876478","0.4872266","0.48717093","0.48668104","0.48648778","0.48599103","0.48599103","0.48493335","0.4841431","0.48378548","0.48362762","0.48337093","0.48309854","0.48256713","0.48179892","0.48160893","0.48124367","0.4809426"],"string":"[\n \"0.64729494\",\n \"0.59081954\",\n \"0.5859355\",\n \"0.58463377\",\n \"0.5835103\",\n \"0.5793143\",\n \"0.5749297\",\n \"0.5747117\",\n \"0.571432\",\n \"0.5694992\",\n \"0.5625121\",\n \"0.55783933\",\n \"0.5532883\",\n \"0.5531398\",\n \"0.55265725\",\n \"0.5519289\",\n \"0.54891366\",\n \"0.5458684\",\n \"0.54542017\",\n \"0.5451329\",\n \"0.53815925\",\n \"0.5368734\",\n \"0.53533536\",\n \"0.5344653\",\n \"0.5337585\",\n \"0.5330999\",\n \"0.53292596\",\n \"0.5327822\",\n \"0.5281993\",\n \"0.527632\",\n \"0.52735966\",\n \"0.5269682\",\n \"0.52684206\",\n \"0.52648\",\n \"0.5231576\",\n \"0.52148795\",\n \"0.5184256\",\n \"0.51838636\",\n \"0.5178946\",\n \"0.5169917\",\n \"0.5168901\",\n \"0.5161907\",\n \"0.5155475\",\n \"0.5154727\",\n \"0.51539874\",\n \"0.51479965\",\n \"0.5140828\",\n \"0.51128596\",\n \"0.5112121\",\n \"0.5096806\",\n \"0.5091921\",\n \"0.5088492\",\n \"0.5076165\",\n \"0.50644964\",\n \"0.5055583\",\n \"0.5042755\",\n \"0.5042422\",\n \"0.5030619\",\n \"0.5025518\",\n \"0.5024839\",\n \"0.50214154\",\n \"0.501631\",\n \"0.50141555\",\n \"0.50037056\",\n \"0.50034815\",\n \"0.5001366\",\n \"0.49843\",\n \"0.49586815\",\n \"0.49437466\",\n \"0.49362272\",\n \"0.49278477\",\n \"0.4926819\",\n \"0.49258405\",\n \"0.4924768\",\n \"0.49194354\",\n \"0.49169534\",\n \"0.4915518\",\n \"0.49011132\",\n \"0.48934844\",\n \"0.48847508\",\n \"0.4884049\",\n \"0.48769063\",\n \"0.4876478\",\n \"0.4872266\",\n \"0.48717093\",\n \"0.48668104\",\n \"0.48648778\",\n \"0.48599103\",\n \"0.48599103\",\n \"0.48493335\",\n \"0.4841431\",\n \"0.48378548\",\n \"0.48362762\",\n \"0.48337093\",\n \"0.48309854\",\n \"0.48256713\",\n \"0.48179892\",\n \"0.48160893\",\n \"0.48124367\",\n \"0.4809426\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7570688"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":8795,"cells":{"query":{"kind":"string","value":"(Product, float, float, radius, list) > boolean Check if the coordinates of a shop is within a radius (in meters) using the Vincenty's formulae and if the shop contains any of the tags provided."},"document":{"kind":"string","value":"def is_matching_product_with_tags(product, lat, lng, radius, tags):\n return vincenty(\n (lat, lng),\n (product.shop.lat, product.shop.lng)\n ).meters <= radius and any(tag in product.shop.tags for tag in tags)"},"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 is_matching_product(product, lat, lng, radius):\n return vincenty(\n (lat, lng),\n (product.shop.lat, product.shop.lng)\n ).meters <= radius","def shops_within_radius(self, lat, lng, radius, tags=None):\n center_point = geoindex.GeoPoint(lat, lng)\n points = self.geoindex.get_nearest_points(center_point, radius, 'km')\n\n def tags_filter(shops):\n for shop in shops:\n for tag in tags:\n if tag in shop['tags']:\n yield shop\n break\n\n def get_shops():\n for point, distance in points:\n point.ref['distance'] = distance\n yield point.ref\n\n if tags:\n return tags_filter(get_shops())\n else:\n return get_shops()","def __contains__(self, position):\n return sum([(c1 - c2) ** 2 for (c1, c2) in zip(self.position, position)]) <= self.radius","def get_matching_products(products, lat, lng, radius, tags):\n if tags:\n tag_list = tags.split(',')\n return list([\n product for product in products\n if is_matching_product_with_tags(\n product,\n lat,\n lng,\n radius,\n tag_list\n )\n ])\n else:\n return list([\n product for product in products\n if is_matching_product(\n product,\n lat,\n lng,\n radius\n )\n ])","def contains(self, position):\n return np.linalg.norm(position - self._center) < self._radius","def __contains__(self, other):\n x, y = other\n return self.radius >= sqrt((x - self.x) ** 2 + (y - self.y) ** 2)","def objects_radius(self, centre, radius):","def contains(self, loc): \n return loc.distance(self.center) <= self.radius","def FindPointsWithinRadius(self, p_float, , vtkIdList):\n ...","def point_inside_circle(x,y,center_x,center_y,radius):\n return (x-center_x)**2 + (y - center_y)**2 < radius**2","def isInside(x1, y1, x2, y2, x3, y3, x, y):\n # Calculate area of triangle ABC\n A = area (x1, y1, x2, y2, x3, y3)\n \n # Calculate area of triangle PBC\n A1 = area (x, y, x2, y2, x3, y3)\n \n # Calculate area of triangle PAC\n A2 = area (x1, y1, x, y, x3, y3)\n \n # Calculate area of triangle PAB\n A3 = area (x1, y1, x2, y2, x, y)\n \n # Check if sum of A1, A2 and A3\n # is same as A\n if(A == A1 + A2 + A3):\n return True\n else:\n return False","def containsPos(self, obst_pos, aerial_pos):\n dist_to_center = obst_pos.distanceTo(aerial_pos)\n return dist_to_center <= self.sphere_radius","def checkBounds(x,y,z,center,radius):\n r2 = (x-center[0])**2 + (y-center[1])**2# + (z-center[0])**2\n if r2 < radius**2:\n return True\n else:\n return False","def isInCircle(self,x1,y1,radius1):\r\n if(distance(self.x,x1,self.y,y1) < (self.radius+radius1)):\r\n return True\r\n return False","def check_point_in_detector(p, radius=radius, height=height, distance=distance):\r\n if p[0]**2 + p[1]**2 <= radius**2: # Are the x and y coordinates in the circle?\r\n if (p[2] >= distance) and (p[2] <= height+distance): # Is the z coordinate between the distance and the height?\r\n return True\r\n else:\r\n return False\r\n else:\r\n return False","def inside(x, y, primitive):\n\n # You should implement your inside test here for all shapes\n # for now, it only returns a false test\n\n if primitive[\"shape\"] == \"circle\":\n dist_sqr = ((primitive[\"center\"][0] - x) ** 2 +\n (primitive[\"center\"][1] - y) ** 2)\n\n return dist_sqr <= primitive[\"radius\"] ** 2\n else:\n return winding_number(x, y, primitive)\n\n return False","def is_point_inside_hypersphere(point: np.array, c: List[float], r: float) -> bool:\n return np.linalg.norm(point - c) < r","def _intersected(positions, radius):\n P1 = positions[0]\n P2 = positions[1]\n P3 = positions[2]\n temp1 = P2 - P1\n e_x = temp1 / np.linalg.norm(temp1)\n temp2 = P3 - P1\n i = np.dot(e_x, temp2)\n temp3 = temp2 - i * e_x\n e_y = temp3 / np.linalg.norm(temp3)\n e_z = np.cross(e_x, e_y)\n d = np.linalg.norm(P2 - P1)\n j = np.dot(e_y, temp2) \n x = d / 2\n y = (-2*i*x + i*i + j*j) / (2*j)\n temp4 = radius**2 - x*x - y*y\n if temp4 < 0:\n return False\n return True","def isoutside(coords, shape):\n # Label external pores for trimming below\n if len(shape) == 1: # Spherical\n # Find external points\n r = np.sqrt(np.sum(coords**2, axis=1))\n Ps = r > shape[0]\n elif len(shape) == 2: # Cylindrical\n # Find external pores outside radius\n r = np.sqrt(np.sum(coords[:, [0, 1]]**2, axis=1))\n Ps = r > shape[0]\n # Find external pores above and below cylinder\n if shape[1] > 0:\n Ps = Ps + (coords[:, 2] > shape[1])\n Ps = Ps + (coords[:, 2] < 0)\n else:\n pass\n elif len(shape) == 3: # Rectilinear\n shape = np.array(shape, dtype=float)\n try:\n lo_lim = shape[:, 0]\n hi_lim = shape[:, 1]\n except IndexError:\n lo_lim = np.array([0, 0, 0])\n hi_lim = shape\n Ps1 = np.any(coords > hi_lim, axis=1)\n Ps2 = np.any(coords < lo_lim, axis=1)\n Ps = Ps1 + Ps2\n return Ps","def sphere_isclose(c1, c2, *args, **kwargs):\n return np.isclose(c1.radius, c2.radius, *args, **kwargs) and np.allclose(\n c1.center, c2.center, *args, **kwargs\n )","def inside_unit_circle(point):\n distance = math.sqrt(point[0] ** 2 + point[1] ** 2)\n return distance < 1","def get_radius(self):","def incircle(self,xpos,ypos,cellx,celly):\n xcell, ycell = self.getcellcenter(cellx,celly)\n if ((xpos - xcell)**2 + (ypos - ycell)**2) < self.crad2:\n return True\n return False\n\n return cellx, celly","def __contains__(self, point): \n corners = self.corners\n\n if isinstance(point, tuple):\n from pyresample.spherical_geometry import Coordinate\n retval = planar_point_inside(Coordinate(*point), corners)\n else:\n retval = planar_point_inside(point, corners)\n\n #print ' retval from FALSE CORNERS contains '+str(retval)\n\n return retval","def is_point_inside_hypermoon(point: np.array, c: Tuple[List[float]], r: Tuple[float]) -> bool:\n return is_point_inside_hypersphere(point, c[0], r[0]) and not is_point_inside_hypersphere(point, c[1], r[1])","def __contains__(self, point):\n #### Original \n from pyresample.spherical_geometry import point_inside, Coordinate\n corners = self.corners\n\n if isinstance(point, tuple):\n return point_inside(Coordinate(*point), corners)\n else:\n return point_inside(point, corners)\n #### End Original\n #from .spherical import SphPolygon\n #log.info('RUNNING SPHERICAL in __contains__')\n #sphpoly = SphPolygon(corners)\n #return sphpoly.intersection(SphPolygon(point), sphpoly)","def containsPos(self, aerial_pos):\n # Check altitude of position\n aerial_alt = aerial_pos.altitude_msl\n if (aerial_alt < 0 or aerial_alt > self.cylinder_height):\n return False\n # Check lat/lon of position\n dist_to_center = self.gps_position.distanceTo(aerial_pos.gps_position)\n if dist_to_center > self.cylinder_radius:\n return False\n # Both within altitude and radius bounds, inside cylinder\n return True","def within_radius(self, radius=5.0):\n\n return GeoEntry.within_radius(self.primary_geocode, radius, ['all',])","def is_clicked(vtx_x, vtx_y, mouse_x, mouse_y, radius):\n return math.sqrt(((mouse_x - vtx_x) ** 2) + ((mouse_y - vtx_y) ** 2)) < radius","def HasPoint(self, vtkAMRBox, , , p_float_6, p_float_7, p_float_8):\n ...","def intersects( self, sphere, dim ):\n nearest = self.__findFarestPoint__( sphere.center );\n dist = utility.euclideanDistSqr( nearest, sphere.center );\n if( dist < sphere.radius**2 ):\n return True;\n else:\n return False;","def isInside(self, position, maxDimLens):\n dim = len(position);\n deltas = [0] * dim;\n distSqr = 0;\n for i in range(0, dim):\n deltas[i] = math.fabs(position[i] - self.mSample[i]);\n if math.fabs(maxDimLens[i] - deltas[i]) < deltas[i]:\n deltas[i] = math.fabs(maxDimLens[i] - deltas[i]);\n distSqr += deltas[i]**2;\n\n if distSqr < ( self.mRadius**2 ):\n return True;\n else:\n return False;","def within(self, right: GeoSpatialValue) -> ir.BooleanValue:\n return ops.GeoWithin(self, right).to_expr()","def test_get_radius():\n center = Coordinates(7, 3)\n radius = 12\n\n returned_rad = get_radius(center, radius, 30)\n\n assert returned_rad == radius\n assert returned_rad != center.get_x()\n assert returned_rad != center.get_y()","def contains_pt(self, pt):\n x, y = pt\n if not self.x - self.radius < x < self.x + self.radius:\n return False\n if not self.y - self.radius < y < self.y + self.radius:\n return False\n return True","def is_point_inside_hypercube(point: List[float], c: List[float], r: float) -> bool:\n diff = np.subtract(point, c)\n return np.all(np.absolute(diff) <= r)","def IsValid(self, *args):\n return _Bnd.Bnd_Sphere_IsValid(self, *args)","def intersects(self, right: GeoSpatialValue) -> ir.BooleanValue:\n return ops.GeoIntersects(self, right).to_expr()","def validate_pos(game: TowerDefenceSolver, position: Tuple[int, int], purchases_list: Purchases) -> bool:\n if (\n position[0] < 0\n or position[1] < 0\n or position[0] >= game.map_height\n or position[1] >= game.map_width\n or position in game.path\n ):\n return False\n\n for purchase in purchases_list:\n if purchase[\"coords\"] == position:\n return False\n\n return True","def test_get_neighborhood_radius_consistent():\r\n grid_spacing = random.uniform(1e-6, 10.0)\r\n center = numpy.random.random(random.randint(1, 3))\r\n\r\n # Find points with radius neighborhood\r\n radius = random.uniform(_distance_to_nearest(grid_spacing, center), grid_spacing*5)\r\n points = ill.get_neighborhood_radius(grid_spacing, center, radius)\r\n\r\n # Every points found within this radius, should be in the points of a larger radius\r\n outer_points = ill.get_neighborhood_radius(grid_spacing, center,\r\n radius+random.uniform(0.0, grid_spacing*5))\r\n\r\n for point in points:\r\n assert point in outer_points","def is_bound(pos1, el1, pos2, el2):\n threshold = 0.1\n if el1 == 'H' or el2 == 'H':\n threshold = 0.2\n if np.linalg.norm(np.array(pos1) - np.array(pos2)) < covalence_radius[el1] + covalence_radius[el2] + threshold:\n return True\n return False","def within_radius(latlong, radius=5.0, ctype_fields=None):\n\n radius = float(radius) # may come through as str\n\n if type(latlong) == GeoEntry:\n latlong = [latlong.latitude, latlong.longitude]\n\n # These are our 4 points (N/S/E/W) We use this to build a bounding box\n HEADINGS = enumerate([0, math.pi/2, math.pi, 3*math.pi/2])\n\n try:\n geoentry = GeoEntry.objects.get(latitude=latlong[0], longitude=latlong[1])\n except GeoEntry.DoesNotExist:\n # Maybe handle more gracefully?\n raise Exception('No GeoEntry matching query')\n except GeoEntry.MultipleObjectsReturned:\n # In this case lets use the first one instead for now\n geoentry = GeoEntry.objects.filter(latitude=latlong[0], longitude=latlong[1])[0]\n\n source_lat = GeoEntry.degrees_to_radians(latlong[0])\n source_long = GeoEntry.degrees_to_radians(latlong[1])\n distance = GeoEntry.miles_to_radians(radius)\n\n boundries = []\n\n for (cnt, heading) in HEADINGS:\n target_lat = GeoEntry.calculate_latitude(source_lat, distance, heading)\n target_long = GeoEntry.calculate_longitude(target_lat, source_long, distance, heading)\n\n boundries.append([GeoEntry.radians_to_degrees(target_lat), \\\n GeoEntry.radians_to_degrees(target_long)])\n\n entries = GeoEntry.objects.all().select_related().filter(latitude__lte=str(boundries[0][0]),\n latitude__gte=str(boundries[2][0]), longitude__gte=str(boundries[1][1]),\n longitude__lte=str(boundries[3][1]))\n\n entry_data = list()\n for entry in entries:\n obj = entry.content_object\n ctype_dict = None,\n if obj and ctype_fields:\n if (len(ctype_fields)==1 and ctype_fields[0]=='all'):\n ctype_list = list()\n for field in obj._meta.fields:\n field_data = getattr(obj, field.name)\n if type(field_data) == unicode:\n ctype_list.append([field.name, field_data.encode('utf-8')])\n else:\n ctype_list.append([field.name, str(field_data)])\n ctype_dict = dict(ctype_list)\n else:\n ctype_dict = dict([[field, getattr(obj, field)] for field in ctype_fields])\n entry_data.append(dict(\n distance=entry.distance_to_latlong((latlong[0], latlong[1])),\n content_type=entry.content_type.pk,\n object_id=entry.object_id,\n object_data=ctype_dict,\n latitude=str(entry.latitude),\n longitude=str(entry.longitude),\n )\n )\n entry_data.sort() # return orderd by distance\n # now fix the bounding box SQL to limit within our radius\n sorted_data = [elem for elem in entry_data if elem['distance']<radius]\n return sorted_data","def has_intersection(self, obj):\r\n obj_x, obj_y = obj.get_location()\r\n x = self.__x\r\n y = self.__y\r\n # Distance formula\r\n distance = sqrt((obj_x - x) ** 2 + (obj_y - y) ** 2)\r\n if distance <= obj.get_radius() + self.__radius:\r\n return True\r\n return False","def hit(bx, by, r, px, py,h):\n if bx >= px:\n distance = bx - px\n else:\n distance = px - bx\n if py<=by and by<=py+h and distance <= r:\n return True\n else:\n return False","def in_area_of_interest (lat, long, min_lat, max_lat, min_long, max_long):\n\n if lat is None or long is None:\n return False\n\n lat = float(lat)\n long = float(long)\n\n if ((lat >= min_lat and lat <= max_lat) and\n (long >= min_long and long <= max_long)):\n return True\n\n return False","def isContainedWithin(self,other):\n retVal = True\n bounds = self.points\n\n if( isinstance(other,Feature) ): # another feature do the containment test\n retVal = other.contains(self)\n elif( isinstance(other,tuple) and len(other)==3 ): # a circle\n #assume we are in x,y, r format\n rr = other[2]*other[2] # radius squared\n x = other[0]\n y = other[1]\n for p in bounds:\n test = ((x-p[0])*(x-p[0]))+((y-p[1])*(y-p[1]))\n if( test > rr ):\n retVal = False\n break\n elif( isinstance(other,tuple) and len(other)==4 and # a bounding box\n ( isinstance(other[0],float) or isinstance(other[0],int))): # we assume a tuple of four is (x,y,w,h)\n retVal = ( self.maxX() <= other[0]+other[2] and\n self.minX() >= other[0] and\n self.maxY() <= other[1]+other[3] and\n self.minY() >= other[1] )\n elif(isinstance(other,list) and len(other) > 2 ): # an arbitrary polygon\n #everything else ....\n retVal = True\n for p in bounds:\n test = self._pointInsidePolygon(p,other)\n if(not test):\n retVal = False\n break\n\n else:\n logger.warning(\"SimpleCV did not recognize the input type to features.contains. This method only takes another blob, an (x,y) tuple, or a ndarray type.\")\n retVal = False\n return retVal","def in_circle(x0, y0, x, y, r):\n return ((x - x0) ** 2 + (y - y0) ** 2) <= (r ** 2)","def WhereAreYou(CurLongitude,CurLatitude,LocationLongitude,LocationLatitude,LocationRadius):\n # Calculate the great circle distance between two points\n # on the earth (specified in decimal degrees)\n # 将十进制度数转化为弧度\n CurLongitude,CurLatitude,LocationLongitude,LocationLatitude = map(radians, [float(CurLongitude),float(CurLatitude),float(LocationLongitude),float(LocationLatitude)])\n\n # haversine公式\n dlon = LocationLongitude - CurLongitude\n dlat = LocationLatitude - CurLatitude\n a = sin(dlat / 2) ** 2 + cos(CurLatitude) * cos(LocationLatitude) * sin(dlon / 2) ** 2\n c = 2 * asin(sqrt(a))\n r = 6371 # 地球平均半径，单位为公里\n distance = c * r * 1000\n if(distance < float(LocationRadius)):\n return True\n else:\n return False","def check_me(triplet, list_of_coords):\n c = True\n for element in list_of_coords:\n if (float(triplet[0])*0.99 <= float(element[0]) <= float(triplet[0])*1.01):\n if (float(triplet[1])*0.99 <= float(element[1]) <= float(triplet[1])*1.01):\n if (float(triplet[2])*0.99 <= float(element[2]) <= float(triplet[2])*1.01):\n c = False\n return c","def contains(self,other):\n retVal = False\n\n bounds = self.points\n if( isinstance(other,Feature) ):# A feature\n retVal = True\n for p in other.points: # this isn't completely correct - only tests if points lie in poly, not edges.\n p2 = (int(p[0]),int(p[1]))\n retVal = self._pointInsidePolygon(p2,bounds)\n if( not retVal ):\n break\n # a single point\n elif( (isinstance(other,tuple) and len(other)==2) or ( isinstance(other,np.ndarray) and other.shape[0]==2) ):\n retVal = self._pointInsidePolygon(other,bounds)\n\n elif( isinstance(other,tuple) and len(other)==3 ): # A circle\n #assume we are in x,y, r format\n retVal = True\n rr = other[2]*other[2]\n x = other[0]\n y = other[1]\n for p in bounds:\n test = ((x-p[0])*(x-p[0]))+((y-p[1])*(y-p[1]))\n if( test < rr ):\n retVal = False\n break\n\n elif( isinstance(other,tuple) and len(other)==4 and ( isinstance(other[0],float) or isinstance(other[0],int))):\n retVal = ( self.maxX() <= other[0]+other[2] and\n self.minX() >= other[0] and\n self.maxY() <= other[1]+other[3] and\n self.minY() >= other[1] )\n elif(isinstance(other,list) and len(other) >= 4): # an arbitrary polygon\n #everything else ....\n retVal = True\n for p in other:\n test = self._pointInsidePolygon(p,bounds)\n if(not test):\n retVal = False\n break\n else:\n logger.warning(\"SimpleCV did not recognize the input type to features.contains. This method only takes another blob, an (x,y) tuple, or a ndarray type.\")\n return False\n\n return retVal","def within(point: tuple, box: tuple) -> bool:\r\n \r\n return box[0] < point[0] < box[2] and box[1] < point[1] < box[3]","def are_close(coord1, coord2, tolerance=10):\n return vincenty(coord1, coord2).meters < tolerance","def covers(self, right: GeoSpatialValue) -> ir.BooleanValue:\n return ops.GeoCovers(self, right).to_expr()","def stores_in_given_radius_of_given_postcode(request):\n\n radius = request.POST.get('radius')\n if radius:\n radius = Decimal(radius)\n else:\n return Response('Radius is required', status=status.HTTP_404_NOT_FOUND)\n\n postcode = request.POST.get('postcode')\n if postcode:\n postcode = postcode.replace(' ', '')\n else:\n return Response('Postcode is required', status=status.HTTP_404_NOT_FOUND)\n\n stores_in_given_radius = []\n source_latitude, source_longitude = get_lat_and_lon_of_given_postcode(postcode)\n\n for store in Store.objects.order_by('-latitude'):\n if store.latitude and store.longitude:\n if check_if_in_radius(store, source_latitude, source_longitude, radius):\n stores_in_given_radius.append(store)\n\n serializer = StoreSerializer(stores_in_given_radius, many=True)\n return Response(serializer.data)","def brute_force(savedPnts, unitRadius, point):\n for pnt in savedPnts:\n d = distance(pnt, point)\n if d < unitRadius: return False\n return True","def test_is_on_intersection():\n center = Coordinates(1, 1)\n radius = 10\n\n i = Intersection(center, radius, 20)\n\n in_circle = Coordinates(2, 2)\n not_in_circle = Coordinates(100, 150)\n before_circumference = Coordinates(1, 10.9)\n on_circumference = Coordinates(1, 11)\n after_circumference = Coordinates(1, 11.1)\n\n assert is_on_intersection(i, in_circle)\n assert is_on_intersection(i, on_circumference)\n assert is_on_intersection(i, before_circumference)\n assert not is_on_intersection(i, not_in_circle)\n assert not is_on_intersection(i, after_circumference)","def _check_overlap(self, points, radius):\n dists = distance.cdist(points, points, 'euclidean')\n dists = dists[np.nonzero(dists)]\n\n return np.any(dists < 2.0 * radius)","def circles_collide(x1: float, y1: float, r1: float, x2: float, y2: float, r2: float) -> bool:\n return distance_between_sq(x1, y1, x2, y2) <= (r1 + r2)**2","def is_inside(self, p):\n s, t = self.get_barycentric_coord(p)\n if 0 <= s <= 1 and 0 <= t <= 1 and s + t <= 1:\n return True\n else:\n return False","def test_update_radius():\n center = Coordinates(1, 1)\n rad1 = 20.3\n speed = 30\n\n i = Intersection(center, rad1, speed)\n\n assert i.get_radius() == 20.3\n\n i.update_radius(56.5)\n\n assert i.get_radius() == 56.5","def radius(x) :\r\n return Feature(x, \"radius\")","def contains(self, Union, QPointF=None, QPoint=None): # real signature unknown; restored from __doc__\n return False","def is_inside(self, points):\n points = np.atleast_2d(points) - self.centroid\n return np.logical_and(\n np.linalg.norm(points, axis=-1) <= self.radius,\n # At present circles are not orientable, so the z position must\n # match exactly.\n np.isclose(points[:, 2], 0),\n )","def contains ( self, pos ):\n dr2 = (pos[0, :]-self.x)**2 + (pos[1, :]-self.y)**2\n # which points are in the circle?\n if self.include_border:\n inds = (dr2 - self.r**2) < self.abs_tol\n else:\n inds = (dr2 - self.r**2) < -self.abs_tol\n \n \n # if there's no poit inside\n if ~inds.any() and self.default_nearest: \n inds[argmin(dr2)] = True\n \n return inds","def is_inside(self, x: int, y: int) -> bool:\n pass","def check_in(x, y, R=Re):\n r = np.sqrt(x ** 2 + y ** 2)\n return r <= R","def testSphereRadius(self):\n sp = nigel.SphereSelection(nb, radius=10)\n self.assertEqual(sp.n, 9)","def dans_cercle(self, r, x, y):\r\n self.r_num(r)\r\n valid = (isinstance(x, int) or isinstance(x, float)) and \\\r\n (isinstance(y, int) or isinstance(y, float))\r\n if valid:\r\n if sqrt(x**2+y**2)<self.r:\r\n return True\r\n else:\r\n return False\r\n else:\r\n raise TypeError","def hitTest( a, b ):\n r = a.radius + b.radius\n x = abs( a.x - b.x )\n y = abs( a.y - b.y )\n if x <= r and y <= r and x*x + y*y <= r*r:\n return 1\n return 0","def is_inside(inner_path, outer_path):\r\n if not hasattr(inner_path, 'bounding_box'):\r\n inner_path.bounding_box = CutPlanner.bounding_box(inner_path)\r\n if not hasattr(outer_path, 'bounding_box'):\r\n outer_path.bounding_box = CutPlanner.bounding_box(outer_path)\r\n if outer_path.bounding_box[0] > inner_path.bounding_box[0]:\r\n # outer minx > inner minx (is not contained)\r\n return False\r\n if outer_path.bounding_box[1] > inner_path.bounding_box[1]:\r\n # outer miny > inner miny (is not contained)\r\n return False\r\n if outer_path.bounding_box[2] < inner_path.bounding_box[2]:\r\n # outer maxx < inner maxx (is not contained)\r\n return False\r\n if outer_path.bounding_box[3] < inner_path.bounding_box[3]:\r\n # outer maxy < inner maxy (is not contained)\r\n return False\r\n if outer_path.bounding_box == inner_path.bounding_box:\r\n if outer_path == inner_path: # This is the same object.\r\n return False\r\n if not hasattr(outer_path, 'vm'):\r\n outer_path = Polygon([outer_path.point(i / 100.0, error=1e4) for i in range(101)])\r\n vm = VectorMontonizer()\r\n vm.add_cluster(outer_path)\r\n outer_path.vm = vm\r\n for i in range(101):\r\n p = inner_path.point(i / 100.0, error=1e4)\r\n if not outer_path.vm.is_point_inside(p.x, p.y):\r\n return False\r\n return True","def is_point_in_box(x, y, bbox):\n if x < 200 and y < 200:\n return True\n return False","def inside(self, p: PointType, q: PointType) -> bool:\n\n # XXX re-implement with ccw and a list of points instead of a pair\n\n i = min(p.x, q.x) < self.x < max(p.x, q.x)\n j = min(p.y, q.y) < self.y < max(p.y, q.y)\n\n return i and j","def get_in_radius(radius):\n def _return_values(user):\n \"\"\"\n :user Dict containing the users information, by keeping this in a nested function if more or less information\n is required to be returned it can be modified in one location rather than multiple locations.\n Returns a predefined dict of values to minimise duplicated code.\n :return: dictionary of user values\n \"\"\"\n return {\"id\":user[\"id\"],\n \"first_name\":user[\"first_name\"],\n \"last_name\": user[\"last_name\"]\n }\n\n users_in_range = [] # dictionary to store user information as we only want first name and last name.\n london = (51.30, 0.5) # Create a position point for london using its latitude and longitude\n\n # ** Note: 'City' is not included in the data returned by the users end point ut it is if you call the\n # users individually i could do this using for loop but that would cause 1000 calls to the API each time\n # the end point is called so instead i've opted to do 2 calls and parsing the data in the API.\n # This should minimise the number of requests being sent to the API.\n\n # First i will get all the users and compute their current distance from london and checking if that is within\n # the radius specified by the end user (radius component of the url), Then i will get all users listed as being\n # in the city of london and checking if those customers are already in the list by creating a list of ids.\n\n # If they are in the list they are discarded if they are not then their first name, last name and id are added\n # to the array, since the requirements did not specify what information was to be returned only those three values\n # are returned (This minimises the data protection implications)\n\n url = \"/users\"\n response = requests.get(f\"{host}{url}\")\n\n for user in json.loads(response.text):\n # Creation location point for the current user and use haversine to compute the distance between the user and\n # london in miles\n user_location = (float(user[\"latitude\"]), float(user[\"longitude\"]))# (lat, lon)\n distance = haversine(london, user_location, unit='mi')\n\n # if the distance is 50 miles or less then add the users first and last name to the users_in_range dict using\n if distance <= float(radius):\n users_in_range.append(_return_values(user))\n\n # Get the used defined as 'living in london' this is not clear in the instructions so i have made the 'assumption'\n # That the city value corresponds to their current city of residence.\n url = \"/city/London/users\"\n response = requests.get(f\"{host}{url}\")\n\n # Parse through the list or returned users and filter entries which already exist and append ones that dont to the\n # list to be returned\n for user in json.loads(response.text):\n if not user[\"id\"] in [user[\"id\"] for user in users_in_range]:\n users_in_range.append(_return_values(user))\n\n # convert the list into a json payload and return using\n return json.dumps(users_in_range)","def containsManyPos(self, aerial_pos_list):\n # Get boundary points\n ordered_pts = self.boundary_pts.order_by('order')\n path_pts = [[wpt.position.gps_position.latitude,\n wpt.position.gps_position.longitude]\n for wpt in ordered_pts]\n # First check enough points to define a polygon\n if len(path_pts) < 3:\n return [False] * len(aerial_pos_list)\n\n # Create path to use for testing polygon inclusion\n path_pts.append(path_pts[0])\n path = mplpath.Path(np.array(path_pts))\n\n # Test each aerial position for altitude\n results = list()\n for aerial_pos in aerial_pos_list:\n # Check altitude bounds\n alt = aerial_pos.altitude_msl\n altitude_check = (alt <= self.altitude_msl_max\n and alt >= self.altitude_msl_min)\n results.append(altitude_check)\n\n # Create a list of positions to test whether inside polygon\n polygon_test_point_ids = [cur_id\n for cur_id in range(len(aerial_pos_list))\n if results[cur_id]]\n if len(polygon_test_point_ids) == 0:\n return results\n polygon_test_points = [[aerial_pos_list[cur_id].gps_position.latitude,\n aerial_pos_list[cur_id].gps_position.longitude]\n for cur_id in polygon_test_point_ids]\n\n # Test each point for inside polygon\n polygon_test_results = path.contains_points(\n np.array(polygon_test_points))\n for test_id in range(len(polygon_test_point_ids)):\n cur_id = polygon_test_point_ids[test_id]\n results[cur_id] = (polygon_test_results[test_id] == True)\n\n return results","def isinsidepointXY(x,p):\n \n return dist(x,p) < epsilon","def at_loc((x, y), (cx, cy), eps=0.000035):\n\treturn (x - cx)**2 + (y - cy)**2 <= eps**2","def inCircleFast(self, tri, p):\n center, radius = self.circles[tri]\n return np.sum(np.square(center - p)) <= radius","def check_coordinates(X, Y):\n\n # Accounting for elliptical Jupiter disk\n Y *= 1.071374\n\n return sqrt(X ** 2 + Y ** 2)","def in_water(latitude: float, longitude: float) -> bool:\n path = os.path.abspath('water_polygons.shp')\n with fiona.open(path) as fiona_collection:\n box_detail = 0.0001\n point = Point(longitude, latitude)\n # here we filter to only scan results near the point in question.\n for record in fiona_collection.filter(bbox=(\n longitude+box_detail, latitude+box_detail,\n longitude-box_detail, latitude-box_detail)):\n if record['geometry']:\n shape = asShape(record['geometry'])\n if shape.contains(point):\n return True\n return False","def isInArea(self, width, height, depth):\n if self.position[0] + self.radius > width / -2 and self.position[0] + self.radius < width / 2:\n if self.position[1] + self.radius > height / -2 and self.position[1] + self.radius < height / 2:\n if self.position[2] + self.radius > -depth and self.position[2] + self.radius < depth:\n return True\n else:\n return False","def contains_properly(self, right: GeoSpatialValue) -> ir.BooleanValue:\n return ops.GeoContainsProperly(self, right).to_expr()","def in_ellipse(x,y,a,b):\n return ellipse(x,y,a,b) <= 1","def conf_test(self, trial_coords: np.ndarray) -> bool:\n #N = len(trial_coords)\n r2: float = 0\n i =0\n r2 = np.inner(trial_coords, trial_coords)\n if (r2> self.m_radius2):\n return False\n return True","def vincenty(p1, p2):\n # Note: GeoPy expects (latitude, longitude) pairs.\n return geopy.distance.vincenty(\n (p1.y, p1.x),\n (p2.y, p2.x)\n ).miles","def area_of_circle(radius):\n return radius","def sphereArea(radius):\n area = 4 * math.pi * radius ** 2\n return area","def point_in_ellipse(point: Vector, center: Vector, angle: float, length: float, width: float) -> bool:\n c, s = np.cos(angle), np.sin(angle)\n r = np.matrix([[c, -s], [s, c]])\n ru = r.dot(point - center)\n return np.sum(np.square(ru / np.array([length, width]))) < 1","def in_geofence(self, coordinates):\n\t\tcoords_transformed = ogr.Geometry(ogr.wkbPoint)\n\t\tcoords_transformed.AddPoint(*coordinates)\n\t\treturn self.polygon.Contains(coords_transformed)","def is_inside(self, mX, mY, point):\n return (math.sqrt((point[0] - mX) * (point[0] - mX)\n + (point[1] - mY) * (point[1] - mY)) <= 2)","def Check(self, vtkGenericCell, p_float):\n ...","def isPrice(price, high, low):\n return (price >= low) and (price <= high)","def check_inside(self, pos):\n x,y = pos\n return x >= self.posx and x <= self.posx + self.sizex and y >= self.posy and y <= self.posy + self.sizey","def sphere_area(radius : number) -> number:\n area = 4*pi*radius*radius\n return area","def calculate(self, real_estate, min_length, min_area, length_unit, area_unit):\n geometry_types = Config.get('geometry_types')\n line_types = geometry_types.get('line').get('types')\n polygon_types = geometry_types.get('polygon').get('types')\n point_types = geometry_types.get('point').get('types')\n if self.published:\n intersection = self.geom.intersection(real_estate.limit)\n # TODO upon update to Shapely 1.7, a check for result.is_emtpy will be needed (see PR#1037)\n # differentiate between Points and MultiPoint\n if not intersection.is_empty:\n result = self._extract_collection(intersection)\n if self.geom.type not in point_types + line_types + polygon_types:\n supported_types = ', '.join(point_types + line_types + polygon_types)\n raise AttributeError(\n u'The passed geometry is not supported: {type}. It should be one of: {types}'.format(\n type=self.geom.type, types=supported_types\n )\n )\n elif self.geom.type in point_types:\n if result.type == point_types[1]:\n # If it is a multipoint make a list and count the number of elements in the list\n self._nr_of_points = len(list(result.geoms))\n self._test_passed = True\n elif result.type == point_types[0]:\n # If it is a single point the number of points is one\n self._nr_of_points = 1\n self._test_passed = True\n elif self.geom.type in line_types and result.type in line_types:\n self._units = length_unit\n length_share = result.length\n if length_share >= min_length:\n self._length_share = length_share\n self._test_passed = True\n elif self.geom.type in polygon_types and result.type in polygon_types:\n self._units = area_unit\n area_share = result.area\n compensated_area = area_share / real_estate.areas_ratio\n if compensated_area >= min_area:\n self._area_share = compensated_area\n self._test_passed = True\n else:\n # This intersection result should not be used for the OEREB extract:\n # for example, if two polygons are touching each other, the intersection geometry will be\n # the point or linestring representing the touching part.\n log.debug(\n u'Intersection result changed geometry type. '\n u'Original geometry was {0} and result is {1}'.format(\n self.geom.type,\n result.type\n )\n )\n self.calculated = True\n return self._test_passed","def match(self, pos, radius):\n\n nodes = self._data[:, 2:5]\n distlist = np.squeeze(cdist(pos.reshape(1, 3), nodes))\n if distlist.size == 0:\n return False, -2\n minidx = distlist.argmin()\n minnode = self._data[minidx, 2:5]\n\n # See if either of them can cover each other with a ball of their own\n # radius\n mindist = np.linalg.norm(pos - minnode)\n return radius > mindist or self._data[minidx, 5] > mindist, minidx","def intersects(self, *__args): # real signature unknown; restored from __doc__ with multiple overloads\r\n return False","def find_channel_neighbors(geom, radius):\n return (squareform(pdist(geom)) <= radius)","def find_channel_neighbors(geom, radius):\n return (squareform(pdist(geom)) <= radius)","def is_on(self, obj1_loc, obj1_dims, obj2_loc, obj2_dims):\n VERT_MEASUREMENT_TOLERANCE = self.VERT_MEASUREMENT_TOLERANCE\n result = None\n obj1_x = obj1_loc[0]\n obj1_y = obj1_loc[1]\n obj1_zmin = obj1_loc[2] - (.5 * obj1_dims[2])\n obj2_xmin, obj2_xmax, obj2_ymin, obj2_ymax, obj2_zmin, obj2_zmax = self.get_corners(obj2_loc, obj2_dims)\n if obj1_x >= obj2_xmin and obj1_x <= obj2_xmax:\n if obj1_y >= obj2_ymin and obj1_y <= obj2_ymax:\n if obj1_zmin >= obj2_zmax-VERT_MEASUREMENT_TOLERANCE and obj1_zmin <= obj2_zmax+VERT_MEASUREMENT_TOLERANCE:\n result = 'on'\n return result","def test_intersect_volume(self):\n\n intersect_shape = ExtrudeCircleShape(points=[(30, 0)], radius=5, distance=50)\n\n intersected_shape = ExtrudeCircleShape(\n points=[(30, 0)],\n radius=10,\n distance=50,\n intersect=[self.test_shape, intersect_shape],\n )\n\n assert intersected_shape.volume() == pytest.approx(math.pi * 5**2 * 30)"],"string":"[\n \"def is_matching_product(product, lat, lng, radius):\\n return vincenty(\\n (lat, lng),\\n (product.shop.lat, product.shop.lng)\\n ).meters <= radius\",\n \"def shops_within_radius(self, lat, lng, radius, tags=None):\\n center_point = geoindex.GeoPoint(lat, lng)\\n points = self.geoindex.get_nearest_points(center_point, radius, 'km')\\n\\n def tags_filter(shops):\\n for shop in shops:\\n for tag in tags:\\n if tag in shop['tags']:\\n yield shop\\n break\\n\\n def get_shops():\\n for point, distance in points:\\n point.ref['distance'] = distance\\n yield point.ref\\n\\n if tags:\\n return tags_filter(get_shops())\\n else:\\n return get_shops()\",\n \"def __contains__(self, position):\\n return sum([(c1 - c2) ** 2 for (c1, c2) in zip(self.position, position)]) <= self.radius\",\n \"def get_matching_products(products, lat, lng, radius, tags):\\n if tags:\\n tag_list = tags.split(',')\\n return list([\\n product for product in products\\n if is_matching_product_with_tags(\\n product,\\n lat,\\n lng,\\n radius,\\n tag_list\\n )\\n ])\\n else:\\n return list([\\n product for product in products\\n if is_matching_product(\\n product,\\n lat,\\n lng,\\n radius\\n )\\n ])\",\n \"def contains(self, position):\\n return np.linalg.norm(position - self._center) < self._radius\",\n \"def __contains__(self, other):\\n x, y = other\\n return self.radius >= sqrt((x - self.x) ** 2 + (y - self.y) ** 2)\",\n \"def objects_radius(self, centre, radius):\",\n \"def contains(self, loc): \\n return loc.distance(self.center) <= self.radius\",\n \"def FindPointsWithinRadius(self, p_float, , vtkIdList):\\n ...\",\n \"def point_inside_circle(x,y,center_x,center_y,radius):\\n return (x-center_x)**2 + (y - center_y)**2 < radius**2\",\n \"def isInside(x1, y1, x2, y2, x3, y3, x, y):\\n # Calculate area of triangle ABC\\n A = area (x1, y1, x2, y2, x3, y3)\\n \\n # Calculate area of triangle PBC\\n A1 = area (x, y, x2, y2, x3, y3)\\n \\n # Calculate area of triangle PAC\\n A2 = area (x1, y1, x, y, x3, y3)\\n \\n # Calculate area of triangle PAB\\n A3 = area (x1, y1, x2, y2, x, y)\\n \\n # Check if sum of A1, A2 and A3\\n # is same as A\\n if(A == A1 + A2 + A3):\\n return True\\n else:\\n return False\",\n \"def containsPos(self, obst_pos, aerial_pos):\\n dist_to_center = obst_pos.distanceTo(aerial_pos)\\n return dist_to_center <= self.sphere_radius\",\n \"def checkBounds(x,y,z,center,radius):\\n r2 = (x-center[0])**2 + (y-center[1])**2# + (z-center[0])**2\\n if r2 < radius**2:\\n return True\\n else:\\n return False\",\n \"def isInCircle(self,x1,y1,radius1):\\r\\n if(distance(self.x,x1,self.y,y1) < (self.radius+radius1)):\\r\\n return True\\r\\n return False\",\n \"def check_point_in_detector(p, radius=radius, height=height, distance=distance):\\r\\n if p[0]**2 + p[1]**2 <= radius**2: # Are the x and y coordinates in the circle?\\r\\n if (p[2] >= distance) and (p[2] <= height+distance): # Is the z coordinate between the distance and the height?\\r\\n return True\\r\\n else:\\r\\n return False\\r\\n else:\\r\\n return False\",\n \"def inside(x, y, primitive):\\n\\n # You should implement your inside test here for all shapes\\n # for now, it only returns a false test\\n\\n if primitive[\\\"shape\\\"] == \\\"circle\\\":\\n dist_sqr = ((primitive[\\\"center\\\"][0] - x) ** 2 +\\n (primitive[\\\"center\\\"][1] - y) ** 2)\\n\\n return dist_sqr <= primitive[\\\"radius\\\"] ** 2\\n else:\\n return winding_number(x, y, primitive)\\n\\n return False\",\n \"def is_point_inside_hypersphere(point: np.array, c: List[float], r: float) -> bool:\\n return np.linalg.norm(point - c) < r\",\n \"def _intersected(positions, radius):\\n P1 = positions[0]\\n P2 = positions[1]\\n P3 = positions[2]\\n temp1 = P2 - P1\\n e_x = temp1 / np.linalg.norm(temp1)\\n temp2 = P3 - P1\\n i = np.dot(e_x, temp2)\\n temp3 = temp2 - i * e_x\\n e_y = temp3 / np.linalg.norm(temp3)\\n e_z = np.cross(e_x, e_y)\\n d = np.linalg.norm(P2 - P1)\\n j = np.dot(e_y, temp2) \\n x = d / 2\\n y = (-2*i*x + i*i + j*j) / (2*j)\\n temp4 = radius**2 - x*x - y*y\\n if temp4 < 0:\\n return False\\n return True\",\n \"def isoutside(coords, shape):\\n # Label external pores for trimming below\\n if len(shape) == 1: # Spherical\\n # Find external points\\n r = np.sqrt(np.sum(coords**2, axis=1))\\n Ps = r > shape[0]\\n elif len(shape) == 2: # Cylindrical\\n # Find external pores outside radius\\n r = np.sqrt(np.sum(coords[:, [0, 1]]**2, axis=1))\\n Ps = r > shape[0]\\n # Find external pores above and below cylinder\\n if shape[1] > 0:\\n Ps = Ps + (coords[:, 2] > shape[1])\\n Ps = Ps + (coords[:, 2] < 0)\\n else:\\n pass\\n elif len(shape) == 3: # Rectilinear\\n shape = np.array(shape, dtype=float)\\n try:\\n lo_lim = shape[:, 0]\\n hi_lim = shape[:, 1]\\n except IndexError:\\n lo_lim = np.array([0, 0, 0])\\n hi_lim = shape\\n Ps1 = np.any(coords > hi_lim, axis=1)\\n Ps2 = np.any(coords < lo_lim, axis=1)\\n Ps = Ps1 + Ps2\\n return Ps\",\n \"def sphere_isclose(c1, c2, *args, **kwargs):\\n return np.isclose(c1.radius, c2.radius, *args, **kwargs) and np.allclose(\\n c1.center, c2.center, *args, **kwargs\\n )\",\n \"def inside_unit_circle(point):\\n distance = math.sqrt(point[0] ** 2 + point[1] ** 2)\\n return distance < 1\",\n \"def get_radius(self):\",\n \"def incircle(self,xpos,ypos,cellx,celly):\\n xcell, ycell = self.getcellcenter(cellx,celly)\\n if ((xpos - xcell)**2 + (ypos - ycell)**2) < self.crad2:\\n return True\\n return False\\n\\n return cellx, celly\",\n \"def __contains__(self, point): \\n corners = self.corners\\n\\n if isinstance(point, tuple):\\n from pyresample.spherical_geometry import Coordinate\\n retval = planar_point_inside(Coordinate(*point), corners)\\n else:\\n retval = planar_point_inside(point, corners)\\n\\n #print ' retval from FALSE CORNERS contains '+str(retval)\\n\\n return retval\",\n \"def is_point_inside_hypermoon(point: np.array, c: Tuple[List[float]], r: Tuple[float]) -> bool:\\n return is_point_inside_hypersphere(point, c[0], r[0]) and not is_point_inside_hypersphere(point, c[1], r[1])\",\n \"def __contains__(self, point):\\n #### Original \\n from pyresample.spherical_geometry import point_inside, Coordinate\\n corners = self.corners\\n\\n if isinstance(point, tuple):\\n return point_inside(Coordinate(*point), corners)\\n else:\\n return point_inside(point, corners)\\n #### End Original\\n #from .spherical import SphPolygon\\n #log.info('RUNNING SPHERICAL in __contains__')\\n #sphpoly = SphPolygon(corners)\\n #return sphpoly.intersection(SphPolygon(point), sphpoly)\",\n \"def containsPos(self, aerial_pos):\\n # Check altitude of position\\n aerial_alt = aerial_pos.altitude_msl\\n if (aerial_alt < 0 or aerial_alt > self.cylinder_height):\\n return False\\n # Check lat/lon of position\\n dist_to_center = self.gps_position.distanceTo(aerial_pos.gps_position)\\n if dist_to_center > self.cylinder_radius:\\n return False\\n # Both within altitude and radius bounds, inside cylinder\\n return True\",\n \"def within_radius(self, radius=5.0):\\n\\n return GeoEntry.within_radius(self.primary_geocode, radius, ['all',])\",\n \"def is_clicked(vtx_x, vtx_y, mouse_x, mouse_y, radius):\\n return math.sqrt(((mouse_x - vtx_x) ** 2) + ((mouse_y - vtx_y) ** 2)) < radius\",\n \"def HasPoint(self, vtkAMRBox, , , p_float_6, p_float_7, p_float_8):\\n ...\",\n \"def intersects( self, sphere, dim ):\\n nearest = self.__findFarestPoint__( sphere.center );\\n dist = utility.euclideanDistSqr( nearest, sphere.center );\\n if( dist < sphere.radius**2 ):\\n return True;\\n else:\\n return False;\",\n \"def isInside(self, position, maxDimLens):\\n dim = len(position);\\n deltas = [0] * dim;\\n distSqr = 0;\\n for i in range(0, dim):\\n deltas[i] = math.fabs(position[i] - self.mSample[i]);\\n if math.fabs(maxDimLens[i] - deltas[i]) < deltas[i]:\\n deltas[i] = math.fabs(maxDimLens[i] - deltas[i]);\\n distSqr += deltas[i]**2;\\n\\n if distSqr < ( self.mRadius**2 ):\\n return True;\\n else:\\n return False;\",\n \"def within(self, right: GeoSpatialValue) -> ir.BooleanValue:\\n return ops.GeoWithin(self, right).to_expr()\",\n \"def test_get_radius():\\n center = Coordinates(7, 3)\\n radius = 12\\n\\n returned_rad = get_radius(center, radius, 30)\\n\\n assert returned_rad == radius\\n assert returned_rad != center.get_x()\\n assert returned_rad != center.get_y()\",\n \"def contains_pt(self, pt):\\n x, y = pt\\n if not self.x - self.radius < x < self.x + self.radius:\\n return False\\n if not self.y - self.radius < y < self.y + self.radius:\\n return False\\n return True\",\n \"def is_point_inside_hypercube(point: List[float], c: List[float], r: float) -> bool:\\n diff = np.subtract(point, c)\\n return np.all(np.absolute(diff) <= r)\",\n \"def IsValid(self, *args):\\n return _Bnd.Bnd_Sphere_IsValid(self, *args)\",\n \"def intersects(self, right: GeoSpatialValue) -> ir.BooleanValue:\\n return ops.GeoIntersects(self, right).to_expr()\",\n \"def validate_pos(game: TowerDefenceSolver, position: Tuple[int, int], purchases_list: Purchases) -> bool:\\n if (\\n position[0] < 0\\n or position[1] < 0\\n or position[0] >= game.map_height\\n or position[1] >= game.map_width\\n or position in game.path\\n ):\\n return False\\n\\n for purchase in purchases_list:\\n if purchase[\\\"coords\\\"] == position:\\n return False\\n\\n return True\",\n \"def test_get_neighborhood_radius_consistent():\\r\\n grid_spacing = random.uniform(1e-6, 10.0)\\r\\n center = numpy.random.random(random.randint(1, 3))\\r\\n\\r\\n # Find points with radius neighborhood\\r\\n radius = random.uniform(_distance_to_nearest(grid_spacing, center), grid_spacing*5)\\r\\n points = ill.get_neighborhood_radius(grid_spacing, center, radius)\\r\\n\\r\\n # Every points found within this radius, should be in the points of a larger radius\\r\\n outer_points = ill.get_neighborhood_radius(grid_spacing, center,\\r\\n radius+random.uniform(0.0, grid_spacing*5))\\r\\n\\r\\n for point in points:\\r\\n assert point in outer_points\",\n \"def is_bound(pos1, el1, pos2, el2):\\n threshold = 0.1\\n if el1 == 'H' or el2 == 'H':\\n threshold = 0.2\\n if np.linalg.norm(np.array(pos1) - np.array(pos2)) < covalence_radius[el1] + covalence_radius[el2] + threshold:\\n return True\\n return False\",\n \"def within_radius(latlong, radius=5.0, ctype_fields=None):\\n\\n radius = float(radius) # may come through as str\\n\\n if type(latlong) == GeoEntry:\\n latlong = [latlong.latitude, latlong.longitude]\\n\\n # These are our 4 points (N/S/E/W) We use this to build a bounding box\\n HEADINGS = enumerate([0, math.pi/2, math.pi, 3*math.pi/2])\\n\\n try:\\n geoentry = GeoEntry.objects.get(latitude=latlong[0], longitude=latlong[1])\\n except GeoEntry.DoesNotExist:\\n # Maybe handle more gracefully?\\n raise Exception('No GeoEntry matching query')\\n except GeoEntry.MultipleObjectsReturned:\\n # In this case lets use the first one instead for now\\n geoentry = GeoEntry.objects.filter(latitude=latlong[0], longitude=latlong[1])[0]\\n\\n source_lat = GeoEntry.degrees_to_radians(latlong[0])\\n source_long = GeoEntry.degrees_to_radians(latlong[1])\\n distance = GeoEntry.miles_to_radians(radius)\\n\\n boundries = []\\n\\n for (cnt, heading) in HEADINGS:\\n target_lat = GeoEntry.calculate_latitude(source_lat, distance, heading)\\n target_long = GeoEntry.calculate_longitude(target_lat, source_long, distance, heading)\\n\\n boundries.append([GeoEntry.radians_to_degrees(target_lat), \\\\\\n GeoEntry.radians_to_degrees(target_long)])\\n\\n entries = GeoEntry.objects.all().select_related().filter(latitude__lte=str(boundries[0][0]),\\n latitude__gte=str(boundries[2][0]), longitude__gte=str(boundries[1][1]),\\n longitude__lte=str(boundries[3][1]))\\n\\n entry_data = list()\\n for entry in entries:\\n obj = entry.content_object\\n ctype_dict = None,\\n if obj and ctype_fields:\\n if (len(ctype_fields)==1 and ctype_fields[0]=='all'):\\n ctype_list = list()\\n for field in obj._meta.fields:\\n field_data = getattr(obj, field.name)\\n if type(field_data) == unicode:\\n ctype_list.append([field.name, field_data.encode('utf-8')])\\n else:\\n ctype_list.append([field.name, str(field_data)])\\n ctype_dict = dict(ctype_list)\\n else:\\n ctype_dict = dict([[field, getattr(obj, field)] for field in ctype_fields])\\n entry_data.append(dict(\\n distance=entry.distance_to_latlong((latlong[0], latlong[1])),\\n content_type=entry.content_type.pk,\\n object_id=entry.object_id,\\n object_data=ctype_dict,\\n latitude=str(entry.latitude),\\n longitude=str(entry.longitude),\\n )\\n )\\n entry_data.sort() # return orderd by distance\\n # now fix the bounding box SQL to limit within our radius\\n sorted_data = [elem for elem in entry_data if elem['distance']<radius]\\n return sorted_data\",\n \"def has_intersection(self, obj):\\r\\n obj_x, obj_y = obj.get_location()\\r\\n x = self.__x\\r\\n y = self.__y\\r\\n # Distance formula\\r\\n distance = sqrt((obj_x - x) ** 2 + (obj_y - y) ** 2)\\r\\n if distance <= obj.get_radius() + self.__radius:\\r\\n return True\\r\\n return False\",\n \"def hit(bx, by, r, px, py,h):\\n if bx >= px:\\n distance = bx - px\\n else:\\n distance = px - bx\\n if py<=by and by<=py+h and distance <= r:\\n return True\\n else:\\n return False\",\n \"def in_area_of_interest (lat, long, min_lat, max_lat, min_long, max_long):\\n\\n if lat is None or long is None:\\n return False\\n\\n lat = float(lat)\\n long = float(long)\\n\\n if ((lat >= min_lat and lat <= max_lat) and\\n (long >= min_long and long <= max_long)):\\n return True\\n\\n return False\",\n \"def isContainedWithin(self,other):\\n retVal = True\\n bounds = self.points\\n\\n if( isinstance(other,Feature) ): # another feature do the containment test\\n retVal = other.contains(self)\\n elif( isinstance(other,tuple) and len(other)==3 ): # a circle\\n #assume we are in x,y, r format\\n rr = other[2]*other[2] # radius squared\\n x = other[0]\\n y = other[1]\\n for p in bounds:\\n test = ((x-p[0])*(x-p[0]))+((y-p[1])*(y-p[1]))\\n if( test > rr ):\\n retVal = False\\n break\\n elif( isinstance(other,tuple) and len(other)==4 and # a bounding box\\n ( isinstance(other[0],float) or isinstance(other[0],int))): # we assume a tuple of four is (x,y,w,h)\\n retVal = ( self.maxX() <= other[0]+other[2] and\\n self.minX() >= other[0] and\\n self.maxY() <= other[1]+other[3] and\\n self.minY() >= other[1] )\\n elif(isinstance(other,list) and len(other) > 2 ): # an arbitrary polygon\\n #everything else ....\\n retVal = True\\n for p in bounds:\\n test = self._pointInsidePolygon(p,other)\\n if(not test):\\n retVal = False\\n break\\n\\n else:\\n logger.warning(\\\"SimpleCV did not recognize the input type to features.contains. This method only takes another blob, an (x,y) tuple, or a ndarray type.\\\")\\n retVal = False\\n return retVal\",\n \"def in_circle(x0, y0, x, y, r):\\n return ((x - x0) ** 2 + (y - y0) ** 2) <= (r ** 2)\",\n \"def WhereAreYou(CurLongitude,CurLatitude,LocationLongitude,LocationLatitude,LocationRadius):\\n # Calculate the great circle distance between two points\\n # on the earth (specified in decimal degrees)\\n # 将十进制度数转化为弧度\\n CurLongitude,CurLatitude,LocationLongitude,LocationLatitude = map(radians, [float(CurLongitude),float(CurLatitude),float(LocationLongitude),float(LocationLatitude)])\\n\\n # haversine公式\\n dlon = LocationLongitude - CurLongitude\\n dlat = LocationLatitude - CurLatitude\\n a = sin(dlat / 2) ** 2 + cos(CurLatitude) * cos(LocationLatitude) * sin(dlon / 2) ** 2\\n c = 2 * asin(sqrt(a))\\n r = 6371 # 地球平均半径，单位为公里\\n distance = c * r * 1000\\n if(distance < float(LocationRadius)):\\n return True\\n else:\\n return False\",\n \"def check_me(triplet, list_of_coords):\\n c = True\\n for element in list_of_coords:\\n if (float(triplet[0])*0.99 <= float(element[0]) <= float(triplet[0])*1.01):\\n if (float(triplet[1])*0.99 <= float(element[1]) <= float(triplet[1])*1.01):\\n if (float(triplet[2])*0.99 <= float(element[2]) <= float(triplet[2])*1.01):\\n c = False\\n return c\",\n \"def contains(self,other):\\n retVal = False\\n\\n bounds = self.points\\n if( isinstance(other,Feature) ):# A feature\\n retVal = True\\n for p in other.points: # this isn't completely correct - only tests if points lie in poly, not edges.\\n p2 = (int(p[0]),int(p[1]))\\n retVal = self._pointInsidePolygon(p2,bounds)\\n if( not retVal ):\\n break\\n # a single point\\n elif( (isinstance(other,tuple) and len(other)==2) or ( isinstance(other,np.ndarray) and other.shape[0]==2) ):\\n retVal = self._pointInsidePolygon(other,bounds)\\n\\n elif( isinstance(other,tuple) and len(other)==3 ): # A circle\\n #assume we are in x,y, r format\\n retVal = True\\n rr = other[2]*other[2]\\n x = other[0]\\n y = other[1]\\n for p in bounds:\\n test = ((x-p[0])*(x-p[0]))+((y-p[1])*(y-p[1]))\\n if( test < rr ):\\n retVal = False\\n break\\n\\n elif( isinstance(other,tuple) and len(other)==4 and ( isinstance(other[0],float) or isinstance(other[0],int))):\\n retVal = ( self.maxX() <= other[0]+other[2] and\\n self.minX() >= other[0] and\\n self.maxY() <= other[1]+other[3] and\\n self.minY() >= other[1] )\\n elif(isinstance(other,list) and len(other) >= 4): # an arbitrary polygon\\n #everything else ....\\n retVal = True\\n for p in other:\\n test = self._pointInsidePolygon(p,bounds)\\n if(not test):\\n retVal = False\\n break\\n else:\\n logger.warning(\\\"SimpleCV did not recognize the input type to features.contains. This method only takes another blob, an (x,y) tuple, or a ndarray type.\\\")\\n return False\\n\\n return retVal\",\n \"def within(point: tuple, box: tuple) -> bool:\\r\\n \\r\\n return box[0] < point[0] < box[2] and box[1] < point[1] < box[3]\",\n \"def are_close(coord1, coord2, tolerance=10):\\n return vincenty(coord1, coord2).meters < tolerance\",\n \"def covers(self, right: GeoSpatialValue) -> ir.BooleanValue:\\n return ops.GeoCovers(self, right).to_expr()\",\n \"def stores_in_given_radius_of_given_postcode(request):\\n\\n radius = request.POST.get('radius')\\n if radius:\\n radius = Decimal(radius)\\n else:\\n return Response('Radius is required', status=status.HTTP_404_NOT_FOUND)\\n\\n postcode = request.POST.get('postcode')\\n if postcode:\\n postcode = postcode.replace(' ', '')\\n else:\\n return Response('Postcode is required', status=status.HTTP_404_NOT_FOUND)\\n\\n stores_in_given_radius = []\\n source_latitude, source_longitude = get_lat_and_lon_of_given_postcode(postcode)\\n\\n for store in Store.objects.order_by('-latitude'):\\n if store.latitude and store.longitude:\\n if check_if_in_radius(store, source_latitude, source_longitude, radius):\\n stores_in_given_radius.append(store)\\n\\n serializer = StoreSerializer(stores_in_given_radius, many=True)\\n return Response(serializer.data)\",\n \"def brute_force(savedPnts, unitRadius, point):\\n for pnt in savedPnts:\\n d = distance(pnt, point)\\n if d < unitRadius: return False\\n return True\",\n \"def test_is_on_intersection():\\n center = Coordinates(1, 1)\\n radius = 10\\n\\n i = Intersection(center, radius, 20)\\n\\n in_circle = Coordinates(2, 2)\\n not_in_circle = Coordinates(100, 150)\\n before_circumference = Coordinates(1, 10.9)\\n on_circumference = Coordinates(1, 11)\\n after_circumference = Coordinates(1, 11.1)\\n\\n assert is_on_intersection(i, in_circle)\\n assert is_on_intersection(i, on_circumference)\\n assert is_on_intersection(i, before_circumference)\\n assert not is_on_intersection(i, not_in_circle)\\n assert not is_on_intersection(i, after_circumference)\",\n \"def _check_overlap(self, points, radius):\\n dists = distance.cdist(points, points, 'euclidean')\\n dists = dists[np.nonzero(dists)]\\n\\n return np.any(dists < 2.0 * radius)\",\n \"def circles_collide(x1: float, y1: float, r1: float, x2: float, y2: float, r2: float) -> bool:\\n return distance_between_sq(x1, y1, x2, y2) <= (r1 + r2)**2\",\n \"def is_inside(self, p):\\n s, t = self.get_barycentric_coord(p)\\n if 0 <= s <= 1 and 0 <= t <= 1 and s + t <= 1:\\n return True\\n else:\\n return False\",\n \"def test_update_radius():\\n center = Coordinates(1, 1)\\n rad1 = 20.3\\n speed = 30\\n\\n i = Intersection(center, rad1, speed)\\n\\n assert i.get_radius() == 20.3\\n\\n i.update_radius(56.5)\\n\\n assert i.get_radius() == 56.5\",\n \"def radius(x) :\\r\\n return Feature(x, \\\"radius\\\")\",\n \"def contains(self, Union, QPointF=None, QPoint=None): # real signature unknown; restored from __doc__\\n return False\",\n \"def is_inside(self, points):\\n points = np.atleast_2d(points) - self.centroid\\n return np.logical_and(\\n np.linalg.norm(points, axis=-1) <= self.radius,\\n # At present circles are not orientable, so the z position must\\n # match exactly.\\n np.isclose(points[:, 2], 0),\\n )\",\n \"def contains ( self, pos ):\\n dr2 = (pos[0, :]-self.x)**2 + (pos[1, :]-self.y)**2\\n # which points are in the circle?\\n if self.include_border:\\n inds = (dr2 - self.r**2) < self.abs_tol\\n else:\\n inds = (dr2 - self.r**2) < -self.abs_tol\\n \\n \\n # if there's no poit inside\\n if ~inds.any() and self.default_nearest: \\n inds[argmin(dr2)] = True\\n \\n return inds\",\n \"def is_inside(self, x: int, y: int) -> bool:\\n pass\",\n \"def check_in(x, y, R=Re):\\n r = np.sqrt(x ** 2 + y ** 2)\\n return r <= R\",\n \"def testSphereRadius(self):\\n sp = nigel.SphereSelection(nb, radius=10)\\n self.assertEqual(sp.n, 9)\",\n \"def dans_cercle(self, r, x, y):\\r\\n self.r_num(r)\\r\\n valid = (isinstance(x, int) or isinstance(x, float)) and \\\\\\r\\n (isinstance(y, int) or isinstance(y, float))\\r\\n if valid:\\r\\n if sqrt(x**2+y**2)<self.r:\\r\\n return True\\r\\n else:\\r\\n return False\\r\\n else:\\r\\n raise TypeError\",\n \"def hitTest( a, b ):\\n r = a.radius + b.radius\\n x = abs( a.x - b.x )\\n y = abs( a.y - b.y )\\n if x <= r and y <= r and x*x + y*y <= r*r:\\n return 1\\n return 0\",\n \"def is_inside(inner_path, outer_path):\\r\\n if not hasattr(inner_path, 'bounding_box'):\\r\\n inner_path.bounding_box = CutPlanner.bounding_box(inner_path)\\r\\n if not hasattr(outer_path, 'bounding_box'):\\r\\n outer_path.bounding_box = CutPlanner.bounding_box(outer_path)\\r\\n if outer_path.bounding_box[0] > inner_path.bounding_box[0]:\\r\\n # outer minx > inner minx (is not contained)\\r\\n return False\\r\\n if outer_path.bounding_box[1] > inner_path.bounding_box[1]:\\r\\n # outer miny > inner miny (is not contained)\\r\\n return False\\r\\n if outer_path.bounding_box[2] < inner_path.bounding_box[2]:\\r\\n # outer maxx < inner maxx (is not contained)\\r\\n return False\\r\\n if outer_path.bounding_box[3] < inner_path.bounding_box[3]:\\r\\n # outer maxy < inner maxy (is not contained)\\r\\n return False\\r\\n if outer_path.bounding_box == inner_path.bounding_box:\\r\\n if outer_path == inner_path: # This is the same object.\\r\\n return False\\r\\n if not hasattr(outer_path, 'vm'):\\r\\n outer_path = Polygon([outer_path.point(i / 100.0, error=1e4) for i in range(101)])\\r\\n vm = VectorMontonizer()\\r\\n vm.add_cluster(outer_path)\\r\\n outer_path.vm = vm\\r\\n for i in range(101):\\r\\n p = inner_path.point(i / 100.0, error=1e4)\\r\\n if not outer_path.vm.is_point_inside(p.x, p.y):\\r\\n return False\\r\\n return True\",\n \"def is_point_in_box(x, y, bbox):\\n if x < 200 and y < 200:\\n return True\\n return False\",\n \"def inside(self, p: PointType, q: PointType) -> bool:\\n\\n # XXX re-implement with ccw and a list of points instead of a pair\\n\\n i = min(p.x, q.x) < self.x < max(p.x, q.x)\\n j = min(p.y, q.y) < self.y < max(p.y, q.y)\\n\\n return i and j\",\n \"def get_in_radius(radius):\\n def _return_values(user):\\n \\\"\\\"\\\"\\n :user Dict containing the users information, by keeping this in a nested function if more or less information\\n is required to be returned it can be modified in one location rather than multiple locations.\\n Returns a predefined dict of values to minimise duplicated code.\\n :return: dictionary of user values\\n \\\"\\\"\\\"\\n return {\\\"id\\\":user[\\\"id\\\"],\\n \\\"first_name\\\":user[\\\"first_name\\\"],\\n \\\"last_name\\\": user[\\\"last_name\\\"]\\n }\\n\\n users_in_range = [] # dictionary to store user information as we only want first name and last name.\\n london = (51.30, 0.5) # Create a position point for london using its latitude and longitude\\n\\n # ** Note: 'City' is not included in the data returned by the users end point ut it is if you call the\\n # users individually i could do this using for loop but that would cause 1000 calls to the API each time\\n # the end point is called so instead i've opted to do 2 calls and parsing the data in the API.\\n # This should minimise the number of requests being sent to the API.\\n\\n # First i will get all the users and compute their current distance from london and checking if that is within\\n # the radius specified by the end user (radius component of the url), Then i will get all users listed as being\\n # in the city of london and checking if those customers are already in the list by creating a list of ids.\\n\\n # If they are in the list they are discarded if they are not then their first name, last name and id are added\\n # to the array, since the requirements did not specify what information was to be returned only those three values\\n # are returned (This minimises the data protection implications)\\n\\n url = \\\"/users\\\"\\n response = requests.get(f\\\"{host}{url}\\\")\\n\\n for user in json.loads(response.text):\\n # Creation location point for the current user and use haversine to compute the distance between the user and\\n # london in miles\\n user_location = (float(user[\\\"latitude\\\"]), float(user[\\\"longitude\\\"]))# (lat, lon)\\n distance = haversine(london, user_location, unit='mi')\\n\\n # if the distance is 50 miles or less then add the users first and last name to the users_in_range dict using\\n if distance <= float(radius):\\n users_in_range.append(_return_values(user))\\n\\n # Get the used defined as 'living in london' this is not clear in the instructions so i have made the 'assumption'\\n # That the city value corresponds to their current city of residence.\\n url = \\\"/city/London/users\\\"\\n response = requests.get(f\\\"{host}{url}\\\")\\n\\n # Parse through the list or returned users and filter entries which already exist and append ones that dont to the\\n # list to be returned\\n for user in json.loads(response.text):\\n if not user[\\\"id\\\"] in [user[\\\"id\\\"] for user in users_in_range]:\\n users_in_range.append(_return_values(user))\\n\\n # convert the list into a json payload and return using\\n return json.dumps(users_in_range)\",\n \"def containsManyPos(self, aerial_pos_list):\\n # Get boundary points\\n ordered_pts = self.boundary_pts.order_by('order')\\n path_pts = [[wpt.position.gps_position.latitude,\\n wpt.position.gps_position.longitude]\\n for wpt in ordered_pts]\\n # First check enough points to define a polygon\\n if len(path_pts) < 3:\\n return [False] * len(aerial_pos_list)\\n\\n # Create path to use for testing polygon inclusion\\n path_pts.append(path_pts[0])\\n path = mplpath.Path(np.array(path_pts))\\n\\n # Test each aerial position for altitude\\n results = list()\\n for aerial_pos in aerial_pos_list:\\n # Check altitude bounds\\n alt = aerial_pos.altitude_msl\\n altitude_check = (alt <= self.altitude_msl_max\\n and alt >= self.altitude_msl_min)\\n results.append(altitude_check)\\n\\n # Create a list of positions to test whether inside polygon\\n polygon_test_point_ids = [cur_id\\n for cur_id in range(len(aerial_pos_list))\\n if results[cur_id]]\\n if len(polygon_test_point_ids) == 0:\\n return results\\n polygon_test_points = [[aerial_pos_list[cur_id].gps_position.latitude,\\n aerial_pos_list[cur_id].gps_position.longitude]\\n for cur_id in polygon_test_point_ids]\\n\\n # Test each point for inside polygon\\n polygon_test_results = path.contains_points(\\n np.array(polygon_test_points))\\n for test_id in range(len(polygon_test_point_ids)):\\n cur_id = polygon_test_point_ids[test_id]\\n results[cur_id] = (polygon_test_results[test_id] == True)\\n\\n return results\",\n \"def isinsidepointXY(x,p):\\n \\n return dist(x,p) < epsilon\",\n \"def at_loc((x, y), (cx, cy), eps=0.000035):\\n\\treturn (x - cx)**2 + (y - cy)**2 <= eps**2\",\n \"def inCircleFast(self, tri, p):\\n center, radius = self.circles[tri]\\n return np.sum(np.square(center - p)) <= radius\",\n \"def check_coordinates(X, Y):\\n\\n # Accounting for elliptical Jupiter disk\\n Y *= 1.071374\\n\\n return sqrt(X ** 2 + Y ** 2)\",\n \"def in_water(latitude: float, longitude: float) -> bool:\\n path = os.path.abspath('water_polygons.shp')\\n with fiona.open(path) as fiona_collection:\\n box_detail = 0.0001\\n point = Point(longitude, latitude)\\n # here we filter to only scan results near the point in question.\\n for record in fiona_collection.filter(bbox=(\\n longitude+box_detail, latitude+box_detail,\\n longitude-box_detail, latitude-box_detail)):\\n if record['geometry']:\\n shape = asShape(record['geometry'])\\n if shape.contains(point):\\n return True\\n return False\",\n \"def isInArea(self, width, height, depth):\\n if self.position[0] + self.radius > width / -2 and self.position[0] + self.radius < width / 2:\\n if self.position[1] + self.radius > height / -2 and self.position[1] + self.radius < height / 2:\\n if self.position[2] + self.radius > -depth and self.position[2] + self.radius < depth:\\n return True\\n else:\\n return False\",\n \"def contains_properly(self, right: GeoSpatialValue) -> ir.BooleanValue:\\n return ops.GeoContainsProperly(self, right).to_expr()\",\n \"def in_ellipse(x,y,a,b):\\n return ellipse(x,y,a,b) <= 1\",\n \"def conf_test(self, trial_coords: np.ndarray) -> bool:\\n #N = len(trial_coords)\\n r2: float = 0\\n i =0\\n r2 = np.inner(trial_coords, trial_coords)\\n if (r2> self.m_radius2):\\n return False\\n return True\",\n \"def vincenty(p1, p2):\\n # Note: GeoPy expects (latitude, longitude) pairs.\\n return geopy.distance.vincenty(\\n (p1.y, p1.x),\\n (p2.y, p2.x)\\n ).miles\",\n \"def area_of_circle(radius):\\n return radius\",\n \"def sphereArea(radius):\\n area = 4 * math.pi * radius ** 2\\n return area\",\n \"def point_in_ellipse(point: Vector, center: Vector, angle: float, length: float, width: float) -> bool:\\n c, s = np.cos(angle), np.sin(angle)\\n r = np.matrix([[c, -s], [s, c]])\\n ru = r.dot(point - center)\\n return np.sum(np.square(ru / np.array([length, width]))) < 1\",\n \"def in_geofence(self, coordinates):\\n\\t\\tcoords_transformed = ogr.Geometry(ogr.wkbPoint)\\n\\t\\tcoords_transformed.AddPoint(*coordinates)\\n\\t\\treturn self.polygon.Contains(coords_transformed)\",\n \"def is_inside(self, mX, mY, point):\\n return (math.sqrt((point[0] - mX) * (point[0] - mX)\\n + (point[1] - mY) * (point[1] - mY)) <= 2)\",\n \"def Check(self, vtkGenericCell, p_float):\\n ...\",\n \"def isPrice(price, high, low):\\n return (price >= low) and (price <= high)\",\n \"def check_inside(self, pos):\\n x,y = pos\\n return x >= self.posx and x <= self.posx + self.sizex and y >= self.posy and y <= self.posy + self.sizey\",\n \"def sphere_area(radius : number) -> number:\\n area = 4*pi*radius*radius\\n return area\",\n \"def calculate(self, real_estate, min_length, min_area, length_unit, area_unit):\\n geometry_types = Config.get('geometry_types')\\n line_types = geometry_types.get('line').get('types')\\n polygon_types = geometry_types.get('polygon').get('types')\\n point_types = geometry_types.get('point').get('types')\\n if self.published:\\n intersection = self.geom.intersection(real_estate.limit)\\n # TODO upon update to Shapely 1.7, a check for result.is_emtpy will be needed (see PR#1037)\\n # differentiate between Points and MultiPoint\\n if not intersection.is_empty:\\n result = self._extract_collection(intersection)\\n if self.geom.type not in point_types + line_types + polygon_types:\\n supported_types = ', '.join(point_types + line_types + polygon_types)\\n raise AttributeError(\\n u'The passed geometry is not supported: {type}. It should be one of: {types}'.format(\\n type=self.geom.type, types=supported_types\\n )\\n )\\n elif self.geom.type in point_types:\\n if result.type == point_types[1]:\\n # If it is a multipoint make a list and count the number of elements in the list\\n self._nr_of_points = len(list(result.geoms))\\n self._test_passed = True\\n elif result.type == point_types[0]:\\n # If it is a single point the number of points is one\\n self._nr_of_points = 1\\n self._test_passed = True\\n elif self.geom.type in line_types and result.type in line_types:\\n self._units = length_unit\\n length_share = result.length\\n if length_share >= min_length:\\n self._length_share = length_share\\n self._test_passed = True\\n elif self.geom.type in polygon_types and result.type in polygon_types:\\n self._units = area_unit\\n area_share = result.area\\n compensated_area = area_share / real_estate.areas_ratio\\n if compensated_area >= min_area:\\n self._area_share = compensated_area\\n self._test_passed = True\\n else:\\n # This intersection result should not be used for the OEREB extract:\\n # for example, if two polygons are touching each other, the intersection geometry will be\\n # the point or linestring representing the touching part.\\n log.debug(\\n u'Intersection result changed geometry type. '\\n u'Original geometry was {0} and result is {1}'.format(\\n self.geom.type,\\n result.type\\n )\\n )\\n self.calculated = True\\n return self._test_passed\",\n \"def match(self, pos, radius):\\n\\n nodes = self._data[:, 2:5]\\n distlist = np.squeeze(cdist(pos.reshape(1, 3), nodes))\\n if distlist.size == 0:\\n return False, -2\\n minidx = distlist.argmin()\\n minnode = self._data[minidx, 2:5]\\n\\n # See if either of them can cover each other with a ball of their own\\n # radius\\n mindist = np.linalg.norm(pos - minnode)\\n return radius > mindist or self._data[minidx, 5] > mindist, minidx\",\n \"def intersects(self, *__args): # real signature unknown; restored from __doc__ with multiple overloads\\r\\n return False\",\n \"def find_channel_neighbors(geom, radius):\\n return (squareform(pdist(geom)) <= radius)\",\n \"def find_channel_neighbors(geom, radius):\\n return (squareform(pdist(geom)) <= radius)\",\n \"def is_on(self, obj1_loc, obj1_dims, obj2_loc, obj2_dims):\\n VERT_MEASUREMENT_TOLERANCE = self.VERT_MEASUREMENT_TOLERANCE\\n result = None\\n obj1_x = obj1_loc[0]\\n obj1_y = obj1_loc[1]\\n obj1_zmin = obj1_loc[2] - (.5 * obj1_dims[2])\\n obj2_xmin, obj2_xmax, obj2_ymin, obj2_ymax, obj2_zmin, obj2_zmax = self.get_corners(obj2_loc, obj2_dims)\\n if obj1_x >= obj2_xmin and obj1_x <= obj2_xmax:\\n if obj1_y >= obj2_ymin and obj1_y <= obj2_ymax:\\n if obj1_zmin >= obj2_zmax-VERT_MEASUREMENT_TOLERANCE and obj1_zmin <= obj2_zmax+VERT_MEASUREMENT_TOLERANCE:\\n result = 'on'\\n return result\",\n \"def test_intersect_volume(self):\\n\\n intersect_shape = ExtrudeCircleShape(points=[(30, 0)], radius=5, distance=50)\\n\\n intersected_shape = ExtrudeCircleShape(\\n points=[(30, 0)],\\n radius=10,\\n distance=50,\\n intersect=[self.test_shape, intersect_shape],\\n )\\n\\n assert intersected_shape.volume() == pytest.approx(math.pi * 5**2 * 30)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7254775","0.61709523","0.5765121","0.57588995","0.5667875","0.5657872","0.5615331","0.5498272","0.54953516","0.5392794","0.5387623","0.5384196","0.53837055","0.5313938","0.52996296","0.5263196","0.5251948","0.5240129","0.5167428","0.51551384","0.5082203","0.5078475","0.5062163","0.5049635","0.50441986","0.50374484","0.5028136","0.50127864","0.5002548","0.49691728","0.49354702","0.4932225","0.49271417","0.49271253","0.4917652","0.48700935","0.48695645","0.48687702","0.48685458","0.4866482","0.48596692","0.4849615","0.48470345","0.48411787","0.48253793","0.48222393","0.4817893","0.4797892","0.4796884","0.47844997","0.47828957","0.47802","0.47730115","0.47672617","0.47622877","0.47617942","0.47549403","0.4748241","0.47443804","0.47426128","0.47390378","0.473851","0.47309265","0.4709521","0.47035718","0.4702084","0.46869373","0.4681313","0.468008","0.46780866","0.46778128","0.46771586","0.46737546","0.46657267","0.46582806","0.46519396","0.46302435","0.46300393","0.46289733","0.4627504","0.4606285","0.4605647","0.46009275","0.45958617","0.4593825","0.45851424","0.45813522","0.45762405","0.45730323","0.45709354","0.45644346","0.45636636","0.4562364","0.45606655","0.4545459","0.45420238","0.45402333","0.45402333","0.4539838","0.45396462"],"string":"[\n \"0.7254775\",\n \"0.61709523\",\n \"0.5765121\",\n \"0.57588995\",\n \"0.5667875\",\n \"0.5657872\",\n \"0.5615331\",\n \"0.5498272\",\n \"0.54953516\",\n \"0.5392794\",\n \"0.5387623\",\n \"0.5384196\",\n \"0.53837055\",\n \"0.5313938\",\n \"0.52996296\",\n \"0.5263196\",\n \"0.5251948\",\n \"0.5240129\",\n \"0.5167428\",\n \"0.51551384\",\n \"0.5082203\",\n \"0.5078475\",\n \"0.5062163\",\n \"0.5049635\",\n \"0.50441986\",\n \"0.50374484\",\n \"0.5028136\",\n \"0.50127864\",\n \"0.5002548\",\n \"0.49691728\",\n \"0.49354702\",\n \"0.4932225\",\n \"0.49271417\",\n \"0.49271253\",\n \"0.4917652\",\n \"0.48700935\",\n \"0.48695645\",\n \"0.48687702\",\n \"0.48685458\",\n \"0.4866482\",\n \"0.48596692\",\n \"0.4849615\",\n \"0.48470345\",\n \"0.48411787\",\n \"0.48253793\",\n \"0.48222393\",\n \"0.4817893\",\n \"0.4797892\",\n \"0.4796884\",\n \"0.47844997\",\n \"0.47828957\",\n \"0.47802\",\n \"0.47730115\",\n \"0.47672617\",\n \"0.47622877\",\n \"0.47617942\",\n \"0.47549403\",\n \"0.4748241\",\n \"0.47443804\",\n \"0.47426128\",\n \"0.47390378\",\n \"0.473851\",\n \"0.47309265\",\n \"0.4709521\",\n \"0.47035718\",\n \"0.4702084\",\n \"0.46869373\",\n \"0.4681313\",\n \"0.468008\",\n \"0.46780866\",\n \"0.46778128\",\n \"0.46771586\",\n \"0.46737546\",\n \"0.46657267\",\n \"0.46582806\",\n \"0.46519396\",\n \"0.46302435\",\n \"0.46300393\",\n \"0.46289733\",\n \"0.4627504\",\n \"0.4606285\",\n \"0.4605647\",\n \"0.46009275\",\n \"0.45958617\",\n \"0.4593825\",\n \"0.45851424\",\n \"0.45813522\",\n \"0.45762405\",\n \"0.45730323\",\n \"0.45709354\",\n \"0.45644346\",\n \"0.45636636\",\n \"0.4562364\",\n \"0.45606655\",\n \"0.4545459\",\n \"0.45420238\",\n \"0.45402333\",\n \"0.45402333\",\n \"0.4539838\",\n \"0.45396462\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.78412956"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":8796,"cells":{"query":{"kind":"string","value":"Create a copy of a facemap proc file, but pointing to a new video. By default, the new proc file is created in the same folder as the new videofile and named videofile_proc.npy."},"document":{"kind":"string","value":"def copy_facemap_roi(procfile, videofile, outputfile=None):\n videodata = np.load(procfile, allow_pickle=True).item() \n videodata['filenames'] = [[videofile]]\n if outputfile is None:\n outputfile = os.path.splitext(videofile)[0]+'_proc.npy'\n if os.path.isfile(outputfile):\n print(f'File {outputfile} exists. It will not be overwritten.')\n return None\n np.save(outputfile, videodata)\n return outputfile"},"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 create_video(input_file, output_file):\n input_video = VideoFileClip(input_file)\n output_video = input_video.fl_image(detect_lane.fit_and_plot)\n output_video.write_videofile(output_file, audio=False)","def process_video(lane, fname, output):\n\tclip = VideoFileClip(fname)\n\toutput_name = output\n\toutput_clip = clip.fl_image(lane.pipeline)\n\toutput_clip.write_videofile(output_name, audio=False)\n\tprint ('Video processed successfully')","def process_video(input_file, output_file):\n # video = VideoFileClip(input_file).subclip(40,44) # from 38s to 46s\n video = VideoFileClip(input_file)\n annotated_video = video.fl_image(process_pipeline)\n annotated_video.write_videofile(output_file, audio=False)","def process_video(input_file, output_file):\n # video = VideoFileClip(input_file).subclip(40,44) # from 38s to 46s\n video = VideoFileClip(input_file)\n annotated_video = video.fl_image(process_pipeline)\n annotated_video.write_videofile(output_file, audio=False)","def process_video(proc_state):\n entry = proc_state.entry\n workbench = proc_state.workbench\n video_config = mgg.global_config['media_type:mediagoblin.media_types.video']\n\n queued_filepath = entry.queued_media_file\n queued_filename = proc_state.get_queued_filename()\n name_builder = FilenameBuilder(queued_filename)\n\n medium_filepath = create_pub_filepath(\n entry, name_builder.fill('{basename}-640p.webm'))\n\n thumbnail_filepath = create_pub_filepath(\n entry, name_builder.fill('{basename}.thumbnail.jpg'))\n\n # Create a temporary file for the video destination (cleaned up with workbench)\n tmp_dst = NamedTemporaryFile(dir=workbench.dir, delete=False)\n with tmp_dst:\n # Transcode queued file to a VP8/vorbis file that fits in a 640x640 square\n progress_callback = ProgressCallback(entry)\n\n dimensions = (\n mgg.global_config['media:medium']['max_width'],\n mgg.global_config['media:medium']['max_height'])\n\n # Extract metadata and keep a record of it\n metadata = transcoders.VideoTranscoder().discover(queued_filename)\n store_metadata(entry, metadata)\n\n # Figure out whether or not we need to transcode this video or\n # if we can skip it\n if skip_transcode(metadata):\n _log.debug('Skipping transcoding')\n\n dst_dimensions = metadata['videowidth'], metadata['videoheight']\n\n # Push original file to public storage\n _log.debug('Saving original...')\n proc_state.copy_original(queued_filepath[-1])\n\n did_transcode = False\n else:\n transcoder = transcoders.VideoTranscoder()\n\n transcoder.transcode(queued_filename, tmp_dst.name,\n vp8_quality=video_config['vp8_quality'],\n vp8_threads=video_config['vp8_threads'],\n vorbis_quality=video_config['vorbis_quality'],\n progress_callback=progress_callback,\n dimensions=dimensions)\n\n dst_dimensions = transcoder.dst_data.videowidth,\\\n transcoder.dst_data.videoheight\n\n # Push transcoded video to public storage\n _log.debug('Saving medium...')\n mgg.public_store.copy_local_to_storage(tmp_dst.name, medium_filepath)\n _log.debug('Saved medium')\n\n entry.media_files['webm_640'] = medium_filepath\n\n did_transcode = True\n\n # Save the width and height of the transcoded video\n entry.media_data_init(\n width=dst_dimensions[0],\n height=dst_dimensions[1])\n\n # Temporary file for the video thumbnail (cleaned up with workbench)\n tmp_thumb = NamedTemporaryFile(dir=workbench.dir, suffix='.jpg', delete=False)\n\n with tmp_thumb:\n # Create a thumbnail.jpg that fits in a 180x180 square\n transcoders.VideoThumbnailerMarkII(\n queued_filename,\n tmp_thumb.name,\n 180)\n\n # Push the thumbnail to public storage\n _log.debug('Saving thumbnail...')\n mgg.public_store.copy_local_to_storage(tmp_thumb.name, thumbnail_filepath)\n entry.media_files['thumb'] = thumbnail_filepath\n\n # save the original... but only if we did a transcoding\n # (if we skipped transcoding and just kept the original anyway as the main\n # media, then why would we save the original twice?)\n if video_config['keep_original'] and did_transcode:\n # Push original file to public storage\n _log.debug('Saving original...')\n proc_state.copy_original(queued_filepath[-1])\n\n # Remove queued media file from storage and database\n proc_state.delete_queue_file()","def process_video(self, tmp_output_folder, video_name, video_num, total_videos):\n vidcap = cv2.VideoCapture(join(tmp_output_folder, video_name))\n print(f\"Processing video {video_num}/{total_videos} with name {video_name} \\n\")\n\n input_length = int(vidcap.get(cv2.CAP_PROP_FRAME_COUNT))\n frame_width = int(vidcap.get(cv2.CAP_PROP_FRAME_WIDTH))\n frame_height = int(vidcap.get(cv2.CAP_PROP_FRAME_HEIGHT))\n fps = int(vidcap.get(cv2.CAP_PROP_FPS))\n\n metadata = []\n faces_all_frames = []\n success, image = vidcap.read()\n count = 0\n frame = 0\n while success:\n if count % self.sample_every == 0:\n height, width = image.shape[:2]\n image = cv2.resize(image, (self.width, self.height), interpolation=cv2.INTER_CUBIC)\n\n # Convert from BGR color (OpenCV) to RGB color (face_recognition)\n rgb_image = image[:, :, ::-1]\n\n # Find all the faces in the current frame of video\n face_locations = face_recognition.face_locations(rgb_image)\n faces = []\n face_num = 0\n # Display the results\n for top, right, bottom, left in face_locations:\n # Draw a box around the face\n faces.append(image[top:bottom, left:right, :].copy())\n metadata.append(\n f\"{video_name},frame-{count}.face-{face_num}.jpg,{count},{face_num},{input_length},{fps},{frame_width},{frame_height},{top},{right},{bottom},{left}\\n\")\n face_num += 1\n faces_all_frames.append(faces)\n\n frame += 1\n success, image = vidcap.read()\n count += 1\n video_num += 1\n vidcap.release()\n\n with open(f\"{self.output_folder}/faces-pickle/{video_name}.pkl\", \"wb\") as f_out:\n pickle.dump(faces_all_frames, f_out)\n return metadata","def process_video(input_file, output_file):\n with open('all-features-rbf-svm.p', 'rb') as svm_fd:\n clf = pickle.load(svm_fd)\n with open('all-features-scaler.p', 'rb') as scaler_fd:\n hog_scaler = pickle.load(scaler_fd)\n hog_parameters = HogParameters(orientations=18, pixels_per_cell=8, cells_per_block=2)\n clip = VideoFileClip(input_file)\n test_clip = clip.fl_image(\n lambda frame: process_frame(frame, clf=clf, norm_scaler=hog_scaler, hog_parameters=hog_parameters, spatial_size=(16, 16), hist_bins=32))\n test_clip.write_videofile(output_file, audio=False)","def convert_video(video_file, output_file_name):\n video_stream = cv2.VideoCapture(video_file)\n total_frames = video_stream.get(cv2.CAP_PROP_FRAME_COUNT)\n background = get_median_frame(video_stream)\n video_stream.release()\n #reopen for processing:\n video_stream = cv2.VideoCapture(video_file)\n #ready an output writer\n writer = cv2.VideoWriter(output_file_name, \n cv2.VideoWriter_fourcc(*\"MP4V\"), fps,(1080,1920)) #(1920,1080))\n frameCnt=0\n pos = [] #Array for the coordinates\n while(frameCnt < total_frames-1):\n frameCnt+=1\n ret, frame = video_stream.read()\n dframe = background_subtraction(frame,background)\n cnts = find_contours(dframe)\n x,y = find_lowest_contour(cnts)\n pos.append([x,y])\n if len(pos): \n cv2.polylines(frame,np.int32([pos]),False,(0, 255, 0),2)\n writer.write(cv2.resize(frame, (1080,1920))) ## size probably shoudn't be fixed.\n writer.release()\n video_stream.release()\n return pos","def create_movie(name, folder):\n cmd = [\"ffmpeg\", \"-framerate\", \"1\", \"-i\", folder + \"/pic%04d.png\", \"-c:v\",\n \"libx264\", \"-r\", \"30\", \"-pix_fmt\", \"yuv420p\", name]\n return subprocess.call(cmd)","def local_video(**kwargs):\n output_dir = run_video_preprocess(\n video_file=input_video,\n roi_locations=kwargs[\"roi_locations\"],\n preprocess_analysis=kwargs[\"preprocess_analysis\"],\n database=False\n )\n\n run_analysis_pipeline(\n preprocess_analysis=kwargs[\"preprocess_analysis\"],\n json_filepath=output_dir,\n )","def make_video(queue, video_file, destination, face_locations, face_encodings, match_encodings, settings):\n trackers = [] # list of tracker objects, one for each matched face\n # get video\n video = cv2.VideoCapture(video_file) # input VideoCapture object\n frame_rate = video.get(cv2.CAP_PROP_FPS) # frames per second in input video\n width = int(video.get(cv2.CAP_PROP_FRAME_WIDTH)) # width of input video frame\n height = int(video.get(cv2.CAP_PROP_FRAME_HEIGHT)) # height of input video frame\n frame_count = int(video.get(cv2.CAP_PROP_FRAME_COUNT)) # number of frames in input video\n # get settings\n track_period = settings[\"track_period\"] # track period from settings\n tolerance = settings[\"tolerance\"] # face matching tolerance from settings\n blur_method = settings[\"blur_method\"] # type of blurring from settings\n blur_intensity = settings[\"blur_intensity\"] # blurring filter size from settings\n display_output = settings[\"display_output\"] # flag indicating whether to display output video from settings\n # initialize writer\n out = video_utils.initialize_writer(destination, (width, height), frame_rate) # VideoWriter object\n for i in range(frame_count):\n ret, img = video.read() # ret indicates if frame was read correctly, img is last read frame\n if i % track_period == 0: # frame for detection\n current_frame_encodings = np.array(face_encodings[i // track_period]) # array of encodings for faces in current frame\n matched_indices, matched_encodings = recognition.match_faces(current_frame_encodings, np.array(match_encodings), tolerance) # indices of matched faces from current frame and their encodings\n matched_locations = [face_locations[i // track_period][k] for k in matched_indices] # locations of matched faces from current frame\n trackers = tracking.start_trackers(img, matched_locations) # list of tracker objects, one for each matched face\n else: # frame for tracking\n matched_locations = tracking.update_locations(trackers, img) # updated locations of matched faces from current frame\n # generate blurred image\n blurred = None # object holding image with blurred faces\n if blur_method == \"pixelate\":\n blurred = blur_methods.pixelated(img, matched_locations, blur_intensity)\n elif blur_method == \"blur\":\n blurred = blur_methods.blurred(img, matched_locations, blur_intensity)\n elif blur_method == \"blacken\":\n blurred = blur_methods.blackened(img, matched_locations)\n out.write(blurred)\n\n out.release()\n queue.put(0)\n if display_output:\n video_utils.display_video(destination)","def process_video(self, input_path, output_path, debug=False):\n clip = VideoFileClip(input_path)\n if debug:\n test_clip = clip.fl_image(self.process_image_debug)\n else:\n test_clip = clip.fl_image(self.process_image)\n test_clip.write_videofile(output_path)","def preprocess_sample(file, params):\n\n videoFile = file + \".mp4\"\n audioFile = file + \".wav\"\n roiFile = file + \".png\"\n visualFeaturesFile = file + \".npy\"\n\n roiSize = params[\"roiSize\"]\n normMean = params[\"normMean\"]\n normStd = params[\"normStd\"]\n vf = params[\"vf\"]\n device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n\n\n #Extract the audio from the video file using the FFmpeg utility and save it to a wav file.\n v2aCommand = \"ffmpeg -y -v quiet -i \" + videoFile + \" -ac 1 -ar 16000 -vn \" + audioFile\n os.system(v2aCommand)\n\n\n #for each frame, resize to 224x224 and crop the central 112x112 region\n captureObj = cv.VideoCapture(videoFile)\n roiSequence = list()\n while (captureObj.isOpened()):\n ret, frame = captureObj.read()\n if ret == True:\n grayed = cv.cvtColor(frame, cv.COLOR_BGR2GRAY)\n grayed = grayed/255\n grayed = cv.resize(grayed, (224,224))\n roi = grayed[int(112-(roiSize/2)):int(112+(roiSize/2)), int(112-(roiSize/2)):int(112+(roiSize/2))]\n roiSequence.append(roi)\n else:\n break\n captureObj.release()\n cv.imwrite(roiFile, np.floor(255*np.concatenate(roiSequence, axis=1)).astype(np.int))\n\n\n #normalise the frames and extract features for each frame using the visual frontend\n #save the visual features to a .npy file\n inp = np.stack(roiSequence, axis=0)\n inp = np.expand_dims(inp, axis=[1,2])\n inp = (inp - normMean)/normStd\n inputBatch = torch.from_numpy(inp)\n inputBatch = (inputBatch.float()).to(device)\n vf.eval()\n with torch.no_grad():\n outputBatch = vf(inputBatch)\n out = torch.squeeze(outputBatch, dim=1)\n out = out.cpu().numpy()\n np.save(visualFeaturesFile, out)\n return","def analyze_video(vidNum_iter, config, pointInds_toUse, pts_spaced, session): # function needed for multiprocessing\n\n optic = config['Optic']\n\n numVids = session['num_vids']\n path_vid_allFiles = session['videos']\n lk_names = [key for key in optic.keys() if 'lk_' in key]\n lk_params = {k.split('lk_')[1]: (tuple(optic[k]) if type(optic[k]) is list else optic[k]) \\\n for k in lk_names}\n\n vid = imageio.get_reader(path_vid_allFiles[vidNum_iter], 'ffmpeg')\n # metadata = vid.get_meta_data()\n\n path_vid = path_vid_allFiles[vidNum_iter] # get path of the current vid\n video = cv2.VideoCapture(path_vid) # open the video object with openCV\n numFrames = int(video.get(\n cv2.CAP_PROP_FRAME_COUNT)) # get frame count of this vid GENERALLY INACCURATE. OFF BY AROUND -25 frames\n\n frameToSet = 0\n frame = vid.get_data(\n frameToSet) # Get a single frame to use as the first 'previous frame' in calculating optic flow\n new_frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\n old_frame = new_frame_gray\n\n displacements_tmp = np.zeros((pts_spaced.shape[0], 2, np.uint64(numFrames + (numVids * 1000)))) * np.nan\n\n print(' ', end='', flush=True)\n text = \"progresser #{}\".format(vidNum_iter)\n print(f'\\n Calculating displacement field: video # {vidNum_iter + 1}/{numVids}')\n\n for iter_frame, new_frame in enumerate(tqdm(vid, total=numFrames, desc=text, position=vidNum_iter)):\n new_frame_gray = cv2.cvtColor(new_frame, cv2.COLOR_BGR2GRAY) # convert to grayscale\n\n ##calculate optical flow\n pointInds_new, status, error = cv2.calcOpticalFlowPyrLK(old_frame, new_frame_gray, pointInds_toUse, None,\n **lk_params) # Calculate displacement distance between STATIC/ANCHORED points and the calculated new points. Also note the excluded 'NextPts' parameter. Could be used for fancier tracking\n\n ## Calculate displacement and place into variable 'displacements' (changes in size every iter)\n if iter_frame == 0:\n displacements_tmp[:, :, iter_frame] = np.zeros((pts_spaced.shape[0], 2))\n else:\n displacements_tmp[:, :, iter_frame] = np.single(np.squeeze((\n pointInds_new - pointInds_toUse))) # this is the important variable. Simply the difference in the estimate\n\n old_frame = new_frame_gray # make current frame the 'old_frame' for the next iteration\n\n return displacements_tmp","def run_video(self, video_path):\n file, ext = os.path.splitext(video_path)\n video_name = file.split('/')[-1]\n out_filename = video_name + '_out' + '.avi'\n\n cap = cv2.VideoCapture(video_path)\n wi = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))\n he = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))\n print(wi, he)\n\n vwriter = cv2.VideoWriter(out_filename, cv2.VideoWriter_fourcc(*'MJPG'), 10, (wi, he))\n counter = 0\n fac = 2\n start = time.time()\n while True:\n ret, image = cap.read()\n\n if ret:\n counter += 1\n\n ## resize image\n\n height, width, channels = image.shape\n resize_ratio = 1.0 * self.INPUT_SIZE / max(width, height)\n target_size = (int(resize_ratio * width), int(resize_ratio * height))\n image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n resized_image = cv2.resize(image, target_size, interpolation=cv2.INTER_AREA)\n output = resized_image.copy()\n\n ## get segmentation map\n batch_seg_map = self.sess.run(\n self.OUTPUT_TENSOR_NAME,\n feed_dict={self.INPUT_TENSOR_NAME: [np.asarray(resized_image)]})\n seg_map = batch_seg_map[0]\n\n ## visualize\n seg_image = label_to_color_image(seg_map).astype(np.uint8)\n\n ## overlay on image\n alpha = 0.7\n cv2.addWeighted(seg_image, alpha, output, 1 - alpha, 0, output)\n\n output = cv2.resize(output, (wi, he), interpolation=cv2.INTER_AREA)\n # outimg = 'image_' + str(counter) + '.jpg'\n # cv2.imwrite(os.path.join(os.getcwd(), 'test_out', outimg),output)\n vwriter.write(output)\n else:\n break\n\n end = time.time()\n print(\"Frames and Time Taken: \", counter, end - start)\n cap.release()\n vwriter.release()","def process_video(filename, args, cfg, net):\n # Split video into frames\n images = split_video(filename)\n # Set output dir\n output_dir = args.output\n # Add brackets and extension to filename\n output_path = create_video_output_path(output_dir, cfg)\n # Get height and width of 1st image\n height, width, _ = check_img_size(images[0]).shape\n # Create VideoWriter object\n video = cv2.VideoWriter(output_path, \n cv2.VideoWriter_fourcc(*'FMP4'), \n cfg['video']['fps'], \n (width, height))\n for image in images:\n # Process frames\n img_steps = process_image(image, cfg, net)\n # Check for --show-detections flag\n output_img = check_if_adding_bboxes(args, img_steps) \n # Write to video\n video.write(output_img) \n # Release video writer object\n video.release()","def video(perspective_matrix_path, source=\"cam\", save=False, save_path=None, file_name=\"out\", cam_cal=None):\n if not os.path.isfile(perspective_matrix_path):\n raise FileNotFoundError(\"Path to perspective matrix file not exist!\")\n\n with open(perspective_matrix_path, \"rb\") as p:\n perspective_matrix = pickle.load(p)\n M = perspective_matrix[\"M\"]\n Minv = perspective_matrix[\"Minv\"]\n\n if source == \"cam\":\n cap = cv2.VideoCapture(0)\n else:\n if not os.path.isfile(source):\n raise FileNotFoundError(source, \" not Exist!\")\n cap = cv2.VideoCapture(source)\n\n # camera calibration parameters [ mtx , dist]\n mtx = None\n dist = None\n\n out = None\n if save:\n if not os.path.isdir(save_path):\n raise FileNotFoundError(save_path, \" Not Exist!\")\n file_name += \".mp4\"\n out = cv2.VideoWriter(save_path + file_name, -1, 20, (int(cap.get(3)), int(cap.get(4))))\n\n if cam_cal:\n if not os.path.isfile(cam_cal):\n raise FileNotFoundError(cam_cal, \" Not Exist!\")\n\n with open(cam_cal, \"rb\") as p:\n calibration = pickle.load(p)\n mtx = calibration[\"mtx\"]\n dist = calibration[\"dist\"]\n\n left_line = Line(5)\n right_line = Line(5)\n\n while True:\n # Capture frame-by-frame\n ret, frame = cap.read()\n if not ret:\n print(\"Finished..\")\n sys.exit(0)\n\n # cv2 read frame as BGR, convert it to RGB\n frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n\n # camera calibration\n if not (mtx is None or dist is None):\n frame = cv2.undistort(frame, mtx, dist, None, mtx)\n\n # get edges in image\n edges = apply_edge_detection(frame)\n\n # transform image to bird view\n warped = warped_img(edges, M)\n\n # init out image which will draw lane line on it then weight it with original frame\n out_img = np.zeros_like(warped)\n if len(warped.shape) == 3 and warped.shape[2] == 3:\n pass\n else:\n out_img = np.dstack((out_img, out_img, out_img))\n\n # if line not detected, apply sliding window\n if not left_line.detected or not right_line.detected:\n leftx, lefty, rightx, righty = sliding_window(warped, 9, 200)\n\n # if already detected apply search around detected line\n else:\n leftx, lefty = search_around_poly(left_line, warped)\n rightx, righty = search_around_poly(right_line, warped)\n\n # will used for plotting line, find x fitted\n ploty = np.linspace(warped.shape[0] // 4, warped.shape[0] - 1, warped.shape[0])\n\n # check if at least 100 pixels detected as line\n if len(leftx) > 100 and len(rightx) > 100:\n\n # make detected flag true\n left_line.detected = True\n right_line.detected = True\n\n left_line.current_x = leftx\n left_line.current_y = lefty\n\n right_line.current_x = rightx\n right_line.current_y = righty\n\n left_line.fit_polynomial(ploty)\n right_line.fit_polynomial(ploty)\n\n else:\n print(\"Line not detected in this frame \")\n # we just draw line form previous frame\n\n # make detected flag true\n left_line.detected = False\n right_line.detected = False\n\n # update Lane line radius\n left_line.radius()\n right_line.radius()\n\n # avg radius of to lines, and plot it\n radius = (left_line.radius_of_curvature + right_line.radius_of_curvature) // 2\n frame = write_text(frame, \"Radius of Curvature = \" + str(radius) + \" M\", pos=(20, 50))\n\n # calculate Alignment ( how much car away from center between Lane lines\n dir = \"Left\" # car far from left or right\n\n left_line.car_offset(frame.shape) # distance from left line\n right_line.car_offset(frame.shape) # distance from right line\n\n distance = round(right_line.line_base_pos - left_line.line_base_pos, 2)\n\n if distance < 0: # car far away from left line not right line\n distance = -distance\n dir = \"Right\"\n frame = write_text(frame, \"Vehicle is {}m {} of center\".format(distance, dir), pos=(20, 80))\n\n # ** plot lane lines on image **\n # left_line.draw_line(out_img, ploty)\n # right_line.draw_line(out_img, ploty)\n\n # color pixel which belong to lane lines\n left_line.color_pixel(out_img, (255, 0, 0))\n right_line.color_pixel(out_img, (255, 100, 0))\n\n # fit green triangle in area between lane lines\n pts_left = np.array([np.transpose(np.vstack([left_line.bestx, ploty]))])\n pts_right = np.array([np.flipud(np.transpose(np.vstack([right_line.bestx, ploty])))])\n pts = np.hstack((pts_left, pts_right))\n\n # Draw the lane onto the warped blank image\n cv2.fillPoly(out_img, np.int_([pts]), (0, 255, 0))\n\n # return image to normal view from bird view\n out_img_undit = warped_img(out_img, Minv)\n\n # weight out_image_undit with original frame\n frame = cv2.addWeighted(out_img_undit, 0.5, frame, 1, 0)\n frame = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)\n\n cv2.imshow(\"frame\", frame)\n\n # write video\n if save:\n out.write(frame)\n if cv2.waitKey(1) & 0xFF == ord('q'):\n break\n\n # When everything done, release the capture\n cap.release()\n cv2.destroyAllWindows()","def emv(inputVideoPath, outputVideoPath, maxLevel, freqLow, freqHigh, alpha, chromAttenuation, startFrameNumber, endFrameNumber, lambdaC=-1, app=\"color\", method=\"ideal\", roi=None): \n fps, frames = getVideoFrames(inputVideoPath, startFrameNumber, endFrameNumber)\n if app==\"color\":\n recreateFrames=emvCoreColor(frames, fps, maxLevel, freqLow, freqHigh, alpha, chromAttenuation, method)\n elif app==\"motion\":\n recreateFrames=emvCoreMotion(frames, fps, maxLevel, freqLow, freqHigh, alpha, lambdaC, chromAttenuation, method)\n saveFramesToVideoROI(frames, recreateFrames, outputVideoPath, roi)\n return","def displacements_monothread(config, pointInds_toUse, pointInds_tracked, pointInds_tracked_tuple, displacements,\n pts_spaced, color_tuples, session):\n\n ## Main loop to pull out displacements in each video\n ind_concat = 0\n fps = 0\n tic_fps = time.time()\n tic_all = time.time()\n\n optic = config['Optic']\n video = config['Video']\n\n vidNums_toUse = optic['vidNums_toUse']\n showVideo_pref = optic['showVideo_pref']\n fps_counterPeriod = video['fps_counterPeriod']\n printFPS_pref = video['printFPS_pref']\n remote = config['General']['remote']\n save_vid = video['save_demo']\n\n Fs = video['Fs']\n vid_width = video['width']\n vid_height = video['height']\n test_len = video['demo_len']\n save_pathFull = str(Path(config['Paths']['viz']) / 'optic_test.avi')\n\n numVids = session['num_vids']\n path_vid_allFiles = session['videos']\n lk_names = [key for key in optic.keys() if 'lk_' in key]\n lk_params = {k.split('lk_')[1]: (tuple(optic[k]) if type(optic[k]) is list else optic[k]) \\\n for k in lk_names}\n\n # Define the codec and create VideoWriter object\n if showVideo_pref and (save_vid or remote):\n fourcc = cv2.VideoWriter_fourcc(*'MJPG')\n print(f'saving to file {save_pathFull}')\n out = cv2.VideoWriter(save_pathFull, fourcc, Fs, (np.int64(vid_width), np.int64(vid_height)))\n else:\n out = None\n vid_lens = []\n for vidNum_iter in vidNums_toUse:\n vid = imageio.get_reader(path_vid_allFiles[vidNum_iter], 'ffmpeg')\n # metadata = vid.get_meta_data()\n\n path_vid = path_vid_allFiles[vidNum_iter] # get path of the current vid\n video = cv2.VideoCapture(path_vid) # open the video object with openCV\n numFrames_rough = int(video.get(\n cv2.CAP_PROP_FRAME_COUNT)) # get frame count of this vid GENERALLY INACCURATE. OFF BY AROUND -25 frames\n\n frameToSet = 0\n frame = vid.get_data(0) # Get a single frame to use as the first 'previous frame' in calculating optic flow\n new_frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\n old_frame = new_frame_gray\n\n print(f'\\n Calculating displacement field: video # {vidNum_iter + 1}/{numVids}')\n # while True:\n for iter_frame, new_frame in enumerate(tqdm(vid, total=numFrames_rough)):\n new_frame_gray = cv2.cvtColor(new_frame, cv2.COLOR_BGR2GRAY) # convert to grayscale\n\n ##calculate optical flow\n pointInds_new, status, error = cv2.calcOpticalFlowPyrLK(old_frame, new_frame_gray, pointInds_toUse, None,\n **lk_params) # Calculate displacement distance between STATIC/ANCHORED points and the calculated new points. Also note the excluded 'NextPts' parameter. Could be used for fancier tracking\n\n ## Calculate displacement and place into variable 'displacements' (changes in size every iter) \n if iter_frame == 0:\n displacements[:, :, ind_concat] = np.zeros((pts_spaced.shape[0], 2))\n else:\n displacements[:, :, ind_concat] = np.single(np.squeeze((\n pointInds_new - pointInds_toUse))) # this is the important variable. Simply the difference in the estimate\n\n old_frame = new_frame_gray # make current frame the 'old_frame' for the next iteration\n\n ## below is just for visualization. Nothing calculated is maintained\n if showVideo_pref:\n pointInds_tracked = pointInds_tracked + (\n pointInds_new - pointInds_toUse) # calculate integrated position\n pointInds_tracked = pointInds_tracked - (\n pointInds_tracked - pointInds_toUse) * 0.01 # multiplied constant is the relaxation term. this is just for display purposes. Relaxation term chosen during cleanup will be real\n pointInds = [pointInds_tracked, pointInds_tracked_tuple]\n counters = [iter_frame, vidNum_iter, ind_concat, fps]\n if (remote and iter_frame < test_len) or not remote:\n videos.visualize_progress(config, session, new_frame, pointInds, color_tuples, counters, out)\n\n if (save_vid or remote) and iter_frame == test_len:\n out.release()\n\n k = cv2.waitKey(1) & 0xff\n if k == 27: break\n\n ind_concat = ind_concat + 1\n\n if ind_concat % fps_counterPeriod == 0:\n elapsed = time.time() - tic_fps\n fps = fps_counterPeriod / elapsed\n if printFPS_pref:\n print(fps)\n tic_fps = time.time()\n vid_lens.append(iter_frame+1)\n ## Calculate how long calculation took\n elapsed = time.time() - tic_all\n helpers.print_time('video time elapsed:', elapsed)\n print(f'Capture rate: {round(ind_concat / elapsed, 3)} fps')\n\n numFrames_total = ind_concat - 1\n cv2.destroyAllWindows()\n\n displacements = displacements[:, :, ~np.isnan(displacements[0, 0, :])]\n\n return displacements, numFrames_total, vid_lens","def write_face_samples(model, output_path, invid):\n \n if not os.path.isdir(output_path) :\n os.mkdir(output_path)\n \n video = mmcv.VideoReader(invid)\n for frame_ix, frame in enumerate(video):\n frame_name = f\"{output_path}webcam_{frame_ix}_0.jpg\"\n if os.path.isfile(frame_name): continue\n \n frame_img = PIL.Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))\n _ = model(frame_img,frame_name)","def makeVideo():\n os.system(\"cd video && ffmpeg -r 10 -i img%05d.jpg -vcodec mpeg4 -y caronthehill_clip.mp4\")","def __call__(self, video_path, per_frames = 1 , offset = None):\n \n cap = cv2.VideoCapture(video_path)\n \n if not cap.isOpened():\n raise Exception(\"Video file does not exist or is invalid\")\n\n \n if offset:\n cap.set(cv2.CAP_PROP_POS_MSEC, offset)\n \n \n info = []\n\n while cap.isOpened():\n ret, frame = cap.read()\n if ret:\n if cap.get(cv2.CAP_PROP_POS_FRAMES) % per_frames == 0:\n frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n faces_info = self.detect_faces_from_image(frame,\n desired_width=224, desired_height=224) \n if faces_info:\n for element in faces_info:\n face_img = image.img_to_array(element[1])\n\n face_img = utils.preprocess_input(face_img, version=1)\n face_img = np.expand_dims(face_img, axis=0)\n\n features = self.vgg_feature_extractor.predict(face_img)\n label = self.gender_svm.predict(features)[0]\n decision_value = round(self.gender_svm.decision_function(features)[0], 3)\n\n bounding_box = element[0][0]\n detection_score = round(element[5], 3)\n bbox_length = bounding_box.bottom() - bounding_box.top()\n\n info.append([\n cap.get(cv2.CAP_PROP_POS_FRAMES), bounding_box, (bbox_length, bbox_length), label,\n decision_value, detection_score\n ])\n\n else:\n break\n cap.release()\n info = pd.DataFrame.from_records(info, columns = ['frame', 'bb', 'size','label', 'decision', 'conf'])\n return info","def run(self):\n\n for file_cnt, file_path in enumerate(self.files_found):\n video_timer = SimbaTimer()\n video_timer.start_timer()\n _, self.video_name, _ = get_fn_ext(file_path)\n self.video_info, self.px_per_mm, self.fps = self.read_video_info(\n video_name=self.video_name\n )\n self.width, self.height = int(\n self.video_info[\"Resolution_width\"].values[0]\n ), int(self.video_info[\"Resolution_height\"].values[0])\n if self.video_setting:\n self.fourcc = cv2.VideoWriter_fourcc(*Formats.MP4_CODEC.value)\n self.video_save_path = os.path.join(\n self.heatmap_clf_location_dir, self.video_name + \".mp4\"\n )\n self.writer = cv2.VideoWriter(\n self.video_save_path,\n self.fourcc,\n self.fps,\n (self.width, self.height),\n )\n if self.frame_setting:\n self.save_video_folder = os.path.join(\n self.heatmap_clf_location_dir, self.video_name\n )\n if not os.path.exists(self.save_video_folder):\n os.makedirs(self.save_video_folder)\n self.data_df = read_df(file_path=file_path, file_type=self.file_type)\n clf_array, aspect_ratio = self.__calculate_bin_attr(\n data_df=self.data_df,\n clf_name=self.clf_name,\n bp_lst=self.bp_lst,\n px_per_mm=self.px_per_mm,\n img_width=self.width,\n img_height=self.height,\n bin_size=self.bin_size,\n fps=self.fps,\n )\n\n if self.max_scale == \"auto\":\n self.max_scale = self.__calculate_max_scale(clf_array=clf_array)\n if self.max_scale == 0:\n self.max_scale = 1\n\n if self.final_img_setting:\n self.make_clf_heatmap_plot(\n frm_data=clf_array[-1, :, :],\n max_scale=self.max_scale,\n palette=self.palette,\n aspect_ratio=aspect_ratio,\n file_name=os.path.join(\n self.heatmap_clf_location_dir,\n self.video_name + \"_final_frm.png\",\n ),\n shading=self.shading,\n clf_name=self.clf_name,\n img_size=(self.width, self.height),\n final_img=True,\n )\n\n if self.video_setting or self.frame_setting:\n for frm_cnt, cumulative_frm_idx in enumerate(range(clf_array.shape[0])):\n frm_data = clf_array[cumulative_frm_idx, :, :]\n cum_df = pd.DataFrame(frm_data).reset_index()\n cum_df = cum_df.melt(\n id_vars=\"index\",\n value_vars=None,\n var_name=None,\n value_name=\"seconds\",\n col_level=None,\n ).rename(\n columns={\"index\": \"vertical_idx\", \"variable\": \"horizontal_idx\"}\n )\n cum_df[\"color\"] = (\n (cum_df[\"seconds\"].astype(float) / float(self.max_scale))\n .round(2)\n .clip(upper=100)\n )\n color_array = np.zeros(\n (\n len(cum_df[\"vertical_idx\"].unique()),\n len(cum_df[\"horizontal_idx\"].unique()),\n )\n )\n for i in range(color_array.shape[0]):\n for j in range(color_array.shape[1]):\n value = cum_df[\"color\"][\n (cum_df[\"horizontal_idx\"] == j)\n & (cum_df[\"vertical_idx\"] == i)\n ].values[0]\n color_array[i, j] = value\n\n fig = plt.figure()\n im_ratio = color_array.shape[0] / color_array.shape[1]\n plt.pcolormesh(\n color_array,\n shading=self.shading,\n cmap=self.palette,\n rasterized=True,\n alpha=1,\n vmin=0.0,\n vmax=float(self.max_scale),\n )\n plt.gca().invert_yaxis()\n plt.xticks([])\n plt.yticks([])\n plt.axis(\"off\")\n plt.tick_params(axis=\"both\", which=\"both\", length=0)\n cb = plt.colorbar(pad=0.0, fraction=0.023 * im_ratio)\n cb.ax.tick_params(size=0)\n cb.outline.set_visible(False)\n cb.set_label(\n \"{} (seconds)\".format(self.clf_name), rotation=270, labelpad=10\n )\n plt.tight_layout()\n plt.gca().set_aspect(aspect_ratio)\n canvas = FigureCanvas(fig)\n canvas.draw()\n mat = np.array(canvas.renderer._renderer)\n image = cv2.cvtColor(mat, cv2.COLOR_RGB2BGR)\n image = cv2.resize(image, (self.width, self.height))\n image = np.uint8(image)\n plt.close()\n\n if self.video_setting:\n self.writer.write(image)\n if self.frame_setting:\n frame_save_path = os.path.join(\n self.save_video_folder, str(frm_cnt) + \".png\"\n )\n cv2.imwrite(frame_save_path, image)\n print(\n \"Created heatmap frame: {} / {}. Video: {} ({}/{})\".format(\n str(frm_cnt + 1),\n str(len(self.data_df)),\n self.video_name,\n str(file_cnt + 1),\n len(self.files_found),\n )\n )\n\n if self.video_setting:\n self.writer.release()\n\n video_timer.stop_timer()\n print(\n \"Heatmap plot for video {} saved (elapsed time: {}s) ... \".format(\n self.video_name, video_timer.elapsed_time_str\n )\n )\n\n self.timer.stop_timer()\n stdout_success(\n msg=\"All heatmap visualizations created in project_folder/frames/output/heatmaps_classifier_locations directory\",\n elapsed_time=\"self.timer.elapsed_time_str\",\n )","def _spawn_ffmpeg(self) -> None:\r\n if self.ffmpeg_proc is not None:\r\n raise RuntimeError('_spawn_ffmpeg called when ffmpeg_proc is '\r\n + f'{self.ffmpeg_proc} (not None)')\r\n\r\n args = ['ffmpeg', '-f', 'rawvideo', '-vcodec', 'rawvideo',\r\n '-s', f'{self.frame_size[0]}x{self.frame_size[1]}',\r\n '-pix_fmt', 'rgba', '-r', str(self.fps),\r\n '-loglevel', 'quiet',\r\n '-i', 'pipe:0',\r\n '-vcodec', 'h264', '-pix_fmt', 'yuv420p',\r\n '-movflags', '+faststart']\r\n\r\n if self.bitrate > 0:\r\n args.extend(['-b', f'{self.bitrate}k'])\r\n args.extend(['-y', self.outfile])\r\n\r\n create_flags = sp.CREATE_NO_WINDOW if 'nt' in os.name else 0\r\n self.ffmpeg_proc = sp.Popen(args, shell=False, stdout=None, stderr=None,\r\n stdin=sp.PIPE, creationflags=create_flags)","def write_video(project_video_output, output_folder, fps=20):\n print(\"Creating video {}, FPS={}\".format(project_video_output, fps))\n clip = ImageSequenceClip(output_folder, fps)\n clip.write_videofile(project_video_output)","def process_video(path, method):\n # TODO: Obtener nombre de video a partir del path\n video_name = ''\n # TODO: Crear carpeta si es que no existe (Deteccion/{method}/{video_name})\n folder_path = f\"Deteccion/{method}/{video_name}\"\n try:\n cap = cv2.VideoCapture(path)\n # Check if camera opened successfully\n if (cap.isOpened() is False):\n print(\"Error opening video stream or file\")\n\n frame_counter = 0\n # Read until video is completed\n while(cap.isOpened()):\n # Capture frame-by-frame\n ret, frame = cap.read()\n if ret is True:\n # TODO: Crear carpeta del frame si es que no existe (Deteccion/{method}/{video_name}/{frame_name})\n frame_name = f\"frame_{frame_counter}\"\n\n faces = process_frame(frame, method)\n # TODO: Guardar bounding boxes\n np.save(f\"{folder_path}/{frame_name}/bounding_boxes.npy\", faces)\n\n # TODO: Guardar imagenes recortadas\n for bb in faces:\n pass\n frame_counter += 1\n\n # Break the loop\n else:\n break\n\n finally:\n # When everything done, release the video capture object\n cap.release()","def mapBackToSurface(array,filename):\n #### Map back to surface\n if array.shape[0]==360:\n out_array = np.zeros((glasser2.shape[0],3))\n\n roicount = 0\n for roi in range(360):\n for col in range(array.shape[1]):\n vertex_ind = np.where(glasser2==roi+1)[0]\n out_array[vertex_ind,col] = array[roicount,col]\n\n roicount += 1\n\n else:\n out_array = array\n\n #### \n # Write file to csv and run wb_command\n np.savetxt(filename + '.csv', out_array,fmt='%s')\n wb_file = filename + '.dscalar.nii'\n wb_command = 'wb_command -cifti-convert -from-text ' + filename + '.csv ' + glasserfile2 + ' ' + wb_file + ' -reset-scalars'\n os.system(wb_command)\n os.remove(filename + '.csv')","def tagVideo(modelpath, videopath, outputPath=None): \n model = get_model_instance_segmentation(3)\n device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n # model.load_state_dict(torch.load(modelpath, map_location=device), strict=False)\n model.load_state_dict(torch.load(modelpath, map_location=device))\n model = model.to(device)\n model.eval()\n\n \n data_transform = transforms.Compose([\n ToPILImage(),\n transforms.ToTensor(), \n ])\n\n\n if outputPath:\n writer = FFmpegWriter(str(outputPath))\n \n font = cv2.FONT_HERSHEY_SIMPLEX\n cv2.namedWindow('main', cv2.WINDOW_NORMAL)\n labels = ['No mask', 'Mask']\n labelColor = [(10, 0, 255), (10, 255, 0)]\n img_count = 0\n outputDir = os.path.dirname(os.path.realpath(outputPath))\n frame_count = 0\n boundingBoxes = []\n for frame in vreader(str(videopath)):\n frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n print('Frame:', frame_count)\n\n if frame_count%30==0:\n frameTensor = data_transform(frame)\n frameTensor = torch.unsqueeze(frameTensor, 0).to(device)\n output = model(frameTensor)\n boundingBoxes = plot_image_new(frame, frameTensor[0], output[0]) \n \n if len(boundingBoxes)>0:\n for bb in boundingBoxes:\n cv2.rectangle(frame,\n (bb[0], bb[1]),\n (bb[2], bb[3]),\n (54, 66, 227),\n thickness=2)\n\n cv2.imshow('main', frame)\n if outputPath:\n writer.writeFrame(cv2.cvtColor(frame, cv2.COLOR_RGB2BGR))\n if cv2.waitKey(1) & 0xFF == ord('q'):\n break\n frame_count += 1\n if outputPath:\n writer.close()\n cv2.destroyAllWindows()","def generateVideo(textFilePath,extractedPath,createdVideoPath):\r\n\t\t#Check if the save directory exists, If not create directory\r\n\t\tif not os.path.exists(createdVideoPath):\r\n\t\t\tos.mkdir(createdVideoPath)\r\n\t\t#Open the text file\r\n\t\tfile = open(textFilePath)\r\n\t\tvideoPath = createdVideoPath\r\n\r\n\t\tfor hashedData in file:\r\n\t\t\thashedData = hashedData.split(\"\\n\")[0]\r\n\t\t\timage_folder = extractedPath + \"/\" + \"data\" + \"/\" + hashedData\r\n\t\t\tvideo_name = hashedData + \".avi\"\r\n\t\t\timages = os.listdir(image_folder)\r\n\t\t\tframe = cv2.imread(os.path.join(image_folder, images[0]))\r\n\t\t\theight, width, layers = frame.shape\r\n\t\t\t#declare the video writter\r\n\t\t\tvideo = cv2.VideoWriter(videoPath + \"/\" +video_name, 0, 1, (width,height))\r\n\t\t\t#Write all images to a single video\r\n\t\t\tfor image in images:\r\n\t\t\t\tvideo.write(cv2.imread(os.path.join(image_folder, image)))\r\n\r\n\t\t\tcv2.destroyAllWindows()\r\n\t\t\tvideo.release()","def create_video():\n print(\"Generating output video\")\n frame_array = []\n files = [f for f in os.listdir(MODIFIED_FRAMES_DIR) if isfile(join(MODIFIED_FRAMES_DIR, f))]\n #for sorting the file names properly\n # files.sort(key = lambda x: x[3:-4])\n files = sorted(files,key=lambda x: int(os.path.splitext(x)[0]))\n for i in range(len(files)):\n filename= MODIFIED_FRAMES_DIR + files[i]\n # print(filename)\n #reading each files\n img = cv2.imread(filename)\n height, width, layers = img.shape\n size = (width,height)\n \n #inserting the frames into an image array\n frame_array.append(img)\n \n out = cv2.VideoWriter(OUTPUT_FILE,cv2.VideoWriter_fourcc(*'DIVX'), FRAME_RATE, size)\n for i in range(len(frame_array)):\n # writing to a image array\n out.write(frame_array[i])\n out.release()\n print(\"Output video generated successfully...\")\n\n # img_array = []\n # for filename in glob.glob(MODIFIED_FRAMES_DIR+'/*.jpg'):\n # img = cv2.imread(filename)\n # height, width, layers = img.shape\n # size = (width,height)\n # img_array.append(img)\n\n # height, width, layers = img_array[0].shape\n # size = (width,height)\n # out = cv2.VideoWriter('output.mov',cv2.VideoWriter_fourcc(*'DIVX'), 15, size) \n # for i in range(len(img_array)):\n # out.write(img_array[i])\n # out.release()","def generate_frame(video_path, video_name, second, label, dest_path):\n print \"video_path\", video_path\n print 'video_name',video_name\n print 'second',second\n print 'label',label\n print 'dest_path',dest_path\n\n vidcap = cv2.VideoCapture(os.path.join(video_path, video_name))\n vidcap.set(0, int(second*1000))\n success, image = vidcap.read()\n if success:\n cv2.imwrite(os.path.join(dest_path, video_name+\"_\"+str(second)+\"_\"+str(label)+\".jpg\"), image)","def generateDataFromVideo(path):\n video = cv2.VideoCapture(path)\n success, frame = video.read()\n cnt = 1\n wiperExist = 0\n file = open(file='annotation.txt', mode='w')\n\n while success:\n cv2.imwrite(filename='./data/{0}.jpg'.format(cnt), img=frame)\n cnt += 1\n success, frame = video.read()\n if (cnt - 4) % 37 == 0 or (wiperExist > 0):\n wiperExist = (wiperExist + 1) % 21\n file.write('./Dataset/data/{0}.jpg 1\\n'.format(cnt))\n else:\n file.write('./Dataset/data/{0}.jpg 0\\n'.format(cnt))","def reconstruction(args):\n\n print('Loading 2D keypoints ...')\n keypoints, scores, _, _ = load_json(args.keypoints_file)\n\n # Loading only one person's keypoints\n if len(keypoints.shape) == 4:\n keypoints = keypoints[0]\n assert len(keypoints.shape) == 3\n\n # Transform the keypoints format from different dataset (MSCOCO, MPII) to h36m format\n if args.kpts_format == 'coco':\n keypoints, valid_frames = coco_h36m(keypoints)\n elif args.kpts_format == 'mpii':\n keypoints, valid_frames = mpii_h36m(keypoints)\n elif args.kpts_format == 'openpose':\n # Convert 'Openpose' format to MSCOCO\n order_coco = [i for i in range(18) if i != 1]\n keypoints = keypoints[:, order_coco]\n keypoints, valid_frames = coco_h36m(keypoints)\n else:\n valid_frames = np.where(np.sum(keypoints.reshape(-1, 34), axis=1) != 0)[0]\n assert args.kpts_format == 'h36m'\n\n # Get the width and height of video\n cap = cv2.VideoCapture(args.video_path)\n width = int(round(cap.get(cv2.CAP_PROP_FRAME_WIDTH)))\n height = int(round(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)))\n\n # normalize keypoints\n input_keypoints = normalize_screen_coordinates(keypoints[..., :2], w=width, h=height)\n\n if args.frames == 27:\n filter_widths = [3, 3, 3]\n channels = 128\n elif args.frames == 81:\n filter_widths = [3, 3, 3, 3]\n channels = 64\n else:\n filter_widths = [3, 3, 3, 3, 3]\n channels = 32\n\n model_pos = SpatioTemporalModel(adj, 17, 2, 17, filter_widths=filter_widths, channels=channels, dropout=0.05)\n\n if torch.cuda.is_available():\n model_pos = model_pos.cuda()\n\n # load trained model\n print('Loading checkpoint', args.weight)\n chk_file = os.path.join('./checkpoint/gastnet', args.weight)\n checkpoint = torch.load(chk_file, map_location=lambda storage, loc: storage)\n model_pos.load_state_dict(checkpoint['model_pos'])\n\n receptive_field = model_pos.receptive_field()\n pad = (receptive_field - 1) // 2 # Padding on each side\n causal_shift = 0\n\n print('Reconstructing ...')\n gen = UnchunkedGenerator(None, None, [input_keypoints[valid_frames]],\n pad=pad, causal_shift=causal_shift, augment=True,\n kps_left=kps_left, kps_right=kps_right, joints_left=joints_left, joints_right=joints_right)\n prediction = evaluate(gen, model_pos, return_predictions=True)\n prediction = camera_to_world(prediction, R=rot, t=0)\n\n # We don't have the trajectory, but at least we can rebase the height\n prediction[:, :, 2] -= np.min(prediction[:, :, 2])\n\n prediction_new = np.zeros((*input_keypoints.shape[:-1], 3), dtype=np.float32)\n prediction_new[valid_frames] = prediction\n\n print('Rendering ...')\n anim_output = {'Reconstruction': prediction_new}\n render_animation(keypoints, keypoints_metadata, anim_output, h36m_skeleton, 25, 3000,\n np.array(70., dtype=np.float32), args.viz_output, limit=-1, downsample=1, size=5,\n input_video_path=args.video_path, viewport=(width, height), input_video_skip=0)","def convert(processed_dir: str, video_file: str):\n\n video_name = osp.splitext(osp.basename(video_file))[0]\n out_dir = processed_dir + video_name\n\n # create img dir\n if not osp.exists(processed_dir):\n os.mkdir(processed_dir)\n\n # Create dir for video file if not existent\n # this is where we save our images\n if not osp.exists(out_dir):\n os.mkdir(out_dir)\n\n if osp.exists(out_dir):\n os.mkdir(out_dir + \"/kermit/\")\n os.mkdir(out_dir + \"/not_kermit/\")\n\n # open video file for processing\n cap = cv.VideoCapture(video_file)\n frame_rate = cap.get(5) # frame rate\n\n sec = 0\n total_count = (60*25)+50 # just an approximation\n pbar = tqdm.tqdm(total=total_count, leave=False)\n\n count = 0\n while (cap.isOpened()):\n frame_id = cap.get(1) # current frame number\n frame_exists, curr_frame = cap.read()\n\n if not frame_exists:\n break\n else:\n if (frame_id % math.floor(frame_rate) == 0):\n # output is : video_file/<video_file>_frameNr.jpg\n cv.imwrite(osp.join(out_dir, '{}_{}.jpg'.format(video_name,count)), curr_frame)\n count = count + 1\n pbar.update(1)\n\n pbar.close()\n # release resources\n cap.release()","def __init__(self, video_folder, output_folder, output_file=None, height=320, width=480,\n sample_every=10, max_workers=32):\n self.video_folder = video_folder\n self.output_folder = output_folder\n self.output_file = output_file\n print(\n f\"Video Preprocessor created with video_folder = {video_folder} , output_folder = {output_folder}, output_file = {output_file}\")\n\n self.height = height\n self.width = width\n self.sample_every = sample_every\n self.max_workers = max_workers\n print(f\"Frames will be created with height = {height} , width = {width} , sample_every = {sample_every}\")","def let_camera_update_parameters(path_to_images, name_image, video_source=\"/dev/video0\"):\n subprocess_cmd(\"ffmpeg -f video4linux2 -s 1280x720 -i {} -ss 00:00:02 -frames 1 ./{}/{} -loglevel error -nostats\".format(video_source, path_to_images, name_image))","def make_video(pattern, plotdir, moviedir, movienametag):\n images_list = glob('%s/%s'%(plotdir, pattern))\n images_list.sort()\n # save all required files into tmp_moviedir, with simple filenames: %.4d.png\n tmp_moviedir = '%s/tmp_movie_%s'%(plotdir, movienametag)\n os.system('mkdir -p %s'%tmp_moviedir)\n for i in range(len(images_list)):\n fname = images_list[i].split('%s/'%plotdir)[-1].split('.png')[0]\n os.system('cp %s/%s.png %s/%.4d.png'%(plotdir, fname, tmp_moviedir, i))\n\n os.system('avconv -i %s'%tmp_moviedir +'/%04d.png ' \\\n +' -y -c:v libx264 -pix_fmt yuv420p %s/%s.mp4'%(moviedir, movienametag))","def precompute_numpy_video_files(self):\n videos = self.get_videos(self.not_collisions, 1) \\\n | chain_with(self.get_videos(self.collisions, 0)) \\\n | where(lambda f: not isfile(self.get_numpy_filename(f[1])))\n\n for v in videos:\n path = self.get_numpy_filename(v[1])\n\n video_to_npy(v[1],\n # note weird thing here, width doesn't work they appear to be inverted\n height=self.video_size,\n squarecrop=self.squarecrop,\n fps=self.framerate,\n maxlength=self.max_length,\n # save a npy replacement\n outfile=path)\n\n print('%s written' % (path))","def recordVideo(args, env, model, filename):\n # env = model.get_env()\n images = []\n images = images + runAGame(model, env, args.method == 'centralized')\n images = images + runAGame(model, env, args.method == 'centralized')\n images = images + runAGame(model, env, args.method == 'centralized')\n images[0].save(filename + '.gif',\n format='GIF',\n append_images=images[1:],\n save_all=True,\n duration=500,\n loop=0)\n print('Video saved:', filename)","def __init__(self, input_file_path, convert_to_bgr=False):\n self.__yuv_video = YuvDecoder(input_file_path, convert_to_bgr=True)\n print('After INSTANTIATION')\n self.__yuv_video.start()","def run(input_video_file, output_video_file):\n print(\"Debut de la transformation du format de la video\")\n #récupération de la vidéo\n video = cv2.VideoCapture(input_video_file)\n #fps de la vidéo\n fps = video.get(cv2.CAP_PROP_FPS)\n #largeur des images de la vidéo\n width_video = int(video.get(cv2.CAP_PROP_FRAME_WIDTH))\n #hauteur des images de la vidéo\n height_video = int(video.get(cv2.CAP_PROP_FRAME_HEIGHT))\n #nombre d'images dans la vidéo\n frame_count = int(video.get(cv2.CAP_PROP_FRAME_COUNT))\n #durée de la vidéo\n duration = frame_count/fps\n #nouvelle durée de la vidéo (on arrondi)\n new_duration = math.floor(duration)\n #nouveau fps de la vidéo\n new_fps = float(round(fps))\n #appliquer le nouveau fps\n video.set(cv2.CAP_PROP_FPS,new_fps)\n #appliquer la nouvelle durée\n print(new_duration)\n print(new_fps)\n print(new_duration*new_fps)\n new_frame_count = new_duration*new_fps\n video.set(cv2.CAP_PROP_FRAME_COUNT,new_duration*new_fps)\n #déffinition du format de la vidéo en sortie\n video_out = cv2.VideoWriter(output_video_file,0x7634706d,new_fps,(width_video,height_video),True)\n \n count = 0\n #ouverture de la vidéo\n while(video.isOpened()):\n #lecture image par image\n ret, frame = video.read()\n if ret==True:\n\n #ecriture de l'image dans la vidéo en sortie\n video_out.write(frame)\n count = count + 1\n \n if (count > (new_frame_count-1)):\n # Libérer la vidéo\n video.release()\n break\n else:\n break\n\n print(\"fin de la transformation\")\n #fermer les vidéos\n video.release()\n video_out.release()","def main(data_dir):\n\n face2face_dir = '{}/manipulated_sequences/Face2Face/c0/videos'.format(data_dir)\n orig_dir = '{}/original_sequences/c0/videos'.format(data_dir)\n base_dir = '{}/manipulated_sequences/GANnotation'.format(data_dir)\n output_enc_dir = '{}/encodings'.format(base_dir)\n output_vid_dir = '{}/{}/videos'.format(base_dir, COMPRESSION_LEVEL)\n\n pairs = get_seq_combos(face2face_dir)\n\n # Compute all video encodings and save them to disk.\n # We precompute these because they take roughly 10 times as long to compute\n # as the reenactments, and we may want to recompute the reenactments with\n # different images later.\n print('Computing video encodings...')\n if not os.path.exists(output_enc_dir):\n os.makedirs(output_enc_dir)\n enc_count = 0\n for source_id, _ in pairs:\n encoding_path = get_encoding_path(output_enc_dir, source_id)\n if os.path.exists(encoding_path):\n continue # Encoding already calculated for this video sequence.\n print('Computing encoding for sequence {}...'.format(source_id))\n video_path = '{}/{}.mp4'.format(orig_dir, source_id)\n cap = cv2.VideoCapture(video_path)\n points = compute_video_encoding(cap)\n cap.release()\n try:\n np.savetxt(encoding_path, points.reshape((132,-1)).transpose())\n except KeyboardInterrupt as e:\n # Safely handle premature termination.\n # Remove unfinished file.\n if os.exists(encoding_path):\n os.remove(encoding_path)\n raise e\n enc_count += 1\n\n if enc_count == 0:\n print('No encodings were calculated')\n else:\n print('{} video sequences encoded'.format(enc_count))\n\n print()\n print('Computing reenactments...')\n\n # Load pre-trained model.\n gann_path = os.path.join(dirname, 'models/myGEN.pth')\n my_gann = GANnotation.GANnotation(path_to_model=gann_path)\n\n image_dir = '{}/original_sequences_images/{}/images'.format(data_dir, COMPRESSION_LEVEL)\n if not os.path.exists(output_vid_dir):\n os.makedirs(output_vid_dir)\n reenact_count = 0\n for source_id, driver_id in pairs:\n output_path = '{}/{}_{}.mp4'.format(output_vid_dir, source_id, driver_id)\n if os.path.exists(output_path):\n # Do not recreate a video if it already exists.\n # If the user wants to recreated a video\n # the existing video must be deleted first.\n continue\n\n print('Computing reenactment for {} onto {}...'.format(driver_id, source_id))\n # Validate that input files exist.\n encoding_path = get_encoding_path(output_enc_dir, driver_id)\n if not os.path.isfile(encoding_path):\n print('Failed to find encoding for video sequence {}'.format(driver_id),\n file=stderr)\n continue\n image_path = '{}/{}.png'.format(image_dir, source_id)\n if not os.path.isfile(image_path):\n print('Failed to find image for sequence {}'.format(source_id),\n file=stderr)\n continue\n\n points = np.loadtxt(encoding_path).transpose().reshape(66, 2, -1)\n\n # Load and transform image for inputting.\n image = cv2.imread(image_path)\n cropped = get_gann_cropped_face(image)\n\n # Compute reenactment.\n frames, _ = my_gann.reenactment(cropped, points)\n\n output_path = os.path.abspath(output_path)\n print('Writing video to \"{}\"'.format(output_path))\n try:\n write_video(frames, FPS, (128, 128), output_path)\n except KeyboardInterrupt as e:\n # Safely handle premature termination.\n # Remove unfinished file.\n if os.exists(output_path):\n os.remove(output_path)\n raise e\n reenact_count += 1\n\n if reenact_count == 0:\n print('No reenactments were created')\n else:\n print('{} reenactments created'.format(reenact_count))","def generate_video(sign, issue, output):\n\n videos = {\n \"Climate Change\": \"ClimateChange.mp4\",\n \"Green Jobs\": \"GreenJobs.mp4\",\n \"Tourism\": \"Tourism.mp4\",\n \"Small Business\": \"SmallBusiness.mp4\",\n \"Public health\": \"PublicHealth.mp4\",\n \"Education Funding\": \"EducationFunding.mp4\"\n }\n\n video_path = CWD(f\"Assets/{videos[issue]}\")\n\n frame = cv2.imread(sign)\n frame = cv2.resize(frame, (1920, 1080))\n height, width, layers = frame.shape\n fourcc = cv2.VideoWriter_fourcc(*'mp4v')\n video = cv2.VideoWriter(CWD(\"temp.mp4\"), fourcc, 1, (width, height))\n for i in range(5):\n video.write(frame)\n video.release()\n\n image_clip = VideoFileClip(CWD(\"temp.mp4\"))\n original_video = VideoFileClip(video_path)\n final_video = concatenate_videoclips([original_video, image_clip], method=\"compose\")\n\n final_video.write_videofile(output)\n os.remove(CWD(\"temp.mp4\"))","def recreateVideoFromLapPyr(pyrVideo): \n maxLevel=len(pyrVideo)\n fNumber, H, W, chNum=pyrVideo[0].shape\n videoResult=np.zeros(pyrVideo[0].shape, dtype=np.float32)\n for fn in range(videoResult.shape[0]):\n framePyr=[pyrVideo[i][fn] for i in range(maxLevel)]\n videoResult[fn]=recreateImgsFromLapPyr(framePyr)\n \n return videoResult","def recreateAnalysis(path,filename, dataset = 'POST',save = False, color = (0,255,0),location = (0,0)):\n\tprint('going to recreate the recording, press anything when ready')\n\tcv2.namedWindow('Video'); cv2.moveWindow('Video',location[0],location[1])\n\tcv2.waitKey(0)\n\tR = cf.OBJECT_RADIUS\n\tmeta,data = loadData(path,filename)\n\tfps = meta['FPS']\n\tfiletype = meta['Format']\n\tvid = []\n\twhile True: #replay loop\n\t\tVidCap = cv2.VideoCapture(path+filename+filetype)\n\t\ti = 0\n\t\twhile True: #video loop\n\t\t\tre,img = VidCap.read()\n\t\t\t#print(len(vid))\n\t\t\t#cv2.imshow('tmp',img)\n\t\t\tif re:\n\t\t\t\tfor k in range(0,meta['Num Objects']):\n\t\t\t\t\tkey = 'object{}'.format(k)\n\t\t\t\t\tcx = data[key+'_x_'+dataset][i]; cy = data[key+'_y_'+dataset][i]; ang = data[key+'_theta_'+dataset][i]\n\t\t\t\t\timg = cv2.circle(img,(cx,cy),4,(200,200,255),-1)\n\t\t\t\t\timg = cv2.circle(img,(cx,cy),R,color)\n\t\t\t\t\timg = cv2.putText(img,key+': '+data[key+'_ID'],(cx,cy-R),cv2.FONT_HERSHEY_SIMPLEX,0.5,(color))\n\t\t\t\t\tpnt1 = (int(cx+R*math.cos(ang)),int(cy-R*math.sin(ang)))\n\t\t\t\t\timg = cv2.arrowedLine(img,(cx,cy),pnt1,color)\n\t\t\t\tcv2.imshow('Video',img)\n\t\t\t\tvid.append(img)\n\t\t\t\ti += 1\n\t\t\t\tif cv2.waitKey(int(1000/fps))== ord('q'):\n\t\t\t\t\tVidCap.release()\n\t\t\t\t\tprint('ending early, not saving')\n\t\t\t\t\tsave = False\n\t\t\t\t\tbreak\n\t\t\telse:\n\t\t\t break\n\t\tprint('press r to replay, or anything else to quit')\n\t\tif cv2.waitKey(0) == ord('r'):\n\t\t print('playing processed video again')\n\t\telse:\n\t\t break\n\tVidCap.release()\n\tif save:\n\t\tim = vid[-1]\n\t\t(frame_height,frame_width) = im.shape[0:2]\n\t\tvideoPath = path+filename + '_EVAL_' + dataset + filetype\n\t\tout = cv2.VideoWriter(videoPath, cf.FOURCC, fps, (frame_width,frame_height))\n\t\tfor i,frame in enumerate(vid):\n\t\t\tout.write(frame)\n\t\tprint('processed video file saved')\n\treturn","def check_video_timestamps(movie_file, desired_format='.mp4', desired_framerate=30):\n\n check_video_format(movie_file, desired_format='.mp4', original_format='.avi')\n\n new_movie_file = movie_file+'_tt'+desired_format\n if not os.path.isfile(new_movie_file):\n #Convert file to 30 fps\n cmd = ['ffmpeg', '-i', movie_file+desired_format]\n cmd += ['-r', str(desired_framerate)]\n cmd += ['-y', movie_file+'_t'+desired_format]\n cmd_string = ''.join([\"%s \" % el for el in cmd]) \n #print '-->Running: ', cmd_string\n p = subprocess.Popen(cmd, shell=False)\n p.wait()\n\n #Add timecode text to video\n cmd = 'ffmpeg -i '+movie_file+'_t'+desired_format+' -vf drawtext=\\\"fontfile=/opt/X11/share/fonts/TTF/VeraMoBd.ttf: timecode=\\'00\\:00\\:00\\:00\\':rate=30: fontcolor=white@0.8: x=7: y=460\\\" -an -y '+movie_file+'_tt'+desired_format\n args = shlex.split(cmd)\n #print args\n p = subprocess.Popen(args, shell=False)\n p.wait()\n\n os.remove(movie_file+'_t'+desired_format)\n\n return new_movie_file","def process_video(weights_path,video_path,output_path,margins=40,facenet_threshold=.985,euclidean_distance_threshold = 120.0):\n with torch.no_grad():\n mtcnn = MTCNN(image_size= 256, margin = 0)\n model = Model.VGGFace_Extractor().to(device)\n model.load_state_dict(torch.load(weights_path))\n model.eval()\n cap = cv2.VideoCapture(video_path)\n rotateCode = check_rotation(video_path)\n fourcc = cv2.VideoWriter_fourcc('M', 'J', 'P', 'G')\n out = cv2.VideoWriter(output_path, fourcc, 20.0, (int(cap.get(3)), int(cap.get(4))))\n ret, frame1 = cap.read()\n hsv = np.zeros_like(frame1)\n hsv[..., 1] = 255\n i = 0\n while (cap.isOpened()):\n i += 1\n ret, frame2 = cap.read()\n if not (ret): break\n if rotateCode is not None:\n frame2 = correct_rotation(frame2, rotateCode)\n\n boxes, probs = mtcnn.detect(frame2)\n img_draw = frame2.copy()\n img_draw = Image.fromarray(img_draw)\n draw = ImageDraw.Draw(img_draw)\n if boxes is not None:\n names = []\n distances_difference = []\n for (box, point) in zip(boxes, probs):\n \"\"\" Loop from the extract_face method from facenet_pytorch\"\"\"\n\n if point < facenet_threshold: continue\n margin = margins\n image_size = 256\n margin = [\n margin * (box[2] - box[0]) / (image_size - margin),\n margin * (box[3] - box[1]) / (image_size - margin),\n ]\n raw_image_size = get_size(img_draw)\n box = [\n int(max(box[0] - margin[0] / 2, 0)),\n int(max(box[1] - margin[1] / 2, 0)),\n int(min(box[2] + margin[0] / 2, raw_image_size[0])),\n int(min(box[3] + margin[1] / 2, raw_image_size[1])),\n ]\n\n face = img_draw.crop(box).copy().resize((image_size, image_size), Image.BILINEAR).convert(\"RGB\")\n features_1 = model(utils.preprocess(face,device).reshape(-1, 3, 224, 224))\n images_path = \"individuals_extracted/\"\n data_path = os.path.join(images_path, '*pt')\n files = glob.glob(data_path)\n name = \"Unknown\"\n best_distance = euclidean_distance_threshold + 5\n for k,f1 in enumerate(files):\n features = torch.load(f1)\n distance = utils.euclidean_distance(features,features_1)\n if distance < euclidean_distance_threshold and distance < best_distance:\n best_distance = distance\n name = re.sub('_[1-9]*[.]*[a-zA-Z]*', '', f1.replace(images_path,\"\"))\n\n names.append(name)\n distances_difference.append(best_distance)\n\n for (box, point,name,distances) in zip(boxes, probs,names,distances_difference):\n if point < facenet_threshold or name == \"Unknown\": continue\n draw.rectangle(box.tolist(), width=4)\n draw.text(box.tolist(), name, font=ImageFont.truetype(\"Keyboard.ttf\",40))\n\n k = cv2.waitKey(3) & 0xff\n if k == 27:\n break\n out.write(np.asarray(img_draw))\n\n out.release()\n cap.release()\n cv2.destroyAllWindows()","def run(self, vid_input_path='project_video.mp4'):\n vid_output_path = self.g.output_movie_path + vid_input_path\n print('Finding lanes for:', vid_input_path) \n\n # Load the Video\n # video_clip = VideoFileClip(video_filename).subclip(10, 11)\n clip1 = VideoFileClip(vid_input_path)\n\n # Feed the video, clip by clip into the pipeline.\n test_clip = clip1.fl_image(self.__image_pipeline) \n test_clip.write_videofile(vid_output_path, audio=False)\n\n return True","def __init__(self,vid_path:str,num_frames:int=None,vid_flow_direction:str='left'):\n \n self.num_frames=num_frames\n if vid_path.split('.')[-1]=='cine' or vid_flow_direction!='left':\n #This is a cine file or needs to be rotated, convert to mp4\n print('Converting .cine file to mp4 (lossless)')\n #detect platform so we can correct file paths for ffmpeg\n is_win=re.compile('.*[Ww]in.*')\n if is_win.match(sys.platform):\n corrected_vid_path='\"'+vid_path+'\"'\n else:\n #Put escape characters in front of spaces in file name\n corrected_vid_path=[]\n for c in vid_path:\n if c==' ':\n corrected_vid_path.append('\\\\')\n corrected_vid_path.append(c)\n corrected_vid_path=''.join(corrected_vid_path)\n if vid_flow_direction=='up':\n rotate='-vf \"transpose=2\" '\n elif vid_flow_direction=='left':\n rotate=''\n elif vid_flow_direction=='right':\n rotate='-vf \"transpose=2,transpose=2\" '\n else:\n raise Exception(\"vid_flow_direction must be 'up', 'left' or 'right'\")\n if num_frames!=None:\n frames='-frames:v {0} '.format(num_frames)\n else:\n frames=''\n os_handle,new_file_path=tempfile.mkstemp(suffix='.mp4')\n #close file, we don't work with it directly\n os.close(os_handle)\n ffmpeg_command='ffmpeg -y -i {orig_file} {frames}{rotate}-f mp4 -crf 0 {new_file}'.format(orig_file=corrected_vid_path,rotate=rotate,new_file=new_file_path,frames=frames)\n print(ffmpeg_command)\n list(os.popen(ffmpeg_command))\n self.vid_path=new_file_path\n self.delete_file=True\n stats=os.stat(new_file_path)\n if stats.st_size==0:\n raise Exception('File conversion failed, check that ffmpeg is on PATH')\n else:\n #Not a cine\n self.vid_path=vid_path\n self.delete_file=False","def generate_heatmap_video(img_list,size,video_filename): \n out = cv2.VideoWriter(video_filename,cv2.VideoWriter_fourcc(*'DIVX'), 25, size)\n for i in range(len(img_list)):\n out.write(img_list[i])\n out.release()\n print('Heatmap video generated at: ', video_filename)","def make_video(data,\n xdim, ydim, sample_read_rows, sample_read_cols, image_write_rows, image_write_cols,\n directory, filename, fps = 24.0, start_frame = 1, end_frame = None, timestamp = False, fontsize = 30, ts_pos = (0,0), save_raw = False):\n\n #Command to send via the command prompt which specifies the pipe parameters\n # command = ['ffmpeg',\n # '-y', # (optional) overwrite output file if it exists\n # '-f', 'image2pipe',\n # '-vcodec', 'mjpeg', #'mjpeg',\n # '-r', '1',\n # '-r', str(fps), # frames per second\n # '-i', '-', # The input comes from a pipe\n # '-an', # Tells FFMPEG not to expect any audio\n # '-vcodec', 'mpeg4',\n # '-b:v', '5000k',\n # directory + filename + \"/\"+filename+\".mp4\",\n # '-hide_banner',\n # '-loglevel', 'panic']\n\n # Create directories if they don't exist\n if not os.path.exists(os.path.join(directory, filename, 'frames/')):\n os.makedirs(os.path.join(directory, filename, 'frames/'))\n if save_raw and not os.path.exists(os.path.join(directory, filename, 'frames-raw/')):\n os.makedirs(os.path.join(directory, filename, 'frames-raw/'))\n\n if end_frame == None:\n end_frame = data.FrameCount\n\n cm = colormap.get_cmap('viridis')\n\n for i, frame_offset in enumerate(tqdm.tqdm(range(start_frame, end_frame))):\n frame = FrameRead(data, frame_offset)\n frame_image = np.zeros([ydim, xdim], dtype=np.uint8)\n frame_image[image_write_rows, image_write_cols] = frame.frame_data[sample_read_rows, sample_read_cols]\n\n rgb_im = Image.fromarray(cm(frame_image, bytes=True)).convert('RGB')\n rgb_im.save(os.path.join(directory, filename, 'frames/', f'{i}.jpg'), 'JPEG')\n\n if save_raw:\n Image.fromarray(np.uint8(frame.frame_data), mode='L').save(os.path.join(directory, filename, 'frames-raw/', f'{i}.jpg'), 'JPEG')","def process_video(self):\n if os.path.isfile(self.source):\n self.cap = cv2.VideoCapture(self.source)\n else:\n try:\n file_name = \"input.mp4\"\n self.source = self.source.replace('open', 'uc')\n print( \"\\nDownloading video file from drive link to %s\\n\"%file_name)\n gdown.download(self.source, file_name, quiet=False)\n print( \"%s downloaded!\\n\"%file_name )\n self.cap = cv2.VideoCapture(file_name)\n except Exception:\n raise RuntimeError(\"Invalid source input, please specify a Google drive link or a downloaded local file as input \\n\")\n\n\n assert self.cap.isOpened(), \"Failed to open %s\" % self.source\n\n self.w = int(self.cap.get(cv2.CAP_PROP_FRAME_WIDTH))\n self.h = int(self.cap.get(cv2.CAP_PROP_FRAME_HEIGHT))\n self.fps = self.cap.get(cv2.CAP_PROP_FPS) \n self.nframes = int(self.cap.get(cv2.CAP_PROP_FRAME_COUNT))\n return","def __init__(self, videoPath=\"\", cacheString=\"-cache\", faceDetector=None):\n self.videoPath = videoPath\n self.cacheString = cacheString\n self.video = None \n self.currentFrame = []\n self.currentFrameNumber = 0\n self.frameCount = 0 #total frame number\n self.fps = 25\n self.ret = True #if the video is over\n self.isPlaying = False\n self.ifDrawAxis = False\n self.ifDrawSquare = False\n self.cacheData = {}\n \n if videoPath != \"\":\n self.load()","def mmap2Channel(self):\n self.memmap = np.memmap(self.inputFilenames['ofd'],\n dtype='uint16',\n mode='r',\n offset=0,\n shape=(\n 2, self.reconstructionSettings['numSamples'], self.scanSettings['numAlinesPerRawFrame'],\n self.scanSettings['numFrames']), order='F')","def video(ctx, video_file, analytic_addr):\n if not analytic_addr:\n analytic_addr = [\"localhost:50051\"]\n db = ctx.obj.db\n client = aceclient.AnalyticMultiClient()\n classes = {}\n cap = cv2.VideoCapture(video_file)\n window_names = []\n f_req = analytic_pb2.FrameRequest()\n for a in analytic_addr:\n analytic = analytic_pb2.AnalyticData()\n analytic.addr = a\n f_req.analytics.append(analytic)\n # Load all frames into a queue buffer\n buf = Queue()\n while (cap.isOpened()):\n ret, frame = cap.read()\n if not ret:\n break\n buf.put(frame)\n try:\n while not buf.empty():\n frame = buf.get(block=False)\n resp = analytic_pb2.CompositeResults()\n resp = client.process_frame(frame, f_req, resp)\n render(resp, window_names, classes, frame, db)\n finally:\n cv2.destroyAllWindows()\n print(\"Shutting down\")","def gen_frame_feature_resNet152(rgb_fpath, rgb_spath, rgb_spath_flip, u_fpath, u_spath, u_spath_flip, v_fpath, v_spath,\n v_spath_flip):\n rgb_fl = Frameloader(rgb_fpath)\n u_fl = Frameloader(u_fpath)\n v_fl = Frameloader(v_fpath)\n\n # construct the model\n input_layer, resNet152, end_points, saver = model()\n\n config = tf.ConfigProto()\n config.gpu_options.allow_growth = True\n # config.log_device_placement = True\n config.allow_soft_placement = True\n with tf.Session(config=config) as sess:\n sess.run(tf.global_variables_initializer())\n saver.restore(sess, \"/home/boy2/UCF101/src/resNet-152/resnet_v1_152.ckpt\")\n # read all video frames and generate frame features by resNet152\n while len(rgb_fl.frame_parent_paths) != 0:\n # save start time\n start = time.time()\n\n # prepare the input frames\n video_name = rgb_fl.get_current_video_name()\n print(\"Current working on: \", video_name)\n rgb_frames = rgb_fl.load_frames()\n u_frames = u_fl.load_frames()\n v_frames = v_fl.load_frames()\n if len(rgb_frames) > len(u_frames) and len(rgb_frames) - 1 == len(u_frames):\n rgb_frames = rgb_frames[:-1]\n rgb_frames_flip, u_frames_flip, v_frames_flip = flip(rgb_frames, u_frames, v_frames)\n\n # resize the frames to (224, 224)\n rgb_frames = resize(rgb_frames, (width, height))\n u_frames = resize(u_frames, (width, height))\n v_frames = resize(v_frames, (width, height))\n rgb_frames_flip = resize(rgb_frames_flip, (width, height))\n u_frames_flip = resize(u_frames_flip, (width, height))\n v_frames_flip = resize(v_frames_flip, (width, height))\n\n if rgb_frames != [] and u_frames != [] and v_frames != [] and rgb_frames_flip != [] \\\n and u_frames_flip != [] and v_frames_flip != []:\n\n rgb_feature = cal_features(rgb_frames, sess, input_layer, resNet152)\n u_feature = cal_features(u_frames, sess, input_layer, resNet152)\n v_feature = cal_features(v_frames, sess, input_layer, resNet152)\n rgb_feature_flip = cal_features(rgb_frames_flip, sess, input_layer, resNet152)\n u_feature_flip = cal_features(u_frames_flip, sess, input_layer, resNet152)\n v_feature_flip = cal_features(v_frames_flip, sess, input_layer, resNet152)\n\n np.save(os.path.join(rgb_spath, video_name), rgb_feature)\n np.save(os.path.join(rgb_spath_flip, video_name), rgb_feature_flip)\n np.save(os.path.join(u_spath, video_name), u_feature)\n np.save(os.path.join(u_spath_flip, video_name), u_feature_flip)\n np.save(os.path.join(v_spath, video_name), v_feature)\n np.save(os.path.join(v_spath_flip, video_name), v_feature_flip)\n\n print(time.time() - start)","def process_video(data_info, name, mode, is_training=True):\r\n data = Action_Dataset(name, mode, [data_info])\r\n if is_training:\r\n clip_seq, label_seq = data.next_batch(1, _CLIP_SIZE)\r\n else:\r\n clip_seq, label_seq = data.next_batch(\r\n 1, _EACH_VIDEO_TEST_SIZE+1, shuffle=False, data_augment=False)\r\n clip_seq = 2*(clip_seq/255) - 1\r\n clip_seq = np.array(clip_seq, dtype='float32')\r\n return clip_seq, label_seq","def process_vid_file(vid_file):\n # dict that holds params for matching\n params = {}\n # scale for motion estimation\n params['fScale'] = 1.0\n # number of descriptors\n params['nFeat'] = 2000\n # minimal number of descriptors\n params['nMinKp'] = 50\n # minimal number of matched descriptors\n params['nMinMatch'] = 30\n # maximum offset in flow \n params['fVhThresh'] = 32.0\n # params for image quality (motion blur)\n params['fQualityThresh'] = 5.0\n params['fQualityRatio'] = 0.2\n\n # get video stats\n video_name = os.path.basename(vid_file[:-4])\n video_name.replace(' ', '')\n output_frame_list = []\n output_homography = []\n frame_index = 0\n\n # open video file\n cap = cv2.VideoCapture(vid_file)\n if not cap.isOpened():\n print \"Can not open video file: {:s}\".format(vid_file)\n return frame_pairs\n \n # fetch the first frame\n ret, prev_frame = cap.read()\n if (not ret) or (prev_frame is None):\n print \"Can not read video file: {:s}\".format(vid_file)\n\n start = time.time()\n\n # loop over all frames\n while(True):\n\n # increase the counter\n frame_index += 1\n\n # read current frame\n ret, frame = cap.read()\n\n # end of file?\n if (not ret) or (prev_frame is None):\n break\n\n # match the frames\n M = match_frames(prev_frame, frame, params)\n\n # copy to previous frame\n prev_frame = frame.copy()\n\n # save the frame number and the homography\n if len(M) > 0:\n output_frame_list.append(frame_index)\n output_homography.append(M)\n if len(output_homography) == 1:\n output_homography.append(M)\n # timing\n end = time.time()\n print \"Averge time per frame: {:2f} s. \".format(float(end-start)/frame_index)\n print \"{:2d} valid frame pairs out of {:2d} total pairs\".format(len(output_frame_list), frame_index-1)\n \n return output_frame_list, output_homography","def startVideo(self,fname):\n\n\n try:\n fourcc = cv2.cv.CV_FOURCC(*'DIVX')\n\n except Exception as e:\n #print \"Exception \",e.args\n fourcc = cv2.VideoWriter_fourcc(*'DIVX')\n\n self.video = cv2.VideoWriter(fname, fourcc, 10, (self.screenWidth, self.screenHeight))\n if self.video is None:\n print \"VideoWriter failed to start.\"\n else:\n print \"VideoWriter started ok\"","def start_ffmpeg_record(stream, stream_url, formatted_date):\n filename = stream + '_' + formatted_date\n save_video_dir = 'rover_stream/' + stream\n subprocess.Popen(['mkdir rover_stream'], shell=True)\n subprocess.Popen(['mkdir ' + save_video_dir], shell=True)\n proc_video[stream] = subprocess.Popen(['ffmpeg -i ' + stream_url + ' -acodec copy -vcodec copy ' + save_video_dir + '/' + filename + '.mp4'], stdin=PIPE, shell=True)","def find_cars_video(input_path, output_path, clf, hyperparams, box_color=None, debug=False):\n v = VideoProcessor(clf, hyperparams, box_color)\n v.process_video(input_path, output_path, debug)","def extract_faces(frame_path, out_path, face_path, processes=1):\n if os.path.exists(out_path):\n msg = '[extract_faces] Skipping extraction since faces already exist at {}'\n print(msg.format(out_path))\n return\n\n from faceoff.faceswap_api import FaceSwapInterface\n\n os.makedirs(out_path)\n print('[extract_faces] Starting on {}'.format(frame_path))\n start_time = time.time()\n\n api = FaceSwapInterface()\n api.extract(frame_path, out_path, face_path, processes)","def video2img(video, csv, output_path, match):\n with open(csv, 'r') as file:\n lines = file.readlines()[1:]\n\n csv_content = []\n for line in lines:\n frame, vis, x, y = line.strip().split(',')\n csv_content.append((int(frame), int(vis), float(x), float(y)))\n\n name_split = os.path.split(video)\n name = \"match%d\"%(match) + '_' + name_split[-1][:-4]\n\n count = 0\n num_data = len(csv_content)\n cap = cv2.VideoCapture(video)\n success, image = cap.read()\n ratio = image.shape[0]/HEIGHT\n while success:\n if count >= num_data:\n break\n label = csv_content[count]\n if label[1] == 0:\n heat_map = genHeatMap(WIDTH, HEIGHT, -1, -1, sigma, mag)\n else:\n heat_map = genHeatMap(WIDTH, HEIGHT, int(label[2]/ratio), int(label[3]/ratio), sigma, mag)\n \n image = cv2.resize(image, (WIDTH, HEIGHT))\n heat_map = (heat_map*255).astype('uint8')\n cv2.imwrite(os.sep.join([output_path, 'x_data', name+'_%d.jpg' %(count)]), image)\n cv2.imwrite(os.sep.join([output_path, 'y_data', name+'_%d.jpg' %(count)]), heat_map)\n success, image = cap.read()\n count += 1","def make_seret(processed_files_directory='files/',fps=5):\r\n # Sort files in processed images directory\r\n files = sort_files(processed_files_directory)\r\n # Create list as container for the movie.\r\n img_array = []\r\n # For each file\r\n for file in files:\r\n file_format = file.split(\".\")\r\n if file_format[-1] == 'jpg': # verify that we will include jpg files only in the movie\r\n # Read the file\r\n img = cv2.imread(file)\r\n # Extract height, width, channels from image\r\n height, width, layers = img.shape\r\n # size = (width, height)\r\n size = (width, height)\r\n # Append image to movie container\r\n img_array.append(img)\r\n # Create a video writer for the movie\r\n out = cv2.VideoWriter(processed_files_directory+'initial.avi', cv2.VideoWriter_fourcc(*'DIVX'), fps, size)\r\n # For each image in container\r\n for image in img_array:\r\n # Write image by video writer\r\n out.write(image)\r\n # Release video writer.\r\n out.release()","def write_proposals_to_video(self, vdir, frms_per_sec=1.0):\n # Input video\n vid_name = self.props['vname']\n vfpath = fdops.get_files_with_kws(vdir, [vid_name, \".mp4\"])\n if len(vfpath) > 1:\n raise Exception(f\"More than one video found\\n\\t{vfpath}\")\n vin = VidReader(vfpath[0])\n\n # Output video\n ovid_path = f\"{self.props['loc']}/{self.props['name']}.mp4\"\n vw = skvideo.io.FFmpegWriter(\n ovid_path,\n outputdict={'-vcodec': 'libx264','-r':'30'}\n )\n\n # Calculate frame numbers(POC) that we will use.\n f0_start = 0 # starting frame poc\n f0_end = vin.props['num_frames'] - 1 # ending frame poc\n f0_skip = vin.props['frame_rate']*(1/frms_per_sec)\n f0s = list(range(f0_start, f0_end, int(f0_skip)))\n\n # Loop over each frame number and draw proposal regions\n # over them\n for f0 in tqdm(f0s):\n frm = vin.get_frame(f0, c='bgr')\n\n # Get proposals for frame f0\n props = self._get_proposals_for_frame(f0)\n\n # Proposals looop\n for p in props:\n if len(p) > 0:\n w0, h0, w, h = p\n frame = cv2.rectangle(\n frm, (w0, h0), (w0+w, h0+h), (0, 256, 0), 1\n )\n # Write frame to output\n vw.writeFrame(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))\n\n vw.close()\n vin.release()\n import sys; sys.exit()","def reencode(filepath, loglevel='panic'):\n try:\n import ffmpeg\n except ImportError:\n logger.error(\n 'Import Error! Cant import ffmpeg. '\n 'Annotations operations will be limited. import manually and fix errors')\n raise\n if not os.path.isfile(filepath):\n raise IOError('File doesnt exists: {}'.format(filepath))\n # re encode video without b frame and as mp4\n basename, ext = os.path.splitext(filepath)\n output_filepath = os.path.join(basename, os.path.basename(filepath).replace(ext, '.mp4'))\n if not os.path.isdir(os.path.dirname(output_filepath)):\n os.makedirs(os.path.dirname(output_filepath))\n try:\n stream = ffmpeg.input(filepath, **{'loglevel': loglevel}).output(output_filepath,\n **{'x264opts': 'bframes=0',\n 'f': 'mp4'})\n ffmpeg.overwrite_output(stream).run()\n except Exception as e:\n logger.exception('ffmpeg error in disassemble:')\n raise\n\n output_probe = Videos.get_info(output_filepath)\n start_time = eval(output_probe['streams'][0]['start_time'])\n fps = eval(output_probe['streams'][0]['avg_frame_rate'])\n has_b_frames = output_probe['streams'][0]['has_b_frames']\n start_frame = fps * start_time\n if start_time != 0:\n logger.warning('Video start_time is not 0!')\n if has_b_frames != 0:\n logger.warning('Video still has b frames!')\n return output_filepath","def make_movie(field='uu1', datadir='data/', proc=-1, extension='xz',\n format='native', tmin=0., tmax=1.e38, amin=0., amax=1.,\n transform='', oldfile=False):\n\n import pylab as plt\n\n datadir = os.path.expanduser(datadir)\n if proc < 0:\n filename = datadir + '/slice_' + field + '.' + extension\n else:\n filename = datadir + '/proc' + \\\n str(proc) + '/slice_' + field + '.' + extension\n\n # Read the global dimensions.\n dim = read_dim(datadir, proc)\n if dim.precision == 'D':\n precision = 'd'\n else:\n precision = 'f'\n\n # Set up slice plane.\n if extension == 'xy' or extension == 'Xy':\n hsize = dim.nx\n vsize = dim.ny\n if extension == 'xz':\n hsize = dim.nx\n vsize = dim.nz\n if extension == 'yz':\n hsize = dim.ny\n vsize = dim.nz\n plane = np.zeros((vsize, hsize), dtype=precision)\n\n infile = npfile(filename, endian=format)\n\n files = []\n fig = plt.figure(figsize=(5, 10))\n ax = fig.add_subplot(111)\n\n ifirst = True\n islice = 0\n while True:\n try:\n raw_data = infile.fort_read(precision)\n except ValueError:\n break\n except TypeError:\n break\n\n if oldfile:\n t = raw_data[-1]\n plane = raw_data[:-1].reshape(vsize, hsize)\n else:\n t = raw_data[-2]\n plane = raw_data[:-2].reshape(vsize, hsize)\n\n if transform:\n exec('plane = plane' + transform)\n\n if t > tmin and t < tmax:\n ax.cla()\n ax.imshow(plane, vmin=amin, vmax=amax)\n fname = '_tmp%03d.png' % islice\n print('Saving frame' + fname)\n fig.savefig(fname)\n files.append(fname)\n\n if ifirst:\n #print \"----islice----------t---------min-------max-------delta\" # Python 2\n print(\"----islice----------t---------min-------max-------delta\")\n #print \"%10i %10.3e %10.3e %10.3e %10.3e\" % \\ # Python 2\n #(islice, t, plane.min(), plane.max(), plane.max() - plane.min()) # Python 2\n print(\"{0:10} {1:10.3e} {2:10.3e} {3:10.3e} {4:10.3e}\".format(islice, t, plane.min(), plane.max(), plane.max() - plane.min()))\n\n ifirst = False\n islice += 1\n\n #print 'Making movie animation.mpg - this make take a while'\n print('Making movie animation.mpg - this make take a while')\n # SC: Not all systems use mencoder. Need to change this into ffmpeg.\n os.system(\"mencoder 'mf://_tmp*.png' -mf type=png:fps=24 -ovc lavc -lavcopts vcodec=wmv2 -oac copy -o animation.mpg\")\n os.system(\"rm _tmp*.png\")\n infile.close()","def process_videos(chapter_info):\n\n print(\"Processing chapter_info:\", chapter_info)\n\n # getting creation time of the first chapter\n # TODO update when adding multiple directory proccessing\n os.chdir(DIR_VIDEO_FILES)\n print(\"1st chapter\", chapter_info[1][0])\n chap1_time = time.strftime(\n r\"%Y-%m-%d_%H-%M\", time.localtime(os.path.getctime(chapter_info[1][0])))\n print(\"1st chapter creation\", chap1_time)\n\n # output_file = f\"M_GH00{chapter_info[0]}_{chap1_time}.MP4\"\n output_file = f\"{chap1_time}_GH00{chapter_info[0]}_MRG.MP4\"\n if os.path.isfile(output_file):\n print(f\"Chapter already processed, found file: {output_file}\")\n return\n\n # preparing text file containing file list for merging (for ffmpeg)\n video_list_file = chapter_info[0] + \"_merge.txt\"\n with open(video_list_file, \"w\") as f:\n for video_chapter in chapter_info[1]:\n f.write(f\"file {video_chapter}\\n\")\n\n command = f\"{FFMPEG_EXE} -f concat -i {video_list_file} -c copy {DIR_OUTPUT}{output_file}\"\n print(\"command =\", command)\n # p = subprocess.run(\"dir\", shell=True, capture_output=True)\n # p = subprocess.run(\"dir\", shell=True, stdout=subprocess.PIPE, text=True)\n p = subprocess.run(command, stdout=subprocess.PIPE, text=True)\n print(\"returncode =\", p.returncode)\n # print(\"stdout =\", p.stdout)\n os.remove(video_list_file) # remove file list after merging\n # rename original chapters after processing\n for video_chapter in chapter_info[1]:\n os.rename(video_chapter, f\"OK_{video_chapter}\")","def video_files():\n p = parse_cmdline(get_parser=get_parser_files)\n log.setup_main_handler(\n mods=(\"fogtools\", \"typhon\", \"fogpy\", \"sattools\", \"fcitools\", \"satpy\",\n \"pyresample\"),\n level=logging.INFO)\n vis.show_video_abi_glm(\n files=p.files,\n img_out=p.filename_pattern_image,\n vid_out=p.filename_pattern_video,\n out_dir=p.outdir)\n print(\"Files written to:\", p.outdir)","def __merge_ts_by_ffmepg(self, local_m3u8_path, video_name):\n try:\n command = 'ffmpeg -allowed_extensions ALL -i {} -c copy -y {}'.format(local_m3u8_path, video_name)\n print(command)\n os.system(command)\n print('merge succeed.')\n except:\n print('merge failed.')","def process_data(self, clip_name) -> Preprocessor:\n\n config: Config = Config.get_config()\n\n folder_name = config.video_data\n video_data_file = ''.join(clip_name.split('.')[:-1]) + '.json'\n video = Video.from_json(os.path.join(folder_name, video_data_file))\n\n # Convert to usable data type period_running_person division, alle fragment soorten\n preprocessor = Preprocessor(video)\n\n return preprocessor","def prepare_video(path_to_video: str, number_of_images=87) -> None:\n\n temp_video = path.join(path_to_video, 'temp_outpy.mp4')\n video = path.join(path_to_video, 'outpy.h264')\n\n # create mp4 video for metadata and compute video duration\n subprocess.run(['ffmpeg', '-i', video, '-c', 'copy', temp_video])\n result = subprocess.run([\"ffprobe\", \"-v\", \"error\", \"-show_entries\",\n \"format=duration\", \"-of\",\n \"default=noprint_wrappers=1:nokey=1\", temp_video],\n stdout=subprocess.PIPE,\n stderr=subprocess.STDOUT)\n video_duration = float(result.stdout)\n\n # create images folder\n path_to_images = path.join(path_to_video, 'images')\n if path.exists(path_to_images) and path.isdir(path_to_images):\n shutil.rmtree(path_to_images)\n makedirs(path_to_images)\n\n # split the given video into images\n subprocess.run(['ffmpeg', '-i', temp_video, '-r', str(number_of_images / video_duration), '-f', 'image2',\n path.join(path_to_images, 'image%d.jpg')])\n\n # remove extra files\n remove_extra_images(path_to_images, number_of_images)\n remove(temp_video)","def on_movie(self):\n path = os.path.normcase(self.pMov)\n os.system('\"%s\"' % path)","def make_video(self, mp4=True, gif=True):\n fn = self.get_output_filename(\".mp4\")\n command = (\n (get_ffmpeg_path() + f\" -loglevel panic -framerate {self.framerate} -i \")\n + os.path.join(self.frame_directory, FRAME_FN_TEMPLATE)\n + \" -s:v \"\n + str(self.width)\n + \"x\"\n + str(self.height)\n + \" -c:v libx264 -profile:v high -crf 1 -pix_fmt yuv420p -y \"\n + fn\n )\n\n os.system(command)\n\n if gif:\n mp4_to_gif(\n self.get_output_filename(\".mp4\"),\n self.get_output_filename(\".gif\"),\n self.framerate,\n )\n\n if not mp4:\n os.remove(fn)","def __init__(self, pn_output=\"./\"):\n # Initialize the video stream, then allow the camera sensor to warm up\n print(\"[INFO] starting video stream...\")\n self.vs = cv2.VideoCapture(0) # Capture video frames, 0 is default video camera\n time.sleep(2.0)\n\n # Load config\n config = configparser.ConfigParser()\n config.read(fn_config)\n self.pn_guest_images = config['DEFAULT']['pn_guest_images_archive']\n self.guest_archive = p7zip(self.pn_guest_images)\n self.camera_rot = int(config['DEFAULT']['camera_rot'])\n self.image_width = int(config['DEFAULT']['image_width'])\n self.max_capture_interval = float(config['DEFAULT']['capture_interval'])\n self.max_capture_length = int(config['DEFAULT']['max_capture_length'])\n self.max_images = int(config['DEFAULT']['max_images'])\n\n # Capture Vars\n self.curr_pic = None # Current image from the camera\n self.gst_capture = None\n self.start_time = time.time()\n self.save_time = time.time()\n self.pic_num = None\n self.pn_gstcap_out = None\n\n # Face Detection Model\n self.min_detec_conf = float(config['DEFAULT']['min_detec_conf'])\n self.min_face_px = make_tuple(config['DEFAULT']['min_face_px'])\n pn_detector_model = config['DEFAULT']['pn_detector_model']\n self.trainRBGavg = make_tuple(config['DEFAULT']['detector_trainrgbavg'])\n print(\"[INFO] loading face detector and embedding model...\")\n protoPath = os.path.sep.join([pn_detector_model, \"deploy.prototxt\"])\n modelPath = os.path.sep.join([pn_detector_model,\n \"res10_300x300_ssd_iter_140000.caffemodel\"])\n self.detector = cv2.dnn.readNetFromCaffe(protoPath, modelPath)\n self.detector.setPreferableTarget(cv2.dnn.DNN_TARGET_CPU)\n\n # Face Recognition (extract/recognize embeddings) Model\n self.min_recog_prob = float(config['DEFAULT']['min_recog_prob'])\n fn_embedding_model = config['DEFAULT']['fn_embedding_model']\n self.embedder = cv2.dnn.readNetFromTorch(fn_embedding_model)\n self.embedder.setPreferableTarget(cv2.dnn.DNN_TARGET_CPU)\n self.gst_identify = False\n self.guest_ids = {}\n\n # Guest Info (update outside of function)\n self.known_guest_meta = None","def create_video_output_path(output_dir, cfg):\n filename = os.path.join(output_dir, cfg['video']['output']) + '{}.mp4'\n # If a file of this name exists increase the counter by 1\n counter = 0\n while os.path.isfile(filename.format(counter)):\n counter += 1\n # Apply counter to filename\n return filename.format(counter)","def take_one_shot(path_to_images, name_image, video_source=\"/dev/video0\"):\n subprocess_cmd(\"ffmpeg -f video4linux2 -s 1280x720 -i {} -frames 1 ./{}/{} -loglevel error -nostats\".format(video_source, path_to_images, name_image))","def _map_fb_memory(fbfid, fix_info):\n return mmap.mmap(fbfid, fix_info.smem_len, mmap.MAP_SHARED, mmap.PROT_READ | mmap.PROT_WRITE, offset=0)","def save_video(foldername, songname, songlen, num_steps, output):\n num_steps_by_len = num_steps / songlen\n p = subprocess.Popen(['ffmpeg', '-f', 'image2', '-r', str(num_steps_by_len), '-i', '%d.png', '-c:v', 'libx264', '-pix_fmt', 'yuv420p', '-vf', 'pad=ceil(iw/2)*2:ceil(ih/2)*2', 'movie.mp4'], cwd=foldername)\n p.wait()\n\n p = subprocess.Popen(['ffmpeg', '-i', 'movie.mp4', '-i', '../audio_files/' + songname + '.mp3', '-map', '0:v', '-map', '1:a', '-c', 'copy', output], cwd=foldername)\n p.wait()","def do_add_ink():\n clip = mpy.VideoClip(mix_video_ink, duration=13.0)\n clip.write_videofile(\"test_edited.mp4\", fps=24)","def get_output_file(self, path, fps=30):\n return cv2.VideoWriter(\n filename=path,\n fourcc=cv2.VideoWriter_fourcc(*\"mp4v\"),\n fps=float(fps),\n frameSize=(self.display_width, self.display_height),\n isColor=True,\n )","def process(in_path, out_path, mouth_height=50, mouth_width=50, frame_dur=1, capture_frame=None, out_img=None, show_boxes=True):\n # Get video capture from in_path.\n vc = cv2.VideoCapture(in_path) \n\n rval, frame = vc.read() if vc.isOpened() else (False, None)\n\n mouth_images = []\n\n #import pdb; pdb.set_trace()\n\n if rval:\n mouths = np.empty((0, mouth_height, mouth_width, frame.shape[2]))\n else:\n return # Skip this video since CV2 can't open it\n\n frame_no = 0\n while rval:\n if DEBUG:\n # Copy of original frame, for annotating.\n image = frame.copy()\n\n try:\n face_rect = locate_face(frame)\n except ValueError:\n print \"No face found for %s at frame %d. Skipping.\" % (in_path, frame_no)\n vc.release()\n return # Skip this video.\n\n if DEBUG:\n highlight_rect(image, face_rect, color=(255,255,255), thickness=2)\n\n mouth_rects = locate_mouth(frame)\n mouth = uniform_rect(select_mouth_candidate(mouth_rects, face_rect), face_rect, 50, 50)\n if not mouth:\n print \"No face found for %s at frame %d. Skipping.\" % (in_path, frame_no)\n vc.release()\n return # Skip this video.\n\n mouth_image = frame[mouth[1]:(mouth[1] + mouth[3]), mouth[0]:(mouth[0] + mouth[2]), :]\n mouth_images.append(mouth_image) \n\n if DEBUG:\n highlight_rect(image, mouth, color=(0,0,0), thickness=2) \n #cv2.imshow('Frame', mouth_image)\n cv2.imshow('Frame', image if show_boxes else frame)\n\n if frame_no == capture_frame:\n cv2.imwrite(out_img, image if show_boxes else frame)\n return\n\n cv2.waitKey(frame_dur)\n\n rval, frame = vc.read()\n frame_no += 1\n\n vc.release()\n\n mouths = np.asarray(mouth_images)\n\n savemat(out_path, {\"mouths\": mouths})","def _post_proc_para_wrapper(pred_map_mmap_path, tile_info, func, func_kwargs):\n idx, tile_tl, tile_br = tile_info\n wsi_pred_map_ptr = np.load(pred_map_mmap_path, mmap_mode=\"r\")\n tile_pred_map = wsi_pred_map_ptr[tile_tl[0] : tile_br[0], tile_tl[1] : tile_br[1]]\n tile_pred_map = np.array(tile_pred_map) # from mmap to ram\n return func(tile_pred_map, **func_kwargs), tile_info","def extract_vob(in_vob, guid):\n\t#Detect interlacing.\n\tmediainfo_command = \"mediainfo --Inform='Video;%ScanType%,%ScanOrder%' \" + in_vob\n\tprint(mediainfo_command)\n\tprocess = subprocess.Popen(mediainfo_command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)\n\t(cout, cerr) = process.communicate()\n\texit_code = process.wait()\n\tif exit_code != 0:\n\t\traise Exception(\"Calling Mediainfo on {in_vob} failed with exit code {exit_code}.\".format(in_vob=in_vob, exit_code=exit_code))\n\tmediainfo_parts = cout.decode(\"utf-8\").split(\",\")\n\tis_interlaced = mediainfo_parts[0] == \"Interlaced\"\n\tfield_order = mediainfo_parts[1].lower().strip()\n\tprint(\"Interlace detection:\", is_interlaced, field_order, \"(\", mediainfo_parts, \")\")\n\n\tffmpeg_command = [\"ffmpeg\", \"-i\", in_vob]\n\tprint(ffmpeg_command)\n\tprocess = subprocess.Popen(ffmpeg_command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)\n\t(cout, cerr) = process.communicate()\n\tprocess.wait() #Ignore the exit code. It always fails.\n\tvobinfo = cerr.decode(\"utf-8\")\n\ttracks = []\n\tfor match in re.finditer(r\" Stream #0:(\\d+)\\[0x[0-9a-f]+\\]: (\\w+): ([^\\n]+)\", vobinfo):\n\t\ttrack_nr = match.group(1)\n\t\ttrack_type = match.group(2)\n\t\ttrack_codec = match.group(3)\n\t\tnew_track = track.Track()\n\t\tnew_track.from_vob(track_nr, track_type, track_codec, is_interlaced, field_order)\n\t\tnew_track.file_name = guid + \"-T\" + str(new_track.track_nr) + \".\" + new_track.codec\n\t\tif new_track.type != \"unknown\":\n\t\t\ttracks.append(new_track)\n\n\t#Generate the parameters to pass to ffmpeg.\n\ttrack_params = [\"-i\", in_vob]\n\tfor track_metadata in tracks:\n\t\ttrack_params.append(\"-map\")\n\t\ttrack_params.append(\"0:\" + str(track_metadata.track_nr))\n\t\ttrack_params.append(\"-c\")\n\t\ttrack_params.append(\"copy\")\n\t\ttrack_params.append(track_metadata.file_name)\n\n\t#Extract all tracks.\n\tprint(\"---- Extracting tracks...\")\n\tffmpeg(*track_params)\n\n\treturn tracks","def heatmap_video(path_in, path_out, frames_sec = 2, thresh = 2, maxValue = 3):\n\n cap = cv2.VideoCapture(path_in)\n fgbg = cv2.bgsegm.createBackgroundSubtractorMOG()\n\n num_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))\n fps = cap.get(cv2.CAP_PROP_FPS) # frames per second\n duration = round(num_frames / fps, 2) # duration of the video in seconds\n print('Total number of frames to process: {}'.format(num_frames))\n print('Duration of the video in seconds: {}'.format(duration))\n step = round(fps / frames_sec)\n\n first_iteration_indicator = 1\n for i in range(0, num_frames, step):\n\n if (first_iteration_indicator == 1):\n ret, frame = cap.read()\n first_frame = copy.deepcopy(frame)\n gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\n height, width = gray.shape[:2]\n accum_image = np.zeros((height, width), np.uint8)\n first_iteration_indicator = 0\n\n else:\n cap.set(cv2.CAP_PROP_POS_FRAMES, i)\n print('Frame process... ' + str(i) + ' of ' + str(num_frames))\n print('Second process... ' + str(int(cap.get(cv2.CAP_PROP_POS_MSEC)) / 1000) + ' of ' + str(duration))\n print('...')\n ret, frame = cap.read() # read a frame\n\n gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) # convert to grayscale\n\n fgmask = fgbg.apply(gray) # remove the background\n ret, th1 = cv2.threshold(fgmask, thresh, maxValue, cv2.THRESH_BINARY)\n\n # add to the accumulated image\n accum_image = cv2.add(accum_image, th1)\n\n # apply a color map\n # COLORMAP_PINK also works well, COLORMAP_BONE is acceptable if the background is dark\n color_image = cv2.applyColorMap(accum_image, cv2.COLORMAP_HOT)\n\n # overlay the color mapped image to the first frame\n result_overlay = cv2.addWeighted(first_frame, 0.7, color_image, 0.7, 0)\n\n # save the final overlay image\n cv2.imwrite(path_out, result_overlay)\n\n # cleanup\n cap.release()\n cv2.destroyAllWindows()","def main(path):\n logger.info(f'Processing video file {path}')\n # Extract audio\n audio_file = extract_audio(path, pipeline_config.audio_target_dir)\n\n # Generate sound classification results and speech recogniser results\n sound_results = SoundRecogniser().process_file(audio_file)\n sound_results = process_overlap(sound_results)\n speech_results = SpeechRecogniser().process_file(audio_file)\n\n # NLP\n wrds = get_words(speech_results)\n nlp = SpaCyNaturalLanguageProcessor(pipeline_config.spacy_model)\n custom_nlp = SpaCyNaturalLanguageProcessor(pipeline_config.custom_spacy_model)\n processor = nlp.get_spacy_results_processor(wrds, speech_results)\n custom_processor = custom_nlp.get_spacy_results_processor(wrds, speech_results)\n chunk_results = processor.process_speech_results_chunk()\n ner_results = processor.process_speech_results_ner()\n ner_results.extend(custom_processor.process_speech_results_ner())\n match_results = processor.process_speech_results_match()\n speech_results = nlp.process_spurious_words(speech_results, chunk_results)\n\n # Add Speech recogniser results, sound classification results and NLP results to a subtitle file\n subs_1 = save_to_subtitles(speech_results,\n lambda speech_result: speech_result['word'])\n subs_1 = compress_subs(subs_1)\n subs_2 = save_to_subtitles(sound_results,\n lambda sound_result: sound_result['class'])\n subs_2 = flatten_subs(subs_2)\n subs_3 = save_to_subtitles(chunk_results,\n lambda chunk_result: f'{chunk_result[\"word\"]} ({chunk_result[\"head\"]})')\n subs_4 = save_to_subtitles(ner_results,\n lambda ner_result: f'{ner_result[\"type\"]} {ner_result[\"word\"]}')\n subs_5 = save_to_subtitles(match_results,\n lambda match_result: match_result[\"word\"])\n\n combined_subs = append_subs(None, subs_1, style='bottom')\n combined_subs = append_subs(combined_subs, subs_2, exclude=['bottom'], style='top', formatter=lambda x: f'({x})')\n combined_subs = append_subs(combined_subs, subs_3, style='left')\n combined_subs = append_subs(combined_subs, subs_4, style='right')\n combined_subs = append_subs(combined_subs, subs_5, style='bottom_left_pred')\n combined_subs = remove_tiny_subs(combined_subs, duration_millis=1000, left_millis=None,\n right_millis=None, style='top')\n subtitle_file_name = os.path.splitext(path)[0] + '.ass'\n create_styles(combined_subs)\n combined_subs.save(subtitle_file_name)\n\n # Burn to a video\n burn_subtitles_into_video(path, subtitle_file_name, pipeline_config.audio_target_dir)\n logger.info(f'Done processing {audio_file}')","def load(fidfile, procfile):\r\n dic, data = _ng.varian.read_fid(fidfile)\r\n procs = _ng.varian.read_procpar(procfile)\r\n\r\n offset = [float(i) for i in procs['tof']['values']][0]\r\n magfreq = [float(i) for i in procs['sfrq']['values']][0]\r\n rangeHz = [float(i) for i in procs['sw']['values']][0]\r\n\r\n rangeppm = rangeHz / magfreq\r\n offsetppm = offset / magfreq\r\n\r\n # Fourier transform\r\n data = _ng.proc_base.fft(data)\r\n data = data / _np.max(data)\r\n\r\n u = data.real.sum(axis=0)\r\n v = data.imag.sum(axis=0)\r\n\r\n w = _np.linspace(rangeppm - offsetppm, -offsetppm, u.size)\r\n\r\n result = _containers.Data(w[::-1], u[::-1], v[::-1])\r\n return result","def main():\n global tmpl_ball, pocket_templates, pocket_markers, last_best_cueball, last_confirmed_cueball, CURRENT_FRAME, out_file\n\n start_time = datetime.datetime.now()\n\n # Open output files\n\n out_file = open(here(\"confirmed_cueballs.txt\"), 'w')\n\n # Initialize pygame\n\n pygame.init()\n pygame.display.set_caption(\"Snooker - main info window\")\n window = pygame.display.set_mode((704, 400))\n\n # Load and initialize template images\n\n tmpl_ball = cvLoadImage(BALL_TMPL, CV_LOAD_IMAGE_COLOR)\n if not tmpl_ball:\n raise Exception(\"Failed to load ball template image\")\n\n # Load pocket templates, find marker pixel in template and remember it\n\n for pocket in ['tl', 'tr', 'bl', 'br']: \n pocket_tmpl = cvLoadImage(globals()['POCKET_%s_TMPL' % pocket.upper()], CV_LOAD_IMAGE_COLOR)\n if not pocket_tmpl:\n raise Exception(\"Failed to load pocket '%s' template\" % pocket)\n pocket_templates[pocket] = pocket_tmpl\n pocket_markers[pocket] = findpixel(pocket_tmpl, cvScalar(255, 0, 255))\n if pocket_markers[pocket]:\n if DEBUG: print(\"Found marker for pocket %s at %d:%d\" % \n (pocket.upper(), pocket_markers[pocket].x, pocket_markers[pocket].y))\n\n stream = pyffmpeg.VideoStream()\n\n stream.open(VIDEO_FILE)\n\n fps = stream.tv.get_fps()\n duration_f = stream.tv.duration()\n\n start_frame = int(START*fps)\n end_frame = int(END*fps)\n interval = int(INTERVAL*fps)\n\n length = float(end_frame-start_frame)/float(fps) # Seconds\n\n i = start_frame\n\n while i < end_frame:\n CURRENT_FRAME = i\n\n # Calculate info about the total progress and display it\n\n percentage = float(i-start_frame)/float(end_frame-start_frame)*100.0\n estimated_length = 0\n if i > start_frame:\n estimated_length = float(total_seconds((datetime.datetime.now()-start_time))) / percentage * 100.0\n\n print(\"Frame #%d (%d-%d) %.1f%%\" % (i, start_frame, end_frame, percentage))\n pygame.display.set_caption(\"Snooker - main info window - Frame %d - %.1f%% (est. total %.1fmin)\" % (i, percentage, estimated_length/60.0))\n\n image = stream.GetFrameNo(i)\n image_ipl = adaptors.PIL2Ipl(image)\n\n table = get_table(image_ipl)\n cueballs = None\n best_ball = None\n\n if table:\n cueballs = find_cueballs(image_ipl, table)\n\n if cueballs:\n\n # See if the best cueball we found now, is the best cueball found in the previous run,\n # which would mean that it's standing still. Only consider the best matches.\n\n if not last_best_cueball:\n last_best_cueball = cueballs[0]\n else:\n\n distance_to_last = math.sqrt( (last_best_cueball.x-cueballs[0].x)**2 + (last_best_cueball.y-cueballs[0].y)**2 )\n distance_to_last_confirmed = math.sqrt( (last_confirmed_cueball.x-cueballs[0].x)**2 + \n (last_confirmed_cueball.y-cueballs[0].y)**2 )\n\n if distance_to_last < CUEBALL_CONFIRM_DISTANCE and distance_to_last_confirmed > CUEBALL_NOMOVEMENT_DISTANCE:\n if cueballs[0].confidence >= 0.72: # Extra check to remove most of the false positives\n # CONFIRMED\n last_confirmed_cueball = cueballs[0]\n cueballs[0].confirmed = True\n if DEBUG: print(\"CONFIRMED cueball %s\" % cueballs[0])\n else:\n if DEBUG: print(\"Dropped the ball because distance condition failed: %.2f<%d and %.2f>%d\" % \n (distance_to_last, CUEBALL_CONFIRM_DISTANCE, \n distance_to_last_confirmed, CUEBALL_NOMOVEMENT_DISTANCE))\n\n # If confirmation or sequence fail, reset and try the whole thing again\n last_best_cueball = False\n\n image_interesting = draw_interesting_stuff(image, table, cueballs)\n\n window.blit(image_interesting, (0,0))\n pygame.display.flip()\n\n store_results(image_interesting, table, cueballs)\n\n for event in pygame.event.get():\n if event.type == pygame.QUIT:\n out_file.close()\n sys.exit(0)\n else:\n pass\n #print event\n\n # Skip <interval> frames\n i += interval\n\n out_file.close()","def make_video(input_files, width=0, height=0, frame_rate=24, crf=20, output_path=\"video.mp4\"):\n if isinstance(input_files, list):\n from PIL import Image # pylint: disable=C0415\n\n with Image.open(input_files[0]) as img:\n width, height = img.size\n tmp_dir = \"tmp_ffmpeg_dir\"\n os.mkdir(tmp_dir)\n if width % 2 != 0:\n print(f\"Width ({width}) not divisible by 2\")\n width -= 1\n if height % 2 != 0:\n print(f\"Height ({width}) not divisible by 2\")\n height -= 1\n for i, inp in enumerate(input_files):\n shutil.copy(inp, os.path.join(tmp_dir, f\"{i:06d}.png\"))\n inputs = f\"{tmp_dir}/%06d.png\"\n command = ffmpeg_common_args(frame_rate, inputs, width, height, crf, output_path)\n ret = os.system(command)\n assert ret == 0, \"ffmpeg failed to generate video file.\"\n for i in range(len(input_files)):\n os.remove(os.path.join(tmp_dir, f\"{i:06d}.png\"))\n os.rmdir(tmp_dir)\n elif isinstance(input_files, str):\n assert width != 0 and height != 0\n command = ffmpeg_common_args(frame_rate, input_files, width, height, crf, output_path)\n ret = os.system(command)\n assert ret == 0, \"ffmpeg failed to generate video file.\"\n else:\n assert (\n False\n ), f'input_files should be list (of files) or str (of file template, e.g., \"%04d.png\") instead of {type(input_files)}'","def new_proc(start_gdb=False, val=None):\n p = process(binary.path)\n if start_gdb is True:\n attach_gdb(p)\n return p","def rescale_video(video_fn, w, h, fps, dir, new_dir, common_suffix, dict_video_length, ffmpeg, crf=17):\n\n # Output video_name\n video_id = video_fn.replace(dir, '').replace(common_suffix, '')\n video_fn_rescaled = video_fn.replace(dir, new_dir)\n video_fn_rescaled = video_fn_rescaled.replace(common_suffix, common_suffix.lower())\n\n # Create the dir\n video_dir_to_create = '/'.join(video_fn_rescaled.split('/')[:-1])\n os.makedirs(video_dir_to_create, exist_ok=True)\n\n # Check if the file already exists\n if os.path.isfile(video_fn_rescaled):\n print(\"{} already exists\".format(video_fn_rescaled))\n else:\n subprocess.call(\n '{ffmpeg} -i {video_input} -vf scale={w}:{h} -crf {crf} -r {fps} -y {video_output} -loglevel panic'.format(\n ffmpeg=ffmpeg,\n video_input=video_fn,\n h=h,\n w=w,\n fps=fps,\n video_output=video_fn_rescaled,\n crf=crf\n ), shell=True)\n\n # Get the duration of the new super_video (in sec)\n duration_sec = get_duration(video_fn_rescaled)\n duration_frames = int(duration_sec * fps)\n\n # update the dict id -> length\n dict_video_length[video_id] = duration_frames\n\n return video_fn_rescaled","def detect_from_video(config: Dict):\n video = config['inference']['video_input']['video_input_path']\n vp = VideoProcessing(video=video)\n vp.generate_frames(export_path=config['inference']['video_input']['video_to_frames_export_path'])\n if config['inference']['video_input']['video_to_frames_export_path'] == config['inference']['predicted_frames_export_path']:\n print(\"[Warning]... You have given Video to frame path same as prediction output path /nPredicted output will overwrite video to frame\")\n img_height = config['inference']['img_height']\n img_width = config['inference']['img_width']\n model = ssd_300(image_size=(img_height, img_width, 3),\n n_classes=config['inference']['n_classes'],\n mode='inference',\n l2_regularization=0.0005,\n scales=[0.1, 0.2, 0.37, 0.54, 0.71, 0.88, 1.05], # The scales for MS COCO are [0.07, 0.15, 0.33, 0.51, 0.69, 0.87, 1.05]\n aspect_ratios_per_layer=[[1.0, 2.0, 0.5],\n [1.0, 2.0, 0.5, 3.0, 1.0/3.0],\n [1.0, 2.0, 0.5, 3.0, 1.0/3.0],\n [1.0, 2.0, 0.5, 3.0, 1.0/3.0],\n [1.0, 2.0, 0.5],\n [1.0, 2.0, 0.5]],\n two_boxes_for_ar1=True,\n steps=[8, 16, 32, 64, 100, 300],\n offsets=[0.5, 0.5, 0.5, 0.5, 0.5, 0.5],\n clip_boxes=False,\n variances=[0.1, 0.1, 0.2, 0.2],\n normalize_coords=True,\n subtract_mean=[123, 117, 104],\n swap_channels=[2, 1, 0],\n confidence_thresh=0.5,\n iou_threshold=0.45,\n top_k=200,\n nms_max_output_size=400)\n\n # Load the trained weights into the model.\n weights_path = config['inference']['weights_path']\n\n model.load_weights(weights_path, by_name=True)\n \n # Working with image\n all_images = glob.glob(f\"{config['inference']['video_input']['video_to_frames_export_path']}/*/*\")\n \n # Setting Up Prediction Threshold\n confidence_threshold = config['inference']['confidence_threshold']\n \n # Setting Up Classes (Note Should be in same order as in training)\n classes = config['inference']['classes']\n \n vp.existsFolder(f\"{config['inference']['predicted_frames_export_path']}/{video.split('.')[0]}\")\n # Working with image\n for current_img in tqdm(all_images):\n current_img_name = current_img.split('/')[-1]\n orig_image = cv2.imread(current_img)\n input_images = [] # Store resized versions of the images here\n img = image.load_img(current_img, target_size=(img_height, img_width))\n img = image.img_to_array(img) \n input_images.append(img)\n input_images = np.array(input_images)\n \n # Prediction\n y_pred = model.predict(input_images)\n\n # Using threshold\n y_pred_thresh = [y_pred[k][y_pred[k,:,1] > confidence_threshold] for k in range(y_pred.shape[0])]\n \n # Drawing Boxes\n for box in y_pred_thresh[0]:\n xmin = box[2] * orig_image.shape[1] / img_width\n ymin = box[3] * orig_image.shape[0] / img_height\n xmax = box[4] * orig_image.shape[1] / img_width\n ymax = box[5] * orig_image.shape[0] / img_height\n \n label = f\"{classes[int(box[0])]}: {box[1]:.2f}\"\n cv2.rectangle(orig_image, (int(xmin), int(ymin)), (int(xmax),int(ymax)), (255, 0, 0), 2)\n cv2.putText(orig_image, label, (int(xmin), int(ymin)), cv2.FONT_HERSHEY_SIMPLEX, 2, (255, 255, 255), 2, cv2.LINE_AA)\n cv2.imwrite(f\"{config['inference']['predicted_frames_export_path']}/{video.split('.')[0]}/{current_img_name}\", orig_image)\n \n # Creating video\n vp.generate_video(import_path=config['inference']['predicted_frames_export_path'],\n export_path=config['inference']['video_input']['video_output_path'])","def make_movie_cart(field='uu1', datadir='data/', proc=-1, extension='xz',\n format='native', tmin=0., tmax=1.e38, amin=0., amax=1.,\n transform='', oldfile=False):\n\n import pylab as plt\n import sys\n from pencil.files.var import read_var\n\n mkmvvar = read_var(trimall=True) \n r2d,phi2d = np.meshgrid(mkmvvar.x,mkmvvar.y)\n x2d=r2d*np.cos(phi2d)\n y2d=r2d*np.sin(phi2d)\n\n datadir = os.path.expanduser(datadir)\n if proc < 0:\n filename = datadir + '/slice_' + field + '.' + extension\n else:\n filename = datadir + '/proc' + \\\n str(proc) + '/slice_' + field + '.' + extension\n\n # Read the global dimensions.\n dim = read_dim(datadir, proc)\n if dim.precision == 'D':\n precision = 'd'\n else:\n precision = 'f'\n\n # Set up slice plane.\n if extension == 'xy' or extension == 'Xy':\n hsize = dim.nx\n vsize = dim.ny\n if extension == 'xz':\n print('only works for xy')\n sys.stop\n if extension == 'yz':\n print('only works for xy')\n sys.stop\n plane = np.zeros((vsize, hsize), dtype=precision)\n\n infile = npfile(filename, endian=format)\n\n files = []\n fig = plt.figure(figsize=(5, 10))\n ax = fig.add_subplot(111)\n\n ifirst = True\n islice = 0\n while True:\n try:\n raw_data = infile.fort_read(precision)\n except ValueError:\n break\n except TypeError:\n break\n\n if oldfile:\n t = raw_data[-1]\n plane = raw_data[:-1].reshape(vsize, hsize)\n else:\n t = raw_data[-2]\n plane = raw_data[:-2].reshape(vsize, hsize)\n\n if transform:\n exec('plane = plane' + transform)\n\n if t > tmin and t < tmax:\n ax.set_aspect('equal')\n ax.cla()\n ax.contourf(x2d, y2d, plane, 256)\n fname = '_tmp%03d.png' % islice\n print('Saving frame' + fname)\n fig.savefig(fname)\n files.append(fname)\n\n if ifirst:\n #print \"----islice----------t---------min-------max-------delta\" # Python 2\n print(\"----islice----------t---------min-------max-------delta\")\n #print \"%10i %10.3e %10.3e %10.3e %10.3e\" % \\ # Python 2\n #(islice, t, plane.min(), plane.max(), plane.max() - plane.min()) # Python 2\n print(\"{0:10} {1:10.3e} {2:10.3e} {3:10.3e} {4:10.3e}\".format(islice, t, plane.min(), plane.max(), plane.max() - plane.min()))\n\n ifirst = False\n islice += 1\n\n #print 'Making movie animation.mpg - this make take a while'\n print('Making movie animation.mpg - this make take a while')\n # SC: Not all systems use mencoder. Need to change this into ffmpeg.\n os.system(\"mencoder 'mf://_tmp*.png' -mf type=png:fps=24 -ovc lavc -lavcopts vcodec=wmv2 -oac copy -o animation.mpg\")\n os.system(\"rm _tmp*.png\")\n infile.close()","def convert_video_path_and_save(video_path, output_path=\"output.mp4\", temp_folder = \"./temp\",\n frame_frequency=24, image_reducer=100, fontSize=10, spacing=1.1, maxsize=None, chars=\" .*:+%S0#@\",\n logs=False, processes=4, progress_tracker=None):\n\n if logs:\n start_time = time.time()\n print (\"Converting video...\")\n \n # set up a capture temporarily so we can grab some basic info about it\n capture = cv2.VideoCapture(video_path)\n if not capture.isOpened():\n print (\"Could not read video. Please enter a valid video file!\")\n exit(0)\n\n fps = capture.get(cv2.CAP_PROP_FPS)\n bitrate = int(capture.get(cv2.CAP_PROP_BITRATE))\n total_frames = int(capture.get(cv2.CAP_PROP_FRAME_COUNT))\n frames_included = int(total_frames / frame_frequency)\n # total_frames / fps gives us our video duration.\n video_duration = total_frames / fps\n # frames included / video duration gives new fps\n new_fps = (total_frames / frame_frequency) / video_duration\n\n capture.release()\n\n # First, we grab all the frames we need and store them in a temp folder\n # After that, we convert all the image frames in the temp folder, and save them back in the temp folder\n # Then, we write them to video and save to disk\n # To utilize mutli processing, we separate grabbing frames and converting the frames into batches\n\n while os.path.isdir(temp_folder):\n temp_folder += \"_\"\n temp_folder += \"/\"\n os.mkdir(temp_folder)\n\n # initial setup\n # we divide our work into batches\n batches = processes\n frames_per_batch = int(total_frames / batches / frame_frequency)\n if progress_tracker is None:\n progress_tracker = Value(\"f\", 0, lock=True)\n # progress: saved frames + converted frames + written frames\n progress_step = 100 / (frames_included * 3)\n\n # grab the frames, and write to separate batch folders\n save_frames_processes = []\n for batch in range(batches):\n starting_frame = batch * frames_per_batch * frame_frequency\n batch_folder = temp_folder + str(batch) + \"/\"\n os.mkdir(batch_folder)\n args = (\n starting_frame,\n starting_frame + frames_per_batch * frame_frequency,\n video_path,\n batch_folder,\n frame_frequency,\n logs,\n progress_tracker,\n progress_step\n )\n p = Process(target=_save_frames, args=args)\n p.daemon = True\n p.start()\n save_frames_processes.append(p)\n for p in save_frames_processes:\n p.join()\n\n # convert all the frames in each batch folder\n convert_processes = []\n for batch in range(batches):\n batch_folder = temp_folder + str(batch) + \"/\"\n args = (\n batch_folder,\n frames_per_batch,\n image_reducer,\n fontSize, spacing, maxsize, chars,\n logs, progress_tracker, progress_step\n )\n p = Process(target=_convert_batch, args=args)\n p.daemon = True\n p.start()\n convert_processes.append(p)\n for p in convert_processes:\n p.join()\n\n # if no extension was assigned, automatically assign .mp4\n output_name, output_ext = os.path.splitext(output_path)\n if output_ext == \"\":\n output_ext = \".mp4\"\n # if final output path was specified, then modify it (append _Copy to it)\n final_output_path = output_name + output_ext\n while os.path.isfile(final_output_path):\n if logs : print (final_output_path, \"already exists!\")\n final_output_path = os.path.splitext(final_output_path)[0] + \"_Copy\" + output_ext\n\n # video settings\n fourcc = cv2.VideoWriter_fourcc(*'mp4v')\n video_out = imageio.get_writer(final_output_path, fps=new_fps, quality=None, bitrate=(bitrate * 1024 * 2.5))\n size = None\n\n # write images to new video\n for batch in range(1, batches + 1):\n batch_folder = temp_folder + str(batch - 1) + \"/\"\n for i in range(1, frames_per_batch + 1):\n img = cv2.imread(batch_folder + str(i) + \".jpg\", 2)\n if size is None:\n height, width = img.shape\n size = (width, height)\n video_out.append_data(img)\n with progress_tracker.get_lock():\n progress_tracker.value += progress_step\n if logs : print (\"Progress: %.4f%%\" % progress_tracker.value, end=\"\\r\")\n video_out.close()\n shutil.rmtree(temp_folder)\n\n # when we are done, there might be some rounding errors when converting some stuff to integers, thus it doesn't appear to be done\n # So we just simply set it to 100\n with progress_tracker.get_lock():\n progress_tracker.value = 100\n\n if logs:\n print (\"=\" * 30)\n print (\"SUMMARY:\")\n print (\"-\" * 20)\n print (\"Progress: %.4f%%\" % progress_tracker.value)\n print (\"Total frames found:\", str(total_frames))\n print (\"Frames included and converted:\", str(frames_per_batch * batches))\n print (\"Original FPS:\", str(fps))\n print(\"New FPS:\", str(new_fps))\n print (\"Resolution:\", str(size))\n print (\"Saved to\", final_output_path)\n print (\"Time took: %.4f secs\" % (time.time() - start_time))","def gen_fps():\n global data_src ,output_dir \n logger = TaskFileLogger(\"GenFP\")\n\n h_vars = load_hydro_var()\n if not os.path.exists(output_dir):\n os.mkdir(output_dir)\n\n for h_type,var_d in h_vars.items():\n print \"considering %s\" %h_type\n\n t_output_dir = os.path.join(output_dir,h_type)\n if not os.path.exists(t_output_dir):\n print \"creating path %s\" %t_output_dir\n os.mkdir(t_output_dir)\n logger.log(\"%s started\" %(h_type))\n\n for fname in glob.glob(data_src):\n complex_id = os.path.basename(fname).split('.')[0] \n fp_path = os.path.join(t_output_dir,complex_id + \".fp\" )\n if os.path.exists(fp_path):\n #print \"%s processed\" %complex_id\n continue\n print \"processing %s,fp saved as %s\" %(fname , fp_path )\n c = Complex(fname,hydro_dict = var_d)\n c.get_fp()\n c.write_fp_to_file(fp_path)\n\n logger.log(\"%s finished\" %(h_type))","def check_video_format(movie_file, desired_format='.mp4', original_format='.avi'):\n\n if not os.path.isfile(movie_file+original_format):\n print 'Error. avi file does not exist:'+movie_file+'.avi'\n if not os.path.isfile(movie_file+desired_format):\n cmd = ['ffmpeg']\n cmd += ['-i', movie_file+original_format]\n cmd += [movie_file+desired_format]\n cmd_string = ''.join([\"%s \" % el for el in cmd])\n #print '-->Running: ', cmd_string\n p = subprocess.Popen(cmd, shell=False)\n p.wait()","def vcf_to_plink(locus, output_directory ,vcf, population):\n logging.info(\"Converting {0} to PLINK format\".format(vcf))\n command = __VCF_TO_PLINK_TEMPLATE__.format(vcf, locus)\n run_command(command)\n try:\n #Rename\n os.rename(locus +'.bed', os.path.join(output_directory, locus + '.' + population + '.bed'))\n os.rename(locus +'.bim', os.path.join(output_directory, locus + '.' + population + '.bim'))\n os.rename(locus +'.fam', os.path.join(output_directory, locus + '.' + population + '.fam'))\n #Remove\n os.remove(locus + '.log')\n os.remove(locus + '.nosex')\n except OSError as e:\n logging.error(\"Could not move or remove PLINK files {0}\".format(e))\n sys.exit(OS_ERROR)","def __init__(self, name, kill_flag, frame_buffer, flushing, query_idx=0, buffer_size=6000, hdf_resize=30000, min_flush=200, n_cams=1, resolution=None):\n super(MovieSaver, self).__init__()\n self.daemon = True\n\n # Saving params\n if not name.endswith('.h5'):\n name += '.h5'\n self.name = name\n self.buffer_size = buffer_size # should be overkill, since flushing will do the real job of saving it out\n self.hdf_resize = hdf_resize\n self.min_flush = min_flush\n\n # Cam params\n self.n_cams = n_cams\n self.resolution = resolution\n\n # Flags and containers\n self.saving_complete = mp.Value('b', False)\n self.kill_flag = kill_flag\n self.flushing = flushing\n self.frame_buffer = frame_buffer\n \n # Queries\n self.query_idx = query_idx #which cam gets queried\n self.query_flag = mp.Value('b',False)\n self.query_queue = mp.Array(ctypes.c_uint8, np.product([self.resolution[self.query_idx][0], self.resolution[self.query_idx][1]]))\n self.query_queue_ts = mp.Value('d',0.)\n \n self.start()","def make_movie_crossflow(field='uu1', datadir='data/', proc=-1, extension='yz',\n format='native', tmin=0., tmax=1.e38, amin=0., amax=1.,\n transform='', oldfile=False):\n\n import pylab as plt\n import matplotlib.patches as patches\n\n datadir = os.path.expanduser(datadir)\n if proc < 0:\n filename = datadir + '/slice_' + field + '.' + extension\n else:\n filename = datadir + '/proc' + \\\n str(proc) + '/slice_' + field + '.' + extension\n\n # Read the global dimensions.\n dim = read_dim(datadir, proc)\n if dim.precision == 'D':\n precision = 'd'\n else:\n precision = 'f'\n\n # Set up slice plane.\n if extension == 'xy' or extension == 'Xy':\n hsize = dim.nx\n vsize = dim.ny\n if extension == 'xz':\n hsize = dim.nx\n vsize = dim.nz\n if extension == 'yz':\n hsize = dim.ny\n vsize = dim.nz\n plane = np.zeros((vsize, hsize), dtype=precision)\n\n infile = npfile(filename, endian=format)\n\n files = []\n fig = plt.figure(figsize=(5, 10))\n ax = fig.add_subplot(111)\n ax.add_patch(patches.Rectangle(\n (220,0),\n 40,\n 320,\n color='gray'\n )\n )\n#\n# ax.add_patch(patches.Rectangle(\n# (220,0),\n# 80,\n# 240,\n# hatch='/'\n# )\n# )\n\n ifirst = True\n islice = 0\n while True:\n try:\n raw_data = infile.fort_read(precision)\n except ValueError:\n break\n except TypeError:\n break\n\n if oldfile:\n t = raw_data[-1]\n plane = raw_data[:-1].reshape(vsize, hsize)\n else:\n t = raw_data[-2]\n plane = raw_data[:-2].reshape(vsize, hsize)\n\n if transform:\n exec('plane = plane' + transform)\n\n if t > tmin and t < tmax:\n ax.cla()\n ax.imshow(plane, vmin=amin, vmax=amax)\n ax.add_patch(patches.Rectangle(\n (220,0),\n 40,\n 320,\n color='gray'\n )\n )\n fname = '_tmp%03d.png' % islice\n print('Saving frame' + fname)\n fig.savefig(fname)\n files.append(fname)","def start_recording(codec, filename=time.strftime(\"%Y-%m-%d_%H-%M-%S\")):\n global video_writer\n folder = 'video_out/' # eventually replace this with the SD card folder\n # TODO: also include branch name and/or commit ID\n path = folder + filename + '.' + filetype\n print \"Saving video to: %s\" % path\n\n height = videoinput.frame_height\n if settings.sidebyside:\n width = 2*videoinput.frame_width\n else:\n width = videoinput.frame_width\n\n try:\n video_writer = cv2.VideoWriter(path, codec, 30, (width, height))\n except:\n print \"Failed to open video file for writing!\""],"string":"[\n \"def create_video(input_file, output_file):\\n input_video = VideoFileClip(input_file)\\n output_video = input_video.fl_image(detect_lane.fit_and_plot)\\n output_video.write_videofile(output_file, audio=False)\",\n \"def process_video(lane, fname, output):\\n\\tclip = VideoFileClip(fname)\\n\\toutput_name = output\\n\\toutput_clip = clip.fl_image(lane.pipeline)\\n\\toutput_clip.write_videofile(output_name, audio=False)\\n\\tprint ('Video processed successfully')\",\n \"def process_video(input_file, output_file):\\n # video = VideoFileClip(input_file).subclip(40,44) # from 38s to 46s\\n video = VideoFileClip(input_file)\\n annotated_video = video.fl_image(process_pipeline)\\n annotated_video.write_videofile(output_file, audio=False)\",\n \"def process_video(input_file, output_file):\\n # video = VideoFileClip(input_file).subclip(40,44) # from 38s to 46s\\n video = VideoFileClip(input_file)\\n annotated_video = video.fl_image(process_pipeline)\\n annotated_video.write_videofile(output_file, audio=False)\",\n \"def process_video(proc_state):\\n entry = proc_state.entry\\n workbench = proc_state.workbench\\n video_config = mgg.global_config['media_type:mediagoblin.media_types.video']\\n\\n queued_filepath = entry.queued_media_file\\n queued_filename = proc_state.get_queued_filename()\\n name_builder = FilenameBuilder(queued_filename)\\n\\n medium_filepath = create_pub_filepath(\\n entry, name_builder.fill('{basename}-640p.webm'))\\n\\n thumbnail_filepath = create_pub_filepath(\\n entry, name_builder.fill('{basename}.thumbnail.jpg'))\\n\\n # Create a temporary file for the video destination (cleaned up with workbench)\\n tmp_dst = NamedTemporaryFile(dir=workbench.dir, delete=False)\\n with tmp_dst:\\n # Transcode queued file to a VP8/vorbis file that fits in a 640x640 square\\n progress_callback = ProgressCallback(entry)\\n\\n dimensions = (\\n mgg.global_config['media:medium']['max_width'],\\n mgg.global_config['media:medium']['max_height'])\\n\\n # Extract metadata and keep a record of it\\n metadata = transcoders.VideoTranscoder().discover(queued_filename)\\n store_metadata(entry, metadata)\\n\\n # Figure out whether or not we need to transcode this video or\\n # if we can skip it\\n if skip_transcode(metadata):\\n _log.debug('Skipping transcoding')\\n\\n dst_dimensions = metadata['videowidth'], metadata['videoheight']\\n\\n # Push original file to public storage\\n _log.debug('Saving original...')\\n proc_state.copy_original(queued_filepath[-1])\\n\\n did_transcode = False\\n else:\\n transcoder = transcoders.VideoTranscoder()\\n\\n transcoder.transcode(queued_filename, tmp_dst.name,\\n vp8_quality=video_config['vp8_quality'],\\n vp8_threads=video_config['vp8_threads'],\\n vorbis_quality=video_config['vorbis_quality'],\\n progress_callback=progress_callback,\\n dimensions=dimensions)\\n\\n dst_dimensions = transcoder.dst_data.videowidth,\\\\\\n transcoder.dst_data.videoheight\\n\\n # Push transcoded video to public storage\\n _log.debug('Saving medium...')\\n mgg.public_store.copy_local_to_storage(tmp_dst.name, medium_filepath)\\n _log.debug('Saved medium')\\n\\n entry.media_files['webm_640'] = medium_filepath\\n\\n did_transcode = True\\n\\n # Save the width and height of the transcoded video\\n entry.media_data_init(\\n width=dst_dimensions[0],\\n height=dst_dimensions[1])\\n\\n # Temporary file for the video thumbnail (cleaned up with workbench)\\n tmp_thumb = NamedTemporaryFile(dir=workbench.dir, suffix='.jpg', delete=False)\\n\\n with tmp_thumb:\\n # Create a thumbnail.jpg that fits in a 180x180 square\\n transcoders.VideoThumbnailerMarkII(\\n queued_filename,\\n tmp_thumb.name,\\n 180)\\n\\n # Push the thumbnail to public storage\\n _log.debug('Saving thumbnail...')\\n mgg.public_store.copy_local_to_storage(tmp_thumb.name, thumbnail_filepath)\\n entry.media_files['thumb'] = thumbnail_filepath\\n\\n # save the original... but only if we did a transcoding\\n # (if we skipped transcoding and just kept the original anyway as the main\\n # media, then why would we save the original twice?)\\n if video_config['keep_original'] and did_transcode:\\n # Push original file to public storage\\n _log.debug('Saving original...')\\n proc_state.copy_original(queued_filepath[-1])\\n\\n # Remove queued media file from storage and database\\n proc_state.delete_queue_file()\",\n \"def process_video(self, tmp_output_folder, video_name, video_num, total_videos):\\n vidcap = cv2.VideoCapture(join(tmp_output_folder, video_name))\\n print(f\\\"Processing video {video_num}/{total_videos} with name {video_name} \\\\n\\\")\\n\\n input_length = int(vidcap.get(cv2.CAP_PROP_FRAME_COUNT))\\n frame_width = int(vidcap.get(cv2.CAP_PROP_FRAME_WIDTH))\\n frame_height = int(vidcap.get(cv2.CAP_PROP_FRAME_HEIGHT))\\n fps = int(vidcap.get(cv2.CAP_PROP_FPS))\\n\\n metadata = []\\n faces_all_frames = []\\n success, image = vidcap.read()\\n count = 0\\n frame = 0\\n while success:\\n if count % self.sample_every == 0:\\n height, width = image.shape[:2]\\n image = cv2.resize(image, (self.width, self.height), interpolation=cv2.INTER_CUBIC)\\n\\n # Convert from BGR color (OpenCV) to RGB color (face_recognition)\\n rgb_image = image[:, :, ::-1]\\n\\n # Find all the faces in the current frame of video\\n face_locations = face_recognition.face_locations(rgb_image)\\n faces = []\\n face_num = 0\\n # Display the results\\n for top, right, bottom, left in face_locations:\\n # Draw a box around the face\\n faces.append(image[top:bottom, left:right, :].copy())\\n metadata.append(\\n f\\\"{video_name},frame-{count}.face-{face_num}.jpg,{count},{face_num},{input_length},{fps},{frame_width},{frame_height},{top},{right},{bottom},{left}\\\\n\\\")\\n face_num += 1\\n faces_all_frames.append(faces)\\n\\n frame += 1\\n success, image = vidcap.read()\\n count += 1\\n video_num += 1\\n vidcap.release()\\n\\n with open(f\\\"{self.output_folder}/faces-pickle/{video_name}.pkl\\\", \\\"wb\\\") as f_out:\\n pickle.dump(faces_all_frames, f_out)\\n return metadata\",\n \"def process_video(input_file, output_file):\\n with open('all-features-rbf-svm.p', 'rb') as svm_fd:\\n clf = pickle.load(svm_fd)\\n with open('all-features-scaler.p', 'rb') as scaler_fd:\\n hog_scaler = pickle.load(scaler_fd)\\n hog_parameters = HogParameters(orientations=18, pixels_per_cell=8, cells_per_block=2)\\n clip = VideoFileClip(input_file)\\n test_clip = clip.fl_image(\\n lambda frame: process_frame(frame, clf=clf, norm_scaler=hog_scaler, hog_parameters=hog_parameters, spatial_size=(16, 16), hist_bins=32))\\n test_clip.write_videofile(output_file, audio=False)\",\n \"def convert_video(video_file, output_file_name):\\n video_stream = cv2.VideoCapture(video_file)\\n total_frames = video_stream.get(cv2.CAP_PROP_FRAME_COUNT)\\n background = get_median_frame(video_stream)\\n video_stream.release()\\n #reopen for processing:\\n video_stream = cv2.VideoCapture(video_file)\\n #ready an output writer\\n writer = cv2.VideoWriter(output_file_name, \\n cv2.VideoWriter_fourcc(*\\\"MP4V\\\"), fps,(1080,1920)) #(1920,1080))\\n frameCnt=0\\n pos = [] #Array for the coordinates\\n while(frameCnt < total_frames-1):\\n frameCnt+=1\\n ret, frame = video_stream.read()\\n dframe = background_subtraction(frame,background)\\n cnts = find_contours(dframe)\\n x,y = find_lowest_contour(cnts)\\n pos.append([x,y])\\n if len(pos): \\n cv2.polylines(frame,np.int32([pos]),False,(0, 255, 0),2)\\n writer.write(cv2.resize(frame, (1080,1920))) ## size probably shoudn't be fixed.\\n writer.release()\\n video_stream.release()\\n return pos\",\n \"def create_movie(name, folder):\\n cmd = [\\\"ffmpeg\\\", \\\"-framerate\\\", \\\"1\\\", \\\"-i\\\", folder + \\\"/pic%04d.png\\\", \\\"-c:v\\\",\\n \\\"libx264\\\", \\\"-r\\\", \\\"30\\\", \\\"-pix_fmt\\\", \\\"yuv420p\\\", name]\\n return subprocess.call(cmd)\",\n \"def local_video(**kwargs):\\n output_dir = run_video_preprocess(\\n video_file=input_video,\\n roi_locations=kwargs[\\\"roi_locations\\\"],\\n preprocess_analysis=kwargs[\\\"preprocess_analysis\\\"],\\n database=False\\n )\\n\\n run_analysis_pipeline(\\n preprocess_analysis=kwargs[\\\"preprocess_analysis\\\"],\\n json_filepath=output_dir,\\n )\",\n \"def make_video(queue, video_file, destination, face_locations, face_encodings, match_encodings, settings):\\n trackers = [] # list of tracker objects, one for each matched face\\n # get video\\n video = cv2.VideoCapture(video_file) # input VideoCapture object\\n frame_rate = video.get(cv2.CAP_PROP_FPS) # frames per second in input video\\n width = int(video.get(cv2.CAP_PROP_FRAME_WIDTH)) # width of input video frame\\n height = int(video.get(cv2.CAP_PROP_FRAME_HEIGHT)) # height of input video frame\\n frame_count = int(video.get(cv2.CAP_PROP_FRAME_COUNT)) # number of frames in input video\\n # get settings\\n track_period = settings[\\\"track_period\\\"] # track period from settings\\n tolerance = settings[\\\"tolerance\\\"] # face matching tolerance from settings\\n blur_method = settings[\\\"blur_method\\\"] # type of blurring from settings\\n blur_intensity = settings[\\\"blur_intensity\\\"] # blurring filter size from settings\\n display_output = settings[\\\"display_output\\\"] # flag indicating whether to display output video from settings\\n # initialize writer\\n out = video_utils.initialize_writer(destination, (width, height), frame_rate) # VideoWriter object\\n for i in range(frame_count):\\n ret, img = video.read() # ret indicates if frame was read correctly, img is last read frame\\n if i % track_period == 0: # frame for detection\\n current_frame_encodings = np.array(face_encodings[i // track_period]) # array of encodings for faces in current frame\\n matched_indices, matched_encodings = recognition.match_faces(current_frame_encodings, np.array(match_encodings), tolerance) # indices of matched faces from current frame and their encodings\\n matched_locations = [face_locations[i // track_period][k] for k in matched_indices] # locations of matched faces from current frame\\n trackers = tracking.start_trackers(img, matched_locations) # list of tracker objects, one for each matched face\\n else: # frame for tracking\\n matched_locations = tracking.update_locations(trackers, img) # updated locations of matched faces from current frame\\n # generate blurred image\\n blurred = None # object holding image with blurred faces\\n if blur_method == \\\"pixelate\\\":\\n blurred = blur_methods.pixelated(img, matched_locations, blur_intensity)\\n elif blur_method == \\\"blur\\\":\\n blurred = blur_methods.blurred(img, matched_locations, blur_intensity)\\n elif blur_method == \\\"blacken\\\":\\n blurred = blur_methods.blackened(img, matched_locations)\\n out.write(blurred)\\n\\n out.release()\\n queue.put(0)\\n if display_output:\\n video_utils.display_video(destination)\",\n \"def process_video(self, input_path, output_path, debug=False):\\n clip = VideoFileClip(input_path)\\n if debug:\\n test_clip = clip.fl_image(self.process_image_debug)\\n else:\\n test_clip = clip.fl_image(self.process_image)\\n test_clip.write_videofile(output_path)\",\n \"def preprocess_sample(file, params):\\n\\n videoFile = file + \\\".mp4\\\"\\n audioFile = file + \\\".wav\\\"\\n roiFile = file + \\\".png\\\"\\n visualFeaturesFile = file + \\\".npy\\\"\\n\\n roiSize = params[\\\"roiSize\\\"]\\n normMean = params[\\\"normMean\\\"]\\n normStd = params[\\\"normStd\\\"]\\n vf = params[\\\"vf\\\"]\\n device = torch.device(\\\"cuda\\\" if torch.cuda.is_available() else \\\"cpu\\\")\\n\\n\\n #Extract the audio from the video file using the FFmpeg utility and save it to a wav file.\\n v2aCommand = \\\"ffmpeg -y -v quiet -i \\\" + videoFile + \\\" -ac 1 -ar 16000 -vn \\\" + audioFile\\n os.system(v2aCommand)\\n\\n\\n #for each frame, resize to 224x224 and crop the central 112x112 region\\n captureObj = cv.VideoCapture(videoFile)\\n roiSequence = list()\\n while (captureObj.isOpened()):\\n ret, frame = captureObj.read()\\n if ret == True:\\n grayed = cv.cvtColor(frame, cv.COLOR_BGR2GRAY)\\n grayed = grayed/255\\n grayed = cv.resize(grayed, (224,224))\\n roi = grayed[int(112-(roiSize/2)):int(112+(roiSize/2)), int(112-(roiSize/2)):int(112+(roiSize/2))]\\n roiSequence.append(roi)\\n else:\\n break\\n captureObj.release()\\n cv.imwrite(roiFile, np.floor(255*np.concatenate(roiSequence, axis=1)).astype(np.int))\\n\\n\\n #normalise the frames and extract features for each frame using the visual frontend\\n #save the visual features to a .npy file\\n inp = np.stack(roiSequence, axis=0)\\n inp = np.expand_dims(inp, axis=[1,2])\\n inp = (inp - normMean)/normStd\\n inputBatch = torch.from_numpy(inp)\\n inputBatch = (inputBatch.float()).to(device)\\n vf.eval()\\n with torch.no_grad():\\n outputBatch = vf(inputBatch)\\n out = torch.squeeze(outputBatch, dim=1)\\n out = out.cpu().numpy()\\n np.save(visualFeaturesFile, out)\\n return\",\n \"def analyze_video(vidNum_iter, config, pointInds_toUse, pts_spaced, session): # function needed for multiprocessing\\n\\n optic = config['Optic']\\n\\n numVids = session['num_vids']\\n path_vid_allFiles = session['videos']\\n lk_names = [key for key in optic.keys() if 'lk_' in key]\\n lk_params = {k.split('lk_')[1]: (tuple(optic[k]) if type(optic[k]) is list else optic[k]) \\\\\\n for k in lk_names}\\n\\n vid = imageio.get_reader(path_vid_allFiles[vidNum_iter], 'ffmpeg')\\n # metadata = vid.get_meta_data()\\n\\n path_vid = path_vid_allFiles[vidNum_iter] # get path of the current vid\\n video = cv2.VideoCapture(path_vid) # open the video object with openCV\\n numFrames = int(video.get(\\n cv2.CAP_PROP_FRAME_COUNT)) # get frame count of this vid GENERALLY INACCURATE. OFF BY AROUND -25 frames\\n\\n frameToSet = 0\\n frame = vid.get_data(\\n frameToSet) # Get a single frame to use as the first 'previous frame' in calculating optic flow\\n new_frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\\n old_frame = new_frame_gray\\n\\n displacements_tmp = np.zeros((pts_spaced.shape[0], 2, np.uint64(numFrames + (numVids * 1000)))) * np.nan\\n\\n print(' ', end='', flush=True)\\n text = \\\"progresser #{}\\\".format(vidNum_iter)\\n print(f'\\\\n Calculating displacement field: video # {vidNum_iter + 1}/{numVids}')\\n\\n for iter_frame, new_frame in enumerate(tqdm(vid, total=numFrames, desc=text, position=vidNum_iter)):\\n new_frame_gray = cv2.cvtColor(new_frame, cv2.COLOR_BGR2GRAY) # convert to grayscale\\n\\n ##calculate optical flow\\n pointInds_new, status, error = cv2.calcOpticalFlowPyrLK(old_frame, new_frame_gray, pointInds_toUse, None,\\n **lk_params) # Calculate displacement distance between STATIC/ANCHORED points and the calculated new points. Also note the excluded 'NextPts' parameter. Could be used for fancier tracking\\n\\n ## Calculate displacement and place into variable 'displacements' (changes in size every iter)\\n if iter_frame == 0:\\n displacements_tmp[:, :, iter_frame] = np.zeros((pts_spaced.shape[0], 2))\\n else:\\n displacements_tmp[:, :, iter_frame] = np.single(np.squeeze((\\n pointInds_new - pointInds_toUse))) # this is the important variable. Simply the difference in the estimate\\n\\n old_frame = new_frame_gray # make current frame the 'old_frame' for the next iteration\\n\\n return displacements_tmp\",\n \"def run_video(self, video_path):\\n file, ext = os.path.splitext(video_path)\\n video_name = file.split('/')[-1]\\n out_filename = video_name + '_out' + '.avi'\\n\\n cap = cv2.VideoCapture(video_path)\\n wi = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))\\n he = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))\\n print(wi, he)\\n\\n vwriter = cv2.VideoWriter(out_filename, cv2.VideoWriter_fourcc(*'MJPG'), 10, (wi, he))\\n counter = 0\\n fac = 2\\n start = time.time()\\n while True:\\n ret, image = cap.read()\\n\\n if ret:\\n counter += 1\\n\\n ## resize image\\n\\n height, width, channels = image.shape\\n resize_ratio = 1.0 * self.INPUT_SIZE / max(width, height)\\n target_size = (int(resize_ratio * width), int(resize_ratio * height))\\n image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\\n resized_image = cv2.resize(image, target_size, interpolation=cv2.INTER_AREA)\\n output = resized_image.copy()\\n\\n ## get segmentation map\\n batch_seg_map = self.sess.run(\\n self.OUTPUT_TENSOR_NAME,\\n feed_dict={self.INPUT_TENSOR_NAME: [np.asarray(resized_image)]})\\n seg_map = batch_seg_map[0]\\n\\n ## visualize\\n seg_image = label_to_color_image(seg_map).astype(np.uint8)\\n\\n ## overlay on image\\n alpha = 0.7\\n cv2.addWeighted(seg_image, alpha, output, 1 - alpha, 0, output)\\n\\n output = cv2.resize(output, (wi, he), interpolation=cv2.INTER_AREA)\\n # outimg = 'image_' + str(counter) + '.jpg'\\n # cv2.imwrite(os.path.join(os.getcwd(), 'test_out', outimg),output)\\n vwriter.write(output)\\n else:\\n break\\n\\n end = time.time()\\n print(\\\"Frames and Time Taken: \\\", counter, end - start)\\n cap.release()\\n vwriter.release()\",\n \"def process_video(filename, args, cfg, net):\\n # Split video into frames\\n images = split_video(filename)\\n # Set output dir\\n output_dir = args.output\\n # Add brackets and extension to filename\\n output_path = create_video_output_path(output_dir, cfg)\\n # Get height and width of 1st image\\n height, width, _ = check_img_size(images[0]).shape\\n # Create VideoWriter object\\n video = cv2.VideoWriter(output_path, \\n cv2.VideoWriter_fourcc(*'FMP4'), \\n cfg['video']['fps'], \\n (width, height))\\n for image in images:\\n # Process frames\\n img_steps = process_image(image, cfg, net)\\n # Check for --show-detections flag\\n output_img = check_if_adding_bboxes(args, img_steps) \\n # Write to video\\n video.write(output_img) \\n # Release video writer object\\n video.release()\",\n \"def video(perspective_matrix_path, source=\\\"cam\\\", save=False, save_path=None, file_name=\\\"out\\\", cam_cal=None):\\n if not os.path.isfile(perspective_matrix_path):\\n raise FileNotFoundError(\\\"Path to perspective matrix file not exist!\\\")\\n\\n with open(perspective_matrix_path, \\\"rb\\\") as p:\\n perspective_matrix = pickle.load(p)\\n M = perspective_matrix[\\\"M\\\"]\\n Minv = perspective_matrix[\\\"Minv\\\"]\\n\\n if source == \\\"cam\\\":\\n cap = cv2.VideoCapture(0)\\n else:\\n if not os.path.isfile(source):\\n raise FileNotFoundError(source, \\\" not Exist!\\\")\\n cap = cv2.VideoCapture(source)\\n\\n # camera calibration parameters [ mtx , dist]\\n mtx = None\\n dist = None\\n\\n out = None\\n if save:\\n if not os.path.isdir(save_path):\\n raise FileNotFoundError(save_path, \\\" Not Exist!\\\")\\n file_name += \\\".mp4\\\"\\n out = cv2.VideoWriter(save_path + file_name, -1, 20, (int(cap.get(3)), int(cap.get(4))))\\n\\n if cam_cal:\\n if not os.path.isfile(cam_cal):\\n raise FileNotFoundError(cam_cal, \\\" Not Exist!\\\")\\n\\n with open(cam_cal, \\\"rb\\\") as p:\\n calibration = pickle.load(p)\\n mtx = calibration[\\\"mtx\\\"]\\n dist = calibration[\\\"dist\\\"]\\n\\n left_line = Line(5)\\n right_line = Line(5)\\n\\n while True:\\n # Capture frame-by-frame\\n ret, frame = cap.read()\\n if not ret:\\n print(\\\"Finished..\\\")\\n sys.exit(0)\\n\\n # cv2 read frame as BGR, convert it to RGB\\n frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\\n\\n # camera calibration\\n if not (mtx is None or dist is None):\\n frame = cv2.undistort(frame, mtx, dist, None, mtx)\\n\\n # get edges in image\\n edges = apply_edge_detection(frame)\\n\\n # transform image to bird view\\n warped = warped_img(edges, M)\\n\\n # init out image which will draw lane line on it then weight it with original frame\\n out_img = np.zeros_like(warped)\\n if len(warped.shape) == 3 and warped.shape[2] == 3:\\n pass\\n else:\\n out_img = np.dstack((out_img, out_img, out_img))\\n\\n # if line not detected, apply sliding window\\n if not left_line.detected or not right_line.detected:\\n leftx, lefty, rightx, righty = sliding_window(warped, 9, 200)\\n\\n # if already detected apply search around detected line\\n else:\\n leftx, lefty = search_around_poly(left_line, warped)\\n rightx, righty = search_around_poly(right_line, warped)\\n\\n # will used for plotting line, find x fitted\\n ploty = np.linspace(warped.shape[0] // 4, warped.shape[0] - 1, warped.shape[0])\\n\\n # check if at least 100 pixels detected as line\\n if len(leftx) > 100 and len(rightx) > 100:\\n\\n # make detected flag true\\n left_line.detected = True\\n right_line.detected = True\\n\\n left_line.current_x = leftx\\n left_line.current_y = lefty\\n\\n right_line.current_x = rightx\\n right_line.current_y = righty\\n\\n left_line.fit_polynomial(ploty)\\n right_line.fit_polynomial(ploty)\\n\\n else:\\n print(\\\"Line not detected in this frame \\\")\\n # we just draw line form previous frame\\n\\n # make detected flag true\\n left_line.detected = False\\n right_line.detected = False\\n\\n # update Lane line radius\\n left_line.radius()\\n right_line.radius()\\n\\n # avg radius of to lines, and plot it\\n radius = (left_line.radius_of_curvature + right_line.radius_of_curvature) // 2\\n frame = write_text(frame, \\\"Radius of Curvature = \\\" + str(radius) + \\\" M\\\", pos=(20, 50))\\n\\n # calculate Alignment ( how much car away from center between Lane lines\\n dir = \\\"Left\\\" # car far from left or right\\n\\n left_line.car_offset(frame.shape) # distance from left line\\n right_line.car_offset(frame.shape) # distance from right line\\n\\n distance = round(right_line.line_base_pos - left_line.line_base_pos, 2)\\n\\n if distance < 0: # car far away from left line not right line\\n distance = -distance\\n dir = \\\"Right\\\"\\n frame = write_text(frame, \\\"Vehicle is {}m {} of center\\\".format(distance, dir), pos=(20, 80))\\n\\n # ** plot lane lines on image **\\n # left_line.draw_line(out_img, ploty)\\n # right_line.draw_line(out_img, ploty)\\n\\n # color pixel which belong to lane lines\\n left_line.color_pixel(out_img, (255, 0, 0))\\n right_line.color_pixel(out_img, (255, 100, 0))\\n\\n # fit green triangle in area between lane lines\\n pts_left = np.array([np.transpose(np.vstack([left_line.bestx, ploty]))])\\n pts_right = np.array([np.flipud(np.transpose(np.vstack([right_line.bestx, ploty])))])\\n pts = np.hstack((pts_left, pts_right))\\n\\n # Draw the lane onto the warped blank image\\n cv2.fillPoly(out_img, np.int_([pts]), (0, 255, 0))\\n\\n # return image to normal view from bird view\\n out_img_undit = warped_img(out_img, Minv)\\n\\n # weight out_image_undit with original frame\\n frame = cv2.addWeighted(out_img_undit, 0.5, frame, 1, 0)\\n frame = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)\\n\\n cv2.imshow(\\\"frame\\\", frame)\\n\\n # write video\\n if save:\\n out.write(frame)\\n if cv2.waitKey(1) & 0xFF == ord('q'):\\n break\\n\\n # When everything done, release the capture\\n cap.release()\\n cv2.destroyAllWindows()\",\n \"def emv(inputVideoPath, outputVideoPath, maxLevel, freqLow, freqHigh, alpha, chromAttenuation, startFrameNumber, endFrameNumber, lambdaC=-1, app=\\\"color\\\", method=\\\"ideal\\\", roi=None): \\n fps, frames = getVideoFrames(inputVideoPath, startFrameNumber, endFrameNumber)\\n if app==\\\"color\\\":\\n recreateFrames=emvCoreColor(frames, fps, maxLevel, freqLow, freqHigh, alpha, chromAttenuation, method)\\n elif app==\\\"motion\\\":\\n recreateFrames=emvCoreMotion(frames, fps, maxLevel, freqLow, freqHigh, alpha, lambdaC, chromAttenuation, method)\\n saveFramesToVideoROI(frames, recreateFrames, outputVideoPath, roi)\\n return\",\n \"def displacements_monothread(config, pointInds_toUse, pointInds_tracked, pointInds_tracked_tuple, displacements,\\n pts_spaced, color_tuples, session):\\n\\n ## Main loop to pull out displacements in each video\\n ind_concat = 0\\n fps = 0\\n tic_fps = time.time()\\n tic_all = time.time()\\n\\n optic = config['Optic']\\n video = config['Video']\\n\\n vidNums_toUse = optic['vidNums_toUse']\\n showVideo_pref = optic['showVideo_pref']\\n fps_counterPeriod = video['fps_counterPeriod']\\n printFPS_pref = video['printFPS_pref']\\n remote = config['General']['remote']\\n save_vid = video['save_demo']\\n\\n Fs = video['Fs']\\n vid_width = video['width']\\n vid_height = video['height']\\n test_len = video['demo_len']\\n save_pathFull = str(Path(config['Paths']['viz']) / 'optic_test.avi')\\n\\n numVids = session['num_vids']\\n path_vid_allFiles = session['videos']\\n lk_names = [key for key in optic.keys() if 'lk_' in key]\\n lk_params = {k.split('lk_')[1]: (tuple(optic[k]) if type(optic[k]) is list else optic[k]) \\\\\\n for k in lk_names}\\n\\n # Define the codec and create VideoWriter object\\n if showVideo_pref and (save_vid or remote):\\n fourcc = cv2.VideoWriter_fourcc(*'MJPG')\\n print(f'saving to file {save_pathFull}')\\n out = cv2.VideoWriter(save_pathFull, fourcc, Fs, (np.int64(vid_width), np.int64(vid_height)))\\n else:\\n out = None\\n vid_lens = []\\n for vidNum_iter in vidNums_toUse:\\n vid = imageio.get_reader(path_vid_allFiles[vidNum_iter], 'ffmpeg')\\n # metadata = vid.get_meta_data()\\n\\n path_vid = path_vid_allFiles[vidNum_iter] # get path of the current vid\\n video = cv2.VideoCapture(path_vid) # open the video object with openCV\\n numFrames_rough = int(video.get(\\n cv2.CAP_PROP_FRAME_COUNT)) # get frame count of this vid GENERALLY INACCURATE. OFF BY AROUND -25 frames\\n\\n frameToSet = 0\\n frame = vid.get_data(0) # Get a single frame to use as the first 'previous frame' in calculating optic flow\\n new_frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\\n old_frame = new_frame_gray\\n\\n print(f'\\\\n Calculating displacement field: video # {vidNum_iter + 1}/{numVids}')\\n # while True:\\n for iter_frame, new_frame in enumerate(tqdm(vid, total=numFrames_rough)):\\n new_frame_gray = cv2.cvtColor(new_frame, cv2.COLOR_BGR2GRAY) # convert to grayscale\\n\\n ##calculate optical flow\\n pointInds_new, status, error = cv2.calcOpticalFlowPyrLK(old_frame, new_frame_gray, pointInds_toUse, None,\\n **lk_params) # Calculate displacement distance between STATIC/ANCHORED points and the calculated new points. Also note the excluded 'NextPts' parameter. Could be used for fancier tracking\\n\\n ## Calculate displacement and place into variable 'displacements' (changes in size every iter) \\n if iter_frame == 0:\\n displacements[:, :, ind_concat] = np.zeros((pts_spaced.shape[0], 2))\\n else:\\n displacements[:, :, ind_concat] = np.single(np.squeeze((\\n pointInds_new - pointInds_toUse))) # this is the important variable. Simply the difference in the estimate\\n\\n old_frame = new_frame_gray # make current frame the 'old_frame' for the next iteration\\n\\n ## below is just for visualization. Nothing calculated is maintained\\n if showVideo_pref:\\n pointInds_tracked = pointInds_tracked + (\\n pointInds_new - pointInds_toUse) # calculate integrated position\\n pointInds_tracked = pointInds_tracked - (\\n pointInds_tracked - pointInds_toUse) * 0.01 # multiplied constant is the relaxation term. this is just for display purposes. Relaxation term chosen during cleanup will be real\\n pointInds = [pointInds_tracked, pointInds_tracked_tuple]\\n counters = [iter_frame, vidNum_iter, ind_concat, fps]\\n if (remote and iter_frame < test_len) or not remote:\\n videos.visualize_progress(config, session, new_frame, pointInds, color_tuples, counters, out)\\n\\n if (save_vid or remote) and iter_frame == test_len:\\n out.release()\\n\\n k = cv2.waitKey(1) & 0xff\\n if k == 27: break\\n\\n ind_concat = ind_concat + 1\\n\\n if ind_concat % fps_counterPeriod == 0:\\n elapsed = time.time() - tic_fps\\n fps = fps_counterPeriod / elapsed\\n if printFPS_pref:\\n print(fps)\\n tic_fps = time.time()\\n vid_lens.append(iter_frame+1)\\n ## Calculate how long calculation took\\n elapsed = time.time() - tic_all\\n helpers.print_time('video time elapsed:', elapsed)\\n print(f'Capture rate: {round(ind_concat / elapsed, 3)} fps')\\n\\n numFrames_total = ind_concat - 1\\n cv2.destroyAllWindows()\\n\\n displacements = displacements[:, :, ~np.isnan(displacements[0, 0, :])]\\n\\n return displacements, numFrames_total, vid_lens\",\n \"def write_face_samples(model, output_path, invid):\\n \\n if not os.path.isdir(output_path) :\\n os.mkdir(output_path)\\n \\n video = mmcv.VideoReader(invid)\\n for frame_ix, frame in enumerate(video):\\n frame_name = f\\\"{output_path}webcam_{frame_ix}_0.jpg\\\"\\n if os.path.isfile(frame_name): continue\\n \\n frame_img = PIL.Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))\\n _ = model(frame_img,frame_name)\",\n \"def makeVideo():\\n os.system(\\\"cd video && ffmpeg -r 10 -i img%05d.jpg -vcodec mpeg4 -y caronthehill_clip.mp4\\\")\",\n \"def __call__(self, video_path, per_frames = 1 , offset = None):\\n \\n cap = cv2.VideoCapture(video_path)\\n \\n if not cap.isOpened():\\n raise Exception(\\\"Video file does not exist or is invalid\\\")\\n\\n \\n if offset:\\n cap.set(cv2.CAP_PROP_POS_MSEC, offset)\\n \\n \\n info = []\\n\\n while cap.isOpened():\\n ret, frame = cap.read()\\n if ret:\\n if cap.get(cv2.CAP_PROP_POS_FRAMES) % per_frames == 0:\\n frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\\n faces_info = self.detect_faces_from_image(frame,\\n desired_width=224, desired_height=224) \\n if faces_info:\\n for element in faces_info:\\n face_img = image.img_to_array(element[1])\\n\\n face_img = utils.preprocess_input(face_img, version=1)\\n face_img = np.expand_dims(face_img, axis=0)\\n\\n features = self.vgg_feature_extractor.predict(face_img)\\n label = self.gender_svm.predict(features)[0]\\n decision_value = round(self.gender_svm.decision_function(features)[0], 3)\\n\\n bounding_box = element[0][0]\\n detection_score = round(element[5], 3)\\n bbox_length = bounding_box.bottom() - bounding_box.top()\\n\\n info.append([\\n cap.get(cv2.CAP_PROP_POS_FRAMES), bounding_box, (bbox_length, bbox_length), label,\\n decision_value, detection_score\\n ])\\n\\n else:\\n break\\n cap.release()\\n info = pd.DataFrame.from_records(info, columns = ['frame', 'bb', 'size','label', 'decision', 'conf'])\\n return info\",\n \"def run(self):\\n\\n for file_cnt, file_path in enumerate(self.files_found):\\n video_timer = SimbaTimer()\\n video_timer.start_timer()\\n _, self.video_name, _ = get_fn_ext(file_path)\\n self.video_info, self.px_per_mm, self.fps = self.read_video_info(\\n video_name=self.video_name\\n )\\n self.width, self.height = int(\\n self.video_info[\\\"Resolution_width\\\"].values[0]\\n ), int(self.video_info[\\\"Resolution_height\\\"].values[0])\\n if self.video_setting:\\n self.fourcc = cv2.VideoWriter_fourcc(*Formats.MP4_CODEC.value)\\n self.video_save_path = os.path.join(\\n self.heatmap_clf_location_dir, self.video_name + \\\".mp4\\\"\\n )\\n self.writer = cv2.VideoWriter(\\n self.video_save_path,\\n self.fourcc,\\n self.fps,\\n (self.width, self.height),\\n )\\n if self.frame_setting:\\n self.save_video_folder = os.path.join(\\n self.heatmap_clf_location_dir, self.video_name\\n )\\n if not os.path.exists(self.save_video_folder):\\n os.makedirs(self.save_video_folder)\\n self.data_df = read_df(file_path=file_path, file_type=self.file_type)\\n clf_array, aspect_ratio = self.__calculate_bin_attr(\\n data_df=self.data_df,\\n clf_name=self.clf_name,\\n bp_lst=self.bp_lst,\\n px_per_mm=self.px_per_mm,\\n img_width=self.width,\\n img_height=self.height,\\n bin_size=self.bin_size,\\n fps=self.fps,\\n )\\n\\n if self.max_scale == \\\"auto\\\":\\n self.max_scale = self.__calculate_max_scale(clf_array=clf_array)\\n if self.max_scale == 0:\\n self.max_scale = 1\\n\\n if self.final_img_setting:\\n self.make_clf_heatmap_plot(\\n frm_data=clf_array[-1, :, :],\\n max_scale=self.max_scale,\\n palette=self.palette,\\n aspect_ratio=aspect_ratio,\\n file_name=os.path.join(\\n self.heatmap_clf_location_dir,\\n self.video_name + \\\"_final_frm.png\\\",\\n ),\\n shading=self.shading,\\n clf_name=self.clf_name,\\n img_size=(self.width, self.height),\\n final_img=True,\\n )\\n\\n if self.video_setting or self.frame_setting:\\n for frm_cnt, cumulative_frm_idx in enumerate(range(clf_array.shape[0])):\\n frm_data = clf_array[cumulative_frm_idx, :, :]\\n cum_df = pd.DataFrame(frm_data).reset_index()\\n cum_df = cum_df.melt(\\n id_vars=\\\"index\\\",\\n value_vars=None,\\n var_name=None,\\n value_name=\\\"seconds\\\",\\n col_level=None,\\n ).rename(\\n columns={\\\"index\\\": \\\"vertical_idx\\\", \\\"variable\\\": \\\"horizontal_idx\\\"}\\n )\\n cum_df[\\\"color\\\"] = (\\n (cum_df[\\\"seconds\\\"].astype(float) / float(self.max_scale))\\n .round(2)\\n .clip(upper=100)\\n )\\n color_array = np.zeros(\\n (\\n len(cum_df[\\\"vertical_idx\\\"].unique()),\\n len(cum_df[\\\"horizontal_idx\\\"].unique()),\\n )\\n )\\n for i in range(color_array.shape[0]):\\n for j in range(color_array.shape[1]):\\n value = cum_df[\\\"color\\\"][\\n (cum_df[\\\"horizontal_idx\\\"] == j)\\n & (cum_df[\\\"vertical_idx\\\"] == i)\\n ].values[0]\\n color_array[i, j] = value\\n\\n fig = plt.figure()\\n im_ratio = color_array.shape[0] / color_array.shape[1]\\n plt.pcolormesh(\\n color_array,\\n shading=self.shading,\\n cmap=self.palette,\\n rasterized=True,\\n alpha=1,\\n vmin=0.0,\\n vmax=float(self.max_scale),\\n )\\n plt.gca().invert_yaxis()\\n plt.xticks([])\\n plt.yticks([])\\n plt.axis(\\\"off\\\")\\n plt.tick_params(axis=\\\"both\\\", which=\\\"both\\\", length=0)\\n cb = plt.colorbar(pad=0.0, fraction=0.023 * im_ratio)\\n cb.ax.tick_params(size=0)\\n cb.outline.set_visible(False)\\n cb.set_label(\\n \\\"{} (seconds)\\\".format(self.clf_name), rotation=270, labelpad=10\\n )\\n plt.tight_layout()\\n plt.gca().set_aspect(aspect_ratio)\\n canvas = FigureCanvas(fig)\\n canvas.draw()\\n mat = np.array(canvas.renderer._renderer)\\n image = cv2.cvtColor(mat, cv2.COLOR_RGB2BGR)\\n image = cv2.resize(image, (self.width, self.height))\\n image = np.uint8(image)\\n plt.close()\\n\\n if self.video_setting:\\n self.writer.write(image)\\n if self.frame_setting:\\n frame_save_path = os.path.join(\\n self.save_video_folder, str(frm_cnt) + \\\".png\\\"\\n )\\n cv2.imwrite(frame_save_path, image)\\n print(\\n \\\"Created heatmap frame: {} / {}. Video: {} ({}/{})\\\".format(\\n str(frm_cnt + 1),\\n str(len(self.data_df)),\\n self.video_name,\\n str(file_cnt + 1),\\n len(self.files_found),\\n )\\n )\\n\\n if self.video_setting:\\n self.writer.release()\\n\\n video_timer.stop_timer()\\n print(\\n \\\"Heatmap plot for video {} saved (elapsed time: {}s) ... \\\".format(\\n self.video_name, video_timer.elapsed_time_str\\n )\\n )\\n\\n self.timer.stop_timer()\\n stdout_success(\\n msg=\\\"All heatmap visualizations created in project_folder/frames/output/heatmaps_classifier_locations directory\\\",\\n elapsed_time=\\\"self.timer.elapsed_time_str\\\",\\n )\",\n \"def _spawn_ffmpeg(self) -> None:\\r\\n if self.ffmpeg_proc is not None:\\r\\n raise RuntimeError('_spawn_ffmpeg called when ffmpeg_proc is '\\r\\n + f'{self.ffmpeg_proc} (not None)')\\r\\n\\r\\n args = ['ffmpeg', '-f', 'rawvideo', '-vcodec', 'rawvideo',\\r\\n '-s', f'{self.frame_size[0]}x{self.frame_size[1]}',\\r\\n '-pix_fmt', 'rgba', '-r', str(self.fps),\\r\\n '-loglevel', 'quiet',\\r\\n '-i', 'pipe:0',\\r\\n '-vcodec', 'h264', '-pix_fmt', 'yuv420p',\\r\\n '-movflags', '+faststart']\\r\\n\\r\\n if self.bitrate > 0:\\r\\n args.extend(['-b', f'{self.bitrate}k'])\\r\\n args.extend(['-y', self.outfile])\\r\\n\\r\\n create_flags = sp.CREATE_NO_WINDOW if 'nt' in os.name else 0\\r\\n self.ffmpeg_proc = sp.Popen(args, shell=False, stdout=None, stderr=None,\\r\\n stdin=sp.PIPE, creationflags=create_flags)\",\n \"def write_video(project_video_output, output_folder, fps=20):\\n print(\\\"Creating video {}, FPS={}\\\".format(project_video_output, fps))\\n clip = ImageSequenceClip(output_folder, fps)\\n clip.write_videofile(project_video_output)\",\n \"def process_video(path, method):\\n # TODO: Obtener nombre de video a partir del path\\n video_name = ''\\n # TODO: Crear carpeta si es que no existe (Deteccion/{method}/{video_name})\\n folder_path = f\\\"Deteccion/{method}/{video_name}\\\"\\n try:\\n cap = cv2.VideoCapture(path)\\n # Check if camera opened successfully\\n if (cap.isOpened() is False):\\n print(\\\"Error opening video stream or file\\\")\\n\\n frame_counter = 0\\n # Read until video is completed\\n while(cap.isOpened()):\\n # Capture frame-by-frame\\n ret, frame = cap.read()\\n if ret is True:\\n # TODO: Crear carpeta del frame si es que no existe (Deteccion/{method}/{video_name}/{frame_name})\\n frame_name = f\\\"frame_{frame_counter}\\\"\\n\\n faces = process_frame(frame, method)\\n # TODO: Guardar bounding boxes\\n np.save(f\\\"{folder_path}/{frame_name}/bounding_boxes.npy\\\", faces)\\n\\n # TODO: Guardar imagenes recortadas\\n for bb in faces:\\n pass\\n frame_counter += 1\\n\\n # Break the loop\\n else:\\n break\\n\\n finally:\\n # When everything done, release the video capture object\\n cap.release()\",\n \"def mapBackToSurface(array,filename):\\n #### Map back to surface\\n if array.shape[0]==360:\\n out_array = np.zeros((glasser2.shape[0],3))\\n\\n roicount = 0\\n for roi in range(360):\\n for col in range(array.shape[1]):\\n vertex_ind = np.where(glasser2==roi+1)[0]\\n out_array[vertex_ind,col] = array[roicount,col]\\n\\n roicount += 1\\n\\n else:\\n out_array = array\\n\\n #### \\n # Write file to csv and run wb_command\\n np.savetxt(filename + '.csv', out_array,fmt='%s')\\n wb_file = filename + '.dscalar.nii'\\n wb_command = 'wb_command -cifti-convert -from-text ' + filename + '.csv ' + glasserfile2 + ' ' + wb_file + ' -reset-scalars'\\n os.system(wb_command)\\n os.remove(filename + '.csv')\",\n \"def tagVideo(modelpath, videopath, outputPath=None): \\n model = get_model_instance_segmentation(3)\\n device = torch.device(\\\"cuda:0\\\" if torch.cuda.is_available() else \\\"cpu\\\")\\n # model.load_state_dict(torch.load(modelpath, map_location=device), strict=False)\\n model.load_state_dict(torch.load(modelpath, map_location=device))\\n model = model.to(device)\\n model.eval()\\n\\n \\n data_transform = transforms.Compose([\\n ToPILImage(),\\n transforms.ToTensor(), \\n ])\\n\\n\\n if outputPath:\\n writer = FFmpegWriter(str(outputPath))\\n \\n font = cv2.FONT_HERSHEY_SIMPLEX\\n cv2.namedWindow('main', cv2.WINDOW_NORMAL)\\n labels = ['No mask', 'Mask']\\n labelColor = [(10, 0, 255), (10, 255, 0)]\\n img_count = 0\\n outputDir = os.path.dirname(os.path.realpath(outputPath))\\n frame_count = 0\\n boundingBoxes = []\\n for frame in vreader(str(videopath)):\\n frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\\n print('Frame:', frame_count)\\n\\n if frame_count%30==0:\\n frameTensor = data_transform(frame)\\n frameTensor = torch.unsqueeze(frameTensor, 0).to(device)\\n output = model(frameTensor)\\n boundingBoxes = plot_image_new(frame, frameTensor[0], output[0]) \\n \\n if len(boundingBoxes)>0:\\n for bb in boundingBoxes:\\n cv2.rectangle(frame,\\n (bb[0], bb[1]),\\n (bb[2], bb[3]),\\n (54, 66, 227),\\n thickness=2)\\n\\n cv2.imshow('main', frame)\\n if outputPath:\\n writer.writeFrame(cv2.cvtColor(frame, cv2.COLOR_RGB2BGR))\\n if cv2.waitKey(1) & 0xFF == ord('q'):\\n break\\n frame_count += 1\\n if outputPath:\\n writer.close()\\n cv2.destroyAllWindows()\",\n \"def generateVideo(textFilePath,extractedPath,createdVideoPath):\\r\\n\\t\\t#Check if the save directory exists, If not create directory\\r\\n\\t\\tif not os.path.exists(createdVideoPath):\\r\\n\\t\\t\\tos.mkdir(createdVideoPath)\\r\\n\\t\\t#Open the text file\\r\\n\\t\\tfile = open(textFilePath)\\r\\n\\t\\tvideoPath = createdVideoPath\\r\\n\\r\\n\\t\\tfor hashedData in file:\\r\\n\\t\\t\\thashedData = hashedData.split(\\\"\\\\n\\\")[0]\\r\\n\\t\\t\\timage_folder = extractedPath + \\\"/\\\" + \\\"data\\\" + \\\"/\\\" + hashedData\\r\\n\\t\\t\\tvideo_name = hashedData + \\\".avi\\\"\\r\\n\\t\\t\\timages = os.listdir(image_folder)\\r\\n\\t\\t\\tframe = cv2.imread(os.path.join(image_folder, images[0]))\\r\\n\\t\\t\\theight, width, layers = frame.shape\\r\\n\\t\\t\\t#declare the video writter\\r\\n\\t\\t\\tvideo = cv2.VideoWriter(videoPath + \\\"/\\\" +video_name, 0, 1, (width,height))\\r\\n\\t\\t\\t#Write all images to a single video\\r\\n\\t\\t\\tfor image in images:\\r\\n\\t\\t\\t\\tvideo.write(cv2.imread(os.path.join(image_folder, image)))\\r\\n\\r\\n\\t\\t\\tcv2.destroyAllWindows()\\r\\n\\t\\t\\tvideo.release()\",\n \"def create_video():\\n print(\\\"Generating output video\\\")\\n frame_array = []\\n files = [f for f in os.listdir(MODIFIED_FRAMES_DIR) if isfile(join(MODIFIED_FRAMES_DIR, f))]\\n #for sorting the file names properly\\n # files.sort(key = lambda x: x[3:-4])\\n files = sorted(files,key=lambda x: int(os.path.splitext(x)[0]))\\n for i in range(len(files)):\\n filename= MODIFIED_FRAMES_DIR + files[i]\\n # print(filename)\\n #reading each files\\n img = cv2.imread(filename)\\n height, width, layers = img.shape\\n size = (width,height)\\n \\n #inserting the frames into an image array\\n frame_array.append(img)\\n \\n out = cv2.VideoWriter(OUTPUT_FILE,cv2.VideoWriter_fourcc(*'DIVX'), FRAME_RATE, size)\\n for i in range(len(frame_array)):\\n # writing to a image array\\n out.write(frame_array[i])\\n out.release()\\n print(\\\"Output video generated successfully...\\\")\\n\\n # img_array = []\\n # for filename in glob.glob(MODIFIED_FRAMES_DIR+'/*.jpg'):\\n # img = cv2.imread(filename)\\n # height, width, layers = img.shape\\n # size = (width,height)\\n # img_array.append(img)\\n\\n # height, width, layers = img_array[0].shape\\n # size = (width,height)\\n # out = cv2.VideoWriter('output.mov',cv2.VideoWriter_fourcc(*'DIVX'), 15, size) \\n # for i in range(len(img_array)):\\n # out.write(img_array[i])\\n # out.release()\",\n \"def generate_frame(video_path, video_name, second, label, dest_path):\\n print \\\"video_path\\\", video_path\\n print 'video_name',video_name\\n print 'second',second\\n print 'label',label\\n print 'dest_path',dest_path\\n\\n vidcap = cv2.VideoCapture(os.path.join(video_path, video_name))\\n vidcap.set(0, int(second*1000))\\n success, image = vidcap.read()\\n if success:\\n cv2.imwrite(os.path.join(dest_path, video_name+\\\"_\\\"+str(second)+\\\"_\\\"+str(label)+\\\".jpg\\\"), image)\",\n \"def generateDataFromVideo(path):\\n video = cv2.VideoCapture(path)\\n success, frame = video.read()\\n cnt = 1\\n wiperExist = 0\\n file = open(file='annotation.txt', mode='w')\\n\\n while success:\\n cv2.imwrite(filename='./data/{0}.jpg'.format(cnt), img=frame)\\n cnt += 1\\n success, frame = video.read()\\n if (cnt - 4) % 37 == 0 or (wiperExist > 0):\\n wiperExist = (wiperExist + 1) % 21\\n file.write('./Dataset/data/{0}.jpg 1\\\\n'.format(cnt))\\n else:\\n file.write('./Dataset/data/{0}.jpg 0\\\\n'.format(cnt))\",\n \"def reconstruction(args):\\n\\n print('Loading 2D keypoints ...')\\n keypoints, scores, _, _ = load_json(args.keypoints_file)\\n\\n # Loading only one person's keypoints\\n if len(keypoints.shape) == 4:\\n keypoints = keypoints[0]\\n assert len(keypoints.shape) == 3\\n\\n # Transform the keypoints format from different dataset (MSCOCO, MPII) to h36m format\\n if args.kpts_format == 'coco':\\n keypoints, valid_frames = coco_h36m(keypoints)\\n elif args.kpts_format == 'mpii':\\n keypoints, valid_frames = mpii_h36m(keypoints)\\n elif args.kpts_format == 'openpose':\\n # Convert 'Openpose' format to MSCOCO\\n order_coco = [i for i in range(18) if i != 1]\\n keypoints = keypoints[:, order_coco]\\n keypoints, valid_frames = coco_h36m(keypoints)\\n else:\\n valid_frames = np.where(np.sum(keypoints.reshape(-1, 34), axis=1) != 0)[0]\\n assert args.kpts_format == 'h36m'\\n\\n # Get the width and height of video\\n cap = cv2.VideoCapture(args.video_path)\\n width = int(round(cap.get(cv2.CAP_PROP_FRAME_WIDTH)))\\n height = int(round(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)))\\n\\n # normalize keypoints\\n input_keypoints = normalize_screen_coordinates(keypoints[..., :2], w=width, h=height)\\n\\n if args.frames == 27:\\n filter_widths = [3, 3, 3]\\n channels = 128\\n elif args.frames == 81:\\n filter_widths = [3, 3, 3, 3]\\n channels = 64\\n else:\\n filter_widths = [3, 3, 3, 3, 3]\\n channels = 32\\n\\n model_pos = SpatioTemporalModel(adj, 17, 2, 17, filter_widths=filter_widths, channels=channels, dropout=0.05)\\n\\n if torch.cuda.is_available():\\n model_pos = model_pos.cuda()\\n\\n # load trained model\\n print('Loading checkpoint', args.weight)\\n chk_file = os.path.join('./checkpoint/gastnet', args.weight)\\n checkpoint = torch.load(chk_file, map_location=lambda storage, loc: storage)\\n model_pos.load_state_dict(checkpoint['model_pos'])\\n\\n receptive_field = model_pos.receptive_field()\\n pad = (receptive_field - 1) // 2 # Padding on each side\\n causal_shift = 0\\n\\n print('Reconstructing ...')\\n gen = UnchunkedGenerator(None, None, [input_keypoints[valid_frames]],\\n pad=pad, causal_shift=causal_shift, augment=True,\\n kps_left=kps_left, kps_right=kps_right, joints_left=joints_left, joints_right=joints_right)\\n prediction = evaluate(gen, model_pos, return_predictions=True)\\n prediction = camera_to_world(prediction, R=rot, t=0)\\n\\n # We don't have the trajectory, but at least we can rebase the height\\n prediction[:, :, 2] -= np.min(prediction[:, :, 2])\\n\\n prediction_new = np.zeros((*input_keypoints.shape[:-1], 3), dtype=np.float32)\\n prediction_new[valid_frames] = prediction\\n\\n print('Rendering ...')\\n anim_output = {'Reconstruction': prediction_new}\\n render_animation(keypoints, keypoints_metadata, anim_output, h36m_skeleton, 25, 3000,\\n np.array(70., dtype=np.float32), args.viz_output, limit=-1, downsample=1, size=5,\\n input_video_path=args.video_path, viewport=(width, height), input_video_skip=0)\",\n \"def convert(processed_dir: str, video_file: str):\\n\\n video_name = osp.splitext(osp.basename(video_file))[0]\\n out_dir = processed_dir + video_name\\n\\n # create img dir\\n if not osp.exists(processed_dir):\\n os.mkdir(processed_dir)\\n\\n # Create dir for video file if not existent\\n # this is where we save our images\\n if not osp.exists(out_dir):\\n os.mkdir(out_dir)\\n\\n if osp.exists(out_dir):\\n os.mkdir(out_dir + \\\"/kermit/\\\")\\n os.mkdir(out_dir + \\\"/not_kermit/\\\")\\n\\n # open video file for processing\\n cap = cv.VideoCapture(video_file)\\n frame_rate = cap.get(5) # frame rate\\n\\n sec = 0\\n total_count = (60*25)+50 # just an approximation\\n pbar = tqdm.tqdm(total=total_count, leave=False)\\n\\n count = 0\\n while (cap.isOpened()):\\n frame_id = cap.get(1) # current frame number\\n frame_exists, curr_frame = cap.read()\\n\\n if not frame_exists:\\n break\\n else:\\n if (frame_id % math.floor(frame_rate) == 0):\\n # output is : video_file/<video_file>_frameNr.jpg\\n cv.imwrite(osp.join(out_dir, '{}_{}.jpg'.format(video_name,count)), curr_frame)\\n count = count + 1\\n pbar.update(1)\\n\\n pbar.close()\\n # release resources\\n cap.release()\",\n \"def __init__(self, video_folder, output_folder, output_file=None, height=320, width=480,\\n sample_every=10, max_workers=32):\\n self.video_folder = video_folder\\n self.output_folder = output_folder\\n self.output_file = output_file\\n print(\\n f\\\"Video Preprocessor created with video_folder = {video_folder} , output_folder = {output_folder}, output_file = {output_file}\\\")\\n\\n self.height = height\\n self.width = width\\n self.sample_every = sample_every\\n self.max_workers = max_workers\\n print(f\\\"Frames will be created with height = {height} , width = {width} , sample_every = {sample_every}\\\")\",\n \"def let_camera_update_parameters(path_to_images, name_image, video_source=\\\"/dev/video0\\\"):\\n subprocess_cmd(\\\"ffmpeg -f video4linux2 -s 1280x720 -i {} -ss 00:00:02 -frames 1 ./{}/{} -loglevel error -nostats\\\".format(video_source, path_to_images, name_image))\",\n \"def make_video(pattern, plotdir, moviedir, movienametag):\\n images_list = glob('%s/%s'%(plotdir, pattern))\\n images_list.sort()\\n # save all required files into tmp_moviedir, with simple filenames: %.4d.png\\n tmp_moviedir = '%s/tmp_movie_%s'%(plotdir, movienametag)\\n os.system('mkdir -p %s'%tmp_moviedir)\\n for i in range(len(images_list)):\\n fname = images_list[i].split('%s/'%plotdir)[-1].split('.png')[0]\\n os.system('cp %s/%s.png %s/%.4d.png'%(plotdir, fname, tmp_moviedir, i))\\n\\n os.system('avconv -i %s'%tmp_moviedir +'/%04d.png ' \\\\\\n +' -y -c:v libx264 -pix_fmt yuv420p %s/%s.mp4'%(moviedir, movienametag))\",\n \"def precompute_numpy_video_files(self):\\n videos = self.get_videos(self.not_collisions, 1) \\\\\\n | chain_with(self.get_videos(self.collisions, 0)) \\\\\\n | where(lambda f: not isfile(self.get_numpy_filename(f[1])))\\n\\n for v in videos:\\n path = self.get_numpy_filename(v[1])\\n\\n video_to_npy(v[1],\\n # note weird thing here, width doesn't work they appear to be inverted\\n height=self.video_size,\\n squarecrop=self.squarecrop,\\n fps=self.framerate,\\n maxlength=self.max_length,\\n # save a npy replacement\\n outfile=path)\\n\\n print('%s written' % (path))\",\n \"def recordVideo(args, env, model, filename):\\n # env = model.get_env()\\n images = []\\n images = images + runAGame(model, env, args.method == 'centralized')\\n images = images + runAGame(model, env, args.method == 'centralized')\\n images = images + runAGame(model, env, args.method == 'centralized')\\n images[0].save(filename + '.gif',\\n format='GIF',\\n append_images=images[1:],\\n save_all=True,\\n duration=500,\\n loop=0)\\n print('Video saved:', filename)\",\n \"def __init__(self, input_file_path, convert_to_bgr=False):\\n self.__yuv_video = YuvDecoder(input_file_path, convert_to_bgr=True)\\n print('After INSTANTIATION')\\n self.__yuv_video.start()\",\n \"def run(input_video_file, output_video_file):\\n print(\\\"Debut de la transformation du format de la video\\\")\\n #récupération de la vidéo\\n video = cv2.VideoCapture(input_video_file)\\n #fps de la vidéo\\n fps = video.get(cv2.CAP_PROP_FPS)\\n #largeur des images de la vidéo\\n width_video = int(video.get(cv2.CAP_PROP_FRAME_WIDTH))\\n #hauteur des images de la vidéo\\n height_video = int(video.get(cv2.CAP_PROP_FRAME_HEIGHT))\\n #nombre d'images dans la vidéo\\n frame_count = int(video.get(cv2.CAP_PROP_FRAME_COUNT))\\n #durée de la vidéo\\n duration = frame_count/fps\\n #nouvelle durée de la vidéo (on arrondi)\\n new_duration = math.floor(duration)\\n #nouveau fps de la vidéo\\n new_fps = float(round(fps))\\n #appliquer le nouveau fps\\n video.set(cv2.CAP_PROP_FPS,new_fps)\\n #appliquer la nouvelle durée\\n print(new_duration)\\n print(new_fps)\\n print(new_duration*new_fps)\\n new_frame_count = new_duration*new_fps\\n video.set(cv2.CAP_PROP_FRAME_COUNT,new_duration*new_fps)\\n #déffinition du format de la vidéo en sortie\\n video_out = cv2.VideoWriter(output_video_file,0x7634706d,new_fps,(width_video,height_video),True)\\n \\n count = 0\\n #ouverture de la vidéo\\n while(video.isOpened()):\\n #lecture image par image\\n ret, frame = video.read()\\n if ret==True:\\n\\n #ecriture de l'image dans la vidéo en sortie\\n video_out.write(frame)\\n count = count + 1\\n \\n if (count > (new_frame_count-1)):\\n # Libérer la vidéo\\n video.release()\\n break\\n else:\\n break\\n\\n print(\\\"fin de la transformation\\\")\\n #fermer les vidéos\\n video.release()\\n video_out.release()\",\n \"def main(data_dir):\\n\\n face2face_dir = '{}/manipulated_sequences/Face2Face/c0/videos'.format(data_dir)\\n orig_dir = '{}/original_sequences/c0/videos'.format(data_dir)\\n base_dir = '{}/manipulated_sequences/GANnotation'.format(data_dir)\\n output_enc_dir = '{}/encodings'.format(base_dir)\\n output_vid_dir = '{}/{}/videos'.format(base_dir, COMPRESSION_LEVEL)\\n\\n pairs = get_seq_combos(face2face_dir)\\n\\n # Compute all video encodings and save them to disk.\\n # We precompute these because they take roughly 10 times as long to compute\\n # as the reenactments, and we may want to recompute the reenactments with\\n # different images later.\\n print('Computing video encodings...')\\n if not os.path.exists(output_enc_dir):\\n os.makedirs(output_enc_dir)\\n enc_count = 0\\n for source_id, _ in pairs:\\n encoding_path = get_encoding_path(output_enc_dir, source_id)\\n if os.path.exists(encoding_path):\\n continue # Encoding already calculated for this video sequence.\\n print('Computing encoding for sequence {}...'.format(source_id))\\n video_path = '{}/{}.mp4'.format(orig_dir, source_id)\\n cap = cv2.VideoCapture(video_path)\\n points = compute_video_encoding(cap)\\n cap.release()\\n try:\\n np.savetxt(encoding_path, points.reshape((132,-1)).transpose())\\n except KeyboardInterrupt as e:\\n # Safely handle premature termination.\\n # Remove unfinished file.\\n if os.exists(encoding_path):\\n os.remove(encoding_path)\\n raise e\\n enc_count += 1\\n\\n if enc_count == 0:\\n print('No encodings were calculated')\\n else:\\n print('{} video sequences encoded'.format(enc_count))\\n\\n print()\\n print('Computing reenactments...')\\n\\n # Load pre-trained model.\\n gann_path = os.path.join(dirname, 'models/myGEN.pth')\\n my_gann = GANnotation.GANnotation(path_to_model=gann_path)\\n\\n image_dir = '{}/original_sequences_images/{}/images'.format(data_dir, COMPRESSION_LEVEL)\\n if not os.path.exists(output_vid_dir):\\n os.makedirs(output_vid_dir)\\n reenact_count = 0\\n for source_id, driver_id in pairs:\\n output_path = '{}/{}_{}.mp4'.format(output_vid_dir, source_id, driver_id)\\n if os.path.exists(output_path):\\n # Do not recreate a video if it already exists.\\n # If the user wants to recreated a video\\n # the existing video must be deleted first.\\n continue\\n\\n print('Computing reenactment for {} onto {}...'.format(driver_id, source_id))\\n # Validate that input files exist.\\n encoding_path = get_encoding_path(output_enc_dir, driver_id)\\n if not os.path.isfile(encoding_path):\\n print('Failed to find encoding for video sequence {}'.format(driver_id),\\n file=stderr)\\n continue\\n image_path = '{}/{}.png'.format(image_dir, source_id)\\n if not os.path.isfile(image_path):\\n print('Failed to find image for sequence {}'.format(source_id),\\n file=stderr)\\n continue\\n\\n points = np.loadtxt(encoding_path).transpose().reshape(66, 2, -1)\\n\\n # Load and transform image for inputting.\\n image = cv2.imread(image_path)\\n cropped = get_gann_cropped_face(image)\\n\\n # Compute reenactment.\\n frames, _ = my_gann.reenactment(cropped, points)\\n\\n output_path = os.path.abspath(output_path)\\n print('Writing video to \\\"{}\\\"'.format(output_path))\\n try:\\n write_video(frames, FPS, (128, 128), output_path)\\n except KeyboardInterrupt as e:\\n # Safely handle premature termination.\\n # Remove unfinished file.\\n if os.exists(output_path):\\n os.remove(output_path)\\n raise e\\n reenact_count += 1\\n\\n if reenact_count == 0:\\n print('No reenactments were created')\\n else:\\n print('{} reenactments created'.format(reenact_count))\",\n \"def generate_video(sign, issue, output):\\n\\n videos = {\\n \\\"Climate Change\\\": \\\"ClimateChange.mp4\\\",\\n \\\"Green Jobs\\\": \\\"GreenJobs.mp4\\\",\\n \\\"Tourism\\\": \\\"Tourism.mp4\\\",\\n \\\"Small Business\\\": \\\"SmallBusiness.mp4\\\",\\n \\\"Public health\\\": \\\"PublicHealth.mp4\\\",\\n \\\"Education Funding\\\": \\\"EducationFunding.mp4\\\"\\n }\\n\\n video_path = CWD(f\\\"Assets/{videos[issue]}\\\")\\n\\n frame = cv2.imread(sign)\\n frame = cv2.resize(frame, (1920, 1080))\\n height, width, layers = frame.shape\\n fourcc = cv2.VideoWriter_fourcc(*'mp4v')\\n video = cv2.VideoWriter(CWD(\\\"temp.mp4\\\"), fourcc, 1, (width, height))\\n for i in range(5):\\n video.write(frame)\\n video.release()\\n\\n image_clip = VideoFileClip(CWD(\\\"temp.mp4\\\"))\\n original_video = VideoFileClip(video_path)\\n final_video = concatenate_videoclips([original_video, image_clip], method=\\\"compose\\\")\\n\\n final_video.write_videofile(output)\\n os.remove(CWD(\\\"temp.mp4\\\"))\",\n \"def recreateVideoFromLapPyr(pyrVideo): \\n maxLevel=len(pyrVideo)\\n fNumber, H, W, chNum=pyrVideo[0].shape\\n videoResult=np.zeros(pyrVideo[0].shape, dtype=np.float32)\\n for fn in range(videoResult.shape[0]):\\n framePyr=[pyrVideo[i][fn] for i in range(maxLevel)]\\n videoResult[fn]=recreateImgsFromLapPyr(framePyr)\\n \\n return videoResult\",\n \"def recreateAnalysis(path,filename, dataset = 'POST',save = False, color = (0,255,0),location = (0,0)):\\n\\tprint('going to recreate the recording, press anything when ready')\\n\\tcv2.namedWindow('Video'); cv2.moveWindow('Video',location[0],location[1])\\n\\tcv2.waitKey(0)\\n\\tR = cf.OBJECT_RADIUS\\n\\tmeta,data = loadData(path,filename)\\n\\tfps = meta['FPS']\\n\\tfiletype = meta['Format']\\n\\tvid = []\\n\\twhile True: #replay loop\\n\\t\\tVidCap = cv2.VideoCapture(path+filename+filetype)\\n\\t\\ti = 0\\n\\t\\twhile True: #video loop\\n\\t\\t\\tre,img = VidCap.read()\\n\\t\\t\\t#print(len(vid))\\n\\t\\t\\t#cv2.imshow('tmp',img)\\n\\t\\t\\tif re:\\n\\t\\t\\t\\tfor k in range(0,meta['Num Objects']):\\n\\t\\t\\t\\t\\tkey = 'object{}'.format(k)\\n\\t\\t\\t\\t\\tcx = data[key+'_x_'+dataset][i]; cy = data[key+'_y_'+dataset][i]; ang = data[key+'_theta_'+dataset][i]\\n\\t\\t\\t\\t\\timg = cv2.circle(img,(cx,cy),4,(200,200,255),-1)\\n\\t\\t\\t\\t\\timg = cv2.circle(img,(cx,cy),R,color)\\n\\t\\t\\t\\t\\timg = cv2.putText(img,key+': '+data[key+'_ID'],(cx,cy-R),cv2.FONT_HERSHEY_SIMPLEX,0.5,(color))\\n\\t\\t\\t\\t\\tpnt1 = (int(cx+R*math.cos(ang)),int(cy-R*math.sin(ang)))\\n\\t\\t\\t\\t\\timg = cv2.arrowedLine(img,(cx,cy),pnt1,color)\\n\\t\\t\\t\\tcv2.imshow('Video',img)\\n\\t\\t\\t\\tvid.append(img)\\n\\t\\t\\t\\ti += 1\\n\\t\\t\\t\\tif cv2.waitKey(int(1000/fps))== ord('q'):\\n\\t\\t\\t\\t\\tVidCap.release()\\n\\t\\t\\t\\t\\tprint('ending early, not saving')\\n\\t\\t\\t\\t\\tsave = False\\n\\t\\t\\t\\t\\tbreak\\n\\t\\t\\telse:\\n\\t\\t\\t break\\n\\t\\tprint('press r to replay, or anything else to quit')\\n\\t\\tif cv2.waitKey(0) == ord('r'):\\n\\t\\t print('playing processed video again')\\n\\t\\telse:\\n\\t\\t break\\n\\tVidCap.release()\\n\\tif save:\\n\\t\\tim = vid[-1]\\n\\t\\t(frame_height,frame_width) = im.shape[0:2]\\n\\t\\tvideoPath = path+filename + '_EVAL_' + dataset + filetype\\n\\t\\tout = cv2.VideoWriter(videoPath, cf.FOURCC, fps, (frame_width,frame_height))\\n\\t\\tfor i,frame in enumerate(vid):\\n\\t\\t\\tout.write(frame)\\n\\t\\tprint('processed video file saved')\\n\\treturn\",\n \"def check_video_timestamps(movie_file, desired_format='.mp4', desired_framerate=30):\\n\\n check_video_format(movie_file, desired_format='.mp4', original_format='.avi')\\n\\n new_movie_file = movie_file+'_tt'+desired_format\\n if not os.path.isfile(new_movie_file):\\n #Convert file to 30 fps\\n cmd = ['ffmpeg', '-i', movie_file+desired_format]\\n cmd += ['-r', str(desired_framerate)]\\n cmd += ['-y', movie_file+'_t'+desired_format]\\n cmd_string = ''.join([\\\"%s \\\" % el for el in cmd]) \\n #print '-->Running: ', cmd_string\\n p = subprocess.Popen(cmd, shell=False)\\n p.wait()\\n\\n #Add timecode text to video\\n cmd = 'ffmpeg -i '+movie_file+'_t'+desired_format+' -vf drawtext=\\\\\\\"fontfile=/opt/X11/share/fonts/TTF/VeraMoBd.ttf: timecode=\\\\'00\\\\:00\\\\:00\\\\:00\\\\':rate=30: fontcolor=white@0.8: x=7: y=460\\\\\\\" -an -y '+movie_file+'_tt'+desired_format\\n args = shlex.split(cmd)\\n #print args\\n p = subprocess.Popen(args, shell=False)\\n p.wait()\\n\\n os.remove(movie_file+'_t'+desired_format)\\n\\n return new_movie_file\",\n \"def process_video(weights_path,video_path,output_path,margins=40,facenet_threshold=.985,euclidean_distance_threshold = 120.0):\\n with torch.no_grad():\\n mtcnn = MTCNN(image_size= 256, margin = 0)\\n model = Model.VGGFace_Extractor().to(device)\\n model.load_state_dict(torch.load(weights_path))\\n model.eval()\\n cap = cv2.VideoCapture(video_path)\\n rotateCode = check_rotation(video_path)\\n fourcc = cv2.VideoWriter_fourcc('M', 'J', 'P', 'G')\\n out = cv2.VideoWriter(output_path, fourcc, 20.0, (int(cap.get(3)), int(cap.get(4))))\\n ret, frame1 = cap.read()\\n hsv = np.zeros_like(frame1)\\n hsv[..., 1] = 255\\n i = 0\\n while (cap.isOpened()):\\n i += 1\\n ret, frame2 = cap.read()\\n if not (ret): break\\n if rotateCode is not None:\\n frame2 = correct_rotation(frame2, rotateCode)\\n\\n boxes, probs = mtcnn.detect(frame2)\\n img_draw = frame2.copy()\\n img_draw = Image.fromarray(img_draw)\\n draw = ImageDraw.Draw(img_draw)\\n if boxes is not None:\\n names = []\\n distances_difference = []\\n for (box, point) in zip(boxes, probs):\\n \\\"\\\"\\\" Loop from the extract_face method from facenet_pytorch\\\"\\\"\\\"\\n\\n if point < facenet_threshold: continue\\n margin = margins\\n image_size = 256\\n margin = [\\n margin * (box[2] - box[0]) / (image_size - margin),\\n margin * (box[3] - box[1]) / (image_size - margin),\\n ]\\n raw_image_size = get_size(img_draw)\\n box = [\\n int(max(box[0] - margin[0] / 2, 0)),\\n int(max(box[1] - margin[1] / 2, 0)),\\n int(min(box[2] + margin[0] / 2, raw_image_size[0])),\\n int(min(box[3] + margin[1] / 2, raw_image_size[1])),\\n ]\\n\\n face = img_draw.crop(box).copy().resize((image_size, image_size), Image.BILINEAR).convert(\\\"RGB\\\")\\n features_1 = model(utils.preprocess(face,device).reshape(-1, 3, 224, 224))\\n images_path = \\\"individuals_extracted/\\\"\\n data_path = os.path.join(images_path, '*pt')\\n files = glob.glob(data_path)\\n name = \\\"Unknown\\\"\\n best_distance = euclidean_distance_threshold + 5\\n for k,f1 in enumerate(files):\\n features = torch.load(f1)\\n distance = utils.euclidean_distance(features,features_1)\\n if distance < euclidean_distance_threshold and distance < best_distance:\\n best_distance = distance\\n name = re.sub('_[1-9]*[.]*[a-zA-Z]*', '', f1.replace(images_path,\\\"\\\"))\\n\\n names.append(name)\\n distances_difference.append(best_distance)\\n\\n for (box, point,name,distances) in zip(boxes, probs,names,distances_difference):\\n if point < facenet_threshold or name == \\\"Unknown\\\": continue\\n draw.rectangle(box.tolist(), width=4)\\n draw.text(box.tolist(), name, font=ImageFont.truetype(\\\"Keyboard.ttf\\\",40))\\n\\n k = cv2.waitKey(3) & 0xff\\n if k == 27:\\n break\\n out.write(np.asarray(img_draw))\\n\\n out.release()\\n cap.release()\\n cv2.destroyAllWindows()\",\n \"def run(self, vid_input_path='project_video.mp4'):\\n vid_output_path = self.g.output_movie_path + vid_input_path\\n print('Finding lanes for:', vid_input_path) \\n\\n # Load the Video\\n # video_clip = VideoFileClip(video_filename).subclip(10, 11)\\n clip1 = VideoFileClip(vid_input_path)\\n\\n # Feed the video, clip by clip into the pipeline.\\n test_clip = clip1.fl_image(self.__image_pipeline) \\n test_clip.write_videofile(vid_output_path, audio=False)\\n\\n return True\",\n \"def __init__(self,vid_path:str,num_frames:int=None,vid_flow_direction:str='left'):\\n \\n self.num_frames=num_frames\\n if vid_path.split('.')[-1]=='cine' or vid_flow_direction!='left':\\n #This is a cine file or needs to be rotated, convert to mp4\\n print('Converting .cine file to mp4 (lossless)')\\n #detect platform so we can correct file paths for ffmpeg\\n is_win=re.compile('.*[Ww]in.*')\\n if is_win.match(sys.platform):\\n corrected_vid_path='\\\"'+vid_path+'\\\"'\\n else:\\n #Put escape characters in front of spaces in file name\\n corrected_vid_path=[]\\n for c in vid_path:\\n if c==' ':\\n corrected_vid_path.append('\\\\\\\\')\\n corrected_vid_path.append(c)\\n corrected_vid_path=''.join(corrected_vid_path)\\n if vid_flow_direction=='up':\\n rotate='-vf \\\"transpose=2\\\" '\\n elif vid_flow_direction=='left':\\n rotate=''\\n elif vid_flow_direction=='right':\\n rotate='-vf \\\"transpose=2,transpose=2\\\" '\\n else:\\n raise Exception(\\\"vid_flow_direction must be 'up', 'left' or 'right'\\\")\\n if num_frames!=None:\\n frames='-frames:v {0} '.format(num_frames)\\n else:\\n frames=''\\n os_handle,new_file_path=tempfile.mkstemp(suffix='.mp4')\\n #close file, we don't work with it directly\\n os.close(os_handle)\\n ffmpeg_command='ffmpeg -y -i {orig_file} {frames}{rotate}-f mp4 -crf 0 {new_file}'.format(orig_file=corrected_vid_path,rotate=rotate,new_file=new_file_path,frames=frames)\\n print(ffmpeg_command)\\n list(os.popen(ffmpeg_command))\\n self.vid_path=new_file_path\\n self.delete_file=True\\n stats=os.stat(new_file_path)\\n if stats.st_size==0:\\n raise Exception('File conversion failed, check that ffmpeg is on PATH')\\n else:\\n #Not a cine\\n self.vid_path=vid_path\\n self.delete_file=False\",\n \"def generate_heatmap_video(img_list,size,video_filename): \\n out = cv2.VideoWriter(video_filename,cv2.VideoWriter_fourcc(*'DIVX'), 25, size)\\n for i in range(len(img_list)):\\n out.write(img_list[i])\\n out.release()\\n print('Heatmap video generated at: ', video_filename)\",\n \"def make_video(data,\\n xdim, ydim, sample_read_rows, sample_read_cols, image_write_rows, image_write_cols,\\n directory, filename, fps = 24.0, start_frame = 1, end_frame = None, timestamp = False, fontsize = 30, ts_pos = (0,0), save_raw = False):\\n\\n #Command to send via the command prompt which specifies the pipe parameters\\n # command = ['ffmpeg',\\n # '-y', # (optional) overwrite output file if it exists\\n # '-f', 'image2pipe',\\n # '-vcodec', 'mjpeg', #'mjpeg',\\n # '-r', '1',\\n # '-r', str(fps), # frames per second\\n # '-i', '-', # The input comes from a pipe\\n # '-an', # Tells FFMPEG not to expect any audio\\n # '-vcodec', 'mpeg4',\\n # '-b:v', '5000k',\\n # directory + filename + \\\"/\\\"+filename+\\\".mp4\\\",\\n # '-hide_banner',\\n # '-loglevel', 'panic']\\n\\n # Create directories if they don't exist\\n if not os.path.exists(os.path.join(directory, filename, 'frames/')):\\n os.makedirs(os.path.join(directory, filename, 'frames/'))\\n if save_raw and not os.path.exists(os.path.join(directory, filename, 'frames-raw/')):\\n os.makedirs(os.path.join(directory, filename, 'frames-raw/'))\\n\\n if end_frame == None:\\n end_frame = data.FrameCount\\n\\n cm = colormap.get_cmap('viridis')\\n\\n for i, frame_offset in enumerate(tqdm.tqdm(range(start_frame, end_frame))):\\n frame = FrameRead(data, frame_offset)\\n frame_image = np.zeros([ydim, xdim], dtype=np.uint8)\\n frame_image[image_write_rows, image_write_cols] = frame.frame_data[sample_read_rows, sample_read_cols]\\n\\n rgb_im = Image.fromarray(cm(frame_image, bytes=True)).convert('RGB')\\n rgb_im.save(os.path.join(directory, filename, 'frames/', f'{i}.jpg'), 'JPEG')\\n\\n if save_raw:\\n Image.fromarray(np.uint8(frame.frame_data), mode='L').save(os.path.join(directory, filename, 'frames-raw/', f'{i}.jpg'), 'JPEG')\",\n \"def process_video(self):\\n if os.path.isfile(self.source):\\n self.cap = cv2.VideoCapture(self.source)\\n else:\\n try:\\n file_name = \\\"input.mp4\\\"\\n self.source = self.source.replace('open', 'uc')\\n print( \\\"\\\\nDownloading video file from drive link to %s\\\\n\\\"%file_name)\\n gdown.download(self.source, file_name, quiet=False)\\n print( \\\"%s downloaded!\\\\n\\\"%file_name )\\n self.cap = cv2.VideoCapture(file_name)\\n except Exception:\\n raise RuntimeError(\\\"Invalid source input, please specify a Google drive link or a downloaded local file as input \\\\n\\\")\\n\\n\\n assert self.cap.isOpened(), \\\"Failed to open %s\\\" % self.source\\n\\n self.w = int(self.cap.get(cv2.CAP_PROP_FRAME_WIDTH))\\n self.h = int(self.cap.get(cv2.CAP_PROP_FRAME_HEIGHT))\\n self.fps = self.cap.get(cv2.CAP_PROP_FPS) \\n self.nframes = int(self.cap.get(cv2.CAP_PROP_FRAME_COUNT))\\n return\",\n \"def __init__(self, videoPath=\\\"\\\", cacheString=\\\"-cache\\\", faceDetector=None):\\n self.videoPath = videoPath\\n self.cacheString = cacheString\\n self.video = None \\n self.currentFrame = []\\n self.currentFrameNumber = 0\\n self.frameCount = 0 #total frame number\\n self.fps = 25\\n self.ret = True #if the video is over\\n self.isPlaying = False\\n self.ifDrawAxis = False\\n self.ifDrawSquare = False\\n self.cacheData = {}\\n \\n if videoPath != \\\"\\\":\\n self.load()\",\n \"def mmap2Channel(self):\\n self.memmap = np.memmap(self.inputFilenames['ofd'],\\n dtype='uint16',\\n mode='r',\\n offset=0,\\n shape=(\\n 2, self.reconstructionSettings['numSamples'], self.scanSettings['numAlinesPerRawFrame'],\\n self.scanSettings['numFrames']), order='F')\",\n \"def video(ctx, video_file, analytic_addr):\\n if not analytic_addr:\\n analytic_addr = [\\\"localhost:50051\\\"]\\n db = ctx.obj.db\\n client = aceclient.AnalyticMultiClient()\\n classes = {}\\n cap = cv2.VideoCapture(video_file)\\n window_names = []\\n f_req = analytic_pb2.FrameRequest()\\n for a in analytic_addr:\\n analytic = analytic_pb2.AnalyticData()\\n analytic.addr = a\\n f_req.analytics.append(analytic)\\n # Load all frames into a queue buffer\\n buf = Queue()\\n while (cap.isOpened()):\\n ret, frame = cap.read()\\n if not ret:\\n break\\n buf.put(frame)\\n try:\\n while not buf.empty():\\n frame = buf.get(block=False)\\n resp = analytic_pb2.CompositeResults()\\n resp = client.process_frame(frame, f_req, resp)\\n render(resp, window_names, classes, frame, db)\\n finally:\\n cv2.destroyAllWindows()\\n print(\\\"Shutting down\\\")\",\n \"def gen_frame_feature_resNet152(rgb_fpath, rgb_spath, rgb_spath_flip, u_fpath, u_spath, u_spath_flip, v_fpath, v_spath,\\n v_spath_flip):\\n rgb_fl = Frameloader(rgb_fpath)\\n u_fl = Frameloader(u_fpath)\\n v_fl = Frameloader(v_fpath)\\n\\n # construct the model\\n input_layer, resNet152, end_points, saver = model()\\n\\n config = tf.ConfigProto()\\n config.gpu_options.allow_growth = True\\n # config.log_device_placement = True\\n config.allow_soft_placement = True\\n with tf.Session(config=config) as sess:\\n sess.run(tf.global_variables_initializer())\\n saver.restore(sess, \\\"/home/boy2/UCF101/src/resNet-152/resnet_v1_152.ckpt\\\")\\n # read all video frames and generate frame features by resNet152\\n while len(rgb_fl.frame_parent_paths) != 0:\\n # save start time\\n start = time.time()\\n\\n # prepare the input frames\\n video_name = rgb_fl.get_current_video_name()\\n print(\\\"Current working on: \\\", video_name)\\n rgb_frames = rgb_fl.load_frames()\\n u_frames = u_fl.load_frames()\\n v_frames = v_fl.load_frames()\\n if len(rgb_frames) > len(u_frames) and len(rgb_frames) - 1 == len(u_frames):\\n rgb_frames = rgb_frames[:-1]\\n rgb_frames_flip, u_frames_flip, v_frames_flip = flip(rgb_frames, u_frames, v_frames)\\n\\n # resize the frames to (224, 224)\\n rgb_frames = resize(rgb_frames, (width, height))\\n u_frames = resize(u_frames, (width, height))\\n v_frames = resize(v_frames, (width, height))\\n rgb_frames_flip = resize(rgb_frames_flip, (width, height))\\n u_frames_flip = resize(u_frames_flip, (width, height))\\n v_frames_flip = resize(v_frames_flip, (width, height))\\n\\n if rgb_frames != [] and u_frames != [] and v_frames != [] and rgb_frames_flip != [] \\\\\\n and u_frames_flip != [] and v_frames_flip != []:\\n\\n rgb_feature = cal_features(rgb_frames, sess, input_layer, resNet152)\\n u_feature = cal_features(u_frames, sess, input_layer, resNet152)\\n v_feature = cal_features(v_frames, sess, input_layer, resNet152)\\n rgb_feature_flip = cal_features(rgb_frames_flip, sess, input_layer, resNet152)\\n u_feature_flip = cal_features(u_frames_flip, sess, input_layer, resNet152)\\n v_feature_flip = cal_features(v_frames_flip, sess, input_layer, resNet152)\\n\\n np.save(os.path.join(rgb_spath, video_name), rgb_feature)\\n np.save(os.path.join(rgb_spath_flip, video_name), rgb_feature_flip)\\n np.save(os.path.join(u_spath, video_name), u_feature)\\n np.save(os.path.join(u_spath_flip, video_name), u_feature_flip)\\n np.save(os.path.join(v_spath, video_name), v_feature)\\n np.save(os.path.join(v_spath_flip, video_name), v_feature_flip)\\n\\n print(time.time() - start)\",\n \"def process_video(data_info, name, mode, is_training=True):\\r\\n data = Action_Dataset(name, mode, [data_info])\\r\\n if is_training:\\r\\n clip_seq, label_seq = data.next_batch(1, _CLIP_SIZE)\\r\\n else:\\r\\n clip_seq, label_seq = data.next_batch(\\r\\n 1, _EACH_VIDEO_TEST_SIZE+1, shuffle=False, data_augment=False)\\r\\n clip_seq = 2*(clip_seq/255) - 1\\r\\n clip_seq = np.array(clip_seq, dtype='float32')\\r\\n return clip_seq, label_seq\",\n \"def process_vid_file(vid_file):\\n # dict that holds params for matching\\n params = {}\\n # scale for motion estimation\\n params['fScale'] = 1.0\\n # number of descriptors\\n params['nFeat'] = 2000\\n # minimal number of descriptors\\n params['nMinKp'] = 50\\n # minimal number of matched descriptors\\n params['nMinMatch'] = 30\\n # maximum offset in flow \\n params['fVhThresh'] = 32.0\\n # params for image quality (motion blur)\\n params['fQualityThresh'] = 5.0\\n params['fQualityRatio'] = 0.2\\n\\n # get video stats\\n video_name = os.path.basename(vid_file[:-4])\\n video_name.replace(' ', '')\\n output_frame_list = []\\n output_homography = []\\n frame_index = 0\\n\\n # open video file\\n cap = cv2.VideoCapture(vid_file)\\n if not cap.isOpened():\\n print \\\"Can not open video file: {:s}\\\".format(vid_file)\\n return frame_pairs\\n \\n # fetch the first frame\\n ret, prev_frame = cap.read()\\n if (not ret) or (prev_frame is None):\\n print \\\"Can not read video file: {:s}\\\".format(vid_file)\\n\\n start = time.time()\\n\\n # loop over all frames\\n while(True):\\n\\n # increase the counter\\n frame_index += 1\\n\\n # read current frame\\n ret, frame = cap.read()\\n\\n # end of file?\\n if (not ret) or (prev_frame is None):\\n break\\n\\n # match the frames\\n M = match_frames(prev_frame, frame, params)\\n\\n # copy to previous frame\\n prev_frame = frame.copy()\\n\\n # save the frame number and the homography\\n if len(M) > 0:\\n output_frame_list.append(frame_index)\\n output_homography.append(M)\\n if len(output_homography) == 1:\\n output_homography.append(M)\\n # timing\\n end = time.time()\\n print \\\"Averge time per frame: {:2f} s. \\\".format(float(end-start)/frame_index)\\n print \\\"{:2d} valid frame pairs out of {:2d} total pairs\\\".format(len(output_frame_list), frame_index-1)\\n \\n return output_frame_list, output_homography\",\n \"def startVideo(self,fname):\\n\\n\\n try:\\n fourcc = cv2.cv.CV_FOURCC(*'DIVX')\\n\\n except Exception as e:\\n #print \\\"Exception \\\",e.args\\n fourcc = cv2.VideoWriter_fourcc(*'DIVX')\\n\\n self.video = cv2.VideoWriter(fname, fourcc, 10, (self.screenWidth, self.screenHeight))\\n if self.video is None:\\n print \\\"VideoWriter failed to start.\\\"\\n else:\\n print \\\"VideoWriter started ok\\\"\",\n \"def start_ffmpeg_record(stream, stream_url, formatted_date):\\n filename = stream + '_' + formatted_date\\n save_video_dir = 'rover_stream/' + stream\\n subprocess.Popen(['mkdir rover_stream'], shell=True)\\n subprocess.Popen(['mkdir ' + save_video_dir], shell=True)\\n proc_video[stream] = subprocess.Popen(['ffmpeg -i ' + stream_url + ' -acodec copy -vcodec copy ' + save_video_dir + '/' + filename + '.mp4'], stdin=PIPE, shell=True)\",\n \"def find_cars_video(input_path, output_path, clf, hyperparams, box_color=None, debug=False):\\n v = VideoProcessor(clf, hyperparams, box_color)\\n v.process_video(input_path, output_path, debug)\",\n \"def extract_faces(frame_path, out_path, face_path, processes=1):\\n if os.path.exists(out_path):\\n msg = '[extract_faces] Skipping extraction since faces already exist at {}'\\n print(msg.format(out_path))\\n return\\n\\n from faceoff.faceswap_api import FaceSwapInterface\\n\\n os.makedirs(out_path)\\n print('[extract_faces] Starting on {}'.format(frame_path))\\n start_time = time.time()\\n\\n api = FaceSwapInterface()\\n api.extract(frame_path, out_path, face_path, processes)\",\n \"def video2img(video, csv, output_path, match):\\n with open(csv, 'r') as file:\\n lines = file.readlines()[1:]\\n\\n csv_content = []\\n for line in lines:\\n frame, vis, x, y = line.strip().split(',')\\n csv_content.append((int(frame), int(vis), float(x), float(y)))\\n\\n name_split = os.path.split(video)\\n name = \\\"match%d\\\"%(match) + '_' + name_split[-1][:-4]\\n\\n count = 0\\n num_data = len(csv_content)\\n cap = cv2.VideoCapture(video)\\n success, image = cap.read()\\n ratio = image.shape[0]/HEIGHT\\n while success:\\n if count >= num_data:\\n break\\n label = csv_content[count]\\n if label[1] == 0:\\n heat_map = genHeatMap(WIDTH, HEIGHT, -1, -1, sigma, mag)\\n else:\\n heat_map = genHeatMap(WIDTH, HEIGHT, int(label[2]/ratio), int(label[3]/ratio), sigma, mag)\\n \\n image = cv2.resize(image, (WIDTH, HEIGHT))\\n heat_map = (heat_map*255).astype('uint8')\\n cv2.imwrite(os.sep.join([output_path, 'x_data', name+'_%d.jpg' %(count)]), image)\\n cv2.imwrite(os.sep.join([output_path, 'y_data', name+'_%d.jpg' %(count)]), heat_map)\\n success, image = cap.read()\\n count += 1\",\n \"def make_seret(processed_files_directory='files/',fps=5):\\r\\n # Sort files in processed images directory\\r\\n files = sort_files(processed_files_directory)\\r\\n # Create list as container for the movie.\\r\\n img_array = []\\r\\n # For each file\\r\\n for file in files:\\r\\n file_format = file.split(\\\".\\\")\\r\\n if file_format[-1] == 'jpg': # verify that we will include jpg files only in the movie\\r\\n # Read the file\\r\\n img = cv2.imread(file)\\r\\n # Extract height, width, channels from image\\r\\n height, width, layers = img.shape\\r\\n # size = (width, height)\\r\\n size = (width, height)\\r\\n # Append image to movie container\\r\\n img_array.append(img)\\r\\n # Create a video writer for the movie\\r\\n out = cv2.VideoWriter(processed_files_directory+'initial.avi', cv2.VideoWriter_fourcc(*'DIVX'), fps, size)\\r\\n # For each image in container\\r\\n for image in img_array:\\r\\n # Write image by video writer\\r\\n out.write(image)\\r\\n # Release video writer.\\r\\n out.release()\",\n \"def write_proposals_to_video(self, vdir, frms_per_sec=1.0):\\n # Input video\\n vid_name = self.props['vname']\\n vfpath = fdops.get_files_with_kws(vdir, [vid_name, \\\".mp4\\\"])\\n if len(vfpath) > 1:\\n raise Exception(f\\\"More than one video found\\\\n\\\\t{vfpath}\\\")\\n vin = VidReader(vfpath[0])\\n\\n # Output video\\n ovid_path = f\\\"{self.props['loc']}/{self.props['name']}.mp4\\\"\\n vw = skvideo.io.FFmpegWriter(\\n ovid_path,\\n outputdict={'-vcodec': 'libx264','-r':'30'}\\n )\\n\\n # Calculate frame numbers(POC) that we will use.\\n f0_start = 0 # starting frame poc\\n f0_end = vin.props['num_frames'] - 1 # ending frame poc\\n f0_skip = vin.props['frame_rate']*(1/frms_per_sec)\\n f0s = list(range(f0_start, f0_end, int(f0_skip)))\\n\\n # Loop over each frame number and draw proposal regions\\n # over them\\n for f0 in tqdm(f0s):\\n frm = vin.get_frame(f0, c='bgr')\\n\\n # Get proposals for frame f0\\n props = self._get_proposals_for_frame(f0)\\n\\n # Proposals looop\\n for p in props:\\n if len(p) > 0:\\n w0, h0, w, h = p\\n frame = cv2.rectangle(\\n frm, (w0, h0), (w0+w, h0+h), (0, 256, 0), 1\\n )\\n # Write frame to output\\n vw.writeFrame(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))\\n\\n vw.close()\\n vin.release()\\n import sys; sys.exit()\",\n \"def reencode(filepath, loglevel='panic'):\\n try:\\n import ffmpeg\\n except ImportError:\\n logger.error(\\n 'Import Error! Cant import ffmpeg. '\\n 'Annotations operations will be limited. import manually and fix errors')\\n raise\\n if not os.path.isfile(filepath):\\n raise IOError('File doesnt exists: {}'.format(filepath))\\n # re encode video without b frame and as mp4\\n basename, ext = os.path.splitext(filepath)\\n output_filepath = os.path.join(basename, os.path.basename(filepath).replace(ext, '.mp4'))\\n if not os.path.isdir(os.path.dirname(output_filepath)):\\n os.makedirs(os.path.dirname(output_filepath))\\n try:\\n stream = ffmpeg.input(filepath, **{'loglevel': loglevel}).output(output_filepath,\\n **{'x264opts': 'bframes=0',\\n 'f': 'mp4'})\\n ffmpeg.overwrite_output(stream).run()\\n except Exception as e:\\n logger.exception('ffmpeg error in disassemble:')\\n raise\\n\\n output_probe = Videos.get_info(output_filepath)\\n start_time = eval(output_probe['streams'][0]['start_time'])\\n fps = eval(output_probe['streams'][0]['avg_frame_rate'])\\n has_b_frames = output_probe['streams'][0]['has_b_frames']\\n start_frame = fps * start_time\\n if start_time != 0:\\n logger.warning('Video start_time is not 0!')\\n if has_b_frames != 0:\\n logger.warning('Video still has b frames!')\\n return output_filepath\",\n \"def make_movie(field='uu1', datadir='data/', proc=-1, extension='xz',\\n format='native', tmin=0., tmax=1.e38, amin=0., amax=1.,\\n transform='', oldfile=False):\\n\\n import pylab as plt\\n\\n datadir = os.path.expanduser(datadir)\\n if proc < 0:\\n filename = datadir + '/slice_' + field + '.' + extension\\n else:\\n filename = datadir + '/proc' + \\\\\\n str(proc) + '/slice_' + field + '.' + extension\\n\\n # Read the global dimensions.\\n dim = read_dim(datadir, proc)\\n if dim.precision == 'D':\\n precision = 'd'\\n else:\\n precision = 'f'\\n\\n # Set up slice plane.\\n if extension == 'xy' or extension == 'Xy':\\n hsize = dim.nx\\n vsize = dim.ny\\n if extension == 'xz':\\n hsize = dim.nx\\n vsize = dim.nz\\n if extension == 'yz':\\n hsize = dim.ny\\n vsize = dim.nz\\n plane = np.zeros((vsize, hsize), dtype=precision)\\n\\n infile = npfile(filename, endian=format)\\n\\n files = []\\n fig = plt.figure(figsize=(5, 10))\\n ax = fig.add_subplot(111)\\n\\n ifirst = True\\n islice = 0\\n while True:\\n try:\\n raw_data = infile.fort_read(precision)\\n except ValueError:\\n break\\n except TypeError:\\n break\\n\\n if oldfile:\\n t = raw_data[-1]\\n plane = raw_data[:-1].reshape(vsize, hsize)\\n else:\\n t = raw_data[-2]\\n plane = raw_data[:-2].reshape(vsize, hsize)\\n\\n if transform:\\n exec('plane = plane' + transform)\\n\\n if t > tmin and t < tmax:\\n ax.cla()\\n ax.imshow(plane, vmin=amin, vmax=amax)\\n fname = '_tmp%03d.png' % islice\\n print('Saving frame' + fname)\\n fig.savefig(fname)\\n files.append(fname)\\n\\n if ifirst:\\n #print \\\"----islice----------t---------min-------max-------delta\\\" # Python 2\\n print(\\\"----islice----------t---------min-------max-------delta\\\")\\n #print \\\"%10i %10.3e %10.3e %10.3e %10.3e\\\" % \\\\ # Python 2\\n #(islice, t, plane.min(), plane.max(), plane.max() - plane.min()) # Python 2\\n print(\\\"{0:10} {1:10.3e} {2:10.3e} {3:10.3e} {4:10.3e}\\\".format(islice, t, plane.min(), plane.max(), plane.max() - plane.min()))\\n\\n ifirst = False\\n islice += 1\\n\\n #print 'Making movie animation.mpg - this make take a while'\\n print('Making movie animation.mpg - this make take a while')\\n # SC: Not all systems use mencoder. Need to change this into ffmpeg.\\n os.system(\\\"mencoder 'mf://_tmp*.png' -mf type=png:fps=24 -ovc lavc -lavcopts vcodec=wmv2 -oac copy -o animation.mpg\\\")\\n os.system(\\\"rm _tmp*.png\\\")\\n infile.close()\",\n \"def process_videos(chapter_info):\\n\\n print(\\\"Processing chapter_info:\\\", chapter_info)\\n\\n # getting creation time of the first chapter\\n # TODO update when adding multiple directory proccessing\\n os.chdir(DIR_VIDEO_FILES)\\n print(\\\"1st chapter\\\", chapter_info[1][0])\\n chap1_time = time.strftime(\\n r\\\"%Y-%m-%d_%H-%M\\\", time.localtime(os.path.getctime(chapter_info[1][0])))\\n print(\\\"1st chapter creation\\\", chap1_time)\\n\\n # output_file = f\\\"M_GH00{chapter_info[0]}_{chap1_time}.MP4\\\"\\n output_file = f\\\"{chap1_time}_GH00{chapter_info[0]}_MRG.MP4\\\"\\n if os.path.isfile(output_file):\\n print(f\\\"Chapter already processed, found file: {output_file}\\\")\\n return\\n\\n # preparing text file containing file list for merging (for ffmpeg)\\n video_list_file = chapter_info[0] + \\\"_merge.txt\\\"\\n with open(video_list_file, \\\"w\\\") as f:\\n for video_chapter in chapter_info[1]:\\n f.write(f\\\"file {video_chapter}\\\\n\\\")\\n\\n command = f\\\"{FFMPEG_EXE} -f concat -i {video_list_file} -c copy {DIR_OUTPUT}{output_file}\\\"\\n print(\\\"command =\\\", command)\\n # p = subprocess.run(\\\"dir\\\", shell=True, capture_output=True)\\n # p = subprocess.run(\\\"dir\\\", shell=True, stdout=subprocess.PIPE, text=True)\\n p = subprocess.run(command, stdout=subprocess.PIPE, text=True)\\n print(\\\"returncode =\\\", p.returncode)\\n # print(\\\"stdout =\\\", p.stdout)\\n os.remove(video_list_file) # remove file list after merging\\n # rename original chapters after processing\\n for video_chapter in chapter_info[1]:\\n os.rename(video_chapter, f\\\"OK_{video_chapter}\\\")\",\n \"def video_files():\\n p = parse_cmdline(get_parser=get_parser_files)\\n log.setup_main_handler(\\n mods=(\\\"fogtools\\\", \\\"typhon\\\", \\\"fogpy\\\", \\\"sattools\\\", \\\"fcitools\\\", \\\"satpy\\\",\\n \\\"pyresample\\\"),\\n level=logging.INFO)\\n vis.show_video_abi_glm(\\n files=p.files,\\n img_out=p.filename_pattern_image,\\n vid_out=p.filename_pattern_video,\\n out_dir=p.outdir)\\n print(\\\"Files written to:\\\", p.outdir)\",\n \"def __merge_ts_by_ffmepg(self, local_m3u8_path, video_name):\\n try:\\n command = 'ffmpeg -allowed_extensions ALL -i {} -c copy -y {}'.format(local_m3u8_path, video_name)\\n print(command)\\n os.system(command)\\n print('merge succeed.')\\n except:\\n print('merge failed.')\",\n \"def process_data(self, clip_name) -> Preprocessor:\\n\\n config: Config = Config.get_config()\\n\\n folder_name = config.video_data\\n video_data_file = ''.join(clip_name.split('.')[:-1]) + '.json'\\n video = Video.from_json(os.path.join(folder_name, video_data_file))\\n\\n # Convert to usable data type period_running_person division, alle fragment soorten\\n preprocessor = Preprocessor(video)\\n\\n return preprocessor\",\n \"def prepare_video(path_to_video: str, number_of_images=87) -> None:\\n\\n temp_video = path.join(path_to_video, 'temp_outpy.mp4')\\n video = path.join(path_to_video, 'outpy.h264')\\n\\n # create mp4 video for metadata and compute video duration\\n subprocess.run(['ffmpeg', '-i', video, '-c', 'copy', temp_video])\\n result = subprocess.run([\\\"ffprobe\\\", \\\"-v\\\", \\\"error\\\", \\\"-show_entries\\\",\\n \\\"format=duration\\\", \\\"-of\\\",\\n \\\"default=noprint_wrappers=1:nokey=1\\\", temp_video],\\n stdout=subprocess.PIPE,\\n stderr=subprocess.STDOUT)\\n video_duration = float(result.stdout)\\n\\n # create images folder\\n path_to_images = path.join(path_to_video, 'images')\\n if path.exists(path_to_images) and path.isdir(path_to_images):\\n shutil.rmtree(path_to_images)\\n makedirs(path_to_images)\\n\\n # split the given video into images\\n subprocess.run(['ffmpeg', '-i', temp_video, '-r', str(number_of_images / video_duration), '-f', 'image2',\\n path.join(path_to_images, 'image%d.jpg')])\\n\\n # remove extra files\\n remove_extra_images(path_to_images, number_of_images)\\n remove(temp_video)\",\n \"def on_movie(self):\\n path = os.path.normcase(self.pMov)\\n os.system('\\\"%s\\\"' % path)\",\n \"def make_video(self, mp4=True, gif=True):\\n fn = self.get_output_filename(\\\".mp4\\\")\\n command = (\\n (get_ffmpeg_path() + f\\\" -loglevel panic -framerate {self.framerate} -i \\\")\\n + os.path.join(self.frame_directory, FRAME_FN_TEMPLATE)\\n + \\\" -s:v \\\"\\n + str(self.width)\\n + \\\"x\\\"\\n + str(self.height)\\n + \\\" -c:v libx264 -profile:v high -crf 1 -pix_fmt yuv420p -y \\\"\\n + fn\\n )\\n\\n os.system(command)\\n\\n if gif:\\n mp4_to_gif(\\n self.get_output_filename(\\\".mp4\\\"),\\n self.get_output_filename(\\\".gif\\\"),\\n self.framerate,\\n )\\n\\n if not mp4:\\n os.remove(fn)\",\n \"def __init__(self, pn_output=\\\"./\\\"):\\n # Initialize the video stream, then allow the camera sensor to warm up\\n print(\\\"[INFO] starting video stream...\\\")\\n self.vs = cv2.VideoCapture(0) # Capture video frames, 0 is default video camera\\n time.sleep(2.0)\\n\\n # Load config\\n config = configparser.ConfigParser()\\n config.read(fn_config)\\n self.pn_guest_images = config['DEFAULT']['pn_guest_images_archive']\\n self.guest_archive = p7zip(self.pn_guest_images)\\n self.camera_rot = int(config['DEFAULT']['camera_rot'])\\n self.image_width = int(config['DEFAULT']['image_width'])\\n self.max_capture_interval = float(config['DEFAULT']['capture_interval'])\\n self.max_capture_length = int(config['DEFAULT']['max_capture_length'])\\n self.max_images = int(config['DEFAULT']['max_images'])\\n\\n # Capture Vars\\n self.curr_pic = None # Current image from the camera\\n self.gst_capture = None\\n self.start_time = time.time()\\n self.save_time = time.time()\\n self.pic_num = None\\n self.pn_gstcap_out = None\\n\\n # Face Detection Model\\n self.min_detec_conf = float(config['DEFAULT']['min_detec_conf'])\\n self.min_face_px = make_tuple(config['DEFAULT']['min_face_px'])\\n pn_detector_model = config['DEFAULT']['pn_detector_model']\\n self.trainRBGavg = make_tuple(config['DEFAULT']['detector_trainrgbavg'])\\n print(\\\"[INFO] loading face detector and embedding model...\\\")\\n protoPath = os.path.sep.join([pn_detector_model, \\\"deploy.prototxt\\\"])\\n modelPath = os.path.sep.join([pn_detector_model,\\n \\\"res10_300x300_ssd_iter_140000.caffemodel\\\"])\\n self.detector = cv2.dnn.readNetFromCaffe(protoPath, modelPath)\\n self.detector.setPreferableTarget(cv2.dnn.DNN_TARGET_CPU)\\n\\n # Face Recognition (extract/recognize embeddings) Model\\n self.min_recog_prob = float(config['DEFAULT']['min_recog_prob'])\\n fn_embedding_model = config['DEFAULT']['fn_embedding_model']\\n self.embedder = cv2.dnn.readNetFromTorch(fn_embedding_model)\\n self.embedder.setPreferableTarget(cv2.dnn.DNN_TARGET_CPU)\\n self.gst_identify = False\\n self.guest_ids = {}\\n\\n # Guest Info (update outside of function)\\n self.known_guest_meta = None\",\n \"def create_video_output_path(output_dir, cfg):\\n filename = os.path.join(output_dir, cfg['video']['output']) + '{}.mp4'\\n # If a file of this name exists increase the counter by 1\\n counter = 0\\n while os.path.isfile(filename.format(counter)):\\n counter += 1\\n # Apply counter to filename\\n return filename.format(counter)\",\n \"def take_one_shot(path_to_images, name_image, video_source=\\\"/dev/video0\\\"):\\n subprocess_cmd(\\\"ffmpeg -f video4linux2 -s 1280x720 -i {} -frames 1 ./{}/{} -loglevel error -nostats\\\".format(video_source, path_to_images, name_image))\",\n \"def _map_fb_memory(fbfid, fix_info):\\n return mmap.mmap(fbfid, fix_info.smem_len, mmap.MAP_SHARED, mmap.PROT_READ | mmap.PROT_WRITE, offset=0)\",\n \"def save_video(foldername, songname, songlen, num_steps, output):\\n num_steps_by_len = num_steps / songlen\\n p = subprocess.Popen(['ffmpeg', '-f', 'image2', '-r', str(num_steps_by_len), '-i', '%d.png', '-c:v', 'libx264', '-pix_fmt', 'yuv420p', '-vf', 'pad=ceil(iw/2)*2:ceil(ih/2)*2', 'movie.mp4'], cwd=foldername)\\n p.wait()\\n\\n p = subprocess.Popen(['ffmpeg', '-i', 'movie.mp4', '-i', '../audio_files/' + songname + '.mp3', '-map', '0:v', '-map', '1:a', '-c', 'copy', output], cwd=foldername)\\n p.wait()\",\n \"def do_add_ink():\\n clip = mpy.VideoClip(mix_video_ink, duration=13.0)\\n clip.write_videofile(\\\"test_edited.mp4\\\", fps=24)\",\n \"def get_output_file(self, path, fps=30):\\n return cv2.VideoWriter(\\n filename=path,\\n fourcc=cv2.VideoWriter_fourcc(*\\\"mp4v\\\"),\\n fps=float(fps),\\n frameSize=(self.display_width, self.display_height),\\n isColor=True,\\n )\",\n \"def process(in_path, out_path, mouth_height=50, mouth_width=50, frame_dur=1, capture_frame=None, out_img=None, show_boxes=True):\\n # Get video capture from in_path.\\n vc = cv2.VideoCapture(in_path) \\n\\n rval, frame = vc.read() if vc.isOpened() else (False, None)\\n\\n mouth_images = []\\n\\n #import pdb; pdb.set_trace()\\n\\n if rval:\\n mouths = np.empty((0, mouth_height, mouth_width, frame.shape[2]))\\n else:\\n return # Skip this video since CV2 can't open it\\n\\n frame_no = 0\\n while rval:\\n if DEBUG:\\n # Copy of original frame, for annotating.\\n image = frame.copy()\\n\\n try:\\n face_rect = locate_face(frame)\\n except ValueError:\\n print \\\"No face found for %s at frame %d. Skipping.\\\" % (in_path, frame_no)\\n vc.release()\\n return # Skip this video.\\n\\n if DEBUG:\\n highlight_rect(image, face_rect, color=(255,255,255), thickness=2)\\n\\n mouth_rects = locate_mouth(frame)\\n mouth = uniform_rect(select_mouth_candidate(mouth_rects, face_rect), face_rect, 50, 50)\\n if not mouth:\\n print \\\"No face found for %s at frame %d. Skipping.\\\" % (in_path, frame_no)\\n vc.release()\\n return # Skip this video.\\n\\n mouth_image = frame[mouth[1]:(mouth[1] + mouth[3]), mouth[0]:(mouth[0] + mouth[2]), :]\\n mouth_images.append(mouth_image) \\n\\n if DEBUG:\\n highlight_rect(image, mouth, color=(0,0,0), thickness=2) \\n #cv2.imshow('Frame', mouth_image)\\n cv2.imshow('Frame', image if show_boxes else frame)\\n\\n if frame_no == capture_frame:\\n cv2.imwrite(out_img, image if show_boxes else frame)\\n return\\n\\n cv2.waitKey(frame_dur)\\n\\n rval, frame = vc.read()\\n frame_no += 1\\n\\n vc.release()\\n\\n mouths = np.asarray(mouth_images)\\n\\n savemat(out_path, {\\\"mouths\\\": mouths})\",\n \"def _post_proc_para_wrapper(pred_map_mmap_path, tile_info, func, func_kwargs):\\n idx, tile_tl, tile_br = tile_info\\n wsi_pred_map_ptr = np.load(pred_map_mmap_path, mmap_mode=\\\"r\\\")\\n tile_pred_map = wsi_pred_map_ptr[tile_tl[0] : tile_br[0], tile_tl[1] : tile_br[1]]\\n tile_pred_map = np.array(tile_pred_map) # from mmap to ram\\n return func(tile_pred_map, **func_kwargs), tile_info\",\n \"def extract_vob(in_vob, guid):\\n\\t#Detect interlacing.\\n\\tmediainfo_command = \\\"mediainfo --Inform='Video;%ScanType%,%ScanOrder%' \\\" + in_vob\\n\\tprint(mediainfo_command)\\n\\tprocess = subprocess.Popen(mediainfo_command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)\\n\\t(cout, cerr) = process.communicate()\\n\\texit_code = process.wait()\\n\\tif exit_code != 0:\\n\\t\\traise Exception(\\\"Calling Mediainfo on {in_vob} failed with exit code {exit_code}.\\\".format(in_vob=in_vob, exit_code=exit_code))\\n\\tmediainfo_parts = cout.decode(\\\"utf-8\\\").split(\\\",\\\")\\n\\tis_interlaced = mediainfo_parts[0] == \\\"Interlaced\\\"\\n\\tfield_order = mediainfo_parts[1].lower().strip()\\n\\tprint(\\\"Interlace detection:\\\", is_interlaced, field_order, \\\"(\\\", mediainfo_parts, \\\")\\\")\\n\\n\\tffmpeg_command = [\\\"ffmpeg\\\", \\\"-i\\\", in_vob]\\n\\tprint(ffmpeg_command)\\n\\tprocess = subprocess.Popen(ffmpeg_command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)\\n\\t(cout, cerr) = process.communicate()\\n\\tprocess.wait() #Ignore the exit code. It always fails.\\n\\tvobinfo = cerr.decode(\\\"utf-8\\\")\\n\\ttracks = []\\n\\tfor match in re.finditer(r\\\" Stream #0:(\\\\d+)\\\\[0x[0-9a-f]+\\\\]: (\\\\w+): ([^\\\\n]+)\\\", vobinfo):\\n\\t\\ttrack_nr = match.group(1)\\n\\t\\ttrack_type = match.group(2)\\n\\t\\ttrack_codec = match.group(3)\\n\\t\\tnew_track = track.Track()\\n\\t\\tnew_track.from_vob(track_nr, track_type, track_codec, is_interlaced, field_order)\\n\\t\\tnew_track.file_name = guid + \\\"-T\\\" + str(new_track.track_nr) + \\\".\\\" + new_track.codec\\n\\t\\tif new_track.type != \\\"unknown\\\":\\n\\t\\t\\ttracks.append(new_track)\\n\\n\\t#Generate the parameters to pass to ffmpeg.\\n\\ttrack_params = [\\\"-i\\\", in_vob]\\n\\tfor track_metadata in tracks:\\n\\t\\ttrack_params.append(\\\"-map\\\")\\n\\t\\ttrack_params.append(\\\"0:\\\" + str(track_metadata.track_nr))\\n\\t\\ttrack_params.append(\\\"-c\\\")\\n\\t\\ttrack_params.append(\\\"copy\\\")\\n\\t\\ttrack_params.append(track_metadata.file_name)\\n\\n\\t#Extract all tracks.\\n\\tprint(\\\"---- Extracting tracks...\\\")\\n\\tffmpeg(*track_params)\\n\\n\\treturn tracks\",\n \"def heatmap_video(path_in, path_out, frames_sec = 2, thresh = 2, maxValue = 3):\\n\\n cap = cv2.VideoCapture(path_in)\\n fgbg = cv2.bgsegm.createBackgroundSubtractorMOG()\\n\\n num_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))\\n fps = cap.get(cv2.CAP_PROP_FPS) # frames per second\\n duration = round(num_frames / fps, 2) # duration of the video in seconds\\n print('Total number of frames to process: {}'.format(num_frames))\\n print('Duration of the video in seconds: {}'.format(duration))\\n step = round(fps / frames_sec)\\n\\n first_iteration_indicator = 1\\n for i in range(0, num_frames, step):\\n\\n if (first_iteration_indicator == 1):\\n ret, frame = cap.read()\\n first_frame = copy.deepcopy(frame)\\n gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\\n height, width = gray.shape[:2]\\n accum_image = np.zeros((height, width), np.uint8)\\n first_iteration_indicator = 0\\n\\n else:\\n cap.set(cv2.CAP_PROP_POS_FRAMES, i)\\n print('Frame process... ' + str(i) + ' of ' + str(num_frames))\\n print('Second process... ' + str(int(cap.get(cv2.CAP_PROP_POS_MSEC)) / 1000) + ' of ' + str(duration))\\n print('...')\\n ret, frame = cap.read() # read a frame\\n\\n gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) # convert to grayscale\\n\\n fgmask = fgbg.apply(gray) # remove the background\\n ret, th1 = cv2.threshold(fgmask, thresh, maxValue, cv2.THRESH_BINARY)\\n\\n # add to the accumulated image\\n accum_image = cv2.add(accum_image, th1)\\n\\n # apply a color map\\n # COLORMAP_PINK also works well, COLORMAP_BONE is acceptable if the background is dark\\n color_image = cv2.applyColorMap(accum_image, cv2.COLORMAP_HOT)\\n\\n # overlay the color mapped image to the first frame\\n result_overlay = cv2.addWeighted(first_frame, 0.7, color_image, 0.7, 0)\\n\\n # save the final overlay image\\n cv2.imwrite(path_out, result_overlay)\\n\\n # cleanup\\n cap.release()\\n cv2.destroyAllWindows()\",\n \"def main(path):\\n logger.info(f'Processing video file {path}')\\n # Extract audio\\n audio_file = extract_audio(path, pipeline_config.audio_target_dir)\\n\\n # Generate sound classification results and speech recogniser results\\n sound_results = SoundRecogniser().process_file(audio_file)\\n sound_results = process_overlap(sound_results)\\n speech_results = SpeechRecogniser().process_file(audio_file)\\n\\n # NLP\\n wrds = get_words(speech_results)\\n nlp = SpaCyNaturalLanguageProcessor(pipeline_config.spacy_model)\\n custom_nlp = SpaCyNaturalLanguageProcessor(pipeline_config.custom_spacy_model)\\n processor = nlp.get_spacy_results_processor(wrds, speech_results)\\n custom_processor = custom_nlp.get_spacy_results_processor(wrds, speech_results)\\n chunk_results = processor.process_speech_results_chunk()\\n ner_results = processor.process_speech_results_ner()\\n ner_results.extend(custom_processor.process_speech_results_ner())\\n match_results = processor.process_speech_results_match()\\n speech_results = nlp.process_spurious_words(speech_results, chunk_results)\\n\\n # Add Speech recogniser results, sound classification results and NLP results to a subtitle file\\n subs_1 = save_to_subtitles(speech_results,\\n lambda speech_result: speech_result['word'])\\n subs_1 = compress_subs(subs_1)\\n subs_2 = save_to_subtitles(sound_results,\\n lambda sound_result: sound_result['class'])\\n subs_2 = flatten_subs(subs_2)\\n subs_3 = save_to_subtitles(chunk_results,\\n lambda chunk_result: f'{chunk_result[\\\"word\\\"]} ({chunk_result[\\\"head\\\"]})')\\n subs_4 = save_to_subtitles(ner_results,\\n lambda ner_result: f'{ner_result[\\\"type\\\"]} {ner_result[\\\"word\\\"]}')\\n subs_5 = save_to_subtitles(match_results,\\n lambda match_result: match_result[\\\"word\\\"])\\n\\n combined_subs = append_subs(None, subs_1, style='bottom')\\n combined_subs = append_subs(combined_subs, subs_2, exclude=['bottom'], style='top', formatter=lambda x: f'({x})')\\n combined_subs = append_subs(combined_subs, subs_3, style='left')\\n combined_subs = append_subs(combined_subs, subs_4, style='right')\\n combined_subs = append_subs(combined_subs, subs_5, style='bottom_left_pred')\\n combined_subs = remove_tiny_subs(combined_subs, duration_millis=1000, left_millis=None,\\n right_millis=None, style='top')\\n subtitle_file_name = os.path.splitext(path)[0] + '.ass'\\n create_styles(combined_subs)\\n combined_subs.save(subtitle_file_name)\\n\\n # Burn to a video\\n burn_subtitles_into_video(path, subtitle_file_name, pipeline_config.audio_target_dir)\\n logger.info(f'Done processing {audio_file}')\",\n \"def load(fidfile, procfile):\\r\\n dic, data = _ng.varian.read_fid(fidfile)\\r\\n procs = _ng.varian.read_procpar(procfile)\\r\\n\\r\\n offset = [float(i) for i in procs['tof']['values']][0]\\r\\n magfreq = [float(i) for i in procs['sfrq']['values']][0]\\r\\n rangeHz = [float(i) for i in procs['sw']['values']][0]\\r\\n\\r\\n rangeppm = rangeHz / magfreq\\r\\n offsetppm = offset / magfreq\\r\\n\\r\\n # Fourier transform\\r\\n data = _ng.proc_base.fft(data)\\r\\n data = data / _np.max(data)\\r\\n\\r\\n u = data.real.sum(axis=0)\\r\\n v = data.imag.sum(axis=0)\\r\\n\\r\\n w = _np.linspace(rangeppm - offsetppm, -offsetppm, u.size)\\r\\n\\r\\n result = _containers.Data(w[::-1], u[::-1], v[::-1])\\r\\n return result\",\n \"def main():\\n global tmpl_ball, pocket_templates, pocket_markers, last_best_cueball, last_confirmed_cueball, CURRENT_FRAME, out_file\\n\\n start_time = datetime.datetime.now()\\n\\n # Open output files\\n\\n out_file = open(here(\\\"confirmed_cueballs.txt\\\"), 'w')\\n\\n # Initialize pygame\\n\\n pygame.init()\\n pygame.display.set_caption(\\\"Snooker - main info window\\\")\\n window = pygame.display.set_mode((704, 400))\\n\\n # Load and initialize template images\\n\\n tmpl_ball = cvLoadImage(BALL_TMPL, CV_LOAD_IMAGE_COLOR)\\n if not tmpl_ball:\\n raise Exception(\\\"Failed to load ball template image\\\")\\n\\n # Load pocket templates, find marker pixel in template and remember it\\n\\n for pocket in ['tl', 'tr', 'bl', 'br']: \\n pocket_tmpl = cvLoadImage(globals()['POCKET_%s_TMPL' % pocket.upper()], CV_LOAD_IMAGE_COLOR)\\n if not pocket_tmpl:\\n raise Exception(\\\"Failed to load pocket '%s' template\\\" % pocket)\\n pocket_templates[pocket] = pocket_tmpl\\n pocket_markers[pocket] = findpixel(pocket_tmpl, cvScalar(255, 0, 255))\\n if pocket_markers[pocket]:\\n if DEBUG: print(\\\"Found marker for pocket %s at %d:%d\\\" % \\n (pocket.upper(), pocket_markers[pocket].x, pocket_markers[pocket].y))\\n\\n stream = pyffmpeg.VideoStream()\\n\\n stream.open(VIDEO_FILE)\\n\\n fps = stream.tv.get_fps()\\n duration_f = stream.tv.duration()\\n\\n start_frame = int(START*fps)\\n end_frame = int(END*fps)\\n interval = int(INTERVAL*fps)\\n\\n length = float(end_frame-start_frame)/float(fps) # Seconds\\n\\n i = start_frame\\n\\n while i < end_frame:\\n CURRENT_FRAME = i\\n\\n # Calculate info about the total progress and display it\\n\\n percentage = float(i-start_frame)/float(end_frame-start_frame)*100.0\\n estimated_length = 0\\n if i > start_frame:\\n estimated_length = float(total_seconds((datetime.datetime.now()-start_time))) / percentage * 100.0\\n\\n print(\\\"Frame #%d (%d-%d) %.1f%%\\\" % (i, start_frame, end_frame, percentage))\\n pygame.display.set_caption(\\\"Snooker - main info window - Frame %d - %.1f%% (est. total %.1fmin)\\\" % (i, percentage, estimated_length/60.0))\\n\\n image = stream.GetFrameNo(i)\\n image_ipl = adaptors.PIL2Ipl(image)\\n\\n table = get_table(image_ipl)\\n cueballs = None\\n best_ball = None\\n\\n if table:\\n cueballs = find_cueballs(image_ipl, table)\\n\\n if cueballs:\\n\\n # See if the best cueball we found now, is the best cueball found in the previous run,\\n # which would mean that it's standing still. Only consider the best matches.\\n\\n if not last_best_cueball:\\n last_best_cueball = cueballs[0]\\n else:\\n\\n distance_to_last = math.sqrt( (last_best_cueball.x-cueballs[0].x)**2 + (last_best_cueball.y-cueballs[0].y)**2 )\\n distance_to_last_confirmed = math.sqrt( (last_confirmed_cueball.x-cueballs[0].x)**2 + \\n (last_confirmed_cueball.y-cueballs[0].y)**2 )\\n\\n if distance_to_last < CUEBALL_CONFIRM_DISTANCE and distance_to_last_confirmed > CUEBALL_NOMOVEMENT_DISTANCE:\\n if cueballs[0].confidence >= 0.72: # Extra check to remove most of the false positives\\n # CONFIRMED\\n last_confirmed_cueball = cueballs[0]\\n cueballs[0].confirmed = True\\n if DEBUG: print(\\\"CONFIRMED cueball %s\\\" % cueballs[0])\\n else:\\n if DEBUG: print(\\\"Dropped the ball because distance condition failed: %.2f<%d and %.2f>%d\\\" % \\n (distance_to_last, CUEBALL_CONFIRM_DISTANCE, \\n distance_to_last_confirmed, CUEBALL_NOMOVEMENT_DISTANCE))\\n\\n # If confirmation or sequence fail, reset and try the whole thing again\\n last_best_cueball = False\\n\\n image_interesting = draw_interesting_stuff(image, table, cueballs)\\n\\n window.blit(image_interesting, (0,0))\\n pygame.display.flip()\\n\\n store_results(image_interesting, table, cueballs)\\n\\n for event in pygame.event.get():\\n if event.type == pygame.QUIT:\\n out_file.close()\\n sys.exit(0)\\n else:\\n pass\\n #print event\\n\\n # Skip <interval> frames\\n i += interval\\n\\n out_file.close()\",\n \"def make_video(input_files, width=0, height=0, frame_rate=24, crf=20, output_path=\\\"video.mp4\\\"):\\n if isinstance(input_files, list):\\n from PIL import Image # pylint: disable=C0415\\n\\n with Image.open(input_files[0]) as img:\\n width, height = img.size\\n tmp_dir = \\\"tmp_ffmpeg_dir\\\"\\n os.mkdir(tmp_dir)\\n if width % 2 != 0:\\n print(f\\\"Width ({width}) not divisible by 2\\\")\\n width -= 1\\n if height % 2 != 0:\\n print(f\\\"Height ({width}) not divisible by 2\\\")\\n height -= 1\\n for i, inp in enumerate(input_files):\\n shutil.copy(inp, os.path.join(tmp_dir, f\\\"{i:06d}.png\\\"))\\n inputs = f\\\"{tmp_dir}/%06d.png\\\"\\n command = ffmpeg_common_args(frame_rate, inputs, width, height, crf, output_path)\\n ret = os.system(command)\\n assert ret == 0, \\\"ffmpeg failed to generate video file.\\\"\\n for i in range(len(input_files)):\\n os.remove(os.path.join(tmp_dir, f\\\"{i:06d}.png\\\"))\\n os.rmdir(tmp_dir)\\n elif isinstance(input_files, str):\\n assert width != 0 and height != 0\\n command = ffmpeg_common_args(frame_rate, input_files, width, height, crf, output_path)\\n ret = os.system(command)\\n assert ret == 0, \\\"ffmpeg failed to generate video file.\\\"\\n else:\\n assert (\\n False\\n ), f'input_files should be list (of files) or str (of file template, e.g., \\\"%04d.png\\\") instead of {type(input_files)}'\",\n \"def new_proc(start_gdb=False, val=None):\\n p = process(binary.path)\\n if start_gdb is True:\\n attach_gdb(p)\\n return p\",\n \"def rescale_video(video_fn, w, h, fps, dir, new_dir, common_suffix, dict_video_length, ffmpeg, crf=17):\\n\\n # Output video_name\\n video_id = video_fn.replace(dir, '').replace(common_suffix, '')\\n video_fn_rescaled = video_fn.replace(dir, new_dir)\\n video_fn_rescaled = video_fn_rescaled.replace(common_suffix, common_suffix.lower())\\n\\n # Create the dir\\n video_dir_to_create = '/'.join(video_fn_rescaled.split('/')[:-1])\\n os.makedirs(video_dir_to_create, exist_ok=True)\\n\\n # Check if the file already exists\\n if os.path.isfile(video_fn_rescaled):\\n print(\\\"{} already exists\\\".format(video_fn_rescaled))\\n else:\\n subprocess.call(\\n '{ffmpeg} -i {video_input} -vf scale={w}:{h} -crf {crf} -r {fps} -y {video_output} -loglevel panic'.format(\\n ffmpeg=ffmpeg,\\n video_input=video_fn,\\n h=h,\\n w=w,\\n fps=fps,\\n video_output=video_fn_rescaled,\\n crf=crf\\n ), shell=True)\\n\\n # Get the duration of the new super_video (in sec)\\n duration_sec = get_duration(video_fn_rescaled)\\n duration_frames = int(duration_sec * fps)\\n\\n # update the dict id -> length\\n dict_video_length[video_id] = duration_frames\\n\\n return video_fn_rescaled\",\n \"def detect_from_video(config: Dict):\\n video = config['inference']['video_input']['video_input_path']\\n vp = VideoProcessing(video=video)\\n vp.generate_frames(export_path=config['inference']['video_input']['video_to_frames_export_path'])\\n if config['inference']['video_input']['video_to_frames_export_path'] == config['inference']['predicted_frames_export_path']:\\n print(\\\"[Warning]... You have given Video to frame path same as prediction output path /nPredicted output will overwrite video to frame\\\")\\n img_height = config['inference']['img_height']\\n img_width = config['inference']['img_width']\\n model = ssd_300(image_size=(img_height, img_width, 3),\\n n_classes=config['inference']['n_classes'],\\n mode='inference',\\n l2_regularization=0.0005,\\n scales=[0.1, 0.2, 0.37, 0.54, 0.71, 0.88, 1.05], # The scales for MS COCO are [0.07, 0.15, 0.33, 0.51, 0.69, 0.87, 1.05]\\n aspect_ratios_per_layer=[[1.0, 2.0, 0.5],\\n [1.0, 2.0, 0.5, 3.0, 1.0/3.0],\\n [1.0, 2.0, 0.5, 3.0, 1.0/3.0],\\n [1.0, 2.0, 0.5, 3.0, 1.0/3.0],\\n [1.0, 2.0, 0.5],\\n [1.0, 2.0, 0.5]],\\n two_boxes_for_ar1=True,\\n steps=[8, 16, 32, 64, 100, 300],\\n offsets=[0.5, 0.5, 0.5, 0.5, 0.5, 0.5],\\n clip_boxes=False,\\n variances=[0.1, 0.1, 0.2, 0.2],\\n normalize_coords=True,\\n subtract_mean=[123, 117, 104],\\n swap_channels=[2, 1, 0],\\n confidence_thresh=0.5,\\n iou_threshold=0.45,\\n top_k=200,\\n nms_max_output_size=400)\\n\\n # Load the trained weights into the model.\\n weights_path = config['inference']['weights_path']\\n\\n model.load_weights(weights_path, by_name=True)\\n \\n # Working with image\\n all_images = glob.glob(f\\\"{config['inference']['video_input']['video_to_frames_export_path']}/*/*\\\")\\n \\n # Setting Up Prediction Threshold\\n confidence_threshold = config['inference']['confidence_threshold']\\n \\n # Setting Up Classes (Note Should be in same order as in training)\\n classes = config['inference']['classes']\\n \\n vp.existsFolder(f\\\"{config['inference']['predicted_frames_export_path']}/{video.split('.')[0]}\\\")\\n # Working with image\\n for current_img in tqdm(all_images):\\n current_img_name = current_img.split('/')[-1]\\n orig_image = cv2.imread(current_img)\\n input_images = [] # Store resized versions of the images here\\n img = image.load_img(current_img, target_size=(img_height, img_width))\\n img = image.img_to_array(img) \\n input_images.append(img)\\n input_images = np.array(input_images)\\n \\n # Prediction\\n y_pred = model.predict(input_images)\\n\\n # Using threshold\\n y_pred_thresh = [y_pred[k][y_pred[k,:,1] > confidence_threshold] for k in range(y_pred.shape[0])]\\n \\n # Drawing Boxes\\n for box in y_pred_thresh[0]:\\n xmin = box[2] * orig_image.shape[1] / img_width\\n ymin = box[3] * orig_image.shape[0] / img_height\\n xmax = box[4] * orig_image.shape[1] / img_width\\n ymax = box[5] * orig_image.shape[0] / img_height\\n \\n label = f\\\"{classes[int(box[0])]}: {box[1]:.2f}\\\"\\n cv2.rectangle(orig_image, (int(xmin), int(ymin)), (int(xmax),int(ymax)), (255, 0, 0), 2)\\n cv2.putText(orig_image, label, (int(xmin), int(ymin)), cv2.FONT_HERSHEY_SIMPLEX, 2, (255, 255, 255), 2, cv2.LINE_AA)\\n cv2.imwrite(f\\\"{config['inference']['predicted_frames_export_path']}/{video.split('.')[0]}/{current_img_name}\\\", orig_image)\\n \\n # Creating video\\n vp.generate_video(import_path=config['inference']['predicted_frames_export_path'],\\n export_path=config['inference']['video_input']['video_output_path'])\",\n \"def make_movie_cart(field='uu1', datadir='data/', proc=-1, extension='xz',\\n format='native', tmin=0., tmax=1.e38, amin=0., amax=1.,\\n transform='', oldfile=False):\\n\\n import pylab as plt\\n import sys\\n from pencil.files.var import read_var\\n\\n mkmvvar = read_var(trimall=True) \\n r2d,phi2d = np.meshgrid(mkmvvar.x,mkmvvar.y)\\n x2d=r2d*np.cos(phi2d)\\n y2d=r2d*np.sin(phi2d)\\n\\n datadir = os.path.expanduser(datadir)\\n if proc < 0:\\n filename = datadir + '/slice_' + field + '.' + extension\\n else:\\n filename = datadir + '/proc' + \\\\\\n str(proc) + '/slice_' + field + '.' + extension\\n\\n # Read the global dimensions.\\n dim = read_dim(datadir, proc)\\n if dim.precision == 'D':\\n precision = 'd'\\n else:\\n precision = 'f'\\n\\n # Set up slice plane.\\n if extension == 'xy' or extension == 'Xy':\\n hsize = dim.nx\\n vsize = dim.ny\\n if extension == 'xz':\\n print('only works for xy')\\n sys.stop\\n if extension == 'yz':\\n print('only works for xy')\\n sys.stop\\n plane = np.zeros((vsize, hsize), dtype=precision)\\n\\n infile = npfile(filename, endian=format)\\n\\n files = []\\n fig = plt.figure(figsize=(5, 10))\\n ax = fig.add_subplot(111)\\n\\n ifirst = True\\n islice = 0\\n while True:\\n try:\\n raw_data = infile.fort_read(precision)\\n except ValueError:\\n break\\n except TypeError:\\n break\\n\\n if oldfile:\\n t = raw_data[-1]\\n plane = raw_data[:-1].reshape(vsize, hsize)\\n else:\\n t = raw_data[-2]\\n plane = raw_data[:-2].reshape(vsize, hsize)\\n\\n if transform:\\n exec('plane = plane' + transform)\\n\\n if t > tmin and t < tmax:\\n ax.set_aspect('equal')\\n ax.cla()\\n ax.contourf(x2d, y2d, plane, 256)\\n fname = '_tmp%03d.png' % islice\\n print('Saving frame' + fname)\\n fig.savefig(fname)\\n files.append(fname)\\n\\n if ifirst:\\n #print \\\"----islice----------t---------min-------max-------delta\\\" # Python 2\\n print(\\\"----islice----------t---------min-------max-------delta\\\")\\n #print \\\"%10i %10.3e %10.3e %10.3e %10.3e\\\" % \\\\ # Python 2\\n #(islice, t, plane.min(), plane.max(), plane.max() - plane.min()) # Python 2\\n print(\\\"{0:10} {1:10.3e} {2:10.3e} {3:10.3e} {4:10.3e}\\\".format(islice, t, plane.min(), plane.max(), plane.max() - plane.min()))\\n\\n ifirst = False\\n islice += 1\\n\\n #print 'Making movie animation.mpg - this make take a while'\\n print('Making movie animation.mpg - this make take a while')\\n # SC: Not all systems use mencoder. Need to change this into ffmpeg.\\n os.system(\\\"mencoder 'mf://_tmp*.png' -mf type=png:fps=24 -ovc lavc -lavcopts vcodec=wmv2 -oac copy -o animation.mpg\\\")\\n os.system(\\\"rm _tmp*.png\\\")\\n infile.close()\",\n \"def convert_video_path_and_save(video_path, output_path=\\\"output.mp4\\\", temp_folder = \\\"./temp\\\",\\n frame_frequency=24, image_reducer=100, fontSize=10, spacing=1.1, maxsize=None, chars=\\\" .*:+%S0#@\\\",\\n logs=False, processes=4, progress_tracker=None):\\n\\n if logs:\\n start_time = time.time()\\n print (\\\"Converting video...\\\")\\n \\n # set up a capture temporarily so we can grab some basic info about it\\n capture = cv2.VideoCapture(video_path)\\n if not capture.isOpened():\\n print (\\\"Could not read video. Please enter a valid video file!\\\")\\n exit(0)\\n\\n fps = capture.get(cv2.CAP_PROP_FPS)\\n bitrate = int(capture.get(cv2.CAP_PROP_BITRATE))\\n total_frames = int(capture.get(cv2.CAP_PROP_FRAME_COUNT))\\n frames_included = int(total_frames / frame_frequency)\\n # total_frames / fps gives us our video duration.\\n video_duration = total_frames / fps\\n # frames included / video duration gives new fps\\n new_fps = (total_frames / frame_frequency) / video_duration\\n\\n capture.release()\\n\\n # First, we grab all the frames we need and store them in a temp folder\\n # After that, we convert all the image frames in the temp folder, and save them back in the temp folder\\n # Then, we write them to video and save to disk\\n # To utilize mutli processing, we separate grabbing frames and converting the frames into batches\\n\\n while os.path.isdir(temp_folder):\\n temp_folder += \\\"_\\\"\\n temp_folder += \\\"/\\\"\\n os.mkdir(temp_folder)\\n\\n # initial setup\\n # we divide our work into batches\\n batches = processes\\n frames_per_batch = int(total_frames / batches / frame_frequency)\\n if progress_tracker is None:\\n progress_tracker = Value(\\\"f\\\", 0, lock=True)\\n # progress: saved frames + converted frames + written frames\\n progress_step = 100 / (frames_included * 3)\\n\\n # grab the frames, and write to separate batch folders\\n save_frames_processes = []\\n for batch in range(batches):\\n starting_frame = batch * frames_per_batch * frame_frequency\\n batch_folder = temp_folder + str(batch) + \\\"/\\\"\\n os.mkdir(batch_folder)\\n args = (\\n starting_frame,\\n starting_frame + frames_per_batch * frame_frequency,\\n video_path,\\n batch_folder,\\n frame_frequency,\\n logs,\\n progress_tracker,\\n progress_step\\n )\\n p = Process(target=_save_frames, args=args)\\n p.daemon = True\\n p.start()\\n save_frames_processes.append(p)\\n for p in save_frames_processes:\\n p.join()\\n\\n # convert all the frames in each batch folder\\n convert_processes = []\\n for batch in range(batches):\\n batch_folder = temp_folder + str(batch) + \\\"/\\\"\\n args = (\\n batch_folder,\\n frames_per_batch,\\n image_reducer,\\n fontSize, spacing, maxsize, chars,\\n logs, progress_tracker, progress_step\\n )\\n p = Process(target=_convert_batch, args=args)\\n p.daemon = True\\n p.start()\\n convert_processes.append(p)\\n for p in convert_processes:\\n p.join()\\n\\n # if no extension was assigned, automatically assign .mp4\\n output_name, output_ext = os.path.splitext(output_path)\\n if output_ext == \\\"\\\":\\n output_ext = \\\".mp4\\\"\\n # if final output path was specified, then modify it (append _Copy to it)\\n final_output_path = output_name + output_ext\\n while os.path.isfile(final_output_path):\\n if logs : print (final_output_path, \\\"already exists!\\\")\\n final_output_path = os.path.splitext(final_output_path)[0] + \\\"_Copy\\\" + output_ext\\n\\n # video settings\\n fourcc = cv2.VideoWriter_fourcc(*'mp4v')\\n video_out = imageio.get_writer(final_output_path, fps=new_fps, quality=None, bitrate=(bitrate * 1024 * 2.5))\\n size = None\\n\\n # write images to new video\\n for batch in range(1, batches + 1):\\n batch_folder = temp_folder + str(batch - 1) + \\\"/\\\"\\n for i in range(1, frames_per_batch + 1):\\n img = cv2.imread(batch_folder + str(i) + \\\".jpg\\\", 2)\\n if size is None:\\n height, width = img.shape\\n size = (width, height)\\n video_out.append_data(img)\\n with progress_tracker.get_lock():\\n progress_tracker.value += progress_step\\n if logs : print (\\\"Progress: %.4f%%\\\" % progress_tracker.value, end=\\\"\\\\r\\\")\\n video_out.close()\\n shutil.rmtree(temp_folder)\\n\\n # when we are done, there might be some rounding errors when converting some stuff to integers, thus it doesn't appear to be done\\n # So we just simply set it to 100\\n with progress_tracker.get_lock():\\n progress_tracker.value = 100\\n\\n if logs:\\n print (\\\"=\\\" * 30)\\n print (\\\"SUMMARY:\\\")\\n print (\\\"-\\\" * 20)\\n print (\\\"Progress: %.4f%%\\\" % progress_tracker.value)\\n print (\\\"Total frames found:\\\", str(total_frames))\\n print (\\\"Frames included and converted:\\\", str(frames_per_batch * batches))\\n print (\\\"Original FPS:\\\", str(fps))\\n print(\\\"New FPS:\\\", str(new_fps))\\n print (\\\"Resolution:\\\", str(size))\\n print (\\\"Saved to\\\", final_output_path)\\n print (\\\"Time took: %.4f secs\\\" % (time.time() - start_time))\",\n \"def gen_fps():\\n global data_src ,output_dir \\n logger = TaskFileLogger(\\\"GenFP\\\")\\n\\n h_vars = load_hydro_var()\\n if not os.path.exists(output_dir):\\n os.mkdir(output_dir)\\n\\n for h_type,var_d in h_vars.items():\\n print \\\"considering %s\\\" %h_type\\n\\n t_output_dir = os.path.join(output_dir,h_type)\\n if not os.path.exists(t_output_dir):\\n print \\\"creating path %s\\\" %t_output_dir\\n os.mkdir(t_output_dir)\\n logger.log(\\\"%s started\\\" %(h_type))\\n\\n for fname in glob.glob(data_src):\\n complex_id = os.path.basename(fname).split('.')[0] \\n fp_path = os.path.join(t_output_dir,complex_id + \\\".fp\\\" )\\n if os.path.exists(fp_path):\\n #print \\\"%s processed\\\" %complex_id\\n continue\\n print \\\"processing %s,fp saved as %s\\\" %(fname , fp_path )\\n c = Complex(fname,hydro_dict = var_d)\\n c.get_fp()\\n c.write_fp_to_file(fp_path)\\n\\n logger.log(\\\"%s finished\\\" %(h_type))\",\n \"def check_video_format(movie_file, desired_format='.mp4', original_format='.avi'):\\n\\n if not os.path.isfile(movie_file+original_format):\\n print 'Error. avi file does not exist:'+movie_file+'.avi'\\n if not os.path.isfile(movie_file+desired_format):\\n cmd = ['ffmpeg']\\n cmd += ['-i', movie_file+original_format]\\n cmd += [movie_file+desired_format]\\n cmd_string = ''.join([\\\"%s \\\" % el for el in cmd])\\n #print '-->Running: ', cmd_string\\n p = subprocess.Popen(cmd, shell=False)\\n p.wait()\",\n \"def vcf_to_plink(locus, output_directory ,vcf, population):\\n logging.info(\\\"Converting {0} to PLINK format\\\".format(vcf))\\n command = __VCF_TO_PLINK_TEMPLATE__.format(vcf, locus)\\n run_command(command)\\n try:\\n #Rename\\n os.rename(locus +'.bed', os.path.join(output_directory, locus + '.' + population + '.bed'))\\n os.rename(locus +'.bim', os.path.join(output_directory, locus + '.' + population + '.bim'))\\n os.rename(locus +'.fam', os.path.join(output_directory, locus + '.' + population + '.fam'))\\n #Remove\\n os.remove(locus + '.log')\\n os.remove(locus + '.nosex')\\n except OSError as e:\\n logging.error(\\\"Could not move or remove PLINK files {0}\\\".format(e))\\n sys.exit(OS_ERROR)\",\n \"def __init__(self, name, kill_flag, frame_buffer, flushing, query_idx=0, buffer_size=6000, hdf_resize=30000, min_flush=200, n_cams=1, resolution=None):\\n super(MovieSaver, self).__init__()\\n self.daemon = True\\n\\n # Saving params\\n if not name.endswith('.h5'):\\n name += '.h5'\\n self.name = name\\n self.buffer_size = buffer_size # should be overkill, since flushing will do the real job of saving it out\\n self.hdf_resize = hdf_resize\\n self.min_flush = min_flush\\n\\n # Cam params\\n self.n_cams = n_cams\\n self.resolution = resolution\\n\\n # Flags and containers\\n self.saving_complete = mp.Value('b', False)\\n self.kill_flag = kill_flag\\n self.flushing = flushing\\n self.frame_buffer = frame_buffer\\n \\n # Queries\\n self.query_idx = query_idx #which cam gets queried\\n self.query_flag = mp.Value('b',False)\\n self.query_queue = mp.Array(ctypes.c_uint8, np.product([self.resolution[self.query_idx][0], self.resolution[self.query_idx][1]]))\\n self.query_queue_ts = mp.Value('d',0.)\\n \\n self.start()\",\n \"def make_movie_crossflow(field='uu1', datadir='data/', proc=-1, extension='yz',\\n format='native', tmin=0., tmax=1.e38, amin=0., amax=1.,\\n transform='', oldfile=False):\\n\\n import pylab as plt\\n import matplotlib.patches as patches\\n\\n datadir = os.path.expanduser(datadir)\\n if proc < 0:\\n filename = datadir + '/slice_' + field + '.' + extension\\n else:\\n filename = datadir + '/proc' + \\\\\\n str(proc) + '/slice_' + field + '.' + extension\\n\\n # Read the global dimensions.\\n dim = read_dim(datadir, proc)\\n if dim.precision == 'D':\\n precision = 'd'\\n else:\\n precision = 'f'\\n\\n # Set up slice plane.\\n if extension == 'xy' or extension == 'Xy':\\n hsize = dim.nx\\n vsize = dim.ny\\n if extension == 'xz':\\n hsize = dim.nx\\n vsize = dim.nz\\n if extension == 'yz':\\n hsize = dim.ny\\n vsize = dim.nz\\n plane = np.zeros((vsize, hsize), dtype=precision)\\n\\n infile = npfile(filename, endian=format)\\n\\n files = []\\n fig = plt.figure(figsize=(5, 10))\\n ax = fig.add_subplot(111)\\n ax.add_patch(patches.Rectangle(\\n (220,0),\\n 40,\\n 320,\\n color='gray'\\n )\\n )\\n#\\n# ax.add_patch(patches.Rectangle(\\n# (220,0),\\n# 80,\\n# 240,\\n# hatch='/'\\n# )\\n# )\\n\\n ifirst = True\\n islice = 0\\n while True:\\n try:\\n raw_data = infile.fort_read(precision)\\n except ValueError:\\n break\\n except TypeError:\\n break\\n\\n if oldfile:\\n t = raw_data[-1]\\n plane = raw_data[:-1].reshape(vsize, hsize)\\n else:\\n t = raw_data[-2]\\n plane = raw_data[:-2].reshape(vsize, hsize)\\n\\n if transform:\\n exec('plane = plane' + transform)\\n\\n if t > tmin and t < tmax:\\n ax.cla()\\n ax.imshow(plane, vmin=amin, vmax=amax)\\n ax.add_patch(patches.Rectangle(\\n (220,0),\\n 40,\\n 320,\\n color='gray'\\n )\\n )\\n fname = '_tmp%03d.png' % islice\\n print('Saving frame' + fname)\\n fig.savefig(fname)\\n files.append(fname)\",\n \"def start_recording(codec, filename=time.strftime(\\\"%Y-%m-%d_%H-%M-%S\\\")):\\n global video_writer\\n folder = 'video_out/' # eventually replace this with the SD card folder\\n # TODO: also include branch name and/or commit ID\\n path = folder + filename + '.' + filetype\\n print \\\"Saving video to: %s\\\" % path\\n\\n height = videoinput.frame_height\\n if settings.sidebyside:\\n width = 2*videoinput.frame_width\\n else:\\n width = videoinput.frame_width\\n\\n try:\\n video_writer = cv2.VideoWriter(path, codec, 30, (width, height))\\n except:\\n print \\\"Failed to open video file for writing!\\\"\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6444913","0.6132553","0.6021357","0.6021357","0.5793323","0.575927","0.56994724","0.5620519","0.5565024","0.5488642","0.54845893","0.5479945","0.5418265","0.5404724","0.53233945","0.5318268","0.5299321","0.5261676","0.52610755","0.51977015","0.51628315","0.5160664","0.5157827","0.5144048","0.5141774","0.51226306","0.51177037","0.5109612","0.5085291","0.5074146","0.50662863","0.50474757","0.50340366","0.50199586","0.5011041","0.5002775","0.49982056","0.49841854","0.4983246","0.49772975","0.49747086","0.4967472","0.49667382","0.4964631","0.4955116","0.49482158","0.4946755","0.49455795","0.49448422","0.4937976","0.49160227","0.4912704","0.49056038","0.48997715","0.48955384","0.48913154","0.48893067","0.48846418","0.488296","0.4865082","0.48621365","0.4856423","0.4849818","0.4848213","0.48274335","0.48259526","0.48196906","0.4819449","0.48163456","0.48151338","0.48045516","0.48039013","0.48005536","0.47901854","0.47781155","0.47677162","0.47668636","0.47591752","0.4755238","0.4751489","0.4751318","0.4750193","0.47489446","0.47462398","0.47455513","0.4745031","0.47406575","0.47356924","0.47326368","0.47321242","0.47300598","0.47297138","0.47185674","0.47185424","0.47160232","0.47107762","0.47041655","0.46944857","0.4690744","0.4688293"],"string":"[\n \"0.6444913\",\n \"0.6132553\",\n \"0.6021357\",\n \"0.6021357\",\n \"0.5793323\",\n \"0.575927\",\n \"0.56994724\",\n \"0.5620519\",\n \"0.5565024\",\n \"0.5488642\",\n \"0.54845893\",\n \"0.5479945\",\n \"0.5418265\",\n \"0.5404724\",\n \"0.53233945\",\n \"0.5318268\",\n \"0.5299321\",\n \"0.5261676\",\n \"0.52610755\",\n \"0.51977015\",\n \"0.51628315\",\n \"0.5160664\",\n \"0.5157827\",\n \"0.5144048\",\n \"0.5141774\",\n \"0.51226306\",\n \"0.51177037\",\n \"0.5109612\",\n \"0.5085291\",\n \"0.5074146\",\n \"0.50662863\",\n \"0.50474757\",\n \"0.50340366\",\n \"0.50199586\",\n \"0.5011041\",\n \"0.5002775\",\n \"0.49982056\",\n \"0.49841854\",\n \"0.4983246\",\n \"0.49772975\",\n \"0.49747086\",\n \"0.4967472\",\n \"0.49667382\",\n \"0.4964631\",\n \"0.4955116\",\n \"0.49482158\",\n \"0.4946755\",\n \"0.49455795\",\n \"0.49448422\",\n \"0.4937976\",\n \"0.49160227\",\n \"0.4912704\",\n \"0.49056038\",\n \"0.48997715\",\n \"0.48955384\",\n \"0.48913154\",\n \"0.48893067\",\n \"0.48846418\",\n \"0.488296\",\n \"0.4865082\",\n \"0.48621365\",\n \"0.4856423\",\n \"0.4849818\",\n \"0.4848213\",\n \"0.48274335\",\n \"0.48259526\",\n \"0.48196906\",\n \"0.4819449\",\n \"0.48163456\",\n \"0.48151338\",\n \"0.48045516\",\n \"0.48039013\",\n \"0.48005536\",\n \"0.47901854\",\n \"0.47781155\",\n \"0.47677162\",\n \"0.47668636\",\n \"0.47591752\",\n \"0.4755238\",\n \"0.4751489\",\n \"0.4751318\",\n \"0.4750193\",\n \"0.47489446\",\n \"0.47462398\",\n \"0.47455513\",\n \"0.4745031\",\n \"0.47406575\",\n \"0.47356924\",\n \"0.47326368\",\n \"0.47321242\",\n \"0.47300598\",\n \"0.47297138\",\n \"0.47185674\",\n \"0.47185424\",\n \"0.47160232\",\n \"0.47107762\",\n \"0.47041655\",\n \"0.46944857\",\n \"0.4690744\",\n \"0.4688293\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8082349"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":8797,"cells":{"query":{"kind":"string","value":"Find the onsets in the array representing the synchronization light. This function assumes the onsets are periodic (with randomness within 0.5T and 1.5T). The function can also fix missing onsets."},"document":{"kind":"string","value":"def find_sync_light_onsets(sync_light, invert=True, fixmissing=False):\n # -- Find changes in synch light --\n sync_light_diff = np.diff(sync_light, prepend=0)\n if invert:\n sync_light_diff = -sync_light_diff\n sync_light_diff[sync_light_diff < 0] = 0\n sync_light_threshold = 0.2*sync_light_diff.max()\n sync_light_onset = sync_light_diff > sync_light_threshold\n\n\n # -- Find period of sync_light_onset --\n sync_light_onset_ind = np.where(sync_light_onset)[0]\n sync_light_onset_diff = np.diff(sync_light_onset_ind) # In units of frames\n expected_onset_period = np.median(sync_light_onset_diff) # In units of (float) frames\n\n # -- Remove repeated onsets --\n onset_freq_upper_threshold = int(1.5 * expected_onset_period)\n onset_freq_lower_threshold = int(0.5 * expected_onset_period)\n repeated_onsets = sync_light_onset_diff < onset_freq_lower_threshold\n repeated_onsets_ind = np.where(repeated_onsets)[0]\n fixed_sync_light_onset = sync_light_onset.copy()\n fixed_sync_light_onset[sync_light_onset_ind[repeated_onsets_ind+1]] = False\n\n # -- Fix missing onsets --\n if fixmissing:\n missing_next_onsets = sync_light_onset_diff > onset_freq_upper_threshold\n missing_next_onsets_ind = np.where(missing_next_onsets)[0]\n for indm, missing_onset_ind in enumerate(missing_next_onsets_ind):\n onset_diff = sync_light_onset_diff[missing_onset_ind]\n n_missing = int(np.round(onset_diff / expected_onset_period))-1\n #print(n_missing)\n last_onset_ind = sync_light_onset_ind[missing_onset_ind]\n next_onset_ind = sync_light_onset_ind[missing_onset_ind+1]\n period_missing = (next_onset_ind - last_onset_ind)//(n_missing+1)\n new_onset_inds = last_onset_ind + np.arange(1, n_missing+1)*period_missing\n #print([last_onset_ind, next_onset_ind])\n #print(new_onset_inds)\n fixed_sync_light_onset[new_onset_inds] = True\n\n return fixed_sync_light_onset"},"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 find_onsets(self):\n get_onsets = ess.OnsetRate()\n # onset_times is np array\n self.onset_times, onset_rate = get_onsets(self.audio)\n # Onset as sample number in the audio signal\n index2delete = []\n previous_time = -9999999\n for index, itime in enumerate(self.onset_times):\n if (itime - previous_time) < 2*self.stroke_length:\n index2delete.append(index)\n else:\n previous_time = itime\n self.onset_times = np.delete(self.onset_times, index2delete)\n self.onset_samples = [int(self.sampling_rate*i) for i in self.onset_times]","def DetectPulseOnset(self, asig, fs, wMS):\n # the percentage of the maximal value of the slope sum function\n # to detect the onset\n AmplitudeRatio = .01\n\n # low pass filter\n sig = self.zpIIR(asig, 3, .1, 20, 5 * 2/fs)\n wSmp = int(np.round(wMS*fs/1000))\n\n BlankWindowRatio = .9\n\n # delta x\n diffsig = np.diff(sig)\n\n z = np.empty((sig.size - 1 - wSmp, 1))\n z[:] = np.NaN\n\n # calculate slope sum function\n for i in range(wSmp,sig.size-1):\n subsig = diffsig[i-wSmp:i]\n z[i-wSmp] = np.sum(subsig[subsig>0])\n\n z0 = np.mean(z)\n onset = [0]\n tPnt = []\n zThres = 0\n blankWin = int(np.round(400*fs/1000))\n subIdx = np.r_[onset[0]: onset[0] + 4*blankWin + 1]\n MedianArrayWinSize = 5\n\n # this value controls the final acceptance\n PrcofMaxAMP = .2\n SSFAmpArray = np.ones((MedianArrayWinSize,1))*(np.max(z) - np.min(z)) * PrcofMaxAMP\n # the percentage of maximal amplitude for threshold crossing\n DetectionThreshold = .2\n SSFCrossThresholdArray = np.ones((MedianArrayWinSize,1))*z0*DetectionThreshold\n idx = 1\n\n # Keep loop going while onsets detected\n while(1):\n\n # look for the first location where z > z0\n try:\n\n # Look in z[subIdx] (and make sure it doesn't go past z's size)\n # find first index where z > the mean of z\n tempIndex = np.trim_zeros(subIdx*(z.size>subIdx), 'b')\n ix = np.amin(np.where(z[tempIndex] > z0)[0])\n except:\n break\n\n ix = tempIndex[ix]\n tPnt.append(ix)\n srcWin = np.r_[np.maximum(0,ix - wSmp): ix + wSmp]\n #if the window has passed the length of the data, then exit\n if srcWin[-1] >= len(z):\n break\n\n # This section of code is to remove the initial zero-region in the SSF function before looking for onset (if such region exists)\n zPnt = np.where(z[srcWin] == 0)\n\n if zPnt[0].size != 0:\n zPnt = srcWin[zPnt[0]]\n\n if np.any(zPnt < ix):\n srcWin = np.r_[zPnt[np.max(np.where(zPnt < ix))]: ix + wSmp]\n\n # accept the window\n if ( np.max(z[srcWin]) - np.min(z[srcWin]) > zThres):\n\n # calculate the threshold for next cycle\n SSFAmp = (np.max(z[srcWin]) - np.min(z[srcWin])) * PrcofMaxAMP\n SSFAmpArray[np.remainder(idx, MedianArrayWinSize)] = SSFAmp\n zThres = np.median(SSFAmpArray)\n SSFCrossThresholdArray[np.remainder(idx, MedianArrayWinSize)] = np.mean(z[srcWin])*DetectionThreshold\n z0 = np.median(SSFCrossThresholdArray)\n minSSF = np.min(z[srcWin]) + SSFAmp *AmplitudeRatio\n a = srcWin[0] + np.min(np.where(z[srcWin] >= minSSF))\n onset.append(a)\n\n # adaptively determine analysis window for next cycle\n bw = blankWin\n subIdx = np.round(np.r_[a + bw: a + 3*bw])\n idx = idx + 1\n\n else:\n # no beat detected\n subIdx = np.round(subIdx + blankWin)\n\n return onset","def _get_run_onsets(\n runs, length_fr, pad_fr, running_threshold_cms, offset_fr):\n out = []\n for run in runs:\n t2p = run.trace2p()\n tr = t2p.trace('deconvolved')\n\n # Add all onsets of \"other\" frames\n others = t2p.nocs(length_fr, pad_fr,\n running_threshold_cms)\n for ot in others:\n start = ot + offset_fr\n out.append(tr[:, start:start + length_fr])\n\n return out","def getOnsetTick(s):\n ticksPerQuarter = getResolution(s)\n onsets = [int(n.offset * ticksPerQuarter) for n in s.flat.notes]\n return onsets","def detect_correction_onset(baseline_llr, \n motiontrajectory, times,\n ptstart, ptend, \n disturbancemode, \n disturbancevalue, \n disturbanceonsettime=None, # if none, reconstruct onset form the threshold ratio\n disturbance_threshold=9.0,\n plotfilename=None):\n\n # Error considering the disturbance\n screentrajectory, err_screen, disturbancetime, disturbanceindex = compute_trial_error(\n motiontrajectory, times,\n ptstart, ptend, \n disturbancemode, \n disturbancevalue, \n disturbanceonsettime,\n disturbance_threshold)\n \n # Error as if there is no disturbance (ballistic)\n err_ballistic = raydistance_error(motiontrajectory, ptstart, ptend)\n is_back = 1 - 1 * is_target_forward(motiontrajectory, ptstart, ptend)\n err_ballistic += is_back # penalty for wrong direction\n \n # Normalized motion phase\n phase = normalized_motion_phase(screentrajectory, ptstart, ptend)\n\n # Correction onset is the point \n # when no-disturbance error exceeds A*sigma and\n # the real error is decreasing\n ionsets = []\n for i in range(disturbanceindex, len(err_screen)-3):\n err_base_mean, err_base_covar = baseline_llr.regress(phase[i])\n err_base_var = np.sqrt(err_base_covar)\n if (np.abs(err_ballistic[i]) > 1 * err_base_var) and \\\n (np.abs(err_screen[i]) > np.abs(err_screen[i+1])) and \\\n (np.abs(err_screen[i+1]) > np.abs(err_screen[i+2])) and \\\n (np.abs(err_screen[i+2]) > np.abs(err_screen[i+3])):\n #(np.abs(err_ballistic[i]) > np.abs(err_screen[i])):\n ionsets.append(i)\n\n # Plot the detected onsets\n make_plots = True\n if make_plots:\n plt.plot(screentrajectory[:, 0], screentrajectory[:, 1])\n plt.plot(motiontrajectory[:, 0], motiontrajectory[:, 1])\n sp = ptstart\n plt.plot(sp[0], sp[1], marker='o', markersize=3,)\n gp = ptend\n plt.plot(gp[0], gp[1], marker='o', markersize=3,)\n \n plt.scatter(screentrajectory[:-1, 0], screentrajectory[:-1, 1], marker='o', s=15, \n linewidths=4, c=err_screen, alpha=0.5, cmap=plt.cm.coolwarm)\n\n onsets = screentrajectory[ionsets]\n plt.scatter(onsets[:, 0], onsets[:, 1], marker='*', s=10, linewidths=4,)\n plt.axis(\"equal\")\n if plotfilename is not None:\n plt.savefig(plotfilename)\n plt.close()\n else:\n plt.show()\n \n\n return onsets","def badMuons(self, allmuons, allvertices):\n\n muons = list(m for m in allmuons) # make it a python list\n goodMuon = []\n\n if len(allvertices) < 1: raise RuntimeError\n PV = allvertices[0].position()\n \n out = [] \n for mu in muons:\n if (not(mu.isPFMuon()) or mu.innerTrack().isNull()):\n goodMuon.append(-1); # bad but we don't care\n continue;\n if (self.preselection(mu)):\n dxypv = abs(mu.innerTrack().dxy(PV));\n dzpv = abs(mu.innerTrack().dz(PV));\n if (self.tighterId(mu)):\n ipLoose = ((dxypv < 0.5 and dzpv < 2.0) or mu.innerTrack().hitPattern().pixelLayersWithMeasurement() >= 2);\n goodMuon.append(ipLoose or (not(self.selectClones_) and self.tightGlobal(mu)));\n elif (self.safeId(mu)):\n ipTight = (dxypv < 0.2 and dzpv < 0.5);\n goodMuon.append(ipTight);\n else:\n goodMuon.append(0);\n else:\n goodMuon.append(3); # maybe good, maybe bad, but we don't care\n\n n = len(muons)\n for i in range(n):\n if (muons[i].pt() < self.ptCut_ or goodMuon[i] != 0): continue;\n bad = True;\n if (self.selectClones_):\n bad = False; # unless proven otherwise\n n1 = muons[i].numberOfMatches(ROOT.reco.Muon.SegmentArbitration);\n for j in range(n):\n if (j == i or goodMuon[j] <= 0 or not(self.partnerId(muons[j]))): continue\n n2 = muons[j].numberOfMatches(ROOT.reco.Muon.SegmentArbitration);\n if (deltaR(muons[i],muons[j]) < 0.4 or (n1 > 0 and n2 > 0 and ROOT.muon.sharedSegments(muons[i],muons[j]) >= 0.5*min(n1,n2))):\n bad = True;\n break;\n if (bad):\n out.append(muons[i]);\n return out","def build_set(ls, dsets):\n\n def noh(ls, dsets):\n \"\"\"\n This function remove hydrogens from the selection\n \"\"\"\n data_set = build_set(ls[1], dsets)\n\n noh_set = set()\n pred = oechem.OEIsHydrogen()\n\n for idx in data_set:\n atom = system.GetAtom(oechem.OEHasAtomIdx(idx))\n if not pred(atom):\n noh_set.add(idx)\n\n return noh_set\n\n def residues(ls):\n \"\"\"\n This function select residues based on the residue numbers. An example of\n selection can be:\n mask = 'resid A:16 17 19 B:1'\n \"\"\"\n # List residue atom index to be restrained\n res_atom_set = set()\n\n # Dictionary of lists with the chain residues selected to be restrained\n # e.g. {chainA:[res1, res15], chainB:[res19, res17]}\n chain_dic = {'': []}\n\n # Fill out the chain dictionary\n i = 0\n while i < len(ls):\n if ls[i].isdigit():\n chain_dic[''].append(int(ls[i]))\n i += 1\n else:\n try:\n chain_dic[ls[i]].append(int(ls[i + 2]))\n except:\n chain_dic[ls[i]] = []\n chain_dic[ls[i]].append(int(ls[i + 2]))\n i += 3\n\n # Loop over the molecular system to select the atom indexes to be selected\n hv = oechem.OEHierView(system, oechem.OEAssumption_BondedResidue + oechem.OEAssumption_ResPerceived)\n for chain in hv.GetChains():\n chain_id = chain.GetChainID()\n if chain_id not in chain_dic:\n continue\n for frag in chain.GetFragments():\n for hres in frag.GetResidues():\n res_num = hres.GetOEResidue().GetResidueNumber()\n if res_num not in chain_dic[chain_id]:\n continue\n for oe_at in hres.GetAtoms():\n res_atom_set.add(oe_at.GetIdx())\n\n return res_atom_set\n\n def around(dist, ls):\n \"\"\"\n This function select atom not far than the threshold distance from\n the current selection. The threshold distance is in Angstrom\n\n selection can be:\n mask = '5.0 around ligand'\n \"\"\"\n # at = system.GetAtom(oechem.OEHasAtomIdx(idx))\n\n # Atom set selection\n atom_set_around = set()\n\n # Create a OE bit vector mask for each atoms\n bv_around = oechem.OEBitVector(system.GetMaxAtomIdx())\n\n # Set the mask atom\n for at in system.GetAtoms():\n if at.GetIdx() in ls:\n bv_around.SetBitOn(at.GetIdx())\n\n # Predicate\n pred = oechem.OEAtomIdxSelected(bv_around)\n\n # Create the system molecule based on the atom mask\n molecules = oechem.OEMol()\n oechem.OESubsetMol(molecules, system, pred)\n\n # Create the Nearest neighbours\n nn = oechem.OENearestNbrs(system, float(dist))\n\n for nbrs in nn.GetNbrs(molecules):\n for atom in oechem.OEGetResidueAtoms(nbrs.GetBgn()):\n if atom.GetIdx() in ls:\n continue\n atom_set_around.add(atom.GetIdx())\n\n return atom_set_around\n\n # Start Body of the selection function by language\n\n # Terminal Literal return the related set\n if isinstance(ls, str):\n return dsets[ls]\n # Not or Noh\n if len(ls) == 2:\n if ls[0] == 'noh': # Noh case\n return noh(ls, dsets)\n elif ls[0] == 'not': # Not case\n return dsets['system'] - build_set(ls[1], dsets)\n else: # Resid case with one index\n return residues(ls[1])\n\n if len(ls) == 3:\n if ls[1] == 'or': # Or Case (set union)\n return build_set(ls[0], dsets) | build_set(ls[2], dsets)\n elif ls[1] == 'and': # And Case (set intersection)\n return build_set(ls[0], dsets) & build_set(ls[2], dsets)\n elif ls[1] == 'diff': # Diff case (set difference)\n return build_set(ls[0], dsets) - build_set(ls[2], dsets)\n elif ls[1] == 'around': # Around case\n return around(ls[0], build_set(ls[2], dsets))\n else:\n return residues(ls[1:]) # Resid case with one or two indexes\n else:\n if ls[0] == 'resid':\n return residues(ls[1:]) # Resid case with multiple indexes\n else:\n raise ValueError(\"The passed list have too many tokens: {}\".format(ls))","def get_selected_muons(muons, trigobj, mask_events, mu_pt_cut_leading, mu_pt_cut_subleading, mu_aeta_cut, mu_iso_cut): \n passes_iso = muons.pfRelIso04_all < mu_iso_cut\n passes_id = muons.mediumId == 1\n passes_subleading_pt = muons.pt > mu_pt_cut_subleading\n passes_leading_pt = muons.pt > mu_pt_cut_leading\n passes_aeta = NUMPY_LIB.abs(muons.eta) < mu_aeta_cut\n \n trigobj.masks[\"mu\"] = (trigobj.id == 13)\n \n muons_matched_to_trigobj = NUMPY_LIB.invert(mask_deltar_first(muons, muons.masks[\"all\"], trigobj, trigobj.masks[\"mu\"], 0.1))\n \n #select muons that pass these cuts\n muons_passing_id = passes_iso & passes_id & passes_subleading_pt & muons_matched_to_trigobj\n \n #select events that have muons passing cuts \n events_passes_muid = sum_in_offsets(muons, muons_passing_id, mask_events, muons.masks[\"all\"], NUMPY_LIB.int8) >= 2\n events_passes_leading_pt = sum_in_offsets(muons, muons_passing_id & passes_leading_pt, mask_events, muons.masks[\"all\"], NUMPY_LIB.int8) >= 1\n events_passes_subleading_pt = sum_in_offsets(muons, muons_passing_id & passes_subleading_pt, mask_events, muons.masks[\"all\"], NUMPY_LIB.int8) >= 2\n\n base_event_sel = mask_events & events_passes_muid & events_passes_leading_pt & events_passes_subleading_pt\n \n muons_passing_os = select_muons_opposite_sign(muons, muons_passing_id & passes_subleading_pt)\n events_passes_os = sum_in_offsets(muons, muons_passing_os, mask_events, muons.masks[\"all\"], NUMPY_LIB.int8) == 2\n \n final_event_sel = base_event_sel & events_passes_os\n final_muon_sel = muons_passing_id & passes_subleading_pt & muons_passing_os\n \n return {\n \"selected_events\": final_event_sel,\n \"selected_muons\": final_muon_sel,\n }","def clean_detections(npts, on_off):\n on = on_off[:,0]\n off = on_off[:,1]\n idx_on = [on[0]]\n idx_off = [off[0]]\n lowest_idx = on[0]\n\n for ion, ioff in zip(on, off):\n if ion > lowest_idx + npts:\n idx_on.append(ion)\n idx_off.append(ioff)\n lowest_idx = ion\n\n return np.asarray((idx_on, idx_off)).T","def onset(sig, stw, ltw, centred=False):\n\n stw = int(round(stw))\n ltw = int(round(ltw))\n\n n_channels, n_samples = sig.shape\n onset = np.copy(sig)\n onset_raw = np.copy(sig)\n for i in range(n_channels):\n if np.sum(sig[i, :]) == 0.0:\n onset[i, :] = 0.0\n onset_raw[i, :] = onset[i, :]\n else:\n if centred is True:\n onset[i, :] = sta_lta_centred(sig[i, :], stw, ltw)\n else:\n onset[i, :] = classic_sta_lta(sig[i, :], stw, ltw)\n onset_raw[i, :] = onset[i, :]\n np.clip(1 + onset[i, :], 0.8, np.inf, onset[i, :])\n np.log(onset[i, :], onset[i, :])\n\n return onset_raw, onset","def merge_sets(sets):\n idxs_skipped = []\n n = len(sets)\n for i in range(n-1):\n if i not in idxs_skipped:\n set_i = sets[i]\n for j in range(i+1,n):\n set_j = sets[j]\n if set_i.intersection( set_j ) > set([]):\n sets[i].update( set_j )\n idxs_skipped.append( j )\n sets_u = [ sets[k] for k in np.setdiff1d(range(n), idxs_skipped).astype(np.int) ]\n return sets_u","def onsets_rt(self) -> Optional[annotations.BeatData]:\n return load_onsets(self.onsets_rt_path)","def find_flats(aperture, side='blue'):\r\n \r\n # find dome flat images\r\n domeflats = iraf.hselect('%s????.fits' % side, '$I', 'TURRET == \"APERTURE\" & APERTURE == \"%s\" & LAMPS == \"0000000\" & AIRMASS < 1.01 & IMGTYPE == \"flat\"' % aperture, Stdout=1)\r\n # find internal flat (incandescent lamp) images\r\n intflats = iraf.hselect('%s????.fits' % side, '$I', 'TURRET == \"LAMPS\" & APERTURE == \"%s\" & LAMPS == \"0000001\" & AIRMASS < 1.01' % aperture, Stdout=1)\r\n # dome flats are prefered over internal flats\r\n flats = []\r\n if (len(intflats) > 0) & (len(domeflats) == 0):\r\n flats = intflats\r\n print \"Using %d internal flats for the %s arcsec slit.\" % (len(intflats), aperture)\r\n if len(domeflats) > 3:\r\n flats = domeflats\r\n print \"Using %d dome flats for the %s arcsec slit.\" % (len(domeflats), aperture)\r\n\r\n return flats","def getmountoffsets():\n r = _getoffsets(isMountoffset=True)\n return r","def add_sets(list_of_sets):\n global true_introns\n for item in list_of_sets:\n true_introns.update(item)","def lights_on(self) -> list:\n return [\n entity for entity in self.all_lights if self.hass.get_state(entity) == \"on\"\n ]","def pointsets_mod_automorphism(self, pointsets):\n points = set()\n for ps in pointsets:\n points.update(ps)\n points = tuple(points)\n Aut = self.lattice_automorphism_group(points,\n point_labels=tuple(range(len(points))))\n indexsets = set([ frozenset([points.index(p) for p in ps]) for ps in pointsets ])\n orbits = []\n while len(indexsets)>0:\n idx = indexsets.pop()\n orbits.append(frozenset([points[i] for i in idx]))\n for g in Aut:\n g_idx = frozenset([g(i) for i in idx])\n indexsets.difference_update([g_idx])\n return tuple(orbits)","def test_find_sets(self):\n cards = numpy.array([[1,1,1,2,0],\n [0,1,2,2,2],\n [0,1,2,2,2],\n [0,1,2,2,2]])\n\n set_indices = set_solver.find_sets(cards)\n self.assertEqual(len(set_indices), 2)\n self.assertTrue((0, 1, 2) in set_indices)\n self.assertTrue((2, 3, 4) in set_indices)","def find_all_ngon_sols():\n ngon = [None for _ in range(N)] \n ngon_set = set()\n numbers = set(range(1, (2 * N) + 1))\n\n for triplet in permutations(numbers, 3):\n ngon[0] = tuple(triplet)\n total = sum(triplet)\n next_ngon_set = set()\n fill_ngon(ngon, numbers - set(triplet), 1, next_ngon_set, total)\n ngon_set |= next_ngon_set\n\n return ngon_set","def powerSetNaive(array):\n\n res = [[d] for d in array]\n res.append([])\n array_ = []\n skip = 1\n while skip <=len(array)-1:\n\n for x in range(0,len(array),skip):\n array_.append(array[x])\n for y in range(len(array_[0:x+skip+1])):\n toAppend = array_[y:x+1]\n if toAppend not in res:\n res.append(toAppend)\n toAppend = array_[0:x]\n if toAppend not in res:\n res.append(toAppend)\n array_=[]\n skip = skip + 1\n\n return res","def simple(onArray, offArray):\n \n Larray = len(onArray)\n Larray2 = len(offArray)\n \n assert Larray == Larray2, \"both arrays should have the same size\"\n \n #onFiltered = numpy.array(onArray)[:,OnOff.misc.constants.dataRange]\n #offFiltered = numpy.array(offArray)[:,OnOff.misc.constants.dataRange]\n \n #return onFiltered,offFiltered,OnOff.misc.constants.dataRange\n drange = OnOffCalc.misc.getDatarange(onArray.shape[1])\n dataMask = numpy.ones(onArray.shape)\n #dataMask[:,OnOffCalc.misc.constants.dataRange] = 0\n dataMask[:,drange] = 0\n \n return dataMask","def getIMA(s, onsets):\n s = s.stripTies()\n\n # with subprocess.Popen([\"onsets2ima\",\"-onsets\"] + [str(o) for o in onsets], stdout=subprocess.PIPE) as proc:\n # output = proc.stdout.read().decode('ascii')\n\n proc = subprocess.Popen([\"onsets2ima\",\"-onsets\"] + [str(o) for o in onsets], stdout=subprocess.PIPE)\n try:\n outs, errs = proc.communicate(timeout=5)\n except TimeoutExpired:\n proc.kill()\n raise IMATimeoutError\n output = outs.decode('ascii')\n\n ima_str = output.split('\\n')[0].strip()\n ima_spect_str = output.split('\\n')[1].strip()\n\n ima = [float(w) for w in ima_str.split(' ')]\n ima_spect = [float(w) for w in ima_spect_str.split(' ')]\n\n #if onset of first note != 0 (start with rest), add zeros to ima_spect\n ima_spect = [0.0]*onsets[0] + ima_spect\n\n ima_spect = [ima_spect[o] for o in onsets]\n\n return ima, ima_spect","def mask_the_images(working_path,set_name):\n\n file_list=glob('/media/talhassid/My Passport/haimTal/test_images_0b8afe447b5f1a2c405f41cf2fb1198e.npy')\n out_images = [] #final set of images for all patients\n for fname in file_list:\n out_images_per_patient = []\n print (\"working on file \", fname)\n imgs_to_process = np.load(fname.replace(\"lungmask\",\"images\")) # images of one patient\n masks = np.load(fname)\n for i in range(len(imgs_to_process)):\n mask = masks[i]\n img = imgs_to_process[i]\n new_size = [512,512] # we're scaling back up to the original size of the image\n img= mask*img # apply lung mask\n #\n # renormalizing the masked image (in the mask region)\n #\n new_mean = np.mean(img[mask>0])\n new_std = np.std(img[mask>0])\n #\n # Pulling the background color up to the lower end\n # of the pixel range for the lungs\n #\n old_min = np.min(img) # background color\n img[img==old_min] = new_mean-1.2*new_std # resetting backgound color\n img = img-new_mean\n img = img/new_std\n #make image bounding box (min row, min col, max row, max col)\n labels = measure.label(mask)\n regions = measure.regionprops(labels)\n #\n # Finding the global min and max row over all regions\n #\n min_row = 512\n max_row = 0\n min_col = 512\n max_col = 0\n for prop in regions:\n B = prop.bbox\n if min_row > B[0]:\n min_row = B[0]\n if min_col > B[1]:\n min_col = B[1]\n if max_row < B[2]:\n max_row = B[2]\n if max_col < B[3]:\n max_col = B[3]\n width = max_col-min_col\n height = max_row - min_row\n if width > height:\n max_row=min_row+width\n else:\n max_col = min_col+height\n #\n # cropping the image down to the bounding box for all regions\n # (there's probably an skimage command that can do this in one line)\n #\n img = img[min_row:max_row,min_col:max_col]\n mask = mask[min_row:max_row,min_col:max_col]\n if max_row-min_row <5 or max_col-min_col<5: # skipping all images with no god regions\n pass\n else:\n # moving range to -1 to 1 to accomodate the resize function\n mean = np.mean(img)\n img = img - mean\n min = np.min(img)\n max = np.max(img)\n img = img/(max-min)\n new_img = resize(img,[512,512], mode='constant')\n out_images_per_patient.append(new_img)\n\n id = re.sub(r'.*_images_(.*)\\.npy',r'\\1',fname)\n patient_images_and_id = (out_images_per_patient,id)\n out_images.append(patient_images_and_id)\n print (\"Delete files: {} \\n\\t {} \".format(fname,re.sub(\"lungmask\",\"images\",fname)))\n os.remove(fname)\n os.remove(fname.replace(\"images\",\"lungmask\")) # images of one patient\n\n\n np.save(working_path+\"{}Images.npy\".format(set_name),out_images)","def nondetects(self, masked=False):\r\n grd = self.grd\r\n xnd = []\r\n ynd = []\r\n ncells = len(grd.cells['depth'])\r\n non_detects_i_tr = np.zeros(ncells, np.int32)\r\n if masked:\r\n not_flagged = np.where(self.rec_track.flagged==0)[0]\r\n rec_track = self.rec_track[not_flagged]\r\n rec_seg = self.make_segments(set_depth=True, \r\n input_rec_track=rec_track)\r\n else:\r\n rec_seg = self.rec_seg\r\n for nr, rseg in enumerate(rec_seg):\r\n seg = rec_seg[nr]\r\n dt = seg.dt\r\n if dt > dt_signal+1:\r\n t1 = seg.t1\r\n t2 = seg.t2\r\n nint = int(np.rint((t2-t1)/dt_signal)) - 1\r\n x1 = seg.x1\r\n x2 = seg.x2\r\n y1 = seg.y1\r\n y2 = seg.y2\r\n dx_nd = (x2 - x1)/float(nint+1)\r\n dy_nd = (y2 - y1)/float(nint+1)\r\n if nint < 120: # 10 minute cutoff for nondetect filling\r\n xint = [x1 + n*dx_nd for n in range(1,nint)]\r\n yint = [y1 + n*dy_nd for n in range(1,nint)]\r\n xnd = xnd + xint\r\n ynd = ynd + yint\r\n\r\n for nd in range(len(xnd)):\r\n xy = [xnd[nd], ynd[nd]]\r\n i = grd.select_cells_nearest(xy)\r\n if (i is not None) and (i >= 0):\r\n non_detects_i_tr[i] += 1\r\n\r\n return non_detects_i_tr","def _compute_soffsets(self):\n self.soffsets = [ [] for i in self.doffsets ]\n for idx,dofs in enumerate(self.doffsets):\n for o in dofs:\n self.soffsets[(idx + o) % self.p].append(-o)","def _gaussian_picker(self, onset, phase, start_time, p_arr, s_arr, ptt,\n stt):\n\n # Determine indices of P and S pick times\n pt_idx = int((p_arr - start_time) * self.sampling_rate)\n st_idx = int((s_arr - start_time) * self.sampling_rate)\n\n # Determine P and S pick window upper and lower bounds based on\n # (P-S)/2 -- either this or the next window definition will be\n # used depending on which is wider.\n pmin_idx = int(pt_idx - (st_idx - pt_idx) / 2)\n pmax_idx = int(pt_idx + (st_idx - pt_idx) / 2)\n smin_idx = int(st_idx - (st_idx - pt_idx) / 2)\n smax_idx = int(st_idx + (st_idx - pt_idx) / 2)\n\n # Check if index falls outside length of onset function; if so set\n # window to start/end at start/end of data.\n for idx in [pmin_idx, pmax_idx, smin_idx, smax_idx]:\n if idx < 0:\n idx = 0\n if idx > len(onset):\n idx = len(onset)\n\n # Defining the bounds to search for the event over\n # Determine P and S pick window upper and lower bounds based on\n # set percentage of total travel time, plus marginal window\n\n # window based on self.fraction_tt of P/S travel time\n pp_ttime = ptt * self.fraction_tt\n ps_ttime = stt * self.fraction_tt\n\n # Add length of marginal window to this. Convert to index.\n P_idxmin_new = int(pt_idx - int((self.marginal_window + pp_ttime)\n * self.sampling_rate))\n P_idxmax_new = int(pt_idx + int((self.marginal_window + pp_ttime)\n * self.sampling_rate))\n S_idxmin_new = int(st_idx - int((self.marginal_window + ps_ttime)\n * self.sampling_rate))\n S_idxmax_new = int(st_idx + int((self.marginal_window + ps_ttime)\n * self.sampling_rate))\n\n # Setting so the search region can't be bigger than (P-S)/2:\n # compare the two window definitions; if (P-S)/2 window is\n # smaller then use this (to avoid picking the wrong phase).\n P_idxmin = np.max([pmin_idx, P_idxmin_new])\n P_idxmax = np.min([pmax_idx, P_idxmax_new])\n S_idxmin = np.max([smin_idx, S_idxmin_new])\n S_idxmax = np.min([smax_idx, S_idxmax_new])\n\n # Setting parameters depending on the phase\n if phase == \"P\":\n sta_winlen = self.p_onset_win[0]\n win_min = P_idxmin\n win_max = P_idxmax\n if phase == \"S\":\n sta_winlen = self.s_onset_win[0]\n win_min = S_idxmin\n win_max = S_idxmax\n\n # Find index of maximum value of onset function in the appropriate\n # pick window\n max_onset = np.argmax(onset[win_min:win_max]) + win_min\n # Trim the onset function in the pick window\n onset_trim = onset[win_min:win_max]\n\n # Only keep the onset function outside the pick windows to\n # calculate the pick threshold\n onset_threshold = onset.copy()\n onset_threshold[P_idxmin:P_idxmax] = -1\n onset_threshold[S_idxmin:S_idxmax] = -1\n onset_threshold = onset_threshold[onset_threshold > -1]\n\n # Calculate the pick threshold: either user-specified percentile of\n # data outside pick windows, or 88th percentile within the relevant\n # pick window (whichever is bigger).\n threshold = np.percentile(onset_threshold, self.pick_threshold * 100)\n threshold_window = np.percentile(onset_trim, 88)\n threshold = np.max([threshold, threshold_window])\n\n # Remove data within the pick window that is lower than the threshold\n tmp = (onset_trim - threshold).any() > 0\n\n # If there is any data that meets this requirement...\n if onset[max_onset] >= threshold and tmp:\n exceedence = np.where((onset_trim - threshold) > 0)[0]\n exceedence_dist = np.zeros(len(exceedence))\n\n # Really faffy process to identify the period of data which is\n # above the threshold around the highest value of the onset\n # function.\n d = 1\n e = 0\n while e < len(exceedence_dist) - 1:\n if e == len(exceedence_dist):\n exceedence_dist[e] = d\n else:\n if exceedence[e + 1] == exceedence[e] + 1:\n exceedence_dist[e] = d\n else:\n exceedence_dist[e] = d\n d += 1\n e += 1\n\n # Find the indices for this period of data\n tmp = exceedence_dist[np.argmax(onset_trim[exceedence])]\n tmp = np.where(exceedence_dist == tmp)\n\n # Add one data point below the threshold at each end of this period\n gau_idxmin = exceedence[tmp][0] + win_min - 1\n gau_idxmax = exceedence[tmp][-1] + win_min + 2\n\n # Initial guess for gaussian half-width based on onset function\n # STA window length\n data_half_range = int(sta_winlen * self.sampling_rate / 2)\n\n # Select data to fit the gaussian to\n x_data = np.arange(gau_idxmin, gau_idxmax, dtype=float)\n x_data = x_data / self.sampling_rate\n y_data = onset[gau_idxmin:gau_idxmax]\n\n # Convert indices to times\n x_data_dt = np.array([])\n for i in range(len(x_data)):\n x_data_dt = np.hstack([x_data_dt, start_time + x_data[i]])\n\n # Try to fit a gaussian.\n try:\n # Initial parameters are:\n # height = max value of onset function\n # mean = time of max value\n # sigma = data half-range (calculated above)\n p0 = [np.max(y_data),\n float(gau_idxmin + np.argmax(y_data))\n / self.sampling_rate,\n data_half_range / self.sampling_rate]\n\n # Do the fit\n popt, _ = curve_fit(util.gaussian_1d, x_data, y_data, p0)\n\n # Results:\n # popt = [height, mean (seconds), sigma (seconds)]\n max_onset = popt[0]\n # Convert mean (pick time) to time\n mean = start_time + float(popt[1])\n sigma = np.absolute(popt[2])\n\n gaussian_fit = {\"popt\": popt,\n \"xdata\": x_data,\n \"xdata_dt\": x_data_dt,\n \"PickValue\": max_onset,\n \"PickThreshold\": threshold}\n\n # If curve_fit fails. Will also spit error message to stdout,\n # though this can be suppressed - see warnings.filterwarnings()\n except (ValueError, RuntimeError):\n gaussian_fit = self.DEFAULT_GAUSSIAN_FIT\n gaussian_fit[\"PickThreshold\"] = threshold\n sigma = -1\n mean = -1\n max_onset = -1\n\n # If onset function does not exceed threshold in pick window\n else:\n gaussian_fit = self.DEFAULT_GAUSSIAN_FIT\n gaussian_fit[\"PickThreshold\"] = threshold\n sigma = -1\n mean = -1\n max_onset = -1\n\n return gaussian_fit, max_onset, sigma, mean","def _get_ring_nodes(m, namin=3, namax=9, remove_redudant=T):\n # first search for rings\n sets = []\n for i in range(namin, namax+1):\n #if i in [3,4,5]:\n pat_i = '*~1' + '~*'*(i-2) + '~*1'\n #else:\n # pat_i = '*:1' + ':*'*(i-2) + ':*1'\n Qi = Chem.MolFromSmarts( pat_i )\n for tsi in m.GetSubstructMatches(Qi):\n set_i = set(tsi)\n if set_i not in sets:\n sets.append( set(tsi) )\n if remove_redudant:\n # now remove those rings that are union of smaller rings\n n = len(sets)\n sets_remove = []\n ijs = itl.combinations( list(range(n)), 2 )\n sets_u = []\n for i,j in ijs:\n set_ij = sets[i].union( sets[j] )\n if (set_ij in sets) and (set_ij not in sets_remove):\n sets_remove.append( set_ij )\n sets_u = cim.get_compl(sets, sets_remove)\n else:\n sets_u = sets\n return sets_u","def onsets_rb(self) -> Optional[annotations.BeatData]:\n return load_onsets(self.onsets_rb_path)","def getSets():","def emg_onsets(emg_amplitude, threshold=0, threshold2=None):\n # Sanity checks.\n if not isinstance(emg_amplitude, np.ndarray):\n emg_amplitude = np.atleast_1d(emg_amplitude).astype('float64')\n if threshold > np.max(emg_amplitude):\n raise ValueError(\"NeuroKit error: emg_onsets(): threshold\"\n \"specified exceeds the maximum of the signal\"\n \"amplitude.\")\n if threshold2 is not None and threshold2 > np.max(emg_amplitude):\n raise ValueError(\"NeuroKit error: emg_onsets(): threshold2\"\n \"specified exceeds the maximum of the signal\"\n \"amplitude.\")\n\n # Extract indices of data points greater than or equal to threshold.\n indices = np.nonzero(emg_amplitude >= threshold)[0]\n\n # Extract initial and final indexes of each activity burst.\n indices = np.vstack((indices[np.diff(np.hstack((-np.inf, indices))) > 1],\n indices[np.diff(np.hstack((indices, np.inf))) > 1])).T\n indices = indices[indices[:, 1]-indices[:, 0] >= 0, :]\n\n # Threshold2.\n if threshold2 is not None:\n indices2 = np.ones(indices.shape[0], dtype=bool)\n for i in range(indices.shape[0]):\n if np.count_nonzero(emg_amplitude[indices[i, 0]: indices[i, 1]+1] >= threshold2) < 1:\n indices2[i] = False\n indices = indices[indices2, :]\n\n # Prepare output.\n indices = list(np.concatenate(indices))\n info = {\"EMG_Onsets\": indices}\n\n return info","def loopreelset(combination, reel_set):\n matching_reels = []\n for index in range(5):\n if if3symbols(combination[index][0],combination[index][1],combination[index][2], reel_set[index]):\n matching_reels.append(index)\n if len(matching_reels) == 5:\n return True","def lego_sets():\n # you must replace this line and return your own list\n return []","def GET_MODIS_LANDSAT_PAIRS(self, datasets, latitude, longitude, start_date, end_date, max_cloud_cover):\n total_scenes = []\n START_DATE = start_date\n END_DATE = end_date\n \"\"\"\n search through given dates\n finds matching dates and position. \n \"\"\"\n\n #while len(total_scenes) < num_pairs and int((date.fromisoformat(START_DATE) - date.fromisoformat(end_date)).days):\n ### Search for Landsat products ###\n Landsat_scenes = self.api.search(\n dataset=datasets[0],\n latitude=latitude,\n longitude=longitude,\n start_date=START_DATE,\n end_date=END_DATE,\n max_cloud_cover=max_cloud_cover,\n max_results=1000)\n\n # the scenes will be ordered oldest -> most recent\n START_DATE = Landsat_scenes[0]['acquisitionDate']\n\n ### Search for MODIS products ###\n MODIS_scenes = self.api.search(\n dataset=datasets[1],\n latitude=latitude,\n longitude=longitude,\n start_date=START_DATE,\n end_date=END_DATE,\n max_cloud_cover=max_cloud_cover,\n max_results=1000)\n\n # the scenes will be ordered oldest -> most recent\n # next iteration starts at last found landsat date\n START_DATE = Landsat_scenes[-1]['acquisitionDate']\n\n\n # make dict so we can access with dates and scene bounds\n Landsat_scenes = {scene['acquisitionDate']: scene for scene in Landsat_scenes}\n MODIS_scenes = {scene['acquisitionDate']: scene for scene in MODIS_scenes}\n ### GET MATCHING DATES ###\n keys = set(MODIS_scenes.keys()).intersection(Landsat_scenes.keys())\n\n ### generate tuple pairs, landsat, modis ###\n found_scenes = [(Landsat_scenes[date], MODIS_scenes[date]) for date in keys]\n total_scenes += found_scenes\n if len(found_scenes):\n print(\"{} scenes found...\".format(len(found_scenes)))\n print(\"{} total scenes\".format(len(total_scenes)))\n else:\n print(\"{} total scenes\".format(len(total_scenes)))\n\n return total_scenes","def check_setpoints(self):\n # TODO: Can possibly put this in the CCBC Brains\n for heater in self.ard_data['heaters'].keys():\n current_temp = float(self.ard_data['tempsensors'][self.ard_data['heaters'][heater]['tsensor_name']]['value'])\n\n # Assign the pin_status the previous value from the previous iteration\n pin_status = self.ard_data['heaters'][heater]['status']\n\n if current_temp > self.ard_data['heaters'][heater]['upper limit']:\n pin_status = 'OFF'\n\n if current_temp < self.ard_data['heaters'][heater]['lower limit']:\n pin_status = 'ON'\n\n if current_temp >= self.ard_data['heaters'][heater]['maxtemp']:\n pin_status = 'OFF'\n\n self.ard_data['heaters'][heater]['status'] = pin_status\n\n for pump in self.ard_data['pumps'].keys():\n pressure = float(self.ard_data['presssensors'][self.ard_data['pumps'][pump]['psensor_name']]['pressure'])\n gallons = float(pressure * self.ard_data['pumps'][pump]['psi_to_gal_slope'] +\n self.ard_data['pumps'][pump]['psi_to_gal_intercept'])\n self.ard_data['pumps'][pump]['gallons'] = gallons\n\n # Assign the pin status the previous value from the previous cycle\n pin_status = self.ard_data['pumps'][pump]['status']\n\n if gallons > self.ard_data['pumps'][pump]['upper limit']:\n # Turn the pump off when the setpoint is above the setpoint\n pin_status = 'OFF'\n # TODO: Account for solenoid valve control when available\n\n if gallons < self.ard_data['pumps'][pump]['lower limit']:\n pin_status = 'ON'\n\n self.ard_data['pumps'][pump]['status'] = pin_status","def lfcSet(file_list):\n # Just out of paranoia, order the LFC files\n pseudo_time = np.empty_like(file_list,dtype='float')\n file_date = np.empty_like(file_list,dtype='float')\n file_obsn = np.empty_like(file_list,dtype='float')\n for i,file_name in enumerate(file_list):\n file_id = os.path.basename(file_name).split('_')[-1][:-5]\n pseudo_time[i] = file_id\n file_date[i], file_obsn[i] = file_id.split('.')\n time_sort = np.argsort(pseudo_time)\n file_list = np.array(file_list)[time_sort]\n file_date = file_date[time_sort]\n file_obsn = file_obsn[time_sort]\n \n sets = []\n consecutive = []\n date = file_date[0]\n for i in range(1,len(file_list)):\n if date != file_date[i]:\n date = file_date[i]\n sets.append(consecutive)\n consecutive=[file_list[i]]\n elif file_obsn[i] != file_obsn[i-1]+1:\n sets.append(consecutive)\n consecutive=[file_list[i]]\n else:\n consecutive.append(file_list[i])\n return sets","def save_conditions_onsets(conditions_onsets,\n onsets_dir=tempfile.gettempdir()):\n condition_files = []\n\n for cid, cframe in conditions_onsets.groupby(['session_name',\n 'condition_id']):\n session_id, condition_id = cid\n onset_dir = os.path.join(onsets_dir, session_id)\n if not os.path.exists(onset_dir):\n os.makedirs(onset_dir)\n fname = os.path.join(onset_dir, 'cond%03i.txt' % condition_id)\n cframe[['onset', 'duration', 'amplitude']].to_csv(\n fname, sep=' ', header=False, index=False)\n condition_files.append(fname)\n\n return condition_files","def buildConnectedSets(self, cars):","def analyze(self, event):\n '''\n\tif not (event.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ or event.HLT_Mu17_TrkIsoVVL_TkMu8_TrkIsoVVL_DZ or event.HLT_IsoTkMu24 or event.HLT_IsoMu24):\n\t self.out.fillBranch(\"pass_selection\",0)\n return True\n '''\n\telectrons = Collection(event, \"Electron\")\n muons = Collection(event, \"Muon\")\n jets = Collection(event, \"Jet\")\n Z = ROOT.TLorentzVector()\n\n\ttight_muons = []\n\tgoodmuons_pt = []\n goodmuons_eta = [] \n\n\tif (len(muons)<=1):\n\t\tself.out.fillBranch(\"pass_selection\",0)\n return True\n\tfor i in range(0,len(muons)):\n #if (muons[i].eta) < 2.4 and (muons[i].mediumId) and (muons[i].pfIsoId)>=3:\n\t if (muons[i].eta) < 2.4 and (muons[i].mediumId):\n\t if (muons[i].pt) <= 25:\n continue\n\t\tfor j in range(i+1,len(muons)):\n \t\t #if (muons[j].eta) < 2.4 and (muons[j].mediumId) and (muons[j].pfIsoId)>=3:\n\t if (muons[j].eta) < 2.4 and (muons[j].mediumId):\n\t if (muons[j].pt) <= 20:\n\t\t\t continue\n\t\t if (muons[i].charge + muons[j].charge == 0):\n\t\t\t Z = muons[i].p4() + muons[j].p4()\n\t\t\t if (Z.M() > 76 and Z.M() < 106):\n\t\t\t\tself.out.fillBranch(\"pass_selection\",1)\n\t \t\tself.out.fillBranch(\"z_pt\",Z.Pt())\n\t\t\t\tself.out.fillBranch(\"z_mass\",Z.M())\n\t\t\t\tself.out.fillBranch(\"z_phi\",Z.Phi())\n\t\t\t\ttight_muons.append(muons[i]) \n\t\t\t\ttight_muons.append(muons[j])\n\t\n\tif len(tight_muons) < 2:\n\t self.out.fillBranch(\"pass_selection\",0)\n\t return True\n\n ngoodmuons = 0\n ngoodmuons = len(tight_muons)\n\tif ngoodmuons != 2:\n print(ngoodmuons)\n\n goodmuons_pt.append(tight_muons[0].pt)\n goodmuons_pt.append(tight_muons[1].pt)\n goodmuons_eta.append(tight_muons[0].eta)\n goodmuons_eta.append(tight_muons[1].eta) \n \n self.out.fillBranch(\"muon_pt\",goodmuons_pt)\n self.out.fillBranch(\"muon_eta\",goodmuons_eta) \n \n\tngoodjets = 0\n goodjets_pt = []\n\tgoodjets_id = []\n\tgoodjets_phi = []\n\tgoodjets_dphi_zjet = []\n\n\tfor k in range(0,len(jets)):\n #print(4)\n\t if abs(jets[k].eta) > 2.4:\n continue\n #print(5) \n\t if jets[k].pt < 30:\n\t\tcontinue\n\t #print(6)\n\t pass_lepton_dr_cut = True\n\n\t for i in range(0,len(tight_muons)):\n\t\t#if deltaR(muons[tight_muons[i]].eta,muons[tight_muons[i]].phi,jets[k].eta,jets[k].phi) < 0.4:\n if deltaR(tight_muons[i].eta,tight_muons[i].phi,jets[k].eta,jets[k].phi) < 0.4:\n\t pass_lepton_dr_cut = False\n\n\t if not pass_lepton_dr_cut:\n\t\tcontinue\n\n ngoodjets += 1\n goodjets_pt.append(jets[k].pt)\n\t #goodjets_id.append(jets[k].jetId)\n\t goodjets_phi.append(jets[k].phi)\t \n\t #goodjets_dphi_zjet.append(deltaPhi(Z.Phi(),jets[k].phi)) \n\n if ngoodjets != len(goodjets_pt):\n print(error)\n\n self.out.fillBranch(\"jet_pt\",goodjets_pt)\n\t#self.out.fillBranch(\"jet_id\",goodjets_id)\n\tself.out.fillBranch(\"jet_phi\",goodjets_phi)\n\t#self.out.fillBranch(\"dphi_zjet\",goodjets_dphi_zjet)\n\t'''\n\tif(njet!=0):\n\t print(njet)\n '''\n\tif hasattr(event,\"Generator_weight\"):\n self.out.fillBranch(\"gen_weight\",event.Generator_weight)\n else:\n self.out.fillBranch(\"gen_weight\",0)\n\treturn True","def get_sparse_noise_onset_index(sparseNoiseDisplayLog):\n\n\n frames = sparseNoiseDisplayLog['presentation']['displayFrames']\n frames = [tuple([np.array([x[1][1],x[1][0]]),x[2],x[3],i]) for i, x in enumerate(frames)]\n dtype = [('location',np.ndarray),('sign',int),('isOnset',int),('index',int)]\n frames = np.array(frames, dtype = dtype)\n\n allOnsetInd = []\n for i in range(len(frames)):\n if frames[i]['isOnset'] == 1 and (i == 0 or frames[i-1]['isOnset'] == -1):\n allOnsetInd.append(i)\n\n onsetFrames = frames[allOnsetInd]\n\n allSquares = list(set([tuple([x[0][0],x[0][1],x[1]]) for x in onsetFrames]))\n\n onsetIndWithLocationSign = []\n\n for square in allSquares:\n indices = []\n for onsetFrame in onsetFrames:\n if onsetFrame['location'][0]==square[0] and onsetFrame['location'][1]==square[1] and onsetFrame['sign']==square[2]:\n indices.append(onsetFrame['index'])\n\n onsetIndWithLocationSign.append([np.array([square[0],square[1]]),square[2],indices])\n\n return allOnsetInd, onsetIndWithLocationSign","def stations(station_let):\n\tstat = ['']*np.size(station_let,0)\n\tfor i in range(len(stat)):\n\t\tfor j in range(4):\n\t\t\tif station_let[i][j] is not np.ma.masked:\n\t\t\t\tstat[i]+=station_let[i][j]\n\treturn stat","def GetBonds(Bonds):\n b = sorted([(min(x), max(x)) for x in Bonds])\n Bonds13, Bonds14 = [], []\n for (a1,b1) in b:\n #check for bonds with a1 at the center of a 1-3 interaction,\n #letting b1 be the higher number of the two flanking\n clist = [b2 for (a2,b2) in b if a2 == a1 and b2 < b1] + \\\n [a2 for (a2,b2) in b if b2 == a1 and a2 < b1]\n Bonds13.extend([(min(c,b1), max(c,b1)) for c in clist])\n #check for bonds with b1 at the center of a 1-3 interaction,\n #letting a1 be the higher number of the two flanking\n clist = [b2 for (a2,b2) in b if a2 == b1 and b2 < a1] + \\\n [a2 for (a2,b2) in b if b2 == b1 and a2 < a1]\n Bonds13.extend([(min(c,a1), max(c,a1)) for c in clist])\n #find atoms connected to a1\n clist = [b2 for (a2,b2) in b if a1==a2 and not b1==b2] +\\\n [a2 for (a2,b2) in b if a1==b2 and not b1==a2]\n #find atoms connected to b1\n dlist = [a2 for (a2,b2) in b if b1==b2 and not a1==a2] +\\\n [b2 for (a2,b2) in b if b1==a2 and not a1==b2]\n Bonds14.extend([(min(c,d), max(c,d)) for c in clist for d in dlist])\n Bonds1213 = b + Bonds13\n #sort\n Bonds1213.sort()\n Bonds14.sort()\n #get unique values in case of loops\n Bonds1213 = [x for (i,x) in enumerate(Bonds1213) if i == 0 or x != Bonds1213[i-1]]\n Bonds14 = [x for (i,x) in enumerate(Bonds14) if i == 0 or x != Bonds14[i-1]]\n #convert to arrays \n Bonds1213 = array(Bonds1213, int)\n Bonds14 = array(Bonds14, int)\n return Bonds1213, Bonds14","def get_max_num_onsets():\r\n \"\"\" based on the numbers above, should equal to 932945... \"\"\"\r\n c1 = len(gen_onset_c1())\r\n c2 = len(gen_onset_c2())\r\n c3 = len(gen_onset_c3_c4())\r\n c4 = len(gen_onset_c3_c4())\r\n temp = c1\r\n temp = temp + ( c1 * c2 )\r\n temp = temp + ( c1 * c3 )\r\n temp = temp + ( c1 * c2 * c3 )\r\n temp = temp + ( c1 * c3 * c4 )\r\n temp = temp + ( c1 * c2 * c3 * c4 )\r\n return temp","def get_sensor_bool_dryspot_runlevel(self, filename, threshold_min_counted_dryspots=5):\n f = h5py.File(filename, \"r\")\n meta_file = h5py.File(str(filename).replace(\"RESULT.erfh5\", \"meta_data.hdf5\"), 'r')\n\n try:\n single_states, set_of_states, useless_states = self.__get_dryspot_data(f, meta_file)\n multi_states = self.__get_pressure_data(f)\n multi_states = multi_states.squeeze()\n\n activated_sensors = np.count_nonzero(multi_states, axis=1)\n percentage_of_all_sensors = activated_sensors / 1140\n len_wanted_seq = 100\n current = 0\n sequence = np.zeros((len_wanted_seq, self.num_sensors))\n frame_labels = []\n\n if self.aux_info:\n original_frame_idxs = np.full(len_wanted_seq, np.nan, np.int16)\n frame_labels_aux = np.full(len_wanted_seq, np.nan, np.int8)\n sample_percentages = np.full(len_wanted_seq, np.nan)\n single_state_indices = np.full(len_wanted_seq, np.nan, np.int16)\n # flowfronts = np.zeros((len_wanted_seq, self.image_size[0], self.image_size[1]))\n # _coords, flat_fillings = self.__get_filling_data(f, single_states)\n\n for i, sample in enumerate(single_states):\n state_num = int(str(sample).replace(\"state\", \"0\"))\n try:\n sample_percentage = percentage_of_all_sensors[state_num - 1]\n if sample_percentage >= current / len_wanted_seq:\n data = multi_states[state_num - 1, :]\n data = np.log(np.add(data, 1)) # TODO make log optional\n if self.sensor_indizes != ((0, 1), (0, 1)):\n rect = data.reshape(38, 30)\n sel = rect[self.sensor_indizes[0][0]::self.sensor_indizes[0][1],\n self.sensor_indizes[1][0]::self.sensor_indizes[1][1]]\n data = sel.flatten()\n sequence[current, :] = data\n\n frame_label = 0\n if state_num in set_of_states:\n frame_label = 1\n frame_labels.append(frame_label)\n\n if self.aux_info:\n original_frame_idxs[current] = state_num\n frame_labels_aux[current] = frame_label\n sample_percentages[current] = sample_percentage\n single_state_indices[current] = i\n # flowfronts[current, :, :] = create_np_image(target_shape=self.image_size,\n # norm_coords=_coords, data=flat_fillings[i])\n current += 1\n except IndexError:\n continue\n\n # determine runlevel label using frame labels and threshold\n lens_of_runs_of_dryspots = [sum(1 for _ in group) for key, group in\n groupby(np.array(frame_labels) == 1) if key]\n max_len = 0 if len(lens_of_runs_of_dryspots) == 0 else max(lens_of_runs_of_dryspots)\n label = 0 if max_len < threshold_min_counted_dryspots else 1\n\n f.close()\n meta_file.close()\n\n if self.aux_info:\n # framelabels, original_frame_idx, original_num_frames, flowfronts, filling_percentage\n aux = {\"framelabel\": frame_labels_aux,\n \"original_frame_idx\": original_frame_idxs,\n \"original_num_multi_states\": len(multi_states),\n \"percent_of_sensors_filled\": sample_percentages,\n \"single_state_indices\": single_state_indices,\n }\n return [(sequence, label, aux)]\n\n return [(sequence, label)]\n except KeyError:\n f.close()\n meta_file.close()\n return None","def extract_onset_events(bin_path, chanList, chunk_size=4000):\n meta = readMeta(bin_path)\n sRate = SampRate(meta)\n\n n_samples = int(float(meta['fileTimeSecs']) * sRate)\n n_chunks = sp.floor(n_samples / chunk_size).astype('int32')\n print(\"leftover samples: %i\" % (n_samples % n_chunks))\n\n rawData = makeMemMapRaw(bin_path, meta)\n\n events = []\n for ch in chanList:\n inds = []\n\n # get digital data for the selected lines\n for i in tqdm(range(n_chunks)):\n start = i * chunk_size\n stop = start + chunk_size\n\n digArray = ExtractDigital(rawData, start, stop, 0, range(8), meta)\n trig_data = digArray[ch,:]\n\n ix = sp.where(sp.diff(trig_data) == 1)[0]\n inds.append(ix+start)\n # if len(ix) > 0:\n # print(len(ix))\n\n inds = sp.concatenate(inds)\n times = inds / sRate\n events.append([inds,times])\n\n return events","def connected_sets(self):\n self._assert_counted_at_lag()\n return self._connected_sets","def find_arms(path,fr_nb):\n im=open_frame(path,fr_nb)\n img=im.copy()\n im=img_as_ubyte(im)\n mask_h = hysteresis_thresholding(img,6,10)\n \n ksize=5\n kernel = np.ones((ksize,ksize),dtype = np.uint8)\n kernel = skimage.morphology.disk(ksize)\n \n mask = cv2.morphologyEx(mask_h, cv2.MORPH_OPEN, kernel,iterations=2)\n \n arms = mask_h-mask\n \"\"\"\n lab,_ = ndi.label(diff)\n \n arms = skimage.morphology.remove_small_objects(lab,60)\"\"\" #Only temporary, to track only the biggest\n return mask,arms","def findSubsetIndices(grdMODEL, min_lat, max_lat, min_lon, max_lon):\n\n\n if min_lon<0 and max_lon>0:\n splitExtract = True; Turns=2\n grdMODEL.splitExtract=splitExtract\n else:\n splitExtract = False; Turns=1\n grdMODEL.splitExtract=splitExtract\n grdMODEL.lon = np.where(grdMODEL.lon>180,grdMODEL.lon-360,grdMODEL.lon)\n \n # Array to store the results returned from the function\n res=np.zeros((Turns,4),dtype=np.float64)\n \n lats=grdMODEL.lat[:,0]\n lons=grdMODEL.lon[0,:]\n\n \n for k in range(Turns):\n\n if k==0 and splitExtract == True:\n minLon=min_lon; maxLon=0\n minLon=minLon+360\n maxLon=maxLon+360\n elif k==1 and splitExtract == True:\n minLon=0; maxLon=max_lon\n else:\n minLon=min_lon; maxLon=max_lon\n \n distances1 = []\n distances2 = []\n indices=[]\n index=1\n for point in lats:\n s1 = max_lat-point # (vector subtract)\n s2 = min_lat-point # (vector subtract)\n distances1.append((np.dot(s1, s1), point, index))\n distances2.append((np.dot(s2, s2), point, index-1))\n index=index+1\n\n distances1.sort()\n distances2.sort()\n indices.append(distances1[0])\n indices.append(distances2[0])\n \n distances1 = []\n distances2 = []\n index=1\n \n for point in lons:\n s1 = maxLon-point # (vector subtract)\n s2 = minLon-point # (vector subtract)\n distances1.append((np.dot(s1, s1), point, index))\n distances2.append((np.dot(s2, s2), point, index-1))\n index=index+1\n \n distances1.sort()\n distances2.sort()\n indices.append(distances1[0])\n indices.append(distances2[0])\n\n # Save final product: max_lat_indices,min_lat_indices,max_lon_indices,min_lon_indices\n minJ=indices[1][2]\n maxJ=indices[0][2]\n minI=indices[3][2]\n maxI=indices[2][2]\n \n res[k,0]=minI; res[k,1]=maxI; res[k,2]=minJ; res[k,3]=maxJ;\n\n # Save final product: max_lat_indices,min_lat_indices,max_lon_indices,min_lon_indices\n grdMODEL.indices=res","def finalSubsets(self):\n subs = self.allSubsets()\n for s in self.graph.observed:\n subs = subs[subs[:,s] == 1,] # remove subsets where values in s are not True\n return subs","def isophase(_groups, colour, period):\n # Whole numbers are required, so odd numbers are dealt with by loading\n # the spare into the off period.\n # As this is in milliseconds, this will be imperceptible.\n # It is also unlikely, as the top-level input is in seconds\n # and has been multiplied up to milliseconds before reaching this\n # function\n return [\n (colour, math.floor(period/2)),\n ('Off', math.ceil(period/2))\n ]","def get_masks(data):\n return [patient[0] for i, patient in enumerate(data) if i in good_patients]","def lego_sets():\n # you must replace this line and return your own list\n return lego_sets_list","def find_rings(atom_list): \n CX_list = [atom0 for atom0 in atom_list if ((atom0.atom_name == \"CX\") or (atom0.atom_name == \"CY\"))]\n atom_dict = {}\n for atom0 in CX_list:\n if (len(identify_bonds(atom0, atom_list)) >= 2):\n atom_dict[atom0] = {}\n for atom1 in identify_bonds(atom0, atom_list):\n if ( ((atom1[0].atom_name == \"CX\") or (atom1[0].atom_name == \"CY\")) and (len(identify_bonds(atom1[0], atom_list)) >= 2) ):\n atom_dict[atom0][atom1[0]] = {}\n for atom2 in identify_bonds(atom1[0], atom_list):\n if ( ((atom2[0].atom_name == \"CX\") or (atom2[0].atom_name == \"CY\")) and (atom2[0] != atom0) and (len(identify_bonds(atom2[0], atom_list)) >= 2)):\n atom_dict[atom0][atom1[0]][atom2[0]] = {}\n for atom3 in identify_bonds(atom2[0], atom_list):\n if ( ((atom3[0].atom_name == \"CX\") or (atom3[0].atom_name == \"CY\")) and (atom3[0] != atom0) and (len(identify_bonds(atom3[0], atom_list)) >= 2)):\n atom_dict[atom0][atom1[0]][atom2[0]][atom3[0]] = [atom3[0].atom_number]\n rings = []\n for key in atom_dict.keys():\n for key2 in atom_dict[key].keys():\n for key3 in atom_dict[key][key2].keys():\n for key4 in atom_dict[key][key2][key3].keys():\n rings.append([key, key2, key3, key4])\n finite_rings = []\n for element in rings:\n for element2 in rings:\n if ((element[0] == element2[0]) and (element[3] == element2[3]) and (element[1] != element2[1]) and (element[1] != element2[2]) and (element[2] != element2[1]) and (element[2] != element2[2]) and (element[0] != element2[1] != element[3]) and (element[0] != element2[2] != element[3])):\n check = True\n for el in finite_rings:\n if ((element[0] in el) and (element[1] in el) and (element[2] in el) and (element[3] in el) and (element2[0] in el) and (element2[1] in el) and (element2[2] in el) and (element2[3] in el)):\n check = False\n if (check == True):\n finite_rings.append([element[0], element[1], element[2], element[3], element2[1], element2[2]])\n return finite_rings","def do_one_set_sims(num_sims=100, num_darts=1000):\n areas = N.zeros(num_sims, dtype='f')\n for isim in range(num_sims):\n areas[isim] = do_one_sim(num_darts)\n return (N.mean(areas), N.std(areas))","def get_effective_lumi(array_from_googledoc,_era,_skoutput ,data_skoutput, _skdatadir,_dirlist,_summary_path,skim_list, _workdir, RunFull):\n\n print_message(1,\"get_effective_lumi [\"+_era+\"]\")\n\n \"\"\" loop over dataset list on tamsa\"\"\"\n var_url = get_url_from_era(_era,False)\n\n arr_alias=[]\n arr_alias_torun=[]\n array_gd = array_from_googledoc\n\n for dsn in _dirlist:\n \n array_gd = array_from_googledoc\n\n\n var_alias = find_googledoc_var_from_dsn(array_gd,_era,\"alias\", dsn)\n\n if var_alias == \"NULL\" :\n print \"Skipping NULL [get_effective_lumi] \" +dsn\n continue\n\n if not os.path.exists(data_skoutput+\"/\"+ var_alias +\".txt\"):\n print \"get_effective_lumi: adding \" + var_alias + \" to processing list\"\n arr_alias_torun.append(var_alias)\n\n \n arr_alias.append(var_alias)\n if os.path.exists( _workdir+\"/MC\"+_era+\".txt\"):\n os.system(\"rm \" + _workdir + \"/MC\"+_era+\".txt\")\n\n w_list=open(_workdir+\"/MC\"+_era+\".txt\",\"w\")\n\n for x in arr_alias_torun:\n w_list.write(x.split()[0]+\"\\n\")\n w_list.close()\n \n return_list=[]\n\n if len(arr_alias_torun) > 0:\n currentdir = os.getenv(\"PWD\")\n print \"SKFlat.py -a GetEffLumi -l \"+currentdir+\"/\"+_workdir+\"/MC\"+_era+\".txt -n 50 --nmax 300 -e \"+_era\n\n os.chdir(os.getenv(\"SKFlat_WD\"))\n os.system(\"SKFlat.py -a GetEffLumi -l \"+currentdir+\"/\"+_workdir+\"/MC\"+_era+\".txt -n 50 --nmax 300 -e \"+_era )\n for x in arr_alias_torun:\n print \"SKFlat.py -a GetEffLumi -i \"+x.split()[0] +\" -n 50 --nmax 300 -e \"+_era \n #print ('cp ' + _skoutput + \"/GetEffLumi/\"+_era + \"/GetEffLumi_\"+ x.split()[0] +\".root \" + data_skoutput+\"/\")\n #os.system('cp ' + _skoutput + \"/GetEffLumi/\"+_era + \"/GetEffLumi_\"+ x.split()[0] +\".root \" + data_skoutput+\"/\")\n\n #GetEFf=False\n #while not GetEFf:\n # l_userinput= raw_input ('Check if Eff lumi job is ok? [y/ MCname]:') \n # if l_userinput == \"y\" : \n # print \"Good\"\n # GetEFf=True\n # else:\n # os.system(\"SKFlat.py -a GetEffLumi -i \"+l_userinput+\" -n 50 --nmax 300 -e \"+_era )\n \n\n for skim in skim_list:\n new_list=open(currentdir+\"/\"+_workdir+\"/MC\"+_era+\".txt\",\"r\")\n new_skimlist=open(currentdir+\"/\"+_workdir+\"/MC_\"+skim+\"_\"+_era+\".txt\",\"w\")\n runSkim=False\n for l in new_list:\n l = l.split()[0]\n #allowed_inputs=['y','n']\n #l_userinput ='NULL'\n #while not l_userinput in allowed_inputs:\n # l_userinput= raw_input ('Sample to update ['+l+']: make skim ' + skim + ' [y/n]:')\n\n \n if run_skim_from_googledoc(_era,l , skim,var_url) == \"Y\": #l_userinput == \"y\":\n print 'Sample to update ['+l+']: make skim ' + skim\n new_skimlist.write(l+'\\n')\n runSkim=True\n return_list.append(find_googledoc_var_from_alias(_era, \"dsn\", l.split()[0],var_url))\n\n new_list.close()\n new_skimlist.close()\n if runSkim:\n os.system(\"SKFlat.py -a \"+skim+\" -l \"+currentdir+\"/\"+_workdir+\"/MC_\"+skim+\"_\"+_era+\".txt -n 100 --nmax 300 -e \"+_era )\n \n \n os.system(\"rm \"+currentdir+\"/\"+_workdir+\"/MC_\"+skim+\"_\"+_era+\".txt\")\n os.chdir(currentdir)\n \n else:\n print \"get_effective_lumi: all samples proccessed previously\"\n\n ''' delete job submittion file '''\n os.system(\"rm \"+ _workdir+ \"/MC\"+_era+\".txt\") \n\n \n ''' run over ds list at tamsa and fill common samplefile'''\n\n print ('Fill CommonSampleFiles')\n\n update_array=[]\n\n for dsn in _dirlist:\n ''' access alias and xsec fmor google doc'''\n\n array_gd = array_from_googledoc\n\n var_alias = find_googledoc_var_from_dsn(array_gd,_era,\"alias\", dsn)\n if var_alias == \"NULL\" :\n continue\n\n\n if not RunFull:\n if not var_alias in arr_alias_torun:\n print (\"skipping \" + var_alias + \" since not running Full mode\")\n continue\n \n else:\n print 'Filling for ' + dsn\n\n var_xsec = find_googledoc_var_from_dsn(array_gd,_era,\"xsec\" , dsn)\n\n #''' get nevents from GetEffLumi job'''\n\n dirpath = _skoutput + \"/GetEffLumi/\"+_era + \"/\"\n _file = ROOT.TFile(dirpath + \"/GetEffLumi_\"+ var_alias + \".root\")\n hist = _file.Get(\"sumW\")\n nevents_w = hist.Integral()\n signhist = _file.Get(\"sumSign\")\n nevents_sign = signhist.Integral()\n _file.Close()\n nevents_no_w=0\n \n orig_xsec=\"\"\n orig_nevent_no_w=\"\"\n orig_nevent_sign=\"\"\n orig_nevent_w=\"\"\n\n \n print \"Reading : \" + dsn\n print \"Reading \" + _skdatadir + _era+ \"/Sample/CommonSampleInfo/\"+var_alias+\".txt\"\n\n orig_common_list = open(_skdatadir + _era+ \"/Sample/CommonSampleInfo/\"+var_alias+\".txt\",\"r\")\n\n for line in orig_common_list:\n if not \"#\" in line:\n if len(line.split()) < 1:\n continue\n orig_xsec=line.split()[2]\n orig_nevent_no_w=line.split()[3]\n orig_nevent_sign=line.split()[4]\n orig_nevent_w=line.split()[5]\n orig_common_list.close()\n\n print ('Filled for original values')\n update_file=False\n\n if not orig_xsec == var_xsec:\n update_file=True\n print \"CommonSampleInfo xsec updated for \" + var_alias\n\n #if not orig_nevent_no_w==str(nevents_no_w):\n #update_file=True\n #print \"CommonSampleInfo xsec updated for nevents_no_w \" + str(nevents_no_w)\n if not float(orig_nevent_w)==nevents_w:\n update_file=True\n nevents_no_w=nevents(_skdatadir + _era+ \"/Sample/ForSNU/\"+var_alias + \".txt\")\n print \"CommonSampleInfo updated for nevents_w \" + str(nevents_w)\n\n elif not float(orig_nevent_sign)==nevents_sign:\n update_file=True\n nevents_no_w=nevents(_skdatadir + _era+ \"/Sample/ForSNU/\"+var_alias + \".txt\")\n print \"CommonSampleInfo updated for nevents_sign \" + str(nevents_sign)\n else: \n nevents_no_w=orig_nevent_no_w\n\n if update_file:\n ''' make commonfile for alias'''\n common_list=open(_skdatadir + _era+ \"/Sample/CommonSampleInfo/\"+var_alias+\".txt\",\"w\")\n common_list.write(\"# alias PD xsec nmc sumsign sumw\\n\")\n common_list.write( var_alias + \"\\t\" + dsn + \"\\t\" + var_xsec + \"\\t\" + str(nevents_no_w) +\"\\t\"+ str(nevents_sign) +\"\\t\"+ str(nevents_w)+\" \\n\") \n\n\n common_list.close()\n os.system(\"git diff \" + _skdatadir + _era+ \"/Sample/CommonSampleInfo/\"+var_alias+\".txt\")\n\n update_array.append([var_alias,var_xsec, nevents_no_w, nevents_sign , nevents_w])\n\n\n if len(update_array) > 0:\n update_summarymc_file(_era)\n\n return return_list","def find_tps(ckt, a):\n return set([x for x in a if ckt[x].fots.isdisjoint(set(a))])","def find_endpoints(batch_trajectories):\n # empty lists to fill\n site_lats = []\n site_lons = []\n last_lats = []\n last_lons = []\n lats_150 = []\n lons_150 = [] \n last_times = []\n times_150 = []\n last_sst = []\n sst_150 = []\n \n # temporary lists as placeholders\n temp_site_lats = []\n temp_site_lons = []\n temp_lats = []\n temp_lons = []\n temp_lats150 = []\n temp_lons150 = []\n temp_times = []\n temp_times150 = []\n temp_sst = []\n temp_sst150 = []\n\n for speed in range(len(batch_trajectories)):\n # working with one speed at a time means working with one nc file at\n # a time\n \n # reset temporary lists\n temp_site_lats = []\n temp_site_lons = []\n temp_lats = []\n temp_lons = []\n temp_lats150 = []\n temp_lons150 = []\n temp_times = []\n temp_times150 = []\n temp_sst = []\n temp_sst150 = []\n\n # extract variables into lists\n lats = batch_trajectories[speed].variables['lat'][:]\n lons = batch_trajectories[speed].variables['lon'][:]\n lats150 = batch_trajectories[speed].variables['lat150'][:]\n lons150 = batch_trajectories[speed].variables['lon150'][:]\n times = batch_trajectories[speed].variables['time'][:]\n ssts = batch_trajectories[speed].variables['temp'][:]\n ssts_150 = batch_trajectories[speed].variables['temp150'][:]\n\n # if a particle is deleted before time is up, values are masked. \n # We'd like to get the last valid number.\n for trajectory in range(len(lats)):\n i = -1 # index for the last value\n while np.ma.is_masked(lats[trajectory][i]) is True:\n i -= 1 # if the value is masked, go to one value sooner\n \n j = i # use j for the 150m values\n while lats150[trajectory][j] > 0:\n # we want the first index where the latitude is recorded.\n # j is actually the last one where it's not recorded, so we\n # extract the information at index j+1\n j -= 1\n\n # once i and j are determined for a trajectory, we can extract the\n # variables and append them to temporary lists.\n temp_site_lats.append(lats[trajectory][0])\n temp_site_lons.append(lons[trajectory][0])\n temp_lats.append(lats[trajectory][i])\n temp_lons.append(lons[trajectory][i])\n temp_lats150.append(lats150[trajectory][j+1])\n temp_lons150.append(lons150[trajectory][j+1])\n temp_times.append(times[trajectory][i])\n temp_sst.append(ssts[trajectory][i])\n temp_sst150.append(ssts_150[trajectory][j+1])\n temp_times150.append(times[trajectory][j+1])\n \n # after the temporary lists are appended by sinking speed, they\n # are appended to the big lists that are returned by the function.\n # this keeps the structure of being separated by sinking speed.\n site_lats.append(temp_site_lats)\n site_lons.append(temp_site_lons)\n last_lats.append(temp_lats)\n last_lons.append(temp_lons)\n lats_150.append(temp_lats150)\n lons_150.append(temp_lons150)\n last_times.append(temp_times)\n times_150.append(temp_times150)\n last_sst.append(temp_sst)\n sst_150.append(temp_sst150)\n \n return site_lats, site_lons, last_lats, last_lons, lats_150, lons_150,\\\n last_times, times_150, last_sst, sst_150","def get_5index_list(self):\n msk = self.load_mask()\n return [i for (i,v) in enumerate(msk) if v==0]","def selectOfSample(self, indexes):\n index_set = set()\n for idx in indexes:\n i = list(self.sample[self.sample['masked'] == False].index)[idx]\n index_set.add(i)\n for ind in list(self.sample[self.sample['masked'] == False].index):\n if ind not in index_set:\n self.sample.at[ind, 'masked'] = True\n return index_set","def mask_incoherent(self):\n self.MaskPrefix = 'i' + self.MaskPrefix\n print('Masking pixel values where .msk value is less than {0}...'.format(threshold))\n for ig in self.Set:\n igram = self.load_ma(ig)\n mskFile = ig.Path[:-3] + 'msk'\n coherence = roipy.tools.load_half(ig, 2, mskFile)\n incoherent = ma.masked_less(coherence, self.Cothresh)\n igram[incoherent.mask] = ma.masked\n mskFile = self.MaskPrefix + 'Mask_' + ig.Name[:-4]\n np.save(os.path.join(self.ProcDir, mskFile), igram.mask)\n print(mskFile)\n\n print('Done')","def masterFlat(flat_list, master_dark_fname, normalize = 'median', local_sig_bad_pix = 3, \\\n global_sig_bad_pix = 9, local_box_size = 11, hotp_map_fname = None, verbose=False,\n output_dir = None,min_flux=1000):\n\n #Open the master dark\n master_dark_hdu = f.open(master_dark_fname)\n master_dark = master_dark_hdu[0].data\n dark_shape = np.shape(master_dark)\n\n if verbose:\n print((\"Subtracting {} from each flat file\".format(master_dark_fname)))\n dark_exp_time = master_dark_hdu[0].header['EXPTIME']\n\n #Open all files into a 3D array\n #foo = np.empty((dark_shape[0],dark_shape[1],len(flat_list)))\n foo = []\n\n #Open first flat file to check exposure time and filter\n first_flat_hdu = f.open(flat_list[0])\n flat_exp_time = first_flat_hdu[0].header['EXPTIME']\n\n\n\n if dark_exp_time != flat_exp_time:\n print(\"The master dark file doesn't have the same exposure time as the flats. We'll scale the dark for now, but this isn't ideal\", UserWarning)\n factor = flat_exp_time/dark_exp_time\n else:\n factor = 1.\n\n #We've already read it, so we'll stick it in foo\n\n print(\"Combining flat files\")\n for i in range(0,len(flat_list)):\n try: \n #subtract dark for each file, then normalize by mode\n hdu = f.open(flat_list[i],ignore_missing_end=True)\n d_sub = hdu[0].data - factor*master_dark\n if np.nanmedian(d_sub) < min_flux:\n #print(\"Skipping file {}, because its flux is lower than {}\".format(flat_list[i],min_flux))\n continue\n #normalize\n if normalize == 'mode':\n d_sub = d_sub/mode(d_sub, axis = None, nan_policy = 'omit')\n elif normalize == 'median':\n d_sub = d_sub/np.nanmedian(d_sub)\n #foo[:,:,i] = d_sub\n foo.append(d_sub)\n except:\n print(\"Some error. Skipping file {}\".format(i)) \n #Median combine frames\n flat = np.median(foo, axis = 0)\n\n #Filter bad pixels\n #bad_px = sigma_clip(flat, sigma = sig_bad_pix) #old and bad\n ###Major update here: do sigma clipping on the pix-to-pix flat with the large scale vignette removed\n ###Also add local sigma clipping\n def stddevFilter(img, box_size):\n \"\"\" from\n https://stackoverflow.com/questions/28931265/calculating-variance-of-an-image-python-efficiently/36266187#36266187\n This function compute the standard deviation of an image in a\n moving box of a given size. The pixel i,j of the output is the\n standard deviation of the pixel value in the box_size x box_size box\n around the i,j pixel in the original image.\n \"\"\"\n wmean, wsqrmean = (cv2.boxFilter(x, -1, (box_size, box_size), \\\n borderType=cv2.BORDER_REFLECT) for x in (img, img*img))\n return np.sqrt(wsqrmean - wmean*wmean)\n\n #median flat\n median_flat = median_filter(flat, local_box_size) #arbitrary size, shouldn't matter as long as it's big enough\n #standard deviation image\n stddev_im = stddevFilter(flat, local_box_size)\n\n #Local clipping\n local_bad_pix = np.abs(median_flat - flat) > local_sig_bad_pix*stddev_im\n\n #Global clipping here to reject awful pixels and dust, bad columns, etc\n pix_to_pix = flat/median_flat\n global_bad_px = sigma_clip(pix_to_pix, sigma = global_sig_bad_pix).mask #9 seems to work best\n\n #also set all 0 and negative pixels in flat as bad\n non_positive = flat <= 0\n\n #logic combine\n bad_px = np.logical_or(global_bad_px, local_bad_pix)\n\n #also add non_positive pixels\n bad_px = np.logical_or(bad_px, non_positive)\n\n #Normalize good pixel values\n if normalize == 'median':\n norm_flat = flat/np.nanmedian(flat[~bad_px])\n elif normalize == 'mode':\n norm_flat = flat/mode(flat, axis = None, nan_policy = 'omit')\n #Stick it back in the last hdu\n hdu[0].data = norm_flat\n\n #Add pipeline version and history keywords\n vers = version.get_version()\n hdu[0].header.set('PL_VERS',vers,'Version of pipeline used for processing')\n hdu[0].header['HISTORY'] = \"############################\"\n hdu[0].header['HISTORY'] = \"Created master flat by median combining the following:\"\n for i in range(len(flat_list)):\n hdu[0].header['HISTORY'] = flat_list[i]\n hdu[0].header['HISTORY'] = \"Normalized to the median of the master flat\"\n hdu[0].header['HISTORY'] = \"Performed bad pixel local and global sigma clipping with {}, {}sigmas\".format(local_sig_bad_pix, global_sig_bad_pix)\n hdu[0].header['HISTORY'] = \"############################\"\n\n #Parse the last fileanme\n if output_dir is not None:\n flat_outname = flat_list[-1].rsplit('.',1)[0]+\"_master_flat.fits\"\n flat_outname = flat_outname.rsplit('/',1)[-1]\n flat_outname = output_dir+flat_outname\n else:\n flat_outname = flat_list[-1].rsplit('.',1)[0]+\"_master_flat.fits\"\n\n #Write the fits file\n if verbose:\n print((\"Writing master flat to {}\".format(flat_outname)))\n hdu.writeto(flat_outname, overwrite=True)\n\n #If there's already a hot pixel map then we'll add to it.\n if hotp_map_fname != None:\n #read in the existing bp map\n #hdu = f.open(hotp_map_fname)\n #hdu[0].data += np.array(bad_px.mask, dtype=float)\n #hdu[0].data = np.logical_or(hdu[0].data.astype(bool), bad_px) #use logical or to combine bad pixel maps\n #bp_outname = flat_list[-1].rsplit('.',1)[0]+\"_bp_map.fits\"\n print(\"Will deal with hot pixel map from dark frames in the calibrate function\")\n\n #else:\n #Parse the last fileanme\n if output_dir is not None:\n bp_outname = flat_list[-1].rsplit('.',1)[0]+\"_bp_map.fits\"\n bp_outname = bp_outname.rsplit('/',1)[-1]\n bp_outname = output_dir+bp_outname\n else:\n bp_outname = flat_list[-1].rsplit('.',1)[0]+\"_bp_map.fits\"\n\n ##### Now write the bad pixel map\n hdu[0].data = bad_px.astype(int)#np.array(bad_px.mask, dtype=float)\n #Parse the last fileanme\n # bp_outname = flat_list[-1].rsplit('.',1)[0]+\"_bp_map.fits\"\n\n #Add history keywords\n hdu[0].header['HISTORY'] = \"############################\"\n hdu[0].header['HISTORY'] = \"Created bad pixel map by sigma clipping on pixel-to-pixel flat{}\".format(flat_outname)\n hdu[0].header['HISTORY'] = \"Bad pixel cutoffs: local sigma = {} and global sigma = {} for clipping\".format(local_sig_bad_pix, global_sig_bad_pix)\n #hdu[0].header['HISTORY'] = \"Bad pixel cutoff of {}sigma\".format(sig_bad_pix)\n hdu[0].header['HISTORY'] = \"A pixel value of 1 indicates a bad pixel\"\n hdu[0].header['HISTORY'] = \"############################\"\n\n if verbose:\n print((\"Writing bad pixel map to {}\".format(bp_outname)))\n #Write the fits file\n hdu.writeto(bp_outname, overwrite=True)\n\n return flat_outname, bp_outname","def srlatch(_signal,reset_th, set_th):\n s = [_signal > set_th][0]\n r = [_signal < reset_th][0]\n L = len(_signal)\n q = np.zeros(L)\n # qrev = np.zeros(L)\n for i in np.arange(L):\n if ((s[i] == 0) & (r[i] == 0) & (i > 0)):\n q[i] = q[i - 1]\n elif ((s[i] == 0) & (r[i] == 1)):\n q[i] = 0\n elif ((s[i] == 1) & (r[i] == 0)):\n q[i] = 1\n else:\n q[i] == -1 # error\n return np.array(q)","def get_nrof_lights(self):\n lights = 0\n for l in self.light_array:\n if l:\n lights += 1\n return lights","def get_muons(limit, selected_run, run_range_low, run_range_high, gold, atm):\n conn = engine_nl.connect()\n\n runs = []\n\n if not selected_run and not run_range_high:\n current_run = get_latest_run()\n run_range = current_run - limit\n # This missed muon array can be very long, so just select on its length\n if not atm:\n result = conn.execute(\"SELECT DISTINCT ON (a.run) a.run, a.gtids, a.days, a.secs, a.nsecs, \"\n \"array_length(b.gtids, 1), c.gtids FROM muons AS a LEFT JOIN missed_muons \"\n \"AS b ON a.run=b.run LEFT JOIN atmospherics AS c ON a.run=c.run \"\n \"WHERE a.run >= %s ORDER BY a.run DESC, a.timestamp DESC, b.timestamp DESC, \" \n \"c.timestamp DESC\", (run_range,))\n else:\n result = conn.execute(\"SELECT DISTINCT ON (a.run) a.run, b.gtids, b.days, b.secs, b.nsecs, \"\n \"array_length(c.gtids, 1), a.gtids FROM atmospherics \"\n \"AS a INNER JOIN muons AS b ON a.run=b.run INNER JOIN \"\n \"missed_muons AS c ON a.run=c.run WHERE array_length(a.gtids, 1) > 0 \"\n \"AND a.run >= %s ORDER BY a.run DESC, a.timestamp DESC, b.timestamp DESC, \"\n \"c.timestamp DESC\", (run_range,))\n status = conn.execute(\"SELECT DISTINCT ON (run) run, muon_time_in_range, missed_muon_time_in_range, \"\n \"atmospheric_time_in_range FROM time_check WHERE run >= %s \"\n \"ORDER BY run DESC, timestamp DESC\", (run_range,))\n elif run_range_high:\n if not atm:\n result = conn.execute(\"SELECT DISTINCT ON (a.run) a.run, a.gtids, a.days, a.secs, a.nsecs, \"\n \"array_length(b.gtids, 1), c.gtids FROM muons AS a LEFT JOIN missed_muons \"\n \"AS b ON a.run=b.run LEFT JOIN atmospherics AS c ON a.run=c.run \"\n \"WHERE a.run >= %s AND a.run <= %s ORDER BY a.run DESC, a.timestamp DESC, \"\n \"b.timestamp DESC, c.timestamp DESC\", (run_range_low, run_range_high))\n else:\n result = conn.execute(\"SELECT DISTINCT ON (a.run) a.run, b.gtids, b.days, b.secs, b.nsecs, \"\n \"array_length(c.gtids, 1), a.gtids FROM atmospherics \"\n \"AS a INNER JOIN muons AS b ON a.run=b.run INNER JOIN \"\n \"missed_muons AS c ON a.run=c.run WHERE array_length(a.gtids, 1) > 0 \"\n \"AND a.run >= %s AND a.run <= %s ORDER BY a.run DESC, a.timestamp DESC, \"\n \"b.timestamp DESC, c.timestamp DESC\", (run_range_low, run_range_high))\n status = conn.execute(\"SELECT DISTINCT ON (run) run, muon_time_in_range, missed_muon_time_in_range, \"\n \"atmospheric_time_in_range FROM time_check WHERE run >= %s AND \"\n \"run <= %s ORDER BY run DESC, timestamp DESC\", (run_range_low, run_range_high)) \n else:\n result = conn.execute(\"SELECT DISTINCT ON (a.run) a.run, a.gtids, a.days, a.secs, a.nsecs, \"\n \"array_length(b.gtids, 1), c.gtids FROM muons AS a LEFT JOIN missed_muons \"\n \"AS b ON a.run=b.run LEFT JOIN atmospherics AS c ON a.run=c.run \"\n \"WHERE a.run = %s ORDER BY a.run, a.timestamp DESC, b.timestamp DESC, \" \n \"c.timestamp DESC\", (selected_run,))\n status = conn.execute(\"SELECT DISTINCT ON (run) run, muon_time_in_range, missed_muon_time_in_range, \"\n \"atmospheric_time_in_range FROM time_check WHERE run = %s ORDER BY run, \" \n \"timestamp DESC\", (selected_run,)) \n\n rows = result.fetchall()\n\n muon_count = {}\n mmuon_count = {}\n atm_count = {}\n livetime_lost = {} \n fake = {}\n check_time = {}\n\n for run, agtids, adays, asecs, ansecs, bgtids, cgtids in rows:\n\n # Check if the run is on the gold list\n if gold != 0 and run not in gold:\n continue\n\n runs.append(run)\n check_time[run] = \"-\"\n\n if agtids is None:\n continue\n\n # Check if we inserted a fake muon\n if len(agtids) > 0 and agtids[0] == -1:\n fake[run] = 1\n muon_count[run] = len(agtids)\n # array_length returns None for size zero arrays\n if bgtids is None:\n mmuon_count[run] = 0\n else:\n mmuon_count[run] = bgtids\n # Calculate livetime lost to muons, which are the dominant source\n livetime_lost[run] = calculate_livetime_lost(adays, asecs, ansecs)\n # Lots of unprocessed runs, so check to make sure \n if cgtids is not None:\n atm_count[run] = len(cgtids)\n continue\n atm_count[run] = \"Not Processed\"\n\n check = status.fetchall()\n for run, muon_status, mm_status, atm_status in check:\n check_time[run] = (muon_status and mm_status and atm_status)\n\n return runs, muon_count, mmuon_count, atm_count, livetime_lost, fake, check_time","def get_idx_set(i, sets):\n idxs = []\n for j, set_j in enumerate(sets):\n if i in set_j: idxs.append(j)\n return idxs","def plateau_finder(data, tol=0.0003):\n from scipy.ndimage.filters import generic_filter\n tol = 0.0003\n filt_data = generic_filter(data, np.std, size=3)\n plat_index = np.where(filt_data < (np.min(filt_data) + tol))[0]\n\n plateaus = group_consecutive(plat_index)\n\n return plateaus","def get_zones(array,kind,relevant=False,threshold=3):\n\n\tresulting_set=[]\n\n\ti=0\n\tif array[i]==kind:\n\t\tcount=1\n\telse:\n\t\tcount=0\n\n\twhile i<len(array):\n\t\t\n\t\tif array[i]==kind:\n\t\t\tcount+=1\n\t\telif array[i]!=kind and array[i-1]==kind:\n\t\t\tresulting_set.append(([kind]*count,i-count))\n\t\t\tcount=0\n\t\telse:\n\t\t\tpass\n\n\t\ti+=1\n\n\tif count>0:\n\t\tresulting_set.append(([kind]*count, i-count))\n\n\tif relevant == False:\n\t\treturn resulting_set\n\telse:\n\t\treturn [item for item in resulting_set if len(item[0])>threshold]","def associate_detections_to_trackers(detections,trackers,iou_threshold = 0.3):\n if(len(trackers)==0):\n return np.empty((0,2),dtype=int), np.arange(len(detections)), np.empty((0,5),dtype=int)\n iou_matrix = iou_batch(detections, trackers)\n\n if min(iou_matrix.shape) > 0:\n a = (iou_matrix > iou_threshold).astype(np.int32)\n if a.sum(1).max() == 1 and a.sum(0).max() == 1:\n matched_indices = np.stack(np.where(a), axis=1)\n else:\n matched_indices = linear_assignment(-iou_matrix)\n else:\n matched_indices = np.empty(shape=(0,2))\n\n unmatched_detections = []\n for d, det in enumerate(detections):\n if(d not in matched_indices[:,0]):\n unmatched_detections.append(d)\n unmatched_trackers = []\n for t, trk in enumerate(trackers):\n if(t not in matched_indices[:,1]):\n unmatched_trackers.append(t)\n\n #filter out matched with low IOU\n matches = []\n for m in matched_indices:\n if(iou_matrix[m[0], m[1]]<iou_threshold):\n unmatched_detections.append(m[0])\n unmatched_trackers.append(m[1])\n else:\n matches.append(m.reshape(1,2))\n if(len(matches)==0):\n matches = np.empty((0,2),dtype=int)\n else:\n matches = np.concatenate(matches,axis=0)\n\n return matches, np.array(unmatched_detections), np.array(unmatched_trackers)","def onsets_b(self) -> Optional[annotations.BeatData]:\n return load_onsets(self.onsets_b_path)","def loopreelset2(combination, reel_set):\n matching_reels = []\n for index in range(5):\n if if2symbols(combination[index][0],combination[index][1], reel_set[index]):\n matching_reels.append(index)\n if len(matching_reels) == 5:\n return True","def onsets_d(self) -> Optional[annotations.BeatData]:\n return load_onsets(self.onsets_d_path)","def isolate_strokes(self):\n if self.onset_times is False:\n self.find_onsets()\n # Defining the frame to contain the strokes\n frame_sz = int(self.stroke_length*self.sampling_rate)\n self.strokes = np.array(\n [self.audio[i:i+frame_sz] for i in self.onset_samples])","def do_dtv_flagging2(data, freqs):\n \n mask = data.mask*1\n dtv_times = []\n \n for ledge in (54, 60, 66, 76, 82):\n uedge = ledge + 6\n band = np.where( (freqs>=ledge) & (freqs<=uedge) )[0]\n trns = np.where( (freqs>=ledge+0.25) & (freqs<=uedge-0.25) )[0]\n empt = np.where( ((freqs>=ledge-0.25) & (freqs<ledge+0.25)) | ((freqs>uedge-0.25) & (freqs<=uedge+0.25)) )[0]\n \n pB = np.mean(data.data[:,band], axis=1)\n pT = np.mean(data.data[:,trns], axis=1)\n pE = np.mean(data.data[:,empt], axis=1)\n \n #import pylab\n #pylab.plot(pB-pE)\n #pylab.plot(pT-pE)\n #pylab.plot(pE-1)\n #pylab.plot(pE*0 + 3*pE.std())\n #pylab.show()\n \n st = np.std(pE)\n bad = np.where( np.abs(pT-pE) > 3*st )[0]\n for b in bad:\n\t dtv_times.append(b)\n mask[b,band] |= True\n if b > 1:\n mask[b-1,band] |= True\n\t\t dtv_times.append(b-1)\n if b < data.shape[0]-2:\n mask[b+1,band] |= True\n\t dtv_times.append(b+1)\n \n dtv_times = sorted(dtv_times)\n\n data.mask = mask*1\n return data.mask, list(set(dtv_times))","def block(array):\r\n grid = []\r\n for z in range(0,7,3): #0,3,6\r\n #vertical down 3\r\n for n in range(0,7,3): #0,3,6\r\n #horiz across 3\r\n line = []\r\n for i in range(3):\r\n for j in range(3):\r\n vert,hor = i+z,j+n\r\n line.append(array[vert][hor])\r\n grid.append(line)\r\n won = True\r\n for i in range(len(grid)):\r\n if won == True:\r\n if len(grid[i]) != len(set(grid[i])):\r\n won = False\r\n else:\r\n pass\r\n else:\r\n break\r\n return won","def get_light_sky(filenames, onoff=True):\n return filter_filenames(filenames, [\"light-off\"], onoff)","def power_set(sett):\n\n powerset_so_far = {frozenset()}\n\n for element in sett:\n set.update(powerset_so_far,\\\n extend_all(element, powerset_so_far))\n \n return powerset_so_far","def gen_all_holds(hand):\n\n mask = sorted(gen_all_sequences((1,0), len(hand)))\n answer_set = []\n for current_mask in mask:\n temp = []\n for indx in range(len(current_mask)):\n if current_mask[indx] == 1:\n temp.append(hand[indx]);\n answer_set.append(tuple(temp))\n return set(answer_set)","def _find_trial_sounds_regions_in_sync(sync_file):\n bit = 'SOUND'\n return _find_bit_in_sync(sync_file, bit, ['up', 'down'])","def find_dark_states(excited_state, ground_states):","def analyze(self, event):\n electrons = self.inputCollection(event)\n muons = Collection(event, \"Muon\")\n triggerObjects = self.triggerObjectCollection(event)\n\n selectedElectrons = []\n unselectedElectrons = []\n \n weight_reco_nominal = 1.\n weight_reco_up = 1.\n weight_reco_down = 1.\n\n weight_id_nominal = 1.\n weight_id_up = 1.\n weight_id_down = 1.\n\n for electron in electrons:\n # https://twiki.cern.ch/twiki/bin/view/CMS/CutBasedElectronIdentificationRun2\n if electron.pt>self.electronMinPt \\\n and math.fabs(electron.eta)<self.electronMaxEta \\\n and self.electronID(electron)\\\n and self.triggerMatched(electron, triggerObjects):\n\n dxy = math.fabs(electron.dxy)\n dz = math.fabs(electron.dz)\n \n if math.fabs(electron.eta) < 1.479 and (dxy>0.05 or dz>0.10):\n unselectedElectrons.append(electron)\n continue\n elif dxy>0.10 or dz>0.20:\n unselectedElectrons.append(electron)\n continue\n\n #reject electron if close-by muon\n if len(muons)>0:\n mindr = min(map(lambda muon: deltaR(muon, electron), muons))\n if mindr < 0.05:\n unselectedElectrons.append(electron)\n continue\n\n selectedElectrons.append(electron)\n \n #TODO: electron reco/ID SFs\n \n \n else:\n unselectedElectrons.append(electron)\n\n \n if not Module.globalOptions[\"isData\"] and self.storeWeights:\n \n self.out.fillBranch(self.outputName+\"_weight_reco_nominal\", weight_reco_nominal)\n self.out.fillBranch(self.outputName+\"_weight_reco_up\", weight_reco_up)\n self.out.fillBranch(self.outputName+\"_weight_reco_down\", weight_reco_down)\n\n self.out.fillBranch(self.outputName+\"_weight_id_nominal\",weight_id_nominal)\n self.out.fillBranch(self.outputName+\"_weight_id_up\",weight_id_up)\n self.out.fillBranch(self.outputName+\"_weight_id_down\",weight_id_down)\n\n self.out.fillBranch(\"n\"+self.outputName,len(selectedElectrons))\n\n for variable in self.storeKinematics:\n self.out.fillBranch(self.outputName+\"_\"+variable,map(lambda electron: getattr(electron,variable), selectedElectrons))\n\n setattr(event,self.outputName,selectedElectrons)\n setattr(event,self.outputName+\"_unselected\",unselectedElectrons)\n\n return True","def associate_detections_to_trackers(detections,trackers,iou_threshold = 0.3):\n if(len(trackers)==0):\n return np.empty((0,2),dtype=int), np.arange(len(detections)), np.empty((0,5),dtype=int)\n\n iou_matrix = iou_batch(detections, trackers)\n\n if min(iou_matrix.shape) > 0:\n a = (iou_matrix > iou_threshold).astype(np.int32)\n if a.sum(1).max() == 1 and a.sum(0).max() == 1:\n matched_indices = np.stack(np.where(a), axis=1)\n else:\n matched_indices = linear_assignment(-iou_matrix)\n else:\n matched_indices = np.empty(shape=(0,2))\n\n unmatched_detections = []\n for d, det in enumerate(detections):\n if(d not in matched_indices[:,0]):\n unmatched_detections.append(d)\n unmatched_trackers = []\n for t, trk in enumerate(trackers):\n if(t not in matched_indices[:,1]):\n unmatched_trackers.append(t)\n\n #filter out matched with low IOU\n matches = []\n for m in matched_indices:\n if(iou_matrix[m[0], m[1]]<iou_threshold):\n unmatched_detections.append(m[0])\n unmatched_trackers.append(m[1])\n else:\n matches.append(m.reshape(1,2))\n if(len(matches)==0):\n matches = np.empty((0,2),dtype=int)\n else:\n matches = np.concatenate(matches,axis=0)\n\n return matches, np.array(unmatched_detections), np.array(unmatched_trackers)","def get_light_sbc(filenames, onoff=True):\n if onoff:\n param = \"on\"\n else:\n param = \"off\"\n return filter_filenames(filenames, [param])","def trackBunchTurns(self, bunch):\n\t\tturns = self.__turns\n\t\t#start\n\t\tfor i in range(turns-1):\t\t\t\n\t\t\tself.trackBunch(bunch)\t\n\t\t\tsyncPart = bunch.getSyncParticle()\n\t\t\ttime = syncPart.time()\n\t\t\tself.setTimeDepStrength(time)\n\t\t\tprint \"debug trackBunchTurns time\",time,\"in\",i,\"turn\"\n\t\t#getsublattice\n\t\t#sublattice.trackBunch(bunch)","def findIntersect(wires):\n allSets = list(map(lambda w: coordsFor(w), wires))\n baseSet = allSets[0]\n for s in allSets[1:]:\n baseSet.intersection_update(s)\n central = (0, 0)\n distances = list(map(lambda c: manhattan(central, c), baseSet))\n return min(distances)","def get_matching_blossom5(graph):\n\n edges = [] # Get all possible edges between the anyons and their weights\n\n def edge_func(edges, e0, e1, weight):\n edges.append([e0, e1, weight])\n\n all_anyons, nxgraph = get_graph_edges(graph, edge_func, edges)\n\n output = pm.getMatching(len(all_anyons), edges) if all_anyons != [] else []\n return [[all_anyons[i0], all_anyons[i1]] for i0, i1 in enumerate(output) if i0 > i1]","def createBridgeSets(blocksize,operating,MPSS):\n sets = tuple()\n xul = blocksize[0]-operating\n xdl = operating\n yul = int(blocksize[0]/2+operating)\n ydl = int(blocksize[0]/2-operating)\n xts = xul\n xbs = xdl\n for i in range(MPSS):\n sets+=(tuple(product(numpy.arange(xdl,xul,1),numpy.arange(ydl,yul,1))),)\n xdl+=operating\n xul-=operating\n ydl-=operating\n yul+=operating\n return sets,sets[::-1]","def calculate_rise_set_lsts(self, telescope_latitude, horizon_buffer=0.04364):\n lat_rad = telescope_latitude.rad\n buff = horizon_buffer\n\n lon, lat = self.get_lon_lat()\n\n tans = np.tan(lat_rad) * np.tan(lat.rad)\n\n with warnings.catch_warnings():\n warnings.filterwarnings(\n \"ignore\", message=\"invalid value encountered\", category=RuntimeWarning\n )\n rise_lst = lon.rad - np.arccos((-1) * tans) - buff\n set_lst = lon.rad + np.arccos((-1) * tans) + buff\n\n rise_lst[rise_lst < 0] += 2 * np.pi\n set_lst[set_lst < 0] += 2 * np.pi\n rise_lst[rise_lst > 2 * np.pi] -= 2 * np.pi\n set_lst[set_lst > 2 * np.pi] -= 2 * np.pi\n\n self._rise_lst = rise_lst\n self._set_lst = set_lst","def _find_trial_beam_breaks_regions_in_sync(sync_file):\n bit = 'BEAM_BREAK'\n return _find_bit_in_sync(sync_file, bit, ['down', 'up'])","def occulting(groups, colour, period):\n if groups == [1]:\n return [\n ('Off', 1000),\n (colour, period - 1000)\n ]\n return light_sequence(groups, 'Off', colour, period, 500, 1000)","def intersection(arrays):\n # Create hash table (dict) to store numbers in for faster O(1) lookup (for \n # any individual lookup):\n # numbers = {}\n\n # Create list for intersection of the sets:\n # intersection = []\n\n # Populate hash table with numbers from the first list (keys), because any numbers \n # not in the first list will not be in the intersection of the lists, by definition.\n numbers = {item:False for item in arrays[0]}\n # Now check the other input lists in order, removing any number/item that is not in both:\n for list in arrays[1:]:\n for item in list: # NOT actually O(n**2); just O(n) for the whole input matrix.\n # Mark as True to flag any items that are in the intersection of the two lists:\n if item in numbers:\n numbers[item] = True\n # Keep only the numbers that are in the intersection of the two lists:\n numbers = {key:value for key, value in numbers.items() if value == True}\n # Mark all as False again to start a fresh comparison with the next list:\n for item in numbers:\n numbers[item] = False\n\n return [*numbers.keys()]","def find_starts(config, data):\n\n trigger = butter_bandpass_filter(\n data, config.bandpass_lower, config.bandpass_upper,\n config.sampling_rate, 6)\n trigger = np.absolute(trigger)\n trigger = butter_lowpass_filter(\n trigger, config.lowpass_freq, config.sampling_rate, 6)\n\n # transient = 0.0005\n # start_idx = int(transient * config.sampling_rate)\n start_idx = 0\n average = np.average(trigger[start_idx:])\n maximum = np.max(trigger[start_idx:])\n minimum = np.min(trigger[start_idx:])\n middle = (np.max(trigger[start_idx:]) - min(trigger[start_idx:])) / 2\n if average < 1.1 * middle:\n print()\n print(\"Adjusting average to avg + (max - avg) / 2\")\n average = average + (maximum - average) / 2\n offset = -int(config.trigger_offset * config.sampling_rate)\n\n if config.trigger_rising:\n trigger_fn = lambda x, y: x > y\n else:\n trigger_fn = lambda x, y: x < y\n\n # The cryptic numpy code below is equivalent to looping over the signal and\n # recording the indices where the trigger crosses the average value in the\n # direction specified by config.trigger_rising. It is faster than a Python\n # loop by a factor of ~1000, so we trade readability for speed.\n trigger_signal = trigger_fn(trigger, average)[start_idx:]\n starts = np.where((trigger_signal[1:] != trigger_signal[:-1])\n * trigger_signal[1:])[0] + start_idx + offset + 1\n if trigger_signal[0]:\n starts = np.insert(starts, 0, start_idx + offset)\n\n # plt.plot(data)\n # plt.plot(trigger*100)\n # plt.axhline(y=average*100)\n # plt.show()\n\n return starts, trigger, average","def denoise(self, offset_arr):\n\n measure_t, otts = zip(*offset_arr)\n all_otts = []\n all_times = []\n otts_per_h = []\n times_per_h = []\n min_arr = []\n hold_x = 0\n hold_y = 0\n ctr = 0\n n = 1\n begin = 0\n end = 120 # N refering to the amount of seconds indicating the first interval\n const = 120 # the coefficient indicating the break interval: every const seconds: must be set the same as end value\n for timel in measure_t: # divide the points every 60 seconds (probe)\n ctr += 1\n if begin <= timel < end:\n times_per_h.append(timel)\n otts_per_h.append(otts[ctr - 1])\n else:\n hold_x = timel\n hold_y = otts[ctr - 1]\n all_times.append(times_per_h)\n all_otts.append(otts_per_h)\n times_per_h = []\n otts_per_h = []\n times_per_h.append(hold_x)\n otts_per_h.append(hold_y) # for the next round\n begin = end\n n += 1\n end = n * const\n if ctr == len(measure_t) and otts_per_h: # belonging to the last hour/min only going through the if statement\n all_times.append(times_per_h)\n all_otts.append(otts_per_h)\n\n for i in range(len(all_otts)):\n try:\n idx = np.array(all_otts[i]).argmin()\n except ValueError as e:\n logging.error(\"{}/{}/{}: denoise: ValueError at argmin -- returning empty array! offset_arr: {}, error e {}\".format(self.domain, self.ip4, self.ip6, offset_arr, e))\n return []\n min_per_probe = all_otts[i][idx]\n assoc_x_per_probe = all_times[i][idx]\n min_arr.append((assoc_x_per_probe, min_per_probe))\n\n return min_arr","def get_all_setups_nodes():\n ta_roots = get_all_setups_roots()\n ta_nodes = [TechAnim_Setup(x) for x in ta_roots]\n return ta_nodes","def find_tfl_lights(image: np.ndarray):\n kernel = np.array(\n [[0, 0, 0],\n [0, 0, 0],\n [0, 1, 0],\n [1, 3, 1],\n [0, 1, 0]])\n\n kernel = kernel - kernel.mean()\n\n red_image = image.copy()\n red_image = red_image[:, :, 0]\n _, red_image = cv2.threshold(red_image, 200, 255, cv2.THRESH_BINARY)\n output = cv2.filter2D(red_image, -1, kernel)\n output_copy = output.copy()\n output = ndimage.maximum_filter(output, size=30)\n output = output - output_copy\n mask = ((output == 0) & (output_copy > 0))\n red_points = np.where(mask)\n positions = []\n final_red_points = []\n for point1 in range(len(red_points[0])):\n point = (red_points[0][point1], red_points[1][point1])\n pixel = image[point[0], point[1]]\n if (pixel[1] < 170 or pixel[2] < 120) and pixel[0] >= 200:\n final_red_points.append(point)\n final_red_points = filter_points(final_red_points)\n positions += final_red_points\n auxilary = ['r'] * len(positions)\n red_x = [val[1] for val in final_red_points]\n red_y = [val[0] for val in final_red_points]\n green_image = image.copy()\n green_image = green_image[:, :, 1]\n _, green_image = cv2.threshold(green_image, 190, 255, cv2.THRESH_BINARY)\n output = cv2.filter2D(green_image, -1, kernel)\n output_copy = output.copy()\n output = ndimage.maximum_filter(output, size=30)\n output = output - output_copy\n mask = ((output == 0) & (output_copy > 0))\n green_points = np.where(mask)\n final_green_points = []\n for point1 in range(len(green_points[0])):\n point = (green_points[0][point1], green_points[1][point1])\n pixel = image[point[0], point[1]]\n if pixel[0] <= 180 and pixel[1] >= 220 and pixel[2] >= 160:\n final_green_points.append(point)\n\n final_green_points = filter_points(final_green_points)\n positions += final_green_points\n auxilary += ['g'] * len(final_green_points)\n green_x = [val[1] for val in final_green_points]\n green_y = [val[0] for val in final_green_points]\n print(f\"There are {len(green_x) + len(red_x)} points\")\n return positions, auxilary","def _random_subset(self, pa_nodes, seq, m, rng):\n targets = set()\n while len(targets) < m:\n x = rng.choice(seq)\n # if x in pa_nodes:\n if pa_nodes.get(x, False):\n targets.add(x)\n else:\n pass\n return targets","def performance_comparison_of_sets( predicted, known ):\n ### Example:\n ### predicted = Set( 2,3,4,5,10,11,12,13,14,15,20,21,22,23,24,25,26,27,28 )\n ### known = Set( 1,2,3,4,5,10,11,12,13,14,15, 21,22,23,24,25,26 )\n ### Return structure:\n ### [\n ### [ [2,3,4,5,10,11,12,13,14,15], [21,22,23,24,25,26] ], # TP correct predicted\n ### [ [20], [27,28] ], # FP over predicted\n ### [ [1] ], # FN under predicted\n ### ]\n\n # make CORRECT, UNDER and OVER predicted list\n correct = predicted.intersection( known )\n overpredicted = predicted.difference( known )\n underpredicted = known.difference( predicted )\n\n returnlists = []\n for item in ( correct, overpredicted, underpredicted ):\n if item:\n item = list(item)\n item.sort()\n tracks = [ [ item[0] ] ]\n for coord in item[1:]:\n if coord == max(tracks[-1])+1:\n tracks[-1].append(coord)\n else:\n tracks.append( [ coord ] )\n returnlists.append( tracks )\n else:\n # no overlap of this kind!\n returnlists.append( [] )\n\n # return the data structure\n return returnlists","def minmax():\n minmaxlist = []\n timelist = []\n #create a list of the filenames of all sentinel-images\n s2files = [f for f in listdir(s2path) if endswith(join(s2path, f),\".tif\")==True]\n print(\"STEP 1/2\")\n print(\"EXPORTING MIN AND MAX VALUES PER BAND\")\n for i in s2files:\n start = time.time()\n nlfile = nlpath + \"/\" + i\n s2file = s2path+\"/\"+i\n #open the file\n s2raster = gdal.Open(s2file) \n #iterate over the bands of each image\n for n in range(s2raster.RasterCount):\n f = n + 1\n s2band = s2raster.GetRasterBand(f)\n #read the pixels of the band as an numpy-array\n s2band = s2band.ReadAsArray()\n #resize the bands to have all images in the same size\n s2band = np.resize(s2band,(1050,1050))\n #get the min and max values of each band to be able to 0-1 normalize after\n min = s2band.min()\n max = s2band.max()\n #check if there are already values for the band\n if len(minmaxlist) < s2raster.RasterCount + 1:\n s2minmax = [min,max]\n minmaxlist.append(s2minmax)\n # if the min value of the open band is smaller than the saved minimal value, overwrite it\n if min < minmaxlist[n][0]:\n minmaxlist[n][0] = min\n #if the max value of the open band is higher than the saves maximum value, overwrite it\n if max > minmaxlist[n][1]:\n minmaxlist[n][1] = max\n #open the nightlight img\n nlraster = gdal.Open(nlfile)\n nlband = nlraster.GetRasterBand(1)\n #read the only band of the image as a numpy-array\n nlband = nlband.ReadAsArray()\n #resize it the same way as the sentinel images\n nlband = np.resize(nlband,(1050,1050))\n #get the min and max values of the band\n nlmin = nlband.min()\n nlmax = nlband.max()\n #check if there are already information about min and max values for the nightlight images\n if len(minmaxlist) < s2raster.RasterCount + 1:\n nlminmax = [nlmin,nlmax]\n minmaxlist.append(nlminmax)\n #if the min value of the open nightlight image is smaller than the saved minimal value, overwrite it\n if nlmin < minmaxlist[16][0]:\n minmaxlist[16][0] = nlmin\n #if the max value of the open nightlight image is higher than the saves maximum value, overwrite it\n if nlmax > minmaxlist[16][1]:\n minmaxlist[16][1] = nlmax\n end = time.time()\n timelist.append(end-start)\n print(\"Step 1/2\",str(s2files.index(i)+1) + \"/\" + str(len(s2files)),\"Est. time left:\",time.strftime('%H:%M:%S',time.gmtime(int(sum(timelist)/len(timelist)*(len(s2files)-s2files.index(i))))))\n #throw out the Quality Bands (QA10,QA20,QA60)\n minmaxlist = [i for j,i in enumerate(minmaxlist) if j not in [13,14,15]]\n return minmaxlist","def build_amg_index_sets(L_sizes):\n neqns = L_sizes[0][0]\n velocityDOF=[]\n for start in range(1,3):\n velocityDOF.append(np.arange(start=start,\n stop=1+neqns,\n step=3,\n dtype='i'))\n velocityDOF_full=np.vstack(velocityDOF).transpose().flatten()\n velocity_u_DOF = []\n velocity_u_DOF.append(np.arange(start=0,\n stop=2*neqns//3,\n step=2,\n dtype='i'))\n velocity_u_DOF_full = np.vstack(velocity_u_DOF).transpose().flatten()\n velocity_v_DOF = []\n velocity_v_DOF.append(np.arange(start=1,\n stop=1+2*neqns//3,\n step=2,\n dtype='i'))\n velocity_v_DOF_full = np.vstack(velocity_v_DOF).transpose().flatten()\n isvelocity = PETSc.IS()\n isvelocity.createGeneral(velocityDOF_full)\n isu = PETSc.IS()\n isu.createGeneral(velocity_u_DOF_full)\n isv = PETSc.IS()\n isv.createGeneral(velocity_v_DOF_full)\n return [isvelocity, isu, isv]","def getSets(unique_name=None):","def eeg_peaks(array,tim,onset,plot='false'):\n\tp1_i,n1_i,p2_i = onset+56,onset+104,onset+176\n\twin_p1,win_n1,win_p2 = 15,20,40\n\t# determine P1,N1 and P2 values on the basis of the maximum in GFP in a window around the expected values\n\tidx_p1 = np.logical_and(tim>p1_i-win_p1, tim<p1_i+win_p1)\n\tidx_n1 = np.logical_and(tim>n1_i-win_n1, tim<n1_i+win_n1)\n\tidx_p2 = np.logical_and(tim>p2_i-win_p2, tim<p2_i+win_p2)\n\tp1 = np.max(array[idx_p1])\n\ttp1 = tim[idx_p1][array[idx_p1].argmax()]\n\tn1 = np.min(array[idx_n1])\n\ttn1 = tim[idx_n1][array[idx_n1].argmin()]\n\tp2 = np.max(array[idx_p2])\n\ttp2 = tim[idx_p2][array[idx_p2].argmax()]\n\n\tlineax = dict(linewidth=1, color='black', linestyle='--')\n\tlinep1 = dict(linewidth=1, color='red', linestyle='--')\n\tlinen1 = dict(linewidth=1, color='green', linestyle='--')\n\tlinep2 = dict(linewidth=1, color='blue', linestyle='--')\n\n\tif plot == 'true':\t\t\n\t\tfig = plt.figure(19,figsize=[7,5])\n\t\tax = fig.add_subplot(111, autoscale_on=False, xlim=[onset-100,tp2+200], ylim=[1.25*np.min([p1,n1,p2]),1.25*np.max([p1,n1,p2])])\n\t\tplt.plot(tim,array,'k-',lw=3)\n\t\tplt.plot(tp1,p1,'ro')\n\t\tplt.plot(tn1,n1,'go')\n\t\tplt.plot(tp2,p2,'bo')\n\t\tax.axvline(p1_i-win_p1,**linep1)\n\t\tax.axvline(p1_i+win_p1,**linep1)\n\t\tax.axvline(n1_i-win_n1,**linen1)\n\t\tax.axvline(n1_i+win_n1,**linen1)\n\t\tax.axvline(p2_i-win_p2,**linep2)\n\t\tax.axvline(p2_i+win_p2,**linep2)\n\t\tax.axhline(**lineax)\n\t\tplt.text(tp1-120,1.25*p1,'P1 = %.2f muV at %.0f ms' %(p1,tp1),fontsize=10)\n\t\tplt.text(tn1-40,1.1*n1,'N1 = %.2f muV at %.0f ms' %(n1,tn1),fontsize=10)\n\t\tplt.text(tn1+40,1.1*p2,'P2 = %.2f muV at %.0f ms' %(p2,tp2),fontsize=10)\n\t\tplt.xlabel('time (ms)',fontsize = 13)\n\t\tplt.ylabel('Amplitude',fontsize = 13)\n\treturn [p1,n1,p2,tp1,tn1,tp2]","def covid(covidSet):\n newcovidSet = set()\n for x in covidSet:\n player = playerList[x]\n player.changeImage(1)\n\n #gotta check if anyone is close to this guy\n for idx, y in enumerate(playerList):\n if idx == x or idx in covidSet or idx in newcovidSet:\n continue\n if abs(player.rect.x - y.rect.x) > covidRange or abs(player.rect.y - y.rect.y) > covidRange:\n continue #to reduce amount of astar checks required\n else:\n xx = changeCoord(player.rect.x)\n xy = changeCoord(player.rect.y)\n yx = changeCoord(y.rect.x)\n yy = changeCoord(y.rect.y)\n path = aStar.astar(maze, (xy, xx), (yy, yx))\n if path != None and len(path) <= mazeRange:\n if randChance(covidChance):\n newcovidSet.add(idx)\n print(\"Person\", x, \"infected\", \"Person\", idx)\n edges[\"edges\"].append({\"from\": x, \"to\": idx})\n else:\n y.changeImage(2)\n # uncomment to see astar algo (that was too far apart)\n #else:\n # if path == None:\n # print(\"none\")\n # else:\n # print(len(path), path)\n return set.union(covidSet, newcovidSet)"],"string":"[\n \"def find_onsets(self):\\n get_onsets = ess.OnsetRate()\\n # onset_times is np array\\n self.onset_times, onset_rate = get_onsets(self.audio)\\n # Onset as sample number in the audio signal\\n index2delete = []\\n previous_time = -9999999\\n for index, itime in enumerate(self.onset_times):\\n if (itime - previous_time) < 2*self.stroke_length:\\n index2delete.append(index)\\n else:\\n previous_time = itime\\n self.onset_times = np.delete(self.onset_times, index2delete)\\n self.onset_samples = [int(self.sampling_rate*i) for i in self.onset_times]\",\n \"def DetectPulseOnset(self, asig, fs, wMS):\\n # the percentage of the maximal value of the slope sum function\\n # to detect the onset\\n AmplitudeRatio = .01\\n\\n # low pass filter\\n sig = self.zpIIR(asig, 3, .1, 20, 5 * 2/fs)\\n wSmp = int(np.round(wMS*fs/1000))\\n\\n BlankWindowRatio = .9\\n\\n # delta x\\n diffsig = np.diff(sig)\\n\\n z = np.empty((sig.size - 1 - wSmp, 1))\\n z[:] = np.NaN\\n\\n # calculate slope sum function\\n for i in range(wSmp,sig.size-1):\\n subsig = diffsig[i-wSmp:i]\\n z[i-wSmp] = np.sum(subsig[subsig>0])\\n\\n z0 = np.mean(z)\\n onset = [0]\\n tPnt = []\\n zThres = 0\\n blankWin = int(np.round(400*fs/1000))\\n subIdx = np.r_[onset[0]: onset[0] + 4*blankWin + 1]\\n MedianArrayWinSize = 5\\n\\n # this value controls the final acceptance\\n PrcofMaxAMP = .2\\n SSFAmpArray = np.ones((MedianArrayWinSize,1))*(np.max(z) - np.min(z)) * PrcofMaxAMP\\n # the percentage of maximal amplitude for threshold crossing\\n DetectionThreshold = .2\\n SSFCrossThresholdArray = np.ones((MedianArrayWinSize,1))*z0*DetectionThreshold\\n idx = 1\\n\\n # Keep loop going while onsets detected\\n while(1):\\n\\n # look for the first location where z > z0\\n try:\\n\\n # Look in z[subIdx] (and make sure it doesn't go past z's size)\\n # find first index where z > the mean of z\\n tempIndex = np.trim_zeros(subIdx*(z.size>subIdx), 'b')\\n ix = np.amin(np.where(z[tempIndex] > z0)[0])\\n except:\\n break\\n\\n ix = tempIndex[ix]\\n tPnt.append(ix)\\n srcWin = np.r_[np.maximum(0,ix - wSmp): ix + wSmp]\\n #if the window has passed the length of the data, then exit\\n if srcWin[-1] >= len(z):\\n break\\n\\n # This section of code is to remove the initial zero-region in the SSF function before looking for onset (if such region exists)\\n zPnt = np.where(z[srcWin] == 0)\\n\\n if zPnt[0].size != 0:\\n zPnt = srcWin[zPnt[0]]\\n\\n if np.any(zPnt < ix):\\n srcWin = np.r_[zPnt[np.max(np.where(zPnt < ix))]: ix + wSmp]\\n\\n # accept the window\\n if ( np.max(z[srcWin]) - np.min(z[srcWin]) > zThres):\\n\\n # calculate the threshold for next cycle\\n SSFAmp = (np.max(z[srcWin]) - np.min(z[srcWin])) * PrcofMaxAMP\\n SSFAmpArray[np.remainder(idx, MedianArrayWinSize)] = SSFAmp\\n zThres = np.median(SSFAmpArray)\\n SSFCrossThresholdArray[np.remainder(idx, MedianArrayWinSize)] = np.mean(z[srcWin])*DetectionThreshold\\n z0 = np.median(SSFCrossThresholdArray)\\n minSSF = np.min(z[srcWin]) + SSFAmp *AmplitudeRatio\\n a = srcWin[0] + np.min(np.where(z[srcWin] >= minSSF))\\n onset.append(a)\\n\\n # adaptively determine analysis window for next cycle\\n bw = blankWin\\n subIdx = np.round(np.r_[a + bw: a + 3*bw])\\n idx = idx + 1\\n\\n else:\\n # no beat detected\\n subIdx = np.round(subIdx + blankWin)\\n\\n return onset\",\n \"def _get_run_onsets(\\n runs, length_fr, pad_fr, running_threshold_cms, offset_fr):\\n out = []\\n for run in runs:\\n t2p = run.trace2p()\\n tr = t2p.trace('deconvolved')\\n\\n # Add all onsets of \\\"other\\\" frames\\n others = t2p.nocs(length_fr, pad_fr,\\n running_threshold_cms)\\n for ot in others:\\n start = ot + offset_fr\\n out.append(tr[:, start:start + length_fr])\\n\\n return out\",\n \"def getOnsetTick(s):\\n ticksPerQuarter = getResolution(s)\\n onsets = [int(n.offset * ticksPerQuarter) for n in s.flat.notes]\\n return onsets\",\n \"def detect_correction_onset(baseline_llr, \\n motiontrajectory, times,\\n ptstart, ptend, \\n disturbancemode, \\n disturbancevalue, \\n disturbanceonsettime=None, # if none, reconstruct onset form the threshold ratio\\n disturbance_threshold=9.0,\\n plotfilename=None):\\n\\n # Error considering the disturbance\\n screentrajectory, err_screen, disturbancetime, disturbanceindex = compute_trial_error(\\n motiontrajectory, times,\\n ptstart, ptend, \\n disturbancemode, \\n disturbancevalue, \\n disturbanceonsettime,\\n disturbance_threshold)\\n \\n # Error as if there is no disturbance (ballistic)\\n err_ballistic = raydistance_error(motiontrajectory, ptstart, ptend)\\n is_back = 1 - 1 * is_target_forward(motiontrajectory, ptstart, ptend)\\n err_ballistic += is_back # penalty for wrong direction\\n \\n # Normalized motion phase\\n phase = normalized_motion_phase(screentrajectory, ptstart, ptend)\\n\\n # Correction onset is the point \\n # when no-disturbance error exceeds A*sigma and\\n # the real error is decreasing\\n ionsets = []\\n for i in range(disturbanceindex, len(err_screen)-3):\\n err_base_mean, err_base_covar = baseline_llr.regress(phase[i])\\n err_base_var = np.sqrt(err_base_covar)\\n if (np.abs(err_ballistic[i]) > 1 * err_base_var) and \\\\\\n (np.abs(err_screen[i]) > np.abs(err_screen[i+1])) and \\\\\\n (np.abs(err_screen[i+1]) > np.abs(err_screen[i+2])) and \\\\\\n (np.abs(err_screen[i+2]) > np.abs(err_screen[i+3])):\\n #(np.abs(err_ballistic[i]) > np.abs(err_screen[i])):\\n ionsets.append(i)\\n\\n # Plot the detected onsets\\n make_plots = True\\n if make_plots:\\n plt.plot(screentrajectory[:, 0], screentrajectory[:, 1])\\n plt.plot(motiontrajectory[:, 0], motiontrajectory[:, 1])\\n sp = ptstart\\n plt.plot(sp[0], sp[1], marker='o', markersize=3,)\\n gp = ptend\\n plt.plot(gp[0], gp[1], marker='o', markersize=3,)\\n \\n plt.scatter(screentrajectory[:-1, 0], screentrajectory[:-1, 1], marker='o', s=15, \\n linewidths=4, c=err_screen, alpha=0.5, cmap=plt.cm.coolwarm)\\n\\n onsets = screentrajectory[ionsets]\\n plt.scatter(onsets[:, 0], onsets[:, 1], marker='*', s=10, linewidths=4,)\\n plt.axis(\\\"equal\\\")\\n if plotfilename is not None:\\n plt.savefig(plotfilename)\\n plt.close()\\n else:\\n plt.show()\\n \\n\\n return onsets\",\n \"def badMuons(self, allmuons, allvertices):\\n\\n muons = list(m for m in allmuons) # make it a python list\\n goodMuon = []\\n\\n if len(allvertices) < 1: raise RuntimeError\\n PV = allvertices[0].position()\\n \\n out = [] \\n for mu in muons:\\n if (not(mu.isPFMuon()) or mu.innerTrack().isNull()):\\n goodMuon.append(-1); # bad but we don't care\\n continue;\\n if (self.preselection(mu)):\\n dxypv = abs(mu.innerTrack().dxy(PV));\\n dzpv = abs(mu.innerTrack().dz(PV));\\n if (self.tighterId(mu)):\\n ipLoose = ((dxypv < 0.5 and dzpv < 2.0) or mu.innerTrack().hitPattern().pixelLayersWithMeasurement() >= 2);\\n goodMuon.append(ipLoose or (not(self.selectClones_) and self.tightGlobal(mu)));\\n elif (self.safeId(mu)):\\n ipTight = (dxypv < 0.2 and dzpv < 0.5);\\n goodMuon.append(ipTight);\\n else:\\n goodMuon.append(0);\\n else:\\n goodMuon.append(3); # maybe good, maybe bad, but we don't care\\n\\n n = len(muons)\\n for i in range(n):\\n if (muons[i].pt() < self.ptCut_ or goodMuon[i] != 0): continue;\\n bad = True;\\n if (self.selectClones_):\\n bad = False; # unless proven otherwise\\n n1 = muons[i].numberOfMatches(ROOT.reco.Muon.SegmentArbitration);\\n for j in range(n):\\n if (j == i or goodMuon[j] <= 0 or not(self.partnerId(muons[j]))): continue\\n n2 = muons[j].numberOfMatches(ROOT.reco.Muon.SegmentArbitration);\\n if (deltaR(muons[i],muons[j]) < 0.4 or (n1 > 0 and n2 > 0 and ROOT.muon.sharedSegments(muons[i],muons[j]) >= 0.5*min(n1,n2))):\\n bad = True;\\n break;\\n if (bad):\\n out.append(muons[i]);\\n return out\",\n \"def build_set(ls, dsets):\\n\\n def noh(ls, dsets):\\n \\\"\\\"\\\"\\n This function remove hydrogens from the selection\\n \\\"\\\"\\\"\\n data_set = build_set(ls[1], dsets)\\n\\n noh_set = set()\\n pred = oechem.OEIsHydrogen()\\n\\n for idx in data_set:\\n atom = system.GetAtom(oechem.OEHasAtomIdx(idx))\\n if not pred(atom):\\n noh_set.add(idx)\\n\\n return noh_set\\n\\n def residues(ls):\\n \\\"\\\"\\\"\\n This function select residues based on the residue numbers. An example of\\n selection can be:\\n mask = 'resid A:16 17 19 B:1'\\n \\\"\\\"\\\"\\n # List residue atom index to be restrained\\n res_atom_set = set()\\n\\n # Dictionary of lists with the chain residues selected to be restrained\\n # e.g. {chainA:[res1, res15], chainB:[res19, res17]}\\n chain_dic = {'': []}\\n\\n # Fill out the chain dictionary\\n i = 0\\n while i < len(ls):\\n if ls[i].isdigit():\\n chain_dic[''].append(int(ls[i]))\\n i += 1\\n else:\\n try:\\n chain_dic[ls[i]].append(int(ls[i + 2]))\\n except:\\n chain_dic[ls[i]] = []\\n chain_dic[ls[i]].append(int(ls[i + 2]))\\n i += 3\\n\\n # Loop over the molecular system to select the atom indexes to be selected\\n hv = oechem.OEHierView(system, oechem.OEAssumption_BondedResidue + oechem.OEAssumption_ResPerceived)\\n for chain in hv.GetChains():\\n chain_id = chain.GetChainID()\\n if chain_id not in chain_dic:\\n continue\\n for frag in chain.GetFragments():\\n for hres in frag.GetResidues():\\n res_num = hres.GetOEResidue().GetResidueNumber()\\n if res_num not in chain_dic[chain_id]:\\n continue\\n for oe_at in hres.GetAtoms():\\n res_atom_set.add(oe_at.GetIdx())\\n\\n return res_atom_set\\n\\n def around(dist, ls):\\n \\\"\\\"\\\"\\n This function select atom not far than the threshold distance from\\n the current selection. The threshold distance is in Angstrom\\n\\n selection can be:\\n mask = '5.0 around ligand'\\n \\\"\\\"\\\"\\n # at = system.GetAtom(oechem.OEHasAtomIdx(idx))\\n\\n # Atom set selection\\n atom_set_around = set()\\n\\n # Create a OE bit vector mask for each atoms\\n bv_around = oechem.OEBitVector(system.GetMaxAtomIdx())\\n\\n # Set the mask atom\\n for at in system.GetAtoms():\\n if at.GetIdx() in ls:\\n bv_around.SetBitOn(at.GetIdx())\\n\\n # Predicate\\n pred = oechem.OEAtomIdxSelected(bv_around)\\n\\n # Create the system molecule based on the atom mask\\n molecules = oechem.OEMol()\\n oechem.OESubsetMol(molecules, system, pred)\\n\\n # Create the Nearest neighbours\\n nn = oechem.OENearestNbrs(system, float(dist))\\n\\n for nbrs in nn.GetNbrs(molecules):\\n for atom in oechem.OEGetResidueAtoms(nbrs.GetBgn()):\\n if atom.GetIdx() in ls:\\n continue\\n atom_set_around.add(atom.GetIdx())\\n\\n return atom_set_around\\n\\n # Start Body of the selection function by language\\n\\n # Terminal Literal return the related set\\n if isinstance(ls, str):\\n return dsets[ls]\\n # Not or Noh\\n if len(ls) == 2:\\n if ls[0] == 'noh': # Noh case\\n return noh(ls, dsets)\\n elif ls[0] == 'not': # Not case\\n return dsets['system'] - build_set(ls[1], dsets)\\n else: # Resid case with one index\\n return residues(ls[1])\\n\\n if len(ls) == 3:\\n if ls[1] == 'or': # Or Case (set union)\\n return build_set(ls[0], dsets) | build_set(ls[2], dsets)\\n elif ls[1] == 'and': # And Case (set intersection)\\n return build_set(ls[0], dsets) & build_set(ls[2], dsets)\\n elif ls[1] == 'diff': # Diff case (set difference)\\n return build_set(ls[0], dsets) - build_set(ls[2], dsets)\\n elif ls[1] == 'around': # Around case\\n return around(ls[0], build_set(ls[2], dsets))\\n else:\\n return residues(ls[1:]) # Resid case with one or two indexes\\n else:\\n if ls[0] == 'resid':\\n return residues(ls[1:]) # Resid case with multiple indexes\\n else:\\n raise ValueError(\\\"The passed list have too many tokens: {}\\\".format(ls))\",\n \"def get_selected_muons(muons, trigobj, mask_events, mu_pt_cut_leading, mu_pt_cut_subleading, mu_aeta_cut, mu_iso_cut): \\n passes_iso = muons.pfRelIso04_all < mu_iso_cut\\n passes_id = muons.mediumId == 1\\n passes_subleading_pt = muons.pt > mu_pt_cut_subleading\\n passes_leading_pt = muons.pt > mu_pt_cut_leading\\n passes_aeta = NUMPY_LIB.abs(muons.eta) < mu_aeta_cut\\n \\n trigobj.masks[\\\"mu\\\"] = (trigobj.id == 13)\\n \\n muons_matched_to_trigobj = NUMPY_LIB.invert(mask_deltar_first(muons, muons.masks[\\\"all\\\"], trigobj, trigobj.masks[\\\"mu\\\"], 0.1))\\n \\n #select muons that pass these cuts\\n muons_passing_id = passes_iso & passes_id & passes_subleading_pt & muons_matched_to_trigobj\\n \\n #select events that have muons passing cuts \\n events_passes_muid = sum_in_offsets(muons, muons_passing_id, mask_events, muons.masks[\\\"all\\\"], NUMPY_LIB.int8) >= 2\\n events_passes_leading_pt = sum_in_offsets(muons, muons_passing_id & passes_leading_pt, mask_events, muons.masks[\\\"all\\\"], NUMPY_LIB.int8) >= 1\\n events_passes_subleading_pt = sum_in_offsets(muons, muons_passing_id & passes_subleading_pt, mask_events, muons.masks[\\\"all\\\"], NUMPY_LIB.int8) >= 2\\n\\n base_event_sel = mask_events & events_passes_muid & events_passes_leading_pt & events_passes_subleading_pt\\n \\n muons_passing_os = select_muons_opposite_sign(muons, muons_passing_id & passes_subleading_pt)\\n events_passes_os = sum_in_offsets(muons, muons_passing_os, mask_events, muons.masks[\\\"all\\\"], NUMPY_LIB.int8) == 2\\n \\n final_event_sel = base_event_sel & events_passes_os\\n final_muon_sel = muons_passing_id & passes_subleading_pt & muons_passing_os\\n \\n return {\\n \\\"selected_events\\\": final_event_sel,\\n \\\"selected_muons\\\": final_muon_sel,\\n }\",\n \"def clean_detections(npts, on_off):\\n on = on_off[:,0]\\n off = on_off[:,1]\\n idx_on = [on[0]]\\n idx_off = [off[0]]\\n lowest_idx = on[0]\\n\\n for ion, ioff in zip(on, off):\\n if ion > lowest_idx + npts:\\n idx_on.append(ion)\\n idx_off.append(ioff)\\n lowest_idx = ion\\n\\n return np.asarray((idx_on, idx_off)).T\",\n \"def onset(sig, stw, ltw, centred=False):\\n\\n stw = int(round(stw))\\n ltw = int(round(ltw))\\n\\n n_channels, n_samples = sig.shape\\n onset = np.copy(sig)\\n onset_raw = np.copy(sig)\\n for i in range(n_channels):\\n if np.sum(sig[i, :]) == 0.0:\\n onset[i, :] = 0.0\\n onset_raw[i, :] = onset[i, :]\\n else:\\n if centred is True:\\n onset[i, :] = sta_lta_centred(sig[i, :], stw, ltw)\\n else:\\n onset[i, :] = classic_sta_lta(sig[i, :], stw, ltw)\\n onset_raw[i, :] = onset[i, :]\\n np.clip(1 + onset[i, :], 0.8, np.inf, onset[i, :])\\n np.log(onset[i, :], onset[i, :])\\n\\n return onset_raw, onset\",\n \"def merge_sets(sets):\\n idxs_skipped = []\\n n = len(sets)\\n for i in range(n-1):\\n if i not in idxs_skipped:\\n set_i = sets[i]\\n for j in range(i+1,n):\\n set_j = sets[j]\\n if set_i.intersection( set_j ) > set([]):\\n sets[i].update( set_j )\\n idxs_skipped.append( j )\\n sets_u = [ sets[k] for k in np.setdiff1d(range(n), idxs_skipped).astype(np.int) ]\\n return sets_u\",\n \"def onsets_rt(self) -> Optional[annotations.BeatData]:\\n return load_onsets(self.onsets_rt_path)\",\n \"def find_flats(aperture, side='blue'):\\r\\n \\r\\n # find dome flat images\\r\\n domeflats = iraf.hselect('%s????.fits' % side, '$I', 'TURRET == \\\"APERTURE\\\" & APERTURE == \\\"%s\\\" & LAMPS == \\\"0000000\\\" & AIRMASS < 1.01 & IMGTYPE == \\\"flat\\\"' % aperture, Stdout=1)\\r\\n # find internal flat (incandescent lamp) images\\r\\n intflats = iraf.hselect('%s????.fits' % side, '$I', 'TURRET == \\\"LAMPS\\\" & APERTURE == \\\"%s\\\" & LAMPS == \\\"0000001\\\" & AIRMASS < 1.01' % aperture, Stdout=1)\\r\\n # dome flats are prefered over internal flats\\r\\n flats = []\\r\\n if (len(intflats) > 0) & (len(domeflats) == 0):\\r\\n flats = intflats\\r\\n print \\\"Using %d internal flats for the %s arcsec slit.\\\" % (len(intflats), aperture)\\r\\n if len(domeflats) > 3:\\r\\n flats = domeflats\\r\\n print \\\"Using %d dome flats for the %s arcsec slit.\\\" % (len(domeflats), aperture)\\r\\n\\r\\n return flats\",\n \"def getmountoffsets():\\n r = _getoffsets(isMountoffset=True)\\n return r\",\n \"def add_sets(list_of_sets):\\n global true_introns\\n for item in list_of_sets:\\n true_introns.update(item)\",\n \"def lights_on(self) -> list:\\n return [\\n entity for entity in self.all_lights if self.hass.get_state(entity) == \\\"on\\\"\\n ]\",\n \"def pointsets_mod_automorphism(self, pointsets):\\n points = set()\\n for ps in pointsets:\\n points.update(ps)\\n points = tuple(points)\\n Aut = self.lattice_automorphism_group(points,\\n point_labels=tuple(range(len(points))))\\n indexsets = set([ frozenset([points.index(p) for p in ps]) for ps in pointsets ])\\n orbits = []\\n while len(indexsets)>0:\\n idx = indexsets.pop()\\n orbits.append(frozenset([points[i] for i in idx]))\\n for g in Aut:\\n g_idx = frozenset([g(i) for i in idx])\\n indexsets.difference_update([g_idx])\\n return tuple(orbits)\",\n \"def test_find_sets(self):\\n cards = numpy.array([[1,1,1,2,0],\\n [0,1,2,2,2],\\n [0,1,2,2,2],\\n [0,1,2,2,2]])\\n\\n set_indices = set_solver.find_sets(cards)\\n self.assertEqual(len(set_indices), 2)\\n self.assertTrue((0, 1, 2) in set_indices)\\n self.assertTrue((2, 3, 4) in set_indices)\",\n \"def find_all_ngon_sols():\\n ngon = [None for _ in range(N)] \\n ngon_set = set()\\n numbers = set(range(1, (2 * N) + 1))\\n\\n for triplet in permutations(numbers, 3):\\n ngon[0] = tuple(triplet)\\n total = sum(triplet)\\n next_ngon_set = set()\\n fill_ngon(ngon, numbers - set(triplet), 1, next_ngon_set, total)\\n ngon_set |= next_ngon_set\\n\\n return ngon_set\",\n \"def powerSetNaive(array):\\n\\n res = [[d] for d in array]\\n res.append([])\\n array_ = []\\n skip = 1\\n while skip <=len(array)-1:\\n\\n for x in range(0,len(array),skip):\\n array_.append(array[x])\\n for y in range(len(array_[0:x+skip+1])):\\n toAppend = array_[y:x+1]\\n if toAppend not in res:\\n res.append(toAppend)\\n toAppend = array_[0:x]\\n if toAppend not in res:\\n res.append(toAppend)\\n array_=[]\\n skip = skip + 1\\n\\n return res\",\n \"def simple(onArray, offArray):\\n \\n Larray = len(onArray)\\n Larray2 = len(offArray)\\n \\n assert Larray == Larray2, \\\"both arrays should have the same size\\\"\\n \\n #onFiltered = numpy.array(onArray)[:,OnOff.misc.constants.dataRange]\\n #offFiltered = numpy.array(offArray)[:,OnOff.misc.constants.dataRange]\\n \\n #return onFiltered,offFiltered,OnOff.misc.constants.dataRange\\n drange = OnOffCalc.misc.getDatarange(onArray.shape[1])\\n dataMask = numpy.ones(onArray.shape)\\n #dataMask[:,OnOffCalc.misc.constants.dataRange] = 0\\n dataMask[:,drange] = 0\\n \\n return dataMask\",\n \"def getIMA(s, onsets):\\n s = s.stripTies()\\n\\n # with subprocess.Popen([\\\"onsets2ima\\\",\\\"-onsets\\\"] + [str(o) for o in onsets], stdout=subprocess.PIPE) as proc:\\n # output = proc.stdout.read().decode('ascii')\\n\\n proc = subprocess.Popen([\\\"onsets2ima\\\",\\\"-onsets\\\"] + [str(o) for o in onsets], stdout=subprocess.PIPE)\\n try:\\n outs, errs = proc.communicate(timeout=5)\\n except TimeoutExpired:\\n proc.kill()\\n raise IMATimeoutError\\n output = outs.decode('ascii')\\n\\n ima_str = output.split('\\\\n')[0].strip()\\n ima_spect_str = output.split('\\\\n')[1].strip()\\n\\n ima = [float(w) for w in ima_str.split(' ')]\\n ima_spect = [float(w) for w in ima_spect_str.split(' ')]\\n\\n #if onset of first note != 0 (start with rest), add zeros to ima_spect\\n ima_spect = [0.0]*onsets[0] + ima_spect\\n\\n ima_spect = [ima_spect[o] for o in onsets]\\n\\n return ima, ima_spect\",\n \"def mask_the_images(working_path,set_name):\\n\\n file_list=glob('/media/talhassid/My Passport/haimTal/test_images_0b8afe447b5f1a2c405f41cf2fb1198e.npy')\\n out_images = [] #final set of images for all patients\\n for fname in file_list:\\n out_images_per_patient = []\\n print (\\\"working on file \\\", fname)\\n imgs_to_process = np.load(fname.replace(\\\"lungmask\\\",\\\"images\\\")) # images of one patient\\n masks = np.load(fname)\\n for i in range(len(imgs_to_process)):\\n mask = masks[i]\\n img = imgs_to_process[i]\\n new_size = [512,512] # we're scaling back up to the original size of the image\\n img= mask*img # apply lung mask\\n #\\n # renormalizing the masked image (in the mask region)\\n #\\n new_mean = np.mean(img[mask>0])\\n new_std = np.std(img[mask>0])\\n #\\n # Pulling the background color up to the lower end\\n # of the pixel range for the lungs\\n #\\n old_min = np.min(img) # background color\\n img[img==old_min] = new_mean-1.2*new_std # resetting backgound color\\n img = img-new_mean\\n img = img/new_std\\n #make image bounding box (min row, min col, max row, max col)\\n labels = measure.label(mask)\\n regions = measure.regionprops(labels)\\n #\\n # Finding the global min and max row over all regions\\n #\\n min_row = 512\\n max_row = 0\\n min_col = 512\\n max_col = 0\\n for prop in regions:\\n B = prop.bbox\\n if min_row > B[0]:\\n min_row = B[0]\\n if min_col > B[1]:\\n min_col = B[1]\\n if max_row < B[2]:\\n max_row = B[2]\\n if max_col < B[3]:\\n max_col = B[3]\\n width = max_col-min_col\\n height = max_row - min_row\\n if width > height:\\n max_row=min_row+width\\n else:\\n max_col = min_col+height\\n #\\n # cropping the image down to the bounding box for all regions\\n # (there's probably an skimage command that can do this in one line)\\n #\\n img = img[min_row:max_row,min_col:max_col]\\n mask = mask[min_row:max_row,min_col:max_col]\\n if max_row-min_row <5 or max_col-min_col<5: # skipping all images with no god regions\\n pass\\n else:\\n # moving range to -1 to 1 to accomodate the resize function\\n mean = np.mean(img)\\n img = img - mean\\n min = np.min(img)\\n max = np.max(img)\\n img = img/(max-min)\\n new_img = resize(img,[512,512], mode='constant')\\n out_images_per_patient.append(new_img)\\n\\n id = re.sub(r'.*_images_(.*)\\\\.npy',r'\\\\1',fname)\\n patient_images_and_id = (out_images_per_patient,id)\\n out_images.append(patient_images_and_id)\\n print (\\\"Delete files: {} \\\\n\\\\t {} \\\".format(fname,re.sub(\\\"lungmask\\\",\\\"images\\\",fname)))\\n os.remove(fname)\\n os.remove(fname.replace(\\\"images\\\",\\\"lungmask\\\")) # images of one patient\\n\\n\\n np.save(working_path+\\\"{}Images.npy\\\".format(set_name),out_images)\",\n \"def nondetects(self, masked=False):\\r\\n grd = self.grd\\r\\n xnd = []\\r\\n ynd = []\\r\\n ncells = len(grd.cells['depth'])\\r\\n non_detects_i_tr = np.zeros(ncells, np.int32)\\r\\n if masked:\\r\\n not_flagged = np.where(self.rec_track.flagged==0)[0]\\r\\n rec_track = self.rec_track[not_flagged]\\r\\n rec_seg = self.make_segments(set_depth=True, \\r\\n input_rec_track=rec_track)\\r\\n else:\\r\\n rec_seg = self.rec_seg\\r\\n for nr, rseg in enumerate(rec_seg):\\r\\n seg = rec_seg[nr]\\r\\n dt = seg.dt\\r\\n if dt > dt_signal+1:\\r\\n t1 = seg.t1\\r\\n t2 = seg.t2\\r\\n nint = int(np.rint((t2-t1)/dt_signal)) - 1\\r\\n x1 = seg.x1\\r\\n x2 = seg.x2\\r\\n y1 = seg.y1\\r\\n y2 = seg.y2\\r\\n dx_nd = (x2 - x1)/float(nint+1)\\r\\n dy_nd = (y2 - y1)/float(nint+1)\\r\\n if nint < 120: # 10 minute cutoff for nondetect filling\\r\\n xint = [x1 + n*dx_nd for n in range(1,nint)]\\r\\n yint = [y1 + n*dy_nd for n in range(1,nint)]\\r\\n xnd = xnd + xint\\r\\n ynd = ynd + yint\\r\\n\\r\\n for nd in range(len(xnd)):\\r\\n xy = [xnd[nd], ynd[nd]]\\r\\n i = grd.select_cells_nearest(xy)\\r\\n if (i is not None) and (i >= 0):\\r\\n non_detects_i_tr[i] += 1\\r\\n\\r\\n return non_detects_i_tr\",\n \"def _compute_soffsets(self):\\n self.soffsets = [ [] for i in self.doffsets ]\\n for idx,dofs in enumerate(self.doffsets):\\n for o in dofs:\\n self.soffsets[(idx + o) % self.p].append(-o)\",\n \"def _gaussian_picker(self, onset, phase, start_time, p_arr, s_arr, ptt,\\n stt):\\n\\n # Determine indices of P and S pick times\\n pt_idx = int((p_arr - start_time) * self.sampling_rate)\\n st_idx = int((s_arr - start_time) * self.sampling_rate)\\n\\n # Determine P and S pick window upper and lower bounds based on\\n # (P-S)/2 -- either this or the next window definition will be\\n # used depending on which is wider.\\n pmin_idx = int(pt_idx - (st_idx - pt_idx) / 2)\\n pmax_idx = int(pt_idx + (st_idx - pt_idx) / 2)\\n smin_idx = int(st_idx - (st_idx - pt_idx) / 2)\\n smax_idx = int(st_idx + (st_idx - pt_idx) / 2)\\n\\n # Check if index falls outside length of onset function; if so set\\n # window to start/end at start/end of data.\\n for idx in [pmin_idx, pmax_idx, smin_idx, smax_idx]:\\n if idx < 0:\\n idx = 0\\n if idx > len(onset):\\n idx = len(onset)\\n\\n # Defining the bounds to search for the event over\\n # Determine P and S pick window upper and lower bounds based on\\n # set percentage of total travel time, plus marginal window\\n\\n # window based on self.fraction_tt of P/S travel time\\n pp_ttime = ptt * self.fraction_tt\\n ps_ttime = stt * self.fraction_tt\\n\\n # Add length of marginal window to this. Convert to index.\\n P_idxmin_new = int(pt_idx - int((self.marginal_window + pp_ttime)\\n * self.sampling_rate))\\n P_idxmax_new = int(pt_idx + int((self.marginal_window + pp_ttime)\\n * self.sampling_rate))\\n S_idxmin_new = int(st_idx - int((self.marginal_window + ps_ttime)\\n * self.sampling_rate))\\n S_idxmax_new = int(st_idx + int((self.marginal_window + ps_ttime)\\n * self.sampling_rate))\\n\\n # Setting so the search region can't be bigger than (P-S)/2:\\n # compare the two window definitions; if (P-S)/2 window is\\n # smaller then use this (to avoid picking the wrong phase).\\n P_idxmin = np.max([pmin_idx, P_idxmin_new])\\n P_idxmax = np.min([pmax_idx, P_idxmax_new])\\n S_idxmin = np.max([smin_idx, S_idxmin_new])\\n S_idxmax = np.min([smax_idx, S_idxmax_new])\\n\\n # Setting parameters depending on the phase\\n if phase == \\\"P\\\":\\n sta_winlen = self.p_onset_win[0]\\n win_min = P_idxmin\\n win_max = P_idxmax\\n if phase == \\\"S\\\":\\n sta_winlen = self.s_onset_win[0]\\n win_min = S_idxmin\\n win_max = S_idxmax\\n\\n # Find index of maximum value of onset function in the appropriate\\n # pick window\\n max_onset = np.argmax(onset[win_min:win_max]) + win_min\\n # Trim the onset function in the pick window\\n onset_trim = onset[win_min:win_max]\\n\\n # Only keep the onset function outside the pick windows to\\n # calculate the pick threshold\\n onset_threshold = onset.copy()\\n onset_threshold[P_idxmin:P_idxmax] = -1\\n onset_threshold[S_idxmin:S_idxmax] = -1\\n onset_threshold = onset_threshold[onset_threshold > -1]\\n\\n # Calculate the pick threshold: either user-specified percentile of\\n # data outside pick windows, or 88th percentile within the relevant\\n # pick window (whichever is bigger).\\n threshold = np.percentile(onset_threshold, self.pick_threshold * 100)\\n threshold_window = np.percentile(onset_trim, 88)\\n threshold = np.max([threshold, threshold_window])\\n\\n # Remove data within the pick window that is lower than the threshold\\n tmp = (onset_trim - threshold).any() > 0\\n\\n # If there is any data that meets this requirement...\\n if onset[max_onset] >= threshold and tmp:\\n exceedence = np.where((onset_trim - threshold) > 0)[0]\\n exceedence_dist = np.zeros(len(exceedence))\\n\\n # Really faffy process to identify the period of data which is\\n # above the threshold around the highest value of the onset\\n # function.\\n d = 1\\n e = 0\\n while e < len(exceedence_dist) - 1:\\n if e == len(exceedence_dist):\\n exceedence_dist[e] = d\\n else:\\n if exceedence[e + 1] == exceedence[e] + 1:\\n exceedence_dist[e] = d\\n else:\\n exceedence_dist[e] = d\\n d += 1\\n e += 1\\n\\n # Find the indices for this period of data\\n tmp = exceedence_dist[np.argmax(onset_trim[exceedence])]\\n tmp = np.where(exceedence_dist == tmp)\\n\\n # Add one data point below the threshold at each end of this period\\n gau_idxmin = exceedence[tmp][0] + win_min - 1\\n gau_idxmax = exceedence[tmp][-1] + win_min + 2\\n\\n # Initial guess for gaussian half-width based on onset function\\n # STA window length\\n data_half_range = int(sta_winlen * self.sampling_rate / 2)\\n\\n # Select data to fit the gaussian to\\n x_data = np.arange(gau_idxmin, gau_idxmax, dtype=float)\\n x_data = x_data / self.sampling_rate\\n y_data = onset[gau_idxmin:gau_idxmax]\\n\\n # Convert indices to times\\n x_data_dt = np.array([])\\n for i in range(len(x_data)):\\n x_data_dt = np.hstack([x_data_dt, start_time + x_data[i]])\\n\\n # Try to fit a gaussian.\\n try:\\n # Initial parameters are:\\n # height = max value of onset function\\n # mean = time of max value\\n # sigma = data half-range (calculated above)\\n p0 = [np.max(y_data),\\n float(gau_idxmin + np.argmax(y_data))\\n / self.sampling_rate,\\n data_half_range / self.sampling_rate]\\n\\n # Do the fit\\n popt, _ = curve_fit(util.gaussian_1d, x_data, y_data, p0)\\n\\n # Results:\\n # popt = [height, mean (seconds), sigma (seconds)]\\n max_onset = popt[0]\\n # Convert mean (pick time) to time\\n mean = start_time + float(popt[1])\\n sigma = np.absolute(popt[2])\\n\\n gaussian_fit = {\\\"popt\\\": popt,\\n \\\"xdata\\\": x_data,\\n \\\"xdata_dt\\\": x_data_dt,\\n \\\"PickValue\\\": max_onset,\\n \\\"PickThreshold\\\": threshold}\\n\\n # If curve_fit fails. Will also spit error message to stdout,\\n # though this can be suppressed - see warnings.filterwarnings()\\n except (ValueError, RuntimeError):\\n gaussian_fit = self.DEFAULT_GAUSSIAN_FIT\\n gaussian_fit[\\\"PickThreshold\\\"] = threshold\\n sigma = -1\\n mean = -1\\n max_onset = -1\\n\\n # If onset function does not exceed threshold in pick window\\n else:\\n gaussian_fit = self.DEFAULT_GAUSSIAN_FIT\\n gaussian_fit[\\\"PickThreshold\\\"] = threshold\\n sigma = -1\\n mean = -1\\n max_onset = -1\\n\\n return gaussian_fit, max_onset, sigma, mean\",\n \"def _get_ring_nodes(m, namin=3, namax=9, remove_redudant=T):\\n # first search for rings\\n sets = []\\n for i in range(namin, namax+1):\\n #if i in [3,4,5]:\\n pat_i = '*~1' + '~*'*(i-2) + '~*1'\\n #else:\\n # pat_i = '*:1' + ':*'*(i-2) + ':*1'\\n Qi = Chem.MolFromSmarts( pat_i )\\n for tsi in m.GetSubstructMatches(Qi):\\n set_i = set(tsi)\\n if set_i not in sets:\\n sets.append( set(tsi) )\\n if remove_redudant:\\n # now remove those rings that are union of smaller rings\\n n = len(sets)\\n sets_remove = []\\n ijs = itl.combinations( list(range(n)), 2 )\\n sets_u = []\\n for i,j in ijs:\\n set_ij = sets[i].union( sets[j] )\\n if (set_ij in sets) and (set_ij not in sets_remove):\\n sets_remove.append( set_ij )\\n sets_u = cim.get_compl(sets, sets_remove)\\n else:\\n sets_u = sets\\n return sets_u\",\n \"def onsets_rb(self) -> Optional[annotations.BeatData]:\\n return load_onsets(self.onsets_rb_path)\",\n \"def getSets():\",\n \"def emg_onsets(emg_amplitude, threshold=0, threshold2=None):\\n # Sanity checks.\\n if not isinstance(emg_amplitude, np.ndarray):\\n emg_amplitude = np.atleast_1d(emg_amplitude).astype('float64')\\n if threshold > np.max(emg_amplitude):\\n raise ValueError(\\\"NeuroKit error: emg_onsets(): threshold\\\"\\n \\\"specified exceeds the maximum of the signal\\\"\\n \\\"amplitude.\\\")\\n if threshold2 is not None and threshold2 > np.max(emg_amplitude):\\n raise ValueError(\\\"NeuroKit error: emg_onsets(): threshold2\\\"\\n \\\"specified exceeds the maximum of the signal\\\"\\n \\\"amplitude.\\\")\\n\\n # Extract indices of data points greater than or equal to threshold.\\n indices = np.nonzero(emg_amplitude >= threshold)[0]\\n\\n # Extract initial and final indexes of each activity burst.\\n indices = np.vstack((indices[np.diff(np.hstack((-np.inf, indices))) > 1],\\n indices[np.diff(np.hstack((indices, np.inf))) > 1])).T\\n indices = indices[indices[:, 1]-indices[:, 0] >= 0, :]\\n\\n # Threshold2.\\n if threshold2 is not None:\\n indices2 = np.ones(indices.shape[0], dtype=bool)\\n for i in range(indices.shape[0]):\\n if np.count_nonzero(emg_amplitude[indices[i, 0]: indices[i, 1]+1] >= threshold2) < 1:\\n indices2[i] = False\\n indices = indices[indices2, :]\\n\\n # Prepare output.\\n indices = list(np.concatenate(indices))\\n info = {\\\"EMG_Onsets\\\": indices}\\n\\n return info\",\n \"def loopreelset(combination, reel_set):\\n matching_reels = []\\n for index in range(5):\\n if if3symbols(combination[index][0],combination[index][1],combination[index][2], reel_set[index]):\\n matching_reels.append(index)\\n if len(matching_reels) == 5:\\n return True\",\n \"def lego_sets():\\n # you must replace this line and return your own list\\n return []\",\n \"def GET_MODIS_LANDSAT_PAIRS(self, datasets, latitude, longitude, start_date, end_date, max_cloud_cover):\\n total_scenes = []\\n START_DATE = start_date\\n END_DATE = end_date\\n \\\"\\\"\\\"\\n search through given dates\\n finds matching dates and position. \\n \\\"\\\"\\\"\\n\\n #while len(total_scenes) < num_pairs and int((date.fromisoformat(START_DATE) - date.fromisoformat(end_date)).days):\\n ### Search for Landsat products ###\\n Landsat_scenes = self.api.search(\\n dataset=datasets[0],\\n latitude=latitude,\\n longitude=longitude,\\n start_date=START_DATE,\\n end_date=END_DATE,\\n max_cloud_cover=max_cloud_cover,\\n max_results=1000)\\n\\n # the scenes will be ordered oldest -> most recent\\n START_DATE = Landsat_scenes[0]['acquisitionDate']\\n\\n ### Search for MODIS products ###\\n MODIS_scenes = self.api.search(\\n dataset=datasets[1],\\n latitude=latitude,\\n longitude=longitude,\\n start_date=START_DATE,\\n end_date=END_DATE,\\n max_cloud_cover=max_cloud_cover,\\n max_results=1000)\\n\\n # the scenes will be ordered oldest -> most recent\\n # next iteration starts at last found landsat date\\n START_DATE = Landsat_scenes[-1]['acquisitionDate']\\n\\n\\n # make dict so we can access with dates and scene bounds\\n Landsat_scenes = {scene['acquisitionDate']: scene for scene in Landsat_scenes}\\n MODIS_scenes = {scene['acquisitionDate']: scene for scene in MODIS_scenes}\\n ### GET MATCHING DATES ###\\n keys = set(MODIS_scenes.keys()).intersection(Landsat_scenes.keys())\\n\\n ### generate tuple pairs, landsat, modis ###\\n found_scenes = [(Landsat_scenes[date], MODIS_scenes[date]) for date in keys]\\n total_scenes += found_scenes\\n if len(found_scenes):\\n print(\\\"{} scenes found...\\\".format(len(found_scenes)))\\n print(\\\"{} total scenes\\\".format(len(total_scenes)))\\n else:\\n print(\\\"{} total scenes\\\".format(len(total_scenes)))\\n\\n return total_scenes\",\n \"def check_setpoints(self):\\n # TODO: Can possibly put this in the CCBC Brains\\n for heater in self.ard_data['heaters'].keys():\\n current_temp = float(self.ard_data['tempsensors'][self.ard_data['heaters'][heater]['tsensor_name']]['value'])\\n\\n # Assign the pin_status the previous value from the previous iteration\\n pin_status = self.ard_data['heaters'][heater]['status']\\n\\n if current_temp > self.ard_data['heaters'][heater]['upper limit']:\\n pin_status = 'OFF'\\n\\n if current_temp < self.ard_data['heaters'][heater]['lower limit']:\\n pin_status = 'ON'\\n\\n if current_temp >= self.ard_data['heaters'][heater]['maxtemp']:\\n pin_status = 'OFF'\\n\\n self.ard_data['heaters'][heater]['status'] = pin_status\\n\\n for pump in self.ard_data['pumps'].keys():\\n pressure = float(self.ard_data['presssensors'][self.ard_data['pumps'][pump]['psensor_name']]['pressure'])\\n gallons = float(pressure * self.ard_data['pumps'][pump]['psi_to_gal_slope'] +\\n self.ard_data['pumps'][pump]['psi_to_gal_intercept'])\\n self.ard_data['pumps'][pump]['gallons'] = gallons\\n\\n # Assign the pin status the previous value from the previous cycle\\n pin_status = self.ard_data['pumps'][pump]['status']\\n\\n if gallons > self.ard_data['pumps'][pump]['upper limit']:\\n # Turn the pump off when the setpoint is above the setpoint\\n pin_status = 'OFF'\\n # TODO: Account for solenoid valve control when available\\n\\n if gallons < self.ard_data['pumps'][pump]['lower limit']:\\n pin_status = 'ON'\\n\\n self.ard_data['pumps'][pump]['status'] = pin_status\",\n \"def lfcSet(file_list):\\n # Just out of paranoia, order the LFC files\\n pseudo_time = np.empty_like(file_list,dtype='float')\\n file_date = np.empty_like(file_list,dtype='float')\\n file_obsn = np.empty_like(file_list,dtype='float')\\n for i,file_name in enumerate(file_list):\\n file_id = os.path.basename(file_name).split('_')[-1][:-5]\\n pseudo_time[i] = file_id\\n file_date[i], file_obsn[i] = file_id.split('.')\\n time_sort = np.argsort(pseudo_time)\\n file_list = np.array(file_list)[time_sort]\\n file_date = file_date[time_sort]\\n file_obsn = file_obsn[time_sort]\\n \\n sets = []\\n consecutive = []\\n date = file_date[0]\\n for i in range(1,len(file_list)):\\n if date != file_date[i]:\\n date = file_date[i]\\n sets.append(consecutive)\\n consecutive=[file_list[i]]\\n elif file_obsn[i] != file_obsn[i-1]+1:\\n sets.append(consecutive)\\n consecutive=[file_list[i]]\\n else:\\n consecutive.append(file_list[i])\\n return sets\",\n \"def save_conditions_onsets(conditions_onsets,\\n onsets_dir=tempfile.gettempdir()):\\n condition_files = []\\n\\n for cid, cframe in conditions_onsets.groupby(['session_name',\\n 'condition_id']):\\n session_id, condition_id = cid\\n onset_dir = os.path.join(onsets_dir, session_id)\\n if not os.path.exists(onset_dir):\\n os.makedirs(onset_dir)\\n fname = os.path.join(onset_dir, 'cond%03i.txt' % condition_id)\\n cframe[['onset', 'duration', 'amplitude']].to_csv(\\n fname, sep=' ', header=False, index=False)\\n condition_files.append(fname)\\n\\n return condition_files\",\n \"def buildConnectedSets(self, cars):\",\n \"def analyze(self, event):\\n '''\\n\\tif not (event.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ or event.HLT_Mu17_TrkIsoVVL_TkMu8_TrkIsoVVL_DZ or event.HLT_IsoTkMu24 or event.HLT_IsoMu24):\\n\\t self.out.fillBranch(\\\"pass_selection\\\",0)\\n return True\\n '''\\n\\telectrons = Collection(event, \\\"Electron\\\")\\n muons = Collection(event, \\\"Muon\\\")\\n jets = Collection(event, \\\"Jet\\\")\\n Z = ROOT.TLorentzVector()\\n\\n\\ttight_muons = []\\n\\tgoodmuons_pt = []\\n goodmuons_eta = [] \\n\\n\\tif (len(muons)<=1):\\n\\t\\tself.out.fillBranch(\\\"pass_selection\\\",0)\\n return True\\n\\tfor i in range(0,len(muons)):\\n #if (muons[i].eta) < 2.4 and (muons[i].mediumId) and (muons[i].pfIsoId)>=3:\\n\\t if (muons[i].eta) < 2.4 and (muons[i].mediumId):\\n\\t if (muons[i].pt) <= 25:\\n continue\\n\\t\\tfor j in range(i+1,len(muons)):\\n \\t\\t #if (muons[j].eta) < 2.4 and (muons[j].mediumId) and (muons[j].pfIsoId)>=3:\\n\\t if (muons[j].eta) < 2.4 and (muons[j].mediumId):\\n\\t if (muons[j].pt) <= 20:\\n\\t\\t\\t continue\\n\\t\\t if (muons[i].charge + muons[j].charge == 0):\\n\\t\\t\\t Z = muons[i].p4() + muons[j].p4()\\n\\t\\t\\t if (Z.M() > 76 and Z.M() < 106):\\n\\t\\t\\t\\tself.out.fillBranch(\\\"pass_selection\\\",1)\\n\\t \\t\\tself.out.fillBranch(\\\"z_pt\\\",Z.Pt())\\n\\t\\t\\t\\tself.out.fillBranch(\\\"z_mass\\\",Z.M())\\n\\t\\t\\t\\tself.out.fillBranch(\\\"z_phi\\\",Z.Phi())\\n\\t\\t\\t\\ttight_muons.append(muons[i]) \\n\\t\\t\\t\\ttight_muons.append(muons[j])\\n\\t\\n\\tif len(tight_muons) < 2:\\n\\t self.out.fillBranch(\\\"pass_selection\\\",0)\\n\\t return True\\n\\n ngoodmuons = 0\\n ngoodmuons = len(tight_muons)\\n\\tif ngoodmuons != 2:\\n print(ngoodmuons)\\n\\n goodmuons_pt.append(tight_muons[0].pt)\\n goodmuons_pt.append(tight_muons[1].pt)\\n goodmuons_eta.append(tight_muons[0].eta)\\n goodmuons_eta.append(tight_muons[1].eta) \\n \\n self.out.fillBranch(\\\"muon_pt\\\",goodmuons_pt)\\n self.out.fillBranch(\\\"muon_eta\\\",goodmuons_eta) \\n \\n\\tngoodjets = 0\\n goodjets_pt = []\\n\\tgoodjets_id = []\\n\\tgoodjets_phi = []\\n\\tgoodjets_dphi_zjet = []\\n\\n\\tfor k in range(0,len(jets)):\\n #print(4)\\n\\t if abs(jets[k].eta) > 2.4:\\n continue\\n #print(5) \\n\\t if jets[k].pt < 30:\\n\\t\\tcontinue\\n\\t #print(6)\\n\\t pass_lepton_dr_cut = True\\n\\n\\t for i in range(0,len(tight_muons)):\\n\\t\\t#if deltaR(muons[tight_muons[i]].eta,muons[tight_muons[i]].phi,jets[k].eta,jets[k].phi) < 0.4:\\n if deltaR(tight_muons[i].eta,tight_muons[i].phi,jets[k].eta,jets[k].phi) < 0.4:\\n\\t pass_lepton_dr_cut = False\\n\\n\\t if not pass_lepton_dr_cut:\\n\\t\\tcontinue\\n\\n ngoodjets += 1\\n goodjets_pt.append(jets[k].pt)\\n\\t #goodjets_id.append(jets[k].jetId)\\n\\t goodjets_phi.append(jets[k].phi)\\t \\n\\t #goodjets_dphi_zjet.append(deltaPhi(Z.Phi(),jets[k].phi)) \\n\\n if ngoodjets != len(goodjets_pt):\\n print(error)\\n\\n self.out.fillBranch(\\\"jet_pt\\\",goodjets_pt)\\n\\t#self.out.fillBranch(\\\"jet_id\\\",goodjets_id)\\n\\tself.out.fillBranch(\\\"jet_phi\\\",goodjets_phi)\\n\\t#self.out.fillBranch(\\\"dphi_zjet\\\",goodjets_dphi_zjet)\\n\\t'''\\n\\tif(njet!=0):\\n\\t print(njet)\\n '''\\n\\tif hasattr(event,\\\"Generator_weight\\\"):\\n self.out.fillBranch(\\\"gen_weight\\\",event.Generator_weight)\\n else:\\n self.out.fillBranch(\\\"gen_weight\\\",0)\\n\\treturn True\",\n \"def get_sparse_noise_onset_index(sparseNoiseDisplayLog):\\n\\n\\n frames = sparseNoiseDisplayLog['presentation']['displayFrames']\\n frames = [tuple([np.array([x[1][1],x[1][0]]),x[2],x[3],i]) for i, x in enumerate(frames)]\\n dtype = [('location',np.ndarray),('sign',int),('isOnset',int),('index',int)]\\n frames = np.array(frames, dtype = dtype)\\n\\n allOnsetInd = []\\n for i in range(len(frames)):\\n if frames[i]['isOnset'] == 1 and (i == 0 or frames[i-1]['isOnset'] == -1):\\n allOnsetInd.append(i)\\n\\n onsetFrames = frames[allOnsetInd]\\n\\n allSquares = list(set([tuple([x[0][0],x[0][1],x[1]]) for x in onsetFrames]))\\n\\n onsetIndWithLocationSign = []\\n\\n for square in allSquares:\\n indices = []\\n for onsetFrame in onsetFrames:\\n if onsetFrame['location'][0]==square[0] and onsetFrame['location'][1]==square[1] and onsetFrame['sign']==square[2]:\\n indices.append(onsetFrame['index'])\\n\\n onsetIndWithLocationSign.append([np.array([square[0],square[1]]),square[2],indices])\\n\\n return allOnsetInd, onsetIndWithLocationSign\",\n \"def stations(station_let):\\n\\tstat = ['']*np.size(station_let,0)\\n\\tfor i in range(len(stat)):\\n\\t\\tfor j in range(4):\\n\\t\\t\\tif station_let[i][j] is not np.ma.masked:\\n\\t\\t\\t\\tstat[i]+=station_let[i][j]\\n\\treturn stat\",\n \"def GetBonds(Bonds):\\n b = sorted([(min(x), max(x)) for x in Bonds])\\n Bonds13, Bonds14 = [], []\\n for (a1,b1) in b:\\n #check for bonds with a1 at the center of a 1-3 interaction,\\n #letting b1 be the higher number of the two flanking\\n clist = [b2 for (a2,b2) in b if a2 == a1 and b2 < b1] + \\\\\\n [a2 for (a2,b2) in b if b2 == a1 and a2 < b1]\\n Bonds13.extend([(min(c,b1), max(c,b1)) for c in clist])\\n #check for bonds with b1 at the center of a 1-3 interaction,\\n #letting a1 be the higher number of the two flanking\\n clist = [b2 for (a2,b2) in b if a2 == b1 and b2 < a1] + \\\\\\n [a2 for (a2,b2) in b if b2 == b1 and a2 < a1]\\n Bonds13.extend([(min(c,a1), max(c,a1)) for c in clist])\\n #find atoms connected to a1\\n clist = [b2 for (a2,b2) in b if a1==a2 and not b1==b2] +\\\\\\n [a2 for (a2,b2) in b if a1==b2 and not b1==a2]\\n #find atoms connected to b1\\n dlist = [a2 for (a2,b2) in b if b1==b2 and not a1==a2] +\\\\\\n [b2 for (a2,b2) in b if b1==a2 and not a1==b2]\\n Bonds14.extend([(min(c,d), max(c,d)) for c in clist for d in dlist])\\n Bonds1213 = b + Bonds13\\n #sort\\n Bonds1213.sort()\\n Bonds14.sort()\\n #get unique values in case of loops\\n Bonds1213 = [x for (i,x) in enumerate(Bonds1213) if i == 0 or x != Bonds1213[i-1]]\\n Bonds14 = [x for (i,x) in enumerate(Bonds14) if i == 0 or x != Bonds14[i-1]]\\n #convert to arrays \\n Bonds1213 = array(Bonds1213, int)\\n Bonds14 = array(Bonds14, int)\\n return Bonds1213, Bonds14\",\n \"def get_max_num_onsets():\\r\\n \\\"\\\"\\\" based on the numbers above, should equal to 932945... \\\"\\\"\\\"\\r\\n c1 = len(gen_onset_c1())\\r\\n c2 = len(gen_onset_c2())\\r\\n c3 = len(gen_onset_c3_c4())\\r\\n c4 = len(gen_onset_c3_c4())\\r\\n temp = c1\\r\\n temp = temp + ( c1 * c2 )\\r\\n temp = temp + ( c1 * c3 )\\r\\n temp = temp + ( c1 * c2 * c3 )\\r\\n temp = temp + ( c1 * c3 * c4 )\\r\\n temp = temp + ( c1 * c2 * c3 * c4 )\\r\\n return temp\",\n \"def get_sensor_bool_dryspot_runlevel(self, filename, threshold_min_counted_dryspots=5):\\n f = h5py.File(filename, \\\"r\\\")\\n meta_file = h5py.File(str(filename).replace(\\\"RESULT.erfh5\\\", \\\"meta_data.hdf5\\\"), 'r')\\n\\n try:\\n single_states, set_of_states, useless_states = self.__get_dryspot_data(f, meta_file)\\n multi_states = self.__get_pressure_data(f)\\n multi_states = multi_states.squeeze()\\n\\n activated_sensors = np.count_nonzero(multi_states, axis=1)\\n percentage_of_all_sensors = activated_sensors / 1140\\n len_wanted_seq = 100\\n current = 0\\n sequence = np.zeros((len_wanted_seq, self.num_sensors))\\n frame_labels = []\\n\\n if self.aux_info:\\n original_frame_idxs = np.full(len_wanted_seq, np.nan, np.int16)\\n frame_labels_aux = np.full(len_wanted_seq, np.nan, np.int8)\\n sample_percentages = np.full(len_wanted_seq, np.nan)\\n single_state_indices = np.full(len_wanted_seq, np.nan, np.int16)\\n # flowfronts = np.zeros((len_wanted_seq, self.image_size[0], self.image_size[1]))\\n # _coords, flat_fillings = self.__get_filling_data(f, single_states)\\n\\n for i, sample in enumerate(single_states):\\n state_num = int(str(sample).replace(\\\"state\\\", \\\"0\\\"))\\n try:\\n sample_percentage = percentage_of_all_sensors[state_num - 1]\\n if sample_percentage >= current / len_wanted_seq:\\n data = multi_states[state_num - 1, :]\\n data = np.log(np.add(data, 1)) # TODO make log optional\\n if self.sensor_indizes != ((0, 1), (0, 1)):\\n rect = data.reshape(38, 30)\\n sel = rect[self.sensor_indizes[0][0]::self.sensor_indizes[0][1],\\n self.sensor_indizes[1][0]::self.sensor_indizes[1][1]]\\n data = sel.flatten()\\n sequence[current, :] = data\\n\\n frame_label = 0\\n if state_num in set_of_states:\\n frame_label = 1\\n frame_labels.append(frame_label)\\n\\n if self.aux_info:\\n original_frame_idxs[current] = state_num\\n frame_labels_aux[current] = frame_label\\n sample_percentages[current] = sample_percentage\\n single_state_indices[current] = i\\n # flowfronts[current, :, :] = create_np_image(target_shape=self.image_size,\\n # norm_coords=_coords, data=flat_fillings[i])\\n current += 1\\n except IndexError:\\n continue\\n\\n # determine runlevel label using frame labels and threshold\\n lens_of_runs_of_dryspots = [sum(1 for _ in group) for key, group in\\n groupby(np.array(frame_labels) == 1) if key]\\n max_len = 0 if len(lens_of_runs_of_dryspots) == 0 else max(lens_of_runs_of_dryspots)\\n label = 0 if max_len < threshold_min_counted_dryspots else 1\\n\\n f.close()\\n meta_file.close()\\n\\n if self.aux_info:\\n # framelabels, original_frame_idx, original_num_frames, flowfronts, filling_percentage\\n aux = {\\\"framelabel\\\": frame_labels_aux,\\n \\\"original_frame_idx\\\": original_frame_idxs,\\n \\\"original_num_multi_states\\\": len(multi_states),\\n \\\"percent_of_sensors_filled\\\": sample_percentages,\\n \\\"single_state_indices\\\": single_state_indices,\\n }\\n return [(sequence, label, aux)]\\n\\n return [(sequence, label)]\\n except KeyError:\\n f.close()\\n meta_file.close()\\n return None\",\n \"def extract_onset_events(bin_path, chanList, chunk_size=4000):\\n meta = readMeta(bin_path)\\n sRate = SampRate(meta)\\n\\n n_samples = int(float(meta['fileTimeSecs']) * sRate)\\n n_chunks = sp.floor(n_samples / chunk_size).astype('int32')\\n print(\\\"leftover samples: %i\\\" % (n_samples % n_chunks))\\n\\n rawData = makeMemMapRaw(bin_path, meta)\\n\\n events = []\\n for ch in chanList:\\n inds = []\\n\\n # get digital data for the selected lines\\n for i in tqdm(range(n_chunks)):\\n start = i * chunk_size\\n stop = start + chunk_size\\n\\n digArray = ExtractDigital(rawData, start, stop, 0, range(8), meta)\\n trig_data = digArray[ch,:]\\n\\n ix = sp.where(sp.diff(trig_data) == 1)[0]\\n inds.append(ix+start)\\n # if len(ix) > 0:\\n # print(len(ix))\\n\\n inds = sp.concatenate(inds)\\n times = inds / sRate\\n events.append([inds,times])\\n\\n return events\",\n \"def connected_sets(self):\\n self._assert_counted_at_lag()\\n return self._connected_sets\",\n \"def find_arms(path,fr_nb):\\n im=open_frame(path,fr_nb)\\n img=im.copy()\\n im=img_as_ubyte(im)\\n mask_h = hysteresis_thresholding(img,6,10)\\n \\n ksize=5\\n kernel = np.ones((ksize,ksize),dtype = np.uint8)\\n kernel = skimage.morphology.disk(ksize)\\n \\n mask = cv2.morphologyEx(mask_h, cv2.MORPH_OPEN, kernel,iterations=2)\\n \\n arms = mask_h-mask\\n \\\"\\\"\\\"\\n lab,_ = ndi.label(diff)\\n \\n arms = skimage.morphology.remove_small_objects(lab,60)\\\"\\\"\\\" #Only temporary, to track only the biggest\\n return mask,arms\",\n \"def findSubsetIndices(grdMODEL, min_lat, max_lat, min_lon, max_lon):\\n\\n\\n if min_lon<0 and max_lon>0:\\n splitExtract = True; Turns=2\\n grdMODEL.splitExtract=splitExtract\\n else:\\n splitExtract = False; Turns=1\\n grdMODEL.splitExtract=splitExtract\\n grdMODEL.lon = np.where(grdMODEL.lon>180,grdMODEL.lon-360,grdMODEL.lon)\\n \\n # Array to store the results returned from the function\\n res=np.zeros((Turns,4),dtype=np.float64)\\n \\n lats=grdMODEL.lat[:,0]\\n lons=grdMODEL.lon[0,:]\\n\\n \\n for k in range(Turns):\\n\\n if k==0 and splitExtract == True:\\n minLon=min_lon; maxLon=0\\n minLon=minLon+360\\n maxLon=maxLon+360\\n elif k==1 and splitExtract == True:\\n minLon=0; maxLon=max_lon\\n else:\\n minLon=min_lon; maxLon=max_lon\\n \\n distances1 = []\\n distances2 = []\\n indices=[]\\n index=1\\n for point in lats:\\n s1 = max_lat-point # (vector subtract)\\n s2 = min_lat-point # (vector subtract)\\n distances1.append((np.dot(s1, s1), point, index))\\n distances2.append((np.dot(s2, s2), point, index-1))\\n index=index+1\\n\\n distances1.sort()\\n distances2.sort()\\n indices.append(distances1[0])\\n indices.append(distances2[0])\\n \\n distances1 = []\\n distances2 = []\\n index=1\\n \\n for point in lons:\\n s1 = maxLon-point # (vector subtract)\\n s2 = minLon-point # (vector subtract)\\n distances1.append((np.dot(s1, s1), point, index))\\n distances2.append((np.dot(s2, s2), point, index-1))\\n index=index+1\\n \\n distances1.sort()\\n distances2.sort()\\n indices.append(distances1[0])\\n indices.append(distances2[0])\\n\\n # Save final product: max_lat_indices,min_lat_indices,max_lon_indices,min_lon_indices\\n minJ=indices[1][2]\\n maxJ=indices[0][2]\\n minI=indices[3][2]\\n maxI=indices[2][2]\\n \\n res[k,0]=minI; res[k,1]=maxI; res[k,2]=minJ; res[k,3]=maxJ;\\n\\n # Save final product: max_lat_indices,min_lat_indices,max_lon_indices,min_lon_indices\\n grdMODEL.indices=res\",\n \"def finalSubsets(self):\\n subs = self.allSubsets()\\n for s in self.graph.observed:\\n subs = subs[subs[:,s] == 1,] # remove subsets where values in s are not True\\n return subs\",\n \"def isophase(_groups, colour, period):\\n # Whole numbers are required, so odd numbers are dealt with by loading\\n # the spare into the off period.\\n # As this is in milliseconds, this will be imperceptible.\\n # It is also unlikely, as the top-level input is in seconds\\n # and has been multiplied up to milliseconds before reaching this\\n # function\\n return [\\n (colour, math.floor(period/2)),\\n ('Off', math.ceil(period/2))\\n ]\",\n \"def get_masks(data):\\n return [patient[0] for i, patient in enumerate(data) if i in good_patients]\",\n \"def lego_sets():\\n # you must replace this line and return your own list\\n return lego_sets_list\",\n \"def find_rings(atom_list): \\n CX_list = [atom0 for atom0 in atom_list if ((atom0.atom_name == \\\"CX\\\") or (atom0.atom_name == \\\"CY\\\"))]\\n atom_dict = {}\\n for atom0 in CX_list:\\n if (len(identify_bonds(atom0, atom_list)) >= 2):\\n atom_dict[atom0] = {}\\n for atom1 in identify_bonds(atom0, atom_list):\\n if ( ((atom1[0].atom_name == \\\"CX\\\") or (atom1[0].atom_name == \\\"CY\\\")) and (len(identify_bonds(atom1[0], atom_list)) >= 2) ):\\n atom_dict[atom0][atom1[0]] = {}\\n for atom2 in identify_bonds(atom1[0], atom_list):\\n if ( ((atom2[0].atom_name == \\\"CX\\\") or (atom2[0].atom_name == \\\"CY\\\")) and (atom2[0] != atom0) and (len(identify_bonds(atom2[0], atom_list)) >= 2)):\\n atom_dict[atom0][atom1[0]][atom2[0]] = {}\\n for atom3 in identify_bonds(atom2[0], atom_list):\\n if ( ((atom3[0].atom_name == \\\"CX\\\") or (atom3[0].atom_name == \\\"CY\\\")) and (atom3[0] != atom0) and (len(identify_bonds(atom3[0], atom_list)) >= 2)):\\n atom_dict[atom0][atom1[0]][atom2[0]][atom3[0]] = [atom3[0].atom_number]\\n rings = []\\n for key in atom_dict.keys():\\n for key2 in atom_dict[key].keys():\\n for key3 in atom_dict[key][key2].keys():\\n for key4 in atom_dict[key][key2][key3].keys():\\n rings.append([key, key2, key3, key4])\\n finite_rings = []\\n for element in rings:\\n for element2 in rings:\\n if ((element[0] == element2[0]) and (element[3] == element2[3]) and (element[1] != element2[1]) and (element[1] != element2[2]) and (element[2] != element2[1]) and (element[2] != element2[2]) and (element[0] != element2[1] != element[3]) and (element[0] != element2[2] != element[3])):\\n check = True\\n for el in finite_rings:\\n if ((element[0] in el) and (element[1] in el) and (element[2] in el) and (element[3] in el) and (element2[0] in el) and (element2[1] in el) and (element2[2] in el) and (element2[3] in el)):\\n check = False\\n if (check == True):\\n finite_rings.append([element[0], element[1], element[2], element[3], element2[1], element2[2]])\\n return finite_rings\",\n \"def do_one_set_sims(num_sims=100, num_darts=1000):\\n areas = N.zeros(num_sims, dtype='f')\\n for isim in range(num_sims):\\n areas[isim] = do_one_sim(num_darts)\\n return (N.mean(areas), N.std(areas))\",\n \"def get_effective_lumi(array_from_googledoc,_era,_skoutput ,data_skoutput, _skdatadir,_dirlist,_summary_path,skim_list, _workdir, RunFull):\\n\\n print_message(1,\\\"get_effective_lumi [\\\"+_era+\\\"]\\\")\\n\\n \\\"\\\"\\\" loop over dataset list on tamsa\\\"\\\"\\\"\\n var_url = get_url_from_era(_era,False)\\n\\n arr_alias=[]\\n arr_alias_torun=[]\\n array_gd = array_from_googledoc\\n\\n for dsn in _dirlist:\\n \\n array_gd = array_from_googledoc\\n\\n\\n var_alias = find_googledoc_var_from_dsn(array_gd,_era,\\\"alias\\\", dsn)\\n\\n if var_alias == \\\"NULL\\\" :\\n print \\\"Skipping NULL [get_effective_lumi] \\\" +dsn\\n continue\\n\\n if not os.path.exists(data_skoutput+\\\"/\\\"+ var_alias +\\\".txt\\\"):\\n print \\\"get_effective_lumi: adding \\\" + var_alias + \\\" to processing list\\\"\\n arr_alias_torun.append(var_alias)\\n\\n \\n arr_alias.append(var_alias)\\n if os.path.exists( _workdir+\\\"/MC\\\"+_era+\\\".txt\\\"):\\n os.system(\\\"rm \\\" + _workdir + \\\"/MC\\\"+_era+\\\".txt\\\")\\n\\n w_list=open(_workdir+\\\"/MC\\\"+_era+\\\".txt\\\",\\\"w\\\")\\n\\n for x in arr_alias_torun:\\n w_list.write(x.split()[0]+\\\"\\\\n\\\")\\n w_list.close()\\n \\n return_list=[]\\n\\n if len(arr_alias_torun) > 0:\\n currentdir = os.getenv(\\\"PWD\\\")\\n print \\\"SKFlat.py -a GetEffLumi -l \\\"+currentdir+\\\"/\\\"+_workdir+\\\"/MC\\\"+_era+\\\".txt -n 50 --nmax 300 -e \\\"+_era\\n\\n os.chdir(os.getenv(\\\"SKFlat_WD\\\"))\\n os.system(\\\"SKFlat.py -a GetEffLumi -l \\\"+currentdir+\\\"/\\\"+_workdir+\\\"/MC\\\"+_era+\\\".txt -n 50 --nmax 300 -e \\\"+_era )\\n for x in arr_alias_torun:\\n print \\\"SKFlat.py -a GetEffLumi -i \\\"+x.split()[0] +\\\" -n 50 --nmax 300 -e \\\"+_era \\n #print ('cp ' + _skoutput + \\\"/GetEffLumi/\\\"+_era + \\\"/GetEffLumi_\\\"+ x.split()[0] +\\\".root \\\" + data_skoutput+\\\"/\\\")\\n #os.system('cp ' + _skoutput + \\\"/GetEffLumi/\\\"+_era + \\\"/GetEffLumi_\\\"+ x.split()[0] +\\\".root \\\" + data_skoutput+\\\"/\\\")\\n\\n #GetEFf=False\\n #while not GetEFf:\\n # l_userinput= raw_input ('Check if Eff lumi job is ok? [y/ MCname]:') \\n # if l_userinput == \\\"y\\\" : \\n # print \\\"Good\\\"\\n # GetEFf=True\\n # else:\\n # os.system(\\\"SKFlat.py -a GetEffLumi -i \\\"+l_userinput+\\\" -n 50 --nmax 300 -e \\\"+_era )\\n \\n\\n for skim in skim_list:\\n new_list=open(currentdir+\\\"/\\\"+_workdir+\\\"/MC\\\"+_era+\\\".txt\\\",\\\"r\\\")\\n new_skimlist=open(currentdir+\\\"/\\\"+_workdir+\\\"/MC_\\\"+skim+\\\"_\\\"+_era+\\\".txt\\\",\\\"w\\\")\\n runSkim=False\\n for l in new_list:\\n l = l.split()[0]\\n #allowed_inputs=['y','n']\\n #l_userinput ='NULL'\\n #while not l_userinput in allowed_inputs:\\n # l_userinput= raw_input ('Sample to update ['+l+']: make skim ' + skim + ' [y/n]:')\\n\\n \\n if run_skim_from_googledoc(_era,l , skim,var_url) == \\\"Y\\\": #l_userinput == \\\"y\\\":\\n print 'Sample to update ['+l+']: make skim ' + skim\\n new_skimlist.write(l+'\\\\n')\\n runSkim=True\\n return_list.append(find_googledoc_var_from_alias(_era, \\\"dsn\\\", l.split()[0],var_url))\\n\\n new_list.close()\\n new_skimlist.close()\\n if runSkim:\\n os.system(\\\"SKFlat.py -a \\\"+skim+\\\" -l \\\"+currentdir+\\\"/\\\"+_workdir+\\\"/MC_\\\"+skim+\\\"_\\\"+_era+\\\".txt -n 100 --nmax 300 -e \\\"+_era )\\n \\n \\n os.system(\\\"rm \\\"+currentdir+\\\"/\\\"+_workdir+\\\"/MC_\\\"+skim+\\\"_\\\"+_era+\\\".txt\\\")\\n os.chdir(currentdir)\\n \\n else:\\n print \\\"get_effective_lumi: all samples proccessed previously\\\"\\n\\n ''' delete job submittion file '''\\n os.system(\\\"rm \\\"+ _workdir+ \\\"/MC\\\"+_era+\\\".txt\\\") \\n\\n \\n ''' run over ds list at tamsa and fill common samplefile'''\\n\\n print ('Fill CommonSampleFiles')\\n\\n update_array=[]\\n\\n for dsn in _dirlist:\\n ''' access alias and xsec fmor google doc'''\\n\\n array_gd = array_from_googledoc\\n\\n var_alias = find_googledoc_var_from_dsn(array_gd,_era,\\\"alias\\\", dsn)\\n if var_alias == \\\"NULL\\\" :\\n continue\\n\\n\\n if not RunFull:\\n if not var_alias in arr_alias_torun:\\n print (\\\"skipping \\\" + var_alias + \\\" since not running Full mode\\\")\\n continue\\n \\n else:\\n print 'Filling for ' + dsn\\n\\n var_xsec = find_googledoc_var_from_dsn(array_gd,_era,\\\"xsec\\\" , dsn)\\n\\n #''' get nevents from GetEffLumi job'''\\n\\n dirpath = _skoutput + \\\"/GetEffLumi/\\\"+_era + \\\"/\\\"\\n _file = ROOT.TFile(dirpath + \\\"/GetEffLumi_\\\"+ var_alias + \\\".root\\\")\\n hist = _file.Get(\\\"sumW\\\")\\n nevents_w = hist.Integral()\\n signhist = _file.Get(\\\"sumSign\\\")\\n nevents_sign = signhist.Integral()\\n _file.Close()\\n nevents_no_w=0\\n \\n orig_xsec=\\\"\\\"\\n orig_nevent_no_w=\\\"\\\"\\n orig_nevent_sign=\\\"\\\"\\n orig_nevent_w=\\\"\\\"\\n\\n \\n print \\\"Reading : \\\" + dsn\\n print \\\"Reading \\\" + _skdatadir + _era+ \\\"/Sample/CommonSampleInfo/\\\"+var_alias+\\\".txt\\\"\\n\\n orig_common_list = open(_skdatadir + _era+ \\\"/Sample/CommonSampleInfo/\\\"+var_alias+\\\".txt\\\",\\\"r\\\")\\n\\n for line in orig_common_list:\\n if not \\\"#\\\" in line:\\n if len(line.split()) < 1:\\n continue\\n orig_xsec=line.split()[2]\\n orig_nevent_no_w=line.split()[3]\\n orig_nevent_sign=line.split()[4]\\n orig_nevent_w=line.split()[5]\\n orig_common_list.close()\\n\\n print ('Filled for original values')\\n update_file=False\\n\\n if not orig_xsec == var_xsec:\\n update_file=True\\n print \\\"CommonSampleInfo xsec updated for \\\" + var_alias\\n\\n #if not orig_nevent_no_w==str(nevents_no_w):\\n #update_file=True\\n #print \\\"CommonSampleInfo xsec updated for nevents_no_w \\\" + str(nevents_no_w)\\n if not float(orig_nevent_w)==nevents_w:\\n update_file=True\\n nevents_no_w=nevents(_skdatadir + _era+ \\\"/Sample/ForSNU/\\\"+var_alias + \\\".txt\\\")\\n print \\\"CommonSampleInfo updated for nevents_w \\\" + str(nevents_w)\\n\\n elif not float(orig_nevent_sign)==nevents_sign:\\n update_file=True\\n nevents_no_w=nevents(_skdatadir + _era+ \\\"/Sample/ForSNU/\\\"+var_alias + \\\".txt\\\")\\n print \\\"CommonSampleInfo updated for nevents_sign \\\" + str(nevents_sign)\\n else: \\n nevents_no_w=orig_nevent_no_w\\n\\n if update_file:\\n ''' make commonfile for alias'''\\n common_list=open(_skdatadir + _era+ \\\"/Sample/CommonSampleInfo/\\\"+var_alias+\\\".txt\\\",\\\"w\\\")\\n common_list.write(\\\"# alias PD xsec nmc sumsign sumw\\\\n\\\")\\n common_list.write( var_alias + \\\"\\\\t\\\" + dsn + \\\"\\\\t\\\" + var_xsec + \\\"\\\\t\\\" + str(nevents_no_w) +\\\"\\\\t\\\"+ str(nevents_sign) +\\\"\\\\t\\\"+ str(nevents_w)+\\\" \\\\n\\\") \\n\\n\\n common_list.close()\\n os.system(\\\"git diff \\\" + _skdatadir + _era+ \\\"/Sample/CommonSampleInfo/\\\"+var_alias+\\\".txt\\\")\\n\\n update_array.append([var_alias,var_xsec, nevents_no_w, nevents_sign , nevents_w])\\n\\n\\n if len(update_array) > 0:\\n update_summarymc_file(_era)\\n\\n return return_list\",\n \"def find_tps(ckt, a):\\n return set([x for x in a if ckt[x].fots.isdisjoint(set(a))])\",\n \"def find_endpoints(batch_trajectories):\\n # empty lists to fill\\n site_lats = []\\n site_lons = []\\n last_lats = []\\n last_lons = []\\n lats_150 = []\\n lons_150 = [] \\n last_times = []\\n times_150 = []\\n last_sst = []\\n sst_150 = []\\n \\n # temporary lists as placeholders\\n temp_site_lats = []\\n temp_site_lons = []\\n temp_lats = []\\n temp_lons = []\\n temp_lats150 = []\\n temp_lons150 = []\\n temp_times = []\\n temp_times150 = []\\n temp_sst = []\\n temp_sst150 = []\\n\\n for speed in range(len(batch_trajectories)):\\n # working with one speed at a time means working with one nc file at\\n # a time\\n \\n # reset temporary lists\\n temp_site_lats = []\\n temp_site_lons = []\\n temp_lats = []\\n temp_lons = []\\n temp_lats150 = []\\n temp_lons150 = []\\n temp_times = []\\n temp_times150 = []\\n temp_sst = []\\n temp_sst150 = []\\n\\n # extract variables into lists\\n lats = batch_trajectories[speed].variables['lat'][:]\\n lons = batch_trajectories[speed].variables['lon'][:]\\n lats150 = batch_trajectories[speed].variables['lat150'][:]\\n lons150 = batch_trajectories[speed].variables['lon150'][:]\\n times = batch_trajectories[speed].variables['time'][:]\\n ssts = batch_trajectories[speed].variables['temp'][:]\\n ssts_150 = batch_trajectories[speed].variables['temp150'][:]\\n\\n # if a particle is deleted before time is up, values are masked. \\n # We'd like to get the last valid number.\\n for trajectory in range(len(lats)):\\n i = -1 # index for the last value\\n while np.ma.is_masked(lats[trajectory][i]) is True:\\n i -= 1 # if the value is masked, go to one value sooner\\n \\n j = i # use j for the 150m values\\n while lats150[trajectory][j] > 0:\\n # we want the first index where the latitude is recorded.\\n # j is actually the last one where it's not recorded, so we\\n # extract the information at index j+1\\n j -= 1\\n\\n # once i and j are determined for a trajectory, we can extract the\\n # variables and append them to temporary lists.\\n temp_site_lats.append(lats[trajectory][0])\\n temp_site_lons.append(lons[trajectory][0])\\n temp_lats.append(lats[trajectory][i])\\n temp_lons.append(lons[trajectory][i])\\n temp_lats150.append(lats150[trajectory][j+1])\\n temp_lons150.append(lons150[trajectory][j+1])\\n temp_times.append(times[trajectory][i])\\n temp_sst.append(ssts[trajectory][i])\\n temp_sst150.append(ssts_150[trajectory][j+1])\\n temp_times150.append(times[trajectory][j+1])\\n \\n # after the temporary lists are appended by sinking speed, they\\n # are appended to the big lists that are returned by the function.\\n # this keeps the structure of being separated by sinking speed.\\n site_lats.append(temp_site_lats)\\n site_lons.append(temp_site_lons)\\n last_lats.append(temp_lats)\\n last_lons.append(temp_lons)\\n lats_150.append(temp_lats150)\\n lons_150.append(temp_lons150)\\n last_times.append(temp_times)\\n times_150.append(temp_times150)\\n last_sst.append(temp_sst)\\n sst_150.append(temp_sst150)\\n \\n return site_lats, site_lons, last_lats, last_lons, lats_150, lons_150,\\\\\\n last_times, times_150, last_sst, sst_150\",\n \"def get_5index_list(self):\\n msk = self.load_mask()\\n return [i for (i,v) in enumerate(msk) if v==0]\",\n \"def selectOfSample(self, indexes):\\n index_set = set()\\n for idx in indexes:\\n i = list(self.sample[self.sample['masked'] == False].index)[idx]\\n index_set.add(i)\\n for ind in list(self.sample[self.sample['masked'] == False].index):\\n if ind not in index_set:\\n self.sample.at[ind, 'masked'] = True\\n return index_set\",\n \"def mask_incoherent(self):\\n self.MaskPrefix = 'i' + self.MaskPrefix\\n print('Masking pixel values where .msk value is less than {0}...'.format(threshold))\\n for ig in self.Set:\\n igram = self.load_ma(ig)\\n mskFile = ig.Path[:-3] + 'msk'\\n coherence = roipy.tools.load_half(ig, 2, mskFile)\\n incoherent = ma.masked_less(coherence, self.Cothresh)\\n igram[incoherent.mask] = ma.masked\\n mskFile = self.MaskPrefix + 'Mask_' + ig.Name[:-4]\\n np.save(os.path.join(self.ProcDir, mskFile), igram.mask)\\n print(mskFile)\\n\\n print('Done')\",\n \"def masterFlat(flat_list, master_dark_fname, normalize = 'median', local_sig_bad_pix = 3, \\\\\\n global_sig_bad_pix = 9, local_box_size = 11, hotp_map_fname = None, verbose=False,\\n output_dir = None,min_flux=1000):\\n\\n #Open the master dark\\n master_dark_hdu = f.open(master_dark_fname)\\n master_dark = master_dark_hdu[0].data\\n dark_shape = np.shape(master_dark)\\n\\n if verbose:\\n print((\\\"Subtracting {} from each flat file\\\".format(master_dark_fname)))\\n dark_exp_time = master_dark_hdu[0].header['EXPTIME']\\n\\n #Open all files into a 3D array\\n #foo = np.empty((dark_shape[0],dark_shape[1],len(flat_list)))\\n foo = []\\n\\n #Open first flat file to check exposure time and filter\\n first_flat_hdu = f.open(flat_list[0])\\n flat_exp_time = first_flat_hdu[0].header['EXPTIME']\\n\\n\\n\\n if dark_exp_time != flat_exp_time:\\n print(\\\"The master dark file doesn't have the same exposure time as the flats. We'll scale the dark for now, but this isn't ideal\\\", UserWarning)\\n factor = flat_exp_time/dark_exp_time\\n else:\\n factor = 1.\\n\\n #We've already read it, so we'll stick it in foo\\n\\n print(\\\"Combining flat files\\\")\\n for i in range(0,len(flat_list)):\\n try: \\n #subtract dark for each file, then normalize by mode\\n hdu = f.open(flat_list[i],ignore_missing_end=True)\\n d_sub = hdu[0].data - factor*master_dark\\n if np.nanmedian(d_sub) < min_flux:\\n #print(\\\"Skipping file {}, because its flux is lower than {}\\\".format(flat_list[i],min_flux))\\n continue\\n #normalize\\n if normalize == 'mode':\\n d_sub = d_sub/mode(d_sub, axis = None, nan_policy = 'omit')\\n elif normalize == 'median':\\n d_sub = d_sub/np.nanmedian(d_sub)\\n #foo[:,:,i] = d_sub\\n foo.append(d_sub)\\n except:\\n print(\\\"Some error. Skipping file {}\\\".format(i)) \\n #Median combine frames\\n flat = np.median(foo, axis = 0)\\n\\n #Filter bad pixels\\n #bad_px = sigma_clip(flat, sigma = sig_bad_pix) #old and bad\\n ###Major update here: do sigma clipping on the pix-to-pix flat with the large scale vignette removed\\n ###Also add local sigma clipping\\n def stddevFilter(img, box_size):\\n \\\"\\\"\\\" from\\n https://stackoverflow.com/questions/28931265/calculating-variance-of-an-image-python-efficiently/36266187#36266187\\n This function compute the standard deviation of an image in a\\n moving box of a given size. The pixel i,j of the output is the\\n standard deviation of the pixel value in the box_size x box_size box\\n around the i,j pixel in the original image.\\n \\\"\\\"\\\"\\n wmean, wsqrmean = (cv2.boxFilter(x, -1, (box_size, box_size), \\\\\\n borderType=cv2.BORDER_REFLECT) for x in (img, img*img))\\n return np.sqrt(wsqrmean - wmean*wmean)\\n\\n #median flat\\n median_flat = median_filter(flat, local_box_size) #arbitrary size, shouldn't matter as long as it's big enough\\n #standard deviation image\\n stddev_im = stddevFilter(flat, local_box_size)\\n\\n #Local clipping\\n local_bad_pix = np.abs(median_flat - flat) > local_sig_bad_pix*stddev_im\\n\\n #Global clipping here to reject awful pixels and dust, bad columns, etc\\n pix_to_pix = flat/median_flat\\n global_bad_px = sigma_clip(pix_to_pix, sigma = global_sig_bad_pix).mask #9 seems to work best\\n\\n #also set all 0 and negative pixels in flat as bad\\n non_positive = flat <= 0\\n\\n #logic combine\\n bad_px = np.logical_or(global_bad_px, local_bad_pix)\\n\\n #also add non_positive pixels\\n bad_px = np.logical_or(bad_px, non_positive)\\n\\n #Normalize good pixel values\\n if normalize == 'median':\\n norm_flat = flat/np.nanmedian(flat[~bad_px])\\n elif normalize == 'mode':\\n norm_flat = flat/mode(flat, axis = None, nan_policy = 'omit')\\n #Stick it back in the last hdu\\n hdu[0].data = norm_flat\\n\\n #Add pipeline version and history keywords\\n vers = version.get_version()\\n hdu[0].header.set('PL_VERS',vers,'Version of pipeline used for processing')\\n hdu[0].header['HISTORY'] = \\\"############################\\\"\\n hdu[0].header['HISTORY'] = \\\"Created master flat by median combining the following:\\\"\\n for i in range(len(flat_list)):\\n hdu[0].header['HISTORY'] = flat_list[i]\\n hdu[0].header['HISTORY'] = \\\"Normalized to the median of the master flat\\\"\\n hdu[0].header['HISTORY'] = \\\"Performed bad pixel local and global sigma clipping with {}, {}sigmas\\\".format(local_sig_bad_pix, global_sig_bad_pix)\\n hdu[0].header['HISTORY'] = \\\"############################\\\"\\n\\n #Parse the last fileanme\\n if output_dir is not None:\\n flat_outname = flat_list[-1].rsplit('.',1)[0]+\\\"_master_flat.fits\\\"\\n flat_outname = flat_outname.rsplit('/',1)[-1]\\n flat_outname = output_dir+flat_outname\\n else:\\n flat_outname = flat_list[-1].rsplit('.',1)[0]+\\\"_master_flat.fits\\\"\\n\\n #Write the fits file\\n if verbose:\\n print((\\\"Writing master flat to {}\\\".format(flat_outname)))\\n hdu.writeto(flat_outname, overwrite=True)\\n\\n #If there's already a hot pixel map then we'll add to it.\\n if hotp_map_fname != None:\\n #read in the existing bp map\\n #hdu = f.open(hotp_map_fname)\\n #hdu[0].data += np.array(bad_px.mask, dtype=float)\\n #hdu[0].data = np.logical_or(hdu[0].data.astype(bool), bad_px) #use logical or to combine bad pixel maps\\n #bp_outname = flat_list[-1].rsplit('.',1)[0]+\\\"_bp_map.fits\\\"\\n print(\\\"Will deal with hot pixel map from dark frames in the calibrate function\\\")\\n\\n #else:\\n #Parse the last fileanme\\n if output_dir is not None:\\n bp_outname = flat_list[-1].rsplit('.',1)[0]+\\\"_bp_map.fits\\\"\\n bp_outname = bp_outname.rsplit('/',1)[-1]\\n bp_outname = output_dir+bp_outname\\n else:\\n bp_outname = flat_list[-1].rsplit('.',1)[0]+\\\"_bp_map.fits\\\"\\n\\n ##### Now write the bad pixel map\\n hdu[0].data = bad_px.astype(int)#np.array(bad_px.mask, dtype=float)\\n #Parse the last fileanme\\n # bp_outname = flat_list[-1].rsplit('.',1)[0]+\\\"_bp_map.fits\\\"\\n\\n #Add history keywords\\n hdu[0].header['HISTORY'] = \\\"############################\\\"\\n hdu[0].header['HISTORY'] = \\\"Created bad pixel map by sigma clipping on pixel-to-pixel flat{}\\\".format(flat_outname)\\n hdu[0].header['HISTORY'] = \\\"Bad pixel cutoffs: local sigma = {} and global sigma = {} for clipping\\\".format(local_sig_bad_pix, global_sig_bad_pix)\\n #hdu[0].header['HISTORY'] = \\\"Bad pixel cutoff of {}sigma\\\".format(sig_bad_pix)\\n hdu[0].header['HISTORY'] = \\\"A pixel value of 1 indicates a bad pixel\\\"\\n hdu[0].header['HISTORY'] = \\\"############################\\\"\\n\\n if verbose:\\n print((\\\"Writing bad pixel map to {}\\\".format(bp_outname)))\\n #Write the fits file\\n hdu.writeto(bp_outname, overwrite=True)\\n\\n return flat_outname, bp_outname\",\n \"def srlatch(_signal,reset_th, set_th):\\n s = [_signal > set_th][0]\\n r = [_signal < reset_th][0]\\n L = len(_signal)\\n q = np.zeros(L)\\n # qrev = np.zeros(L)\\n for i in np.arange(L):\\n if ((s[i] == 0) & (r[i] == 0) & (i > 0)):\\n q[i] = q[i - 1]\\n elif ((s[i] == 0) & (r[i] == 1)):\\n q[i] = 0\\n elif ((s[i] == 1) & (r[i] == 0)):\\n q[i] = 1\\n else:\\n q[i] == -1 # error\\n return np.array(q)\",\n \"def get_nrof_lights(self):\\n lights = 0\\n for l in self.light_array:\\n if l:\\n lights += 1\\n return lights\",\n \"def get_muons(limit, selected_run, run_range_low, run_range_high, gold, atm):\\n conn = engine_nl.connect()\\n\\n runs = []\\n\\n if not selected_run and not run_range_high:\\n current_run = get_latest_run()\\n run_range = current_run - limit\\n # This missed muon array can be very long, so just select on its length\\n if not atm:\\n result = conn.execute(\\\"SELECT DISTINCT ON (a.run) a.run, a.gtids, a.days, a.secs, a.nsecs, \\\"\\n \\\"array_length(b.gtids, 1), c.gtids FROM muons AS a LEFT JOIN missed_muons \\\"\\n \\\"AS b ON a.run=b.run LEFT JOIN atmospherics AS c ON a.run=c.run \\\"\\n \\\"WHERE a.run >= %s ORDER BY a.run DESC, a.timestamp DESC, b.timestamp DESC, \\\" \\n \\\"c.timestamp DESC\\\", (run_range,))\\n else:\\n result = conn.execute(\\\"SELECT DISTINCT ON (a.run) a.run, b.gtids, b.days, b.secs, b.nsecs, \\\"\\n \\\"array_length(c.gtids, 1), a.gtids FROM atmospherics \\\"\\n \\\"AS a INNER JOIN muons AS b ON a.run=b.run INNER JOIN \\\"\\n \\\"missed_muons AS c ON a.run=c.run WHERE array_length(a.gtids, 1) > 0 \\\"\\n \\\"AND a.run >= %s ORDER BY a.run DESC, a.timestamp DESC, b.timestamp DESC, \\\"\\n \\\"c.timestamp DESC\\\", (run_range,))\\n status = conn.execute(\\\"SELECT DISTINCT ON (run) run, muon_time_in_range, missed_muon_time_in_range, \\\"\\n \\\"atmospheric_time_in_range FROM time_check WHERE run >= %s \\\"\\n \\\"ORDER BY run DESC, timestamp DESC\\\", (run_range,))\\n elif run_range_high:\\n if not atm:\\n result = conn.execute(\\\"SELECT DISTINCT ON (a.run) a.run, a.gtids, a.days, a.secs, a.nsecs, \\\"\\n \\\"array_length(b.gtids, 1), c.gtids FROM muons AS a LEFT JOIN missed_muons \\\"\\n \\\"AS b ON a.run=b.run LEFT JOIN atmospherics AS c ON a.run=c.run \\\"\\n \\\"WHERE a.run >= %s AND a.run <= %s ORDER BY a.run DESC, a.timestamp DESC, \\\"\\n \\\"b.timestamp DESC, c.timestamp DESC\\\", (run_range_low, run_range_high))\\n else:\\n result = conn.execute(\\\"SELECT DISTINCT ON (a.run) a.run, b.gtids, b.days, b.secs, b.nsecs, \\\"\\n \\\"array_length(c.gtids, 1), a.gtids FROM atmospherics \\\"\\n \\\"AS a INNER JOIN muons AS b ON a.run=b.run INNER JOIN \\\"\\n \\\"missed_muons AS c ON a.run=c.run WHERE array_length(a.gtids, 1) > 0 \\\"\\n \\\"AND a.run >= %s AND a.run <= %s ORDER BY a.run DESC, a.timestamp DESC, \\\"\\n \\\"b.timestamp DESC, c.timestamp DESC\\\", (run_range_low, run_range_high))\\n status = conn.execute(\\\"SELECT DISTINCT ON (run) run, muon_time_in_range, missed_muon_time_in_range, \\\"\\n \\\"atmospheric_time_in_range FROM time_check WHERE run >= %s AND \\\"\\n \\\"run <= %s ORDER BY run DESC, timestamp DESC\\\", (run_range_low, run_range_high)) \\n else:\\n result = conn.execute(\\\"SELECT DISTINCT ON (a.run) a.run, a.gtids, a.days, a.secs, a.nsecs, \\\"\\n \\\"array_length(b.gtids, 1), c.gtids FROM muons AS a LEFT JOIN missed_muons \\\"\\n \\\"AS b ON a.run=b.run LEFT JOIN atmospherics AS c ON a.run=c.run \\\"\\n \\\"WHERE a.run = %s ORDER BY a.run, a.timestamp DESC, b.timestamp DESC, \\\" \\n \\\"c.timestamp DESC\\\", (selected_run,))\\n status = conn.execute(\\\"SELECT DISTINCT ON (run) run, muon_time_in_range, missed_muon_time_in_range, \\\"\\n \\\"atmospheric_time_in_range FROM time_check WHERE run = %s ORDER BY run, \\\" \\n \\\"timestamp DESC\\\", (selected_run,)) \\n\\n rows = result.fetchall()\\n\\n muon_count = {}\\n mmuon_count = {}\\n atm_count = {}\\n livetime_lost = {} \\n fake = {}\\n check_time = {}\\n\\n for run, agtids, adays, asecs, ansecs, bgtids, cgtids in rows:\\n\\n # Check if the run is on the gold list\\n if gold != 0 and run not in gold:\\n continue\\n\\n runs.append(run)\\n check_time[run] = \\\"-\\\"\\n\\n if agtids is None:\\n continue\\n\\n # Check if we inserted a fake muon\\n if len(agtids) > 0 and agtids[0] == -1:\\n fake[run] = 1\\n muon_count[run] = len(agtids)\\n # array_length returns None for size zero arrays\\n if bgtids is None:\\n mmuon_count[run] = 0\\n else:\\n mmuon_count[run] = bgtids\\n # Calculate livetime lost to muons, which are the dominant source\\n livetime_lost[run] = calculate_livetime_lost(adays, asecs, ansecs)\\n # Lots of unprocessed runs, so check to make sure \\n if cgtids is not None:\\n atm_count[run] = len(cgtids)\\n continue\\n atm_count[run] = \\\"Not Processed\\\"\\n\\n check = status.fetchall()\\n for run, muon_status, mm_status, atm_status in check:\\n check_time[run] = (muon_status and mm_status and atm_status)\\n\\n return runs, muon_count, mmuon_count, atm_count, livetime_lost, fake, check_time\",\n \"def get_idx_set(i, sets):\\n idxs = []\\n for j, set_j in enumerate(sets):\\n if i in set_j: idxs.append(j)\\n return idxs\",\n \"def plateau_finder(data, tol=0.0003):\\n from scipy.ndimage.filters import generic_filter\\n tol = 0.0003\\n filt_data = generic_filter(data, np.std, size=3)\\n plat_index = np.where(filt_data < (np.min(filt_data) + tol))[0]\\n\\n plateaus = group_consecutive(plat_index)\\n\\n return plateaus\",\n \"def get_zones(array,kind,relevant=False,threshold=3):\\n\\n\\tresulting_set=[]\\n\\n\\ti=0\\n\\tif array[i]==kind:\\n\\t\\tcount=1\\n\\telse:\\n\\t\\tcount=0\\n\\n\\twhile i<len(array):\\n\\t\\t\\n\\t\\tif array[i]==kind:\\n\\t\\t\\tcount+=1\\n\\t\\telif array[i]!=kind and array[i-1]==kind:\\n\\t\\t\\tresulting_set.append(([kind]*count,i-count))\\n\\t\\t\\tcount=0\\n\\t\\telse:\\n\\t\\t\\tpass\\n\\n\\t\\ti+=1\\n\\n\\tif count>0:\\n\\t\\tresulting_set.append(([kind]*count, i-count))\\n\\n\\tif relevant == False:\\n\\t\\treturn resulting_set\\n\\telse:\\n\\t\\treturn [item for item in resulting_set if len(item[0])>threshold]\",\n \"def associate_detections_to_trackers(detections,trackers,iou_threshold = 0.3):\\n if(len(trackers)==0):\\n return np.empty((0,2),dtype=int), np.arange(len(detections)), np.empty((0,5),dtype=int)\\n iou_matrix = iou_batch(detections, trackers)\\n\\n if min(iou_matrix.shape) > 0:\\n a = (iou_matrix > iou_threshold).astype(np.int32)\\n if a.sum(1).max() == 1 and a.sum(0).max() == 1:\\n matched_indices = np.stack(np.where(a), axis=1)\\n else:\\n matched_indices = linear_assignment(-iou_matrix)\\n else:\\n matched_indices = np.empty(shape=(0,2))\\n\\n unmatched_detections = []\\n for d, det in enumerate(detections):\\n if(d not in matched_indices[:,0]):\\n unmatched_detections.append(d)\\n unmatched_trackers = []\\n for t, trk in enumerate(trackers):\\n if(t not in matched_indices[:,1]):\\n unmatched_trackers.append(t)\\n\\n #filter out matched with low IOU\\n matches = []\\n for m in matched_indices:\\n if(iou_matrix[m[0], m[1]]<iou_threshold):\\n unmatched_detections.append(m[0])\\n unmatched_trackers.append(m[1])\\n else:\\n matches.append(m.reshape(1,2))\\n if(len(matches)==0):\\n matches = np.empty((0,2),dtype=int)\\n else:\\n matches = np.concatenate(matches,axis=0)\\n\\n return matches, np.array(unmatched_detections), np.array(unmatched_trackers)\",\n \"def onsets_b(self) -> Optional[annotations.BeatData]:\\n return load_onsets(self.onsets_b_path)\",\n \"def loopreelset2(combination, reel_set):\\n matching_reels = []\\n for index in range(5):\\n if if2symbols(combination[index][0],combination[index][1], reel_set[index]):\\n matching_reels.append(index)\\n if len(matching_reels) == 5:\\n return True\",\n \"def onsets_d(self) -> Optional[annotations.BeatData]:\\n return load_onsets(self.onsets_d_path)\",\n \"def isolate_strokes(self):\\n if self.onset_times is False:\\n self.find_onsets()\\n # Defining the frame to contain the strokes\\n frame_sz = int(self.stroke_length*self.sampling_rate)\\n self.strokes = np.array(\\n [self.audio[i:i+frame_sz] for i in self.onset_samples])\",\n \"def do_dtv_flagging2(data, freqs):\\n \\n mask = data.mask*1\\n dtv_times = []\\n \\n for ledge in (54, 60, 66, 76, 82):\\n uedge = ledge + 6\\n band = np.where( (freqs>=ledge) & (freqs<=uedge) )[0]\\n trns = np.where( (freqs>=ledge+0.25) & (freqs<=uedge-0.25) )[0]\\n empt = np.where( ((freqs>=ledge-0.25) & (freqs<ledge+0.25)) | ((freqs>uedge-0.25) & (freqs<=uedge+0.25)) )[0]\\n \\n pB = np.mean(data.data[:,band], axis=1)\\n pT = np.mean(data.data[:,trns], axis=1)\\n pE = np.mean(data.data[:,empt], axis=1)\\n \\n #import pylab\\n #pylab.plot(pB-pE)\\n #pylab.plot(pT-pE)\\n #pylab.plot(pE-1)\\n #pylab.plot(pE*0 + 3*pE.std())\\n #pylab.show()\\n \\n st = np.std(pE)\\n bad = np.where( np.abs(pT-pE) > 3*st )[0]\\n for b in bad:\\n\\t dtv_times.append(b)\\n mask[b,band] |= True\\n if b > 1:\\n mask[b-1,band] |= True\\n\\t\\t dtv_times.append(b-1)\\n if b < data.shape[0]-2:\\n mask[b+1,band] |= True\\n\\t dtv_times.append(b+1)\\n \\n dtv_times = sorted(dtv_times)\\n\\n data.mask = mask*1\\n return data.mask, list(set(dtv_times))\",\n \"def block(array):\\r\\n grid = []\\r\\n for z in range(0,7,3): #0,3,6\\r\\n #vertical down 3\\r\\n for n in range(0,7,3): #0,3,6\\r\\n #horiz across 3\\r\\n line = []\\r\\n for i in range(3):\\r\\n for j in range(3):\\r\\n vert,hor = i+z,j+n\\r\\n line.append(array[vert][hor])\\r\\n grid.append(line)\\r\\n won = True\\r\\n for i in range(len(grid)):\\r\\n if won == True:\\r\\n if len(grid[i]) != len(set(grid[i])):\\r\\n won = False\\r\\n else:\\r\\n pass\\r\\n else:\\r\\n break\\r\\n return won\",\n \"def get_light_sky(filenames, onoff=True):\\n return filter_filenames(filenames, [\\\"light-off\\\"], onoff)\",\n \"def power_set(sett):\\n\\n powerset_so_far = {frozenset()}\\n\\n for element in sett:\\n set.update(powerset_so_far,\\\\\\n extend_all(element, powerset_so_far))\\n \\n return powerset_so_far\",\n \"def gen_all_holds(hand):\\n\\n mask = sorted(gen_all_sequences((1,0), len(hand)))\\n answer_set = []\\n for current_mask in mask:\\n temp = []\\n for indx in range(len(current_mask)):\\n if current_mask[indx] == 1:\\n temp.append(hand[indx]);\\n answer_set.append(tuple(temp))\\n return set(answer_set)\",\n \"def _find_trial_sounds_regions_in_sync(sync_file):\\n bit = 'SOUND'\\n return _find_bit_in_sync(sync_file, bit, ['up', 'down'])\",\n \"def find_dark_states(excited_state, ground_states):\",\n \"def analyze(self, event):\\n electrons = self.inputCollection(event)\\n muons = Collection(event, \\\"Muon\\\")\\n triggerObjects = self.triggerObjectCollection(event)\\n\\n selectedElectrons = []\\n unselectedElectrons = []\\n \\n weight_reco_nominal = 1.\\n weight_reco_up = 1.\\n weight_reco_down = 1.\\n\\n weight_id_nominal = 1.\\n weight_id_up = 1.\\n weight_id_down = 1.\\n\\n for electron in electrons:\\n # https://twiki.cern.ch/twiki/bin/view/CMS/CutBasedElectronIdentificationRun2\\n if electron.pt>self.electronMinPt \\\\\\n and math.fabs(electron.eta)<self.electronMaxEta \\\\\\n and self.electronID(electron)\\\\\\n and self.triggerMatched(electron, triggerObjects):\\n\\n dxy = math.fabs(electron.dxy)\\n dz = math.fabs(electron.dz)\\n \\n if math.fabs(electron.eta) < 1.479 and (dxy>0.05 or dz>0.10):\\n unselectedElectrons.append(electron)\\n continue\\n elif dxy>0.10 or dz>0.20:\\n unselectedElectrons.append(electron)\\n continue\\n\\n #reject electron if close-by muon\\n if len(muons)>0:\\n mindr = min(map(lambda muon: deltaR(muon, electron), muons))\\n if mindr < 0.05:\\n unselectedElectrons.append(electron)\\n continue\\n\\n selectedElectrons.append(electron)\\n \\n #TODO: electron reco/ID SFs\\n \\n \\n else:\\n unselectedElectrons.append(electron)\\n\\n \\n if not Module.globalOptions[\\\"isData\\\"] and self.storeWeights:\\n \\n self.out.fillBranch(self.outputName+\\\"_weight_reco_nominal\\\", weight_reco_nominal)\\n self.out.fillBranch(self.outputName+\\\"_weight_reco_up\\\", weight_reco_up)\\n self.out.fillBranch(self.outputName+\\\"_weight_reco_down\\\", weight_reco_down)\\n\\n self.out.fillBranch(self.outputName+\\\"_weight_id_nominal\\\",weight_id_nominal)\\n self.out.fillBranch(self.outputName+\\\"_weight_id_up\\\",weight_id_up)\\n self.out.fillBranch(self.outputName+\\\"_weight_id_down\\\",weight_id_down)\\n\\n self.out.fillBranch(\\\"n\\\"+self.outputName,len(selectedElectrons))\\n\\n for variable in self.storeKinematics:\\n self.out.fillBranch(self.outputName+\\\"_\\\"+variable,map(lambda electron: getattr(electron,variable), selectedElectrons))\\n\\n setattr(event,self.outputName,selectedElectrons)\\n setattr(event,self.outputName+\\\"_unselected\\\",unselectedElectrons)\\n\\n return True\",\n \"def associate_detections_to_trackers(detections,trackers,iou_threshold = 0.3):\\n if(len(trackers)==0):\\n return np.empty((0,2),dtype=int), np.arange(len(detections)), np.empty((0,5),dtype=int)\\n\\n iou_matrix = iou_batch(detections, trackers)\\n\\n if min(iou_matrix.shape) > 0:\\n a = (iou_matrix > iou_threshold).astype(np.int32)\\n if a.sum(1).max() == 1 and a.sum(0).max() == 1:\\n matched_indices = np.stack(np.where(a), axis=1)\\n else:\\n matched_indices = linear_assignment(-iou_matrix)\\n else:\\n matched_indices = np.empty(shape=(0,2))\\n\\n unmatched_detections = []\\n for d, det in enumerate(detections):\\n if(d not in matched_indices[:,0]):\\n unmatched_detections.append(d)\\n unmatched_trackers = []\\n for t, trk in enumerate(trackers):\\n if(t not in matched_indices[:,1]):\\n unmatched_trackers.append(t)\\n\\n #filter out matched with low IOU\\n matches = []\\n for m in matched_indices:\\n if(iou_matrix[m[0], m[1]]<iou_threshold):\\n unmatched_detections.append(m[0])\\n unmatched_trackers.append(m[1])\\n else:\\n matches.append(m.reshape(1,2))\\n if(len(matches)==0):\\n matches = np.empty((0,2),dtype=int)\\n else:\\n matches = np.concatenate(matches,axis=0)\\n\\n return matches, np.array(unmatched_detections), np.array(unmatched_trackers)\",\n \"def get_light_sbc(filenames, onoff=True):\\n if onoff:\\n param = \\\"on\\\"\\n else:\\n param = \\\"off\\\"\\n return filter_filenames(filenames, [param])\",\n \"def trackBunchTurns(self, bunch):\\n\\t\\tturns = self.__turns\\n\\t\\t#start\\n\\t\\tfor i in range(turns-1):\\t\\t\\t\\n\\t\\t\\tself.trackBunch(bunch)\\t\\n\\t\\t\\tsyncPart = bunch.getSyncParticle()\\n\\t\\t\\ttime = syncPart.time()\\n\\t\\t\\tself.setTimeDepStrength(time)\\n\\t\\t\\tprint \\\"debug trackBunchTurns time\\\",time,\\\"in\\\",i,\\\"turn\\\"\\n\\t\\t#getsublattice\\n\\t\\t#sublattice.trackBunch(bunch)\",\n \"def findIntersect(wires):\\n allSets = list(map(lambda w: coordsFor(w), wires))\\n baseSet = allSets[0]\\n for s in allSets[1:]:\\n baseSet.intersection_update(s)\\n central = (0, 0)\\n distances = list(map(lambda c: manhattan(central, c), baseSet))\\n return min(distances)\",\n \"def get_matching_blossom5(graph):\\n\\n edges = [] # Get all possible edges between the anyons and their weights\\n\\n def edge_func(edges, e0, e1, weight):\\n edges.append([e0, e1, weight])\\n\\n all_anyons, nxgraph = get_graph_edges(graph, edge_func, edges)\\n\\n output = pm.getMatching(len(all_anyons), edges) if all_anyons != [] else []\\n return [[all_anyons[i0], all_anyons[i1]] for i0, i1 in enumerate(output) if i0 > i1]\",\n \"def createBridgeSets(blocksize,operating,MPSS):\\n sets = tuple()\\n xul = blocksize[0]-operating\\n xdl = operating\\n yul = int(blocksize[0]/2+operating)\\n ydl = int(blocksize[0]/2-operating)\\n xts = xul\\n xbs = xdl\\n for i in range(MPSS):\\n sets+=(tuple(product(numpy.arange(xdl,xul,1),numpy.arange(ydl,yul,1))),)\\n xdl+=operating\\n xul-=operating\\n ydl-=operating\\n yul+=operating\\n return sets,sets[::-1]\",\n \"def calculate_rise_set_lsts(self, telescope_latitude, horizon_buffer=0.04364):\\n lat_rad = telescope_latitude.rad\\n buff = horizon_buffer\\n\\n lon, lat = self.get_lon_lat()\\n\\n tans = np.tan(lat_rad) * np.tan(lat.rad)\\n\\n with warnings.catch_warnings():\\n warnings.filterwarnings(\\n \\\"ignore\\\", message=\\\"invalid value encountered\\\", category=RuntimeWarning\\n )\\n rise_lst = lon.rad - np.arccos((-1) * tans) - buff\\n set_lst = lon.rad + np.arccos((-1) * tans) + buff\\n\\n rise_lst[rise_lst < 0] += 2 * np.pi\\n set_lst[set_lst < 0] += 2 * np.pi\\n rise_lst[rise_lst > 2 * np.pi] -= 2 * np.pi\\n set_lst[set_lst > 2 * np.pi] -= 2 * np.pi\\n\\n self._rise_lst = rise_lst\\n self._set_lst = set_lst\",\n \"def _find_trial_beam_breaks_regions_in_sync(sync_file):\\n bit = 'BEAM_BREAK'\\n return _find_bit_in_sync(sync_file, bit, ['down', 'up'])\",\n \"def occulting(groups, colour, period):\\n if groups == [1]:\\n return [\\n ('Off', 1000),\\n (colour, period - 1000)\\n ]\\n return light_sequence(groups, 'Off', colour, period, 500, 1000)\",\n \"def intersection(arrays):\\n # Create hash table (dict) to store numbers in for faster O(1) lookup (for \\n # any individual lookup):\\n # numbers = {}\\n\\n # Create list for intersection of the sets:\\n # intersection = []\\n\\n # Populate hash table with numbers from the first list (keys), because any numbers \\n # not in the first list will not be in the intersection of the lists, by definition.\\n numbers = {item:False for item in arrays[0]}\\n # Now check the other input lists in order, removing any number/item that is not in both:\\n for list in arrays[1:]:\\n for item in list: # NOT actually O(n**2); just O(n) for the whole input matrix.\\n # Mark as True to flag any items that are in the intersection of the two lists:\\n if item in numbers:\\n numbers[item] = True\\n # Keep only the numbers that are in the intersection of the two lists:\\n numbers = {key:value for key, value in numbers.items() if value == True}\\n # Mark all as False again to start a fresh comparison with the next list:\\n for item in numbers:\\n numbers[item] = False\\n\\n return [*numbers.keys()]\",\n \"def find_starts(config, data):\\n\\n trigger = butter_bandpass_filter(\\n data, config.bandpass_lower, config.bandpass_upper,\\n config.sampling_rate, 6)\\n trigger = np.absolute(trigger)\\n trigger = butter_lowpass_filter(\\n trigger, config.lowpass_freq, config.sampling_rate, 6)\\n\\n # transient = 0.0005\\n # start_idx = int(transient * config.sampling_rate)\\n start_idx = 0\\n average = np.average(trigger[start_idx:])\\n maximum = np.max(trigger[start_idx:])\\n minimum = np.min(trigger[start_idx:])\\n middle = (np.max(trigger[start_idx:]) - min(trigger[start_idx:])) / 2\\n if average < 1.1 * middle:\\n print()\\n print(\\\"Adjusting average to avg + (max - avg) / 2\\\")\\n average = average + (maximum - average) / 2\\n offset = -int(config.trigger_offset * config.sampling_rate)\\n\\n if config.trigger_rising:\\n trigger_fn = lambda x, y: x > y\\n else:\\n trigger_fn = lambda x, y: x < y\\n\\n # The cryptic numpy code below is equivalent to looping over the signal and\\n # recording the indices where the trigger crosses the average value in the\\n # direction specified by config.trigger_rising. It is faster than a Python\\n # loop by a factor of ~1000, so we trade readability for speed.\\n trigger_signal = trigger_fn(trigger, average)[start_idx:]\\n starts = np.where((trigger_signal[1:] != trigger_signal[:-1])\\n * trigger_signal[1:])[0] + start_idx + offset + 1\\n if trigger_signal[0]:\\n starts = np.insert(starts, 0, start_idx + offset)\\n\\n # plt.plot(data)\\n # plt.plot(trigger*100)\\n # plt.axhline(y=average*100)\\n # plt.show()\\n\\n return starts, trigger, average\",\n \"def denoise(self, offset_arr):\\n\\n measure_t, otts = zip(*offset_arr)\\n all_otts = []\\n all_times = []\\n otts_per_h = []\\n times_per_h = []\\n min_arr = []\\n hold_x = 0\\n hold_y = 0\\n ctr = 0\\n n = 1\\n begin = 0\\n end = 120 # N refering to the amount of seconds indicating the first interval\\n const = 120 # the coefficient indicating the break interval: every const seconds: must be set the same as end value\\n for timel in measure_t: # divide the points every 60 seconds (probe)\\n ctr += 1\\n if begin <= timel < end:\\n times_per_h.append(timel)\\n otts_per_h.append(otts[ctr - 1])\\n else:\\n hold_x = timel\\n hold_y = otts[ctr - 1]\\n all_times.append(times_per_h)\\n all_otts.append(otts_per_h)\\n times_per_h = []\\n otts_per_h = []\\n times_per_h.append(hold_x)\\n otts_per_h.append(hold_y) # for the next round\\n begin = end\\n n += 1\\n end = n * const\\n if ctr == len(measure_t) and otts_per_h: # belonging to the last hour/min only going through the if statement\\n all_times.append(times_per_h)\\n all_otts.append(otts_per_h)\\n\\n for i in range(len(all_otts)):\\n try:\\n idx = np.array(all_otts[i]).argmin()\\n except ValueError as e:\\n logging.error(\\\"{}/{}/{}: denoise: ValueError at argmin -- returning empty array! offset_arr: {}, error e {}\\\".format(self.domain, self.ip4, self.ip6, offset_arr, e))\\n return []\\n min_per_probe = all_otts[i][idx]\\n assoc_x_per_probe = all_times[i][idx]\\n min_arr.append((assoc_x_per_probe, min_per_probe))\\n\\n return min_arr\",\n \"def get_all_setups_nodes():\\n ta_roots = get_all_setups_roots()\\n ta_nodes = [TechAnim_Setup(x) for x in ta_roots]\\n return ta_nodes\",\n \"def find_tfl_lights(image: np.ndarray):\\n kernel = np.array(\\n [[0, 0, 0],\\n [0, 0, 0],\\n [0, 1, 0],\\n [1, 3, 1],\\n [0, 1, 0]])\\n\\n kernel = kernel - kernel.mean()\\n\\n red_image = image.copy()\\n red_image = red_image[:, :, 0]\\n _, red_image = cv2.threshold(red_image, 200, 255, cv2.THRESH_BINARY)\\n output = cv2.filter2D(red_image, -1, kernel)\\n output_copy = output.copy()\\n output = ndimage.maximum_filter(output, size=30)\\n output = output - output_copy\\n mask = ((output == 0) & (output_copy > 0))\\n red_points = np.where(mask)\\n positions = []\\n final_red_points = []\\n for point1 in range(len(red_points[0])):\\n point = (red_points[0][point1], red_points[1][point1])\\n pixel = image[point[0], point[1]]\\n if (pixel[1] < 170 or pixel[2] < 120) and pixel[0] >= 200:\\n final_red_points.append(point)\\n final_red_points = filter_points(final_red_points)\\n positions += final_red_points\\n auxilary = ['r'] * len(positions)\\n red_x = [val[1] for val in final_red_points]\\n red_y = [val[0] for val in final_red_points]\\n green_image = image.copy()\\n green_image = green_image[:, :, 1]\\n _, green_image = cv2.threshold(green_image, 190, 255, cv2.THRESH_BINARY)\\n output = cv2.filter2D(green_image, -1, kernel)\\n output_copy = output.copy()\\n output = ndimage.maximum_filter(output, size=30)\\n output = output - output_copy\\n mask = ((output == 0) & (output_copy > 0))\\n green_points = np.where(mask)\\n final_green_points = []\\n for point1 in range(len(green_points[0])):\\n point = (green_points[0][point1], green_points[1][point1])\\n pixel = image[point[0], point[1]]\\n if pixel[0] <= 180 and pixel[1] >= 220 and pixel[2] >= 160:\\n final_green_points.append(point)\\n\\n final_green_points = filter_points(final_green_points)\\n positions += final_green_points\\n auxilary += ['g'] * len(final_green_points)\\n green_x = [val[1] for val in final_green_points]\\n green_y = [val[0] for val in final_green_points]\\n print(f\\\"There are {len(green_x) + len(red_x)} points\\\")\\n return positions, auxilary\",\n \"def _random_subset(self, pa_nodes, seq, m, rng):\\n targets = set()\\n while len(targets) < m:\\n x = rng.choice(seq)\\n # if x in pa_nodes:\\n if pa_nodes.get(x, False):\\n targets.add(x)\\n else:\\n pass\\n return targets\",\n \"def performance_comparison_of_sets( predicted, known ):\\n ### Example:\\n ### predicted = Set( 2,3,4,5,10,11,12,13,14,15,20,21,22,23,24,25,26,27,28 )\\n ### known = Set( 1,2,3,4,5,10,11,12,13,14,15, 21,22,23,24,25,26 )\\n ### Return structure:\\n ### [\\n ### [ [2,3,4,5,10,11,12,13,14,15], [21,22,23,24,25,26] ], # TP correct predicted\\n ### [ [20], [27,28] ], # FP over predicted\\n ### [ [1] ], # FN under predicted\\n ### ]\\n\\n # make CORRECT, UNDER and OVER predicted list\\n correct = predicted.intersection( known )\\n overpredicted = predicted.difference( known )\\n underpredicted = known.difference( predicted )\\n\\n returnlists = []\\n for item in ( correct, overpredicted, underpredicted ):\\n if item:\\n item = list(item)\\n item.sort()\\n tracks = [ [ item[0] ] ]\\n for coord in item[1:]:\\n if coord == max(tracks[-1])+1:\\n tracks[-1].append(coord)\\n else:\\n tracks.append( [ coord ] )\\n returnlists.append( tracks )\\n else:\\n # no overlap of this kind!\\n returnlists.append( [] )\\n\\n # return the data structure\\n return returnlists\",\n \"def minmax():\\n minmaxlist = []\\n timelist = []\\n #create a list of the filenames of all sentinel-images\\n s2files = [f for f in listdir(s2path) if endswith(join(s2path, f),\\\".tif\\\")==True]\\n print(\\\"STEP 1/2\\\")\\n print(\\\"EXPORTING MIN AND MAX VALUES PER BAND\\\")\\n for i in s2files:\\n start = time.time()\\n nlfile = nlpath + \\\"/\\\" + i\\n s2file = s2path+\\\"/\\\"+i\\n #open the file\\n s2raster = gdal.Open(s2file) \\n #iterate over the bands of each image\\n for n in range(s2raster.RasterCount):\\n f = n + 1\\n s2band = s2raster.GetRasterBand(f)\\n #read the pixels of the band as an numpy-array\\n s2band = s2band.ReadAsArray()\\n #resize the bands to have all images in the same size\\n s2band = np.resize(s2band,(1050,1050))\\n #get the min and max values of each band to be able to 0-1 normalize after\\n min = s2band.min()\\n max = s2band.max()\\n #check if there are already values for the band\\n if len(minmaxlist) < s2raster.RasterCount + 1:\\n s2minmax = [min,max]\\n minmaxlist.append(s2minmax)\\n # if the min value of the open band is smaller than the saved minimal value, overwrite it\\n if min < minmaxlist[n][0]:\\n minmaxlist[n][0] = min\\n #if the max value of the open band is higher than the saves maximum value, overwrite it\\n if max > minmaxlist[n][1]:\\n minmaxlist[n][1] = max\\n #open the nightlight img\\n nlraster = gdal.Open(nlfile)\\n nlband = nlraster.GetRasterBand(1)\\n #read the only band of the image as a numpy-array\\n nlband = nlband.ReadAsArray()\\n #resize it the same way as the sentinel images\\n nlband = np.resize(nlband,(1050,1050))\\n #get the min and max values of the band\\n nlmin = nlband.min()\\n nlmax = nlband.max()\\n #check if there are already information about min and max values for the nightlight images\\n if len(minmaxlist) < s2raster.RasterCount + 1:\\n nlminmax = [nlmin,nlmax]\\n minmaxlist.append(nlminmax)\\n #if the min value of the open nightlight image is smaller than the saved minimal value, overwrite it\\n if nlmin < minmaxlist[16][0]:\\n minmaxlist[16][0] = nlmin\\n #if the max value of the open nightlight image is higher than the saves maximum value, overwrite it\\n if nlmax > minmaxlist[16][1]:\\n minmaxlist[16][1] = nlmax\\n end = time.time()\\n timelist.append(end-start)\\n print(\\\"Step 1/2\\\",str(s2files.index(i)+1) + \\\"/\\\" + str(len(s2files)),\\\"Est. time left:\\\",time.strftime('%H:%M:%S',time.gmtime(int(sum(timelist)/len(timelist)*(len(s2files)-s2files.index(i))))))\\n #throw out the Quality Bands (QA10,QA20,QA60)\\n minmaxlist = [i for j,i in enumerate(minmaxlist) if j not in [13,14,15]]\\n return minmaxlist\",\n \"def build_amg_index_sets(L_sizes):\\n neqns = L_sizes[0][0]\\n velocityDOF=[]\\n for start in range(1,3):\\n velocityDOF.append(np.arange(start=start,\\n stop=1+neqns,\\n step=3,\\n dtype='i'))\\n velocityDOF_full=np.vstack(velocityDOF).transpose().flatten()\\n velocity_u_DOF = []\\n velocity_u_DOF.append(np.arange(start=0,\\n stop=2*neqns//3,\\n step=2,\\n dtype='i'))\\n velocity_u_DOF_full = np.vstack(velocity_u_DOF).transpose().flatten()\\n velocity_v_DOF = []\\n velocity_v_DOF.append(np.arange(start=1,\\n stop=1+2*neqns//3,\\n step=2,\\n dtype='i'))\\n velocity_v_DOF_full = np.vstack(velocity_v_DOF).transpose().flatten()\\n isvelocity = PETSc.IS()\\n isvelocity.createGeneral(velocityDOF_full)\\n isu = PETSc.IS()\\n isu.createGeneral(velocity_u_DOF_full)\\n isv = PETSc.IS()\\n isv.createGeneral(velocity_v_DOF_full)\\n return [isvelocity, isu, isv]\",\n \"def getSets(unique_name=None):\",\n \"def eeg_peaks(array,tim,onset,plot='false'):\\n\\tp1_i,n1_i,p2_i = onset+56,onset+104,onset+176\\n\\twin_p1,win_n1,win_p2 = 15,20,40\\n\\t# determine P1,N1 and P2 values on the basis of the maximum in GFP in a window around the expected values\\n\\tidx_p1 = np.logical_and(tim>p1_i-win_p1, tim<p1_i+win_p1)\\n\\tidx_n1 = np.logical_and(tim>n1_i-win_n1, tim<n1_i+win_n1)\\n\\tidx_p2 = np.logical_and(tim>p2_i-win_p2, tim<p2_i+win_p2)\\n\\tp1 = np.max(array[idx_p1])\\n\\ttp1 = tim[idx_p1][array[idx_p1].argmax()]\\n\\tn1 = np.min(array[idx_n1])\\n\\ttn1 = tim[idx_n1][array[idx_n1].argmin()]\\n\\tp2 = np.max(array[idx_p2])\\n\\ttp2 = tim[idx_p2][array[idx_p2].argmax()]\\n\\n\\tlineax = dict(linewidth=1, color='black', linestyle='--')\\n\\tlinep1 = dict(linewidth=1, color='red', linestyle='--')\\n\\tlinen1 = dict(linewidth=1, color='green', linestyle='--')\\n\\tlinep2 = dict(linewidth=1, color='blue', linestyle='--')\\n\\n\\tif plot == 'true':\\t\\t\\n\\t\\tfig = plt.figure(19,figsize=[7,5])\\n\\t\\tax = fig.add_subplot(111, autoscale_on=False, xlim=[onset-100,tp2+200], ylim=[1.25*np.min([p1,n1,p2]),1.25*np.max([p1,n1,p2])])\\n\\t\\tplt.plot(tim,array,'k-',lw=3)\\n\\t\\tplt.plot(tp1,p1,'ro')\\n\\t\\tplt.plot(tn1,n1,'go')\\n\\t\\tplt.plot(tp2,p2,'bo')\\n\\t\\tax.axvline(p1_i-win_p1,**linep1)\\n\\t\\tax.axvline(p1_i+win_p1,**linep1)\\n\\t\\tax.axvline(n1_i-win_n1,**linen1)\\n\\t\\tax.axvline(n1_i+win_n1,**linen1)\\n\\t\\tax.axvline(p2_i-win_p2,**linep2)\\n\\t\\tax.axvline(p2_i+win_p2,**linep2)\\n\\t\\tax.axhline(**lineax)\\n\\t\\tplt.text(tp1-120,1.25*p1,'P1 = %.2f muV at %.0f ms' %(p1,tp1),fontsize=10)\\n\\t\\tplt.text(tn1-40,1.1*n1,'N1 = %.2f muV at %.0f ms' %(n1,tn1),fontsize=10)\\n\\t\\tplt.text(tn1+40,1.1*p2,'P2 = %.2f muV at %.0f ms' %(p2,tp2),fontsize=10)\\n\\t\\tplt.xlabel('time (ms)',fontsize = 13)\\n\\t\\tplt.ylabel('Amplitude',fontsize = 13)\\n\\treturn [p1,n1,p2,tp1,tn1,tp2]\",\n \"def covid(covidSet):\\n newcovidSet = set()\\n for x in covidSet:\\n player = playerList[x]\\n player.changeImage(1)\\n\\n #gotta check if anyone is close to this guy\\n for idx, y in enumerate(playerList):\\n if idx == x or idx in covidSet or idx in newcovidSet:\\n continue\\n if abs(player.rect.x - y.rect.x) > covidRange or abs(player.rect.y - y.rect.y) > covidRange:\\n continue #to reduce amount of astar checks required\\n else:\\n xx = changeCoord(player.rect.x)\\n xy = changeCoord(player.rect.y)\\n yx = changeCoord(y.rect.x)\\n yy = changeCoord(y.rect.y)\\n path = aStar.astar(maze, (xy, xx), (yy, yx))\\n if path != None and len(path) <= mazeRange:\\n if randChance(covidChance):\\n newcovidSet.add(idx)\\n print(\\\"Person\\\", x, \\\"infected\\\", \\\"Person\\\", idx)\\n edges[\\\"edges\\\"].append({\\\"from\\\": x, \\\"to\\\": idx})\\n else:\\n y.changeImage(2)\\n # uncomment to see astar algo (that was too far apart)\\n #else:\\n # if path == None:\\n # print(\\\"none\\\")\\n # else:\\n # print(len(path), path)\\n return set.union(covidSet, newcovidSet)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6857784","0.6249284","0.58837444","0.5452273","0.53577805","0.5303218","0.52744794","0.52505463","0.51989776","0.51802486","0.51636773","0.50905186","0.507182","0.5051442","0.5007559","0.50056607","0.49910834","0.4961425","0.4949146","0.493811","0.49135157","0.49105212","0.49056417","0.48830733","0.48685992","0.48603174","0.4848229","0.48321086","0.48042777","0.47821876","0.47757435","0.4767048","0.4765696","0.47633648","0.47509626","0.47479573","0.4718518","0.47159487","0.47055426","0.4698063","0.46974832","0.46953535","0.4694091","0.4691179","0.46858895","0.46830046","0.46810395","0.46765524","0.46642125","0.46454656","0.46438295","0.46283516","0.46255508","0.46239224","0.46237698","0.46159163","0.46082196","0.46046174","0.45912626","0.45858124","0.4584342","0.45794848","0.45726305","0.4567295","0.4562011","0.45587313","0.45538047","0.45506278","0.4545687","0.4543421","0.4540708","0.45392558","0.4529454","0.45134875","0.45065075","0.4505932","0.4501985","0.44990826","0.4495074","0.44833398","0.44735572","0.44697222","0.44684306","0.4465541","0.44651774","0.4449681","0.44485477","0.444564","0.44361293","0.44357154","0.4435594","0.44350225","0.44332066","0.44280732","0.44272992","0.44264206","0.44258034","0.4424545","0.44241107","0.44170743"],"string":"[\n \"0.6857784\",\n \"0.6249284\",\n \"0.58837444\",\n \"0.5452273\",\n \"0.53577805\",\n \"0.5303218\",\n \"0.52744794\",\n \"0.52505463\",\n \"0.51989776\",\n \"0.51802486\",\n \"0.51636773\",\n \"0.50905186\",\n \"0.507182\",\n \"0.5051442\",\n \"0.5007559\",\n \"0.50056607\",\n \"0.49910834\",\n \"0.4961425\",\n \"0.4949146\",\n \"0.493811\",\n \"0.49135157\",\n \"0.49105212\",\n \"0.49056417\",\n \"0.48830733\",\n \"0.48685992\",\n \"0.48603174\",\n \"0.4848229\",\n \"0.48321086\",\n \"0.48042777\",\n \"0.47821876\",\n \"0.47757435\",\n \"0.4767048\",\n \"0.4765696\",\n \"0.47633648\",\n \"0.47509626\",\n \"0.47479573\",\n \"0.4718518\",\n \"0.47159487\",\n \"0.47055426\",\n \"0.4698063\",\n \"0.46974832\",\n \"0.46953535\",\n \"0.4694091\",\n \"0.4691179\",\n \"0.46858895\",\n \"0.46830046\",\n \"0.46810395\",\n \"0.46765524\",\n \"0.46642125\",\n \"0.46454656\",\n \"0.46438295\",\n \"0.46283516\",\n \"0.46255508\",\n \"0.46239224\",\n \"0.46237698\",\n \"0.46159163\",\n \"0.46082196\",\n \"0.46046174\",\n \"0.45912626\",\n \"0.45858124\",\n \"0.4584342\",\n \"0.45794848\",\n \"0.45726305\",\n \"0.4567295\",\n \"0.4562011\",\n \"0.45587313\",\n \"0.45538047\",\n \"0.45506278\",\n \"0.4545687\",\n \"0.4543421\",\n \"0.4540708\",\n \"0.45392558\",\n \"0.4529454\",\n \"0.45134875\",\n \"0.45065075\",\n \"0.4505932\",\n \"0.4501985\",\n \"0.44990826\",\n \"0.4495074\",\n \"0.44833398\",\n \"0.44735572\",\n \"0.44697222\",\n \"0.44684306\",\n \"0.4465541\",\n \"0.44651774\",\n \"0.4449681\",\n \"0.44485477\",\n \"0.444564\",\n \"0.44361293\",\n \"0.44357154\",\n \"0.4435594\",\n \"0.44350225\",\n \"0.44332066\",\n \"0.44280732\",\n \"0.44272992\",\n \"0.44264206\",\n \"0.44258034\",\n \"0.4424545\",\n \"0.44241107\",\n \"0.44170743\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7570172"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":8798,"cells":{"query":{"kind":"string","value":"Estimate whether the animal was running during each trial. This function first smooths the running trace according to smoothsize (noncausal), it then uses the average of N presamples before the onset to to estimate whether running was higher than the threshold."},"document":{"kind":"string","value":"def estimate_running_each_trial(running_trace, trial_onset, smoothsize=10, presamples=4,\n threshold=3, showfig=False):\n smoothwin = np.ones(smoothsize)/(smoothsize)\n running_trace_smooth = np.convolve(running_trace, smoothwin, mode='same')\n trial_onset_ind = np.where(trial_onset)[0]\n presamples_inds = np.arange(-presamples, 0) + trial_onset_ind[:, np.newaxis]\n pretrial_avg = running_trace_smooth[presamples_inds].mean(axis=1)\n running_each_trial = pretrial_avg > threshold\n if showfig:\n plt.cla()\n plt.plot(running_trace_smooth, '0.8')\n plt.plot(trial_onset_ind, pretrial_avg, 'xg')\n plt.plot(trial_onset_ind, running_each_trial*running_trace_smooth.max(), 'og')\n plt.axhline(threshold, color='k')\n plt.legend(['running_trace_smooth', 'pretrial_avg', 'running_each_trial'],\n loc='upper right')\n plt.show()\n return running_each_trial, running_trace_smooth"},"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 punches(self):\n #:TODO Need to parameterize n\n # Initialize smoothing function\n # Also because I can't take the second derivitive\n\n n = 3\n assert (len(self.averages)==len(self.timestamps))\n size = len(self.averages)\n slopes = []\n for t in [0,size-n]:\n averages = np.asarray(self.averages[t:size])\n timestamps = np.asarray(self.timestamps[t:size])\n \"\"\"\n slope = np.absolute((np.corrcoef(averages,\n timestamps))*np.std(averages)/np.std(timestamps))\n \"\"\"\n slope = np.absolute(np.polyfit(timestamps, averages, 1)[0])*1000000\n #plt.scatter(timestamps, averages)\n slopes.append(slope)\n # If you were punching you are likely still punching need to set a weighting factor to this somehow\n # print(slopes[1])\n self.smoothing_queue.pop(0)\n if self.SIG_DELTA_AVERAGE < slopes[1]:\n self.smoothing_queue.append(1)\n else:\n self.smoothing_queue.append(0)\n if self.smoothing_queue.count(1) > len(self.smoothing_queue)/2:\n punching = True\n else: punching = False\n # print(self.smoothing_queue)\n\n return punching\n #self.counter +=1\n \"\"\"\n if self.counter==self.timing:\n self.counter == 0\n else:\n \"\"\"","def is_SNP(count):\n counts = sum(count)\n return counts and float(counts - max(count)) / counts > MAX_NOISE","def stationarity(self, nfactor=20):\n \n tau = self.sampler.get_autocorr_time(tol=0)\n converged = np.all(tau * nfactor < self.sampler.iteration)\n return converged","def stop_on_low_ais_ess(trial_id, result):\n return result[\"ais_effective_sample_size\"] < 0.1","def current_threshold_hit(self):\n\n\t\tnew_current = self.robot.pdp.getCurrent(const.CARGO_PDP_ID)\n\n\t\tself._current_samples.append(new_current)\n\n\t\tif len(self._current_samples) > 10:\n\t\t\tself._current_samples.pop(0)\n\n\t\t# Calculate new running average\n\t\tnew_avg = sum(self._current_samples) / len(self._current_samples)\n\n\t\treturn new_avg > const.CARGO_INTAKE_THRESHOLD","def is_artificial(self):\n\t\treturn 0","def epidemic_finish(states, iteration):\n return np.sum(states) == 0 and iteration > 10","def autorange(self, analyte=None, gwin=11, win=40, smwin=5,\n conf=0.01, on_mult=(1., 1.), off_mult=(1., 1.), d_mult=1.2):\n\n if analyte is None:\n analyte = self.internal_standard\n\n bins = 50 # determine automatically? As a function of bkg rms noise?\n\n v = self.focus[analyte] # get trace data\n vl = np.log10(v[v > 1]) # remove zeros from value\n x = np.linspace(vl.min(), vl.max(), bins) # define bin limits\n\n n, _ = np.histogram(vl, x) # make histogram of sample\n kde = gaussian_kde(vl)\n yd = kde.pdf(x) # calculate gaussian_kde of sample\n\n mins = self.findmins(x, yd) # find minima in kde\n\n vs = fastsmooth(v, gwin)\n bkg = vs < 10**(d_mult * mins[0]) # set background as lowest distribution\n if not bkg[0]:\n bkg[0] = True\n\n # assign rough background and signal regions based on kde minima\n self.bkg = bkg\n self.sig = ~bkg\n\n # remove transitions by fitting a gaussian to the gradients of\n # each transition\n # 1. calculate the absolute gradient of the target trace.\n g = abs(fastgrad(v, gwin))\n # 2. determine the approximate index of each transition\n zeros = bool_2_indices(bkg).flatten()\n if zeros[0] == 0:\n zeros = zeros[1:]\n if zeros[-1] == bkg.size:\n zeros = zeros[:-1]\n tran = [] # initialise empty list for transition pairs\n\n for z in zeros: # for each approximate transition\n # isolate the data around the transition\n if z - win > 0:\n xs = self.Time[z - win:z + win]\n ys = g[z - win:z + win]\n # determine type of transition (on/off)\n # checkes whether first - last value in window is\n # positive ('on') or negative ('off')\n tp = np.diff(v[z - win:z + win][[0, -1]]) > 0\n\n else:\n xs = self.Time[:z + win]\n ys = g[:z + win]\n # determine type of transition (on/off)\n tp = np.diff(v[:z + win][[0, -1]]) > 0\n # determine location of maximum gradient\n c = self.Time[z] # xs[ys == np.nanmax(ys)]\n try: # in case some of them don't work...\n # fit a gaussian to the first derivative of each\n # transition. Initial guess parameters are determined\n # by:\n # - A: maximum gradient in data\n # - mu: c\n # - sigma: half the exponential decay coefficient used\n # for despiking OR 1., if there is no exponent.\n try:\n width = 0.5 * abs(self.despike_params['exponent'])\n except:\n width = 1.\n # The 'sigma' parameter of curve_fit:\n # This weights the fit by distance from c - i.e. data closer\n # to c are more important in the fit than data further away\n # from c. This allows the function to fit the correct curve,\n # even if the data window has captured two independent\n # transitions (i.e. end of one ablation and start of next)\n # ablation are < win time steps apart).\n pg, _ = curve_fit(gauss, xs, ys,\n p0=(np.nanmax(ys),\n c,\n width),\n sigma=abs(xs - c) + .1)\n # get the x positions when the fitted gaussian is at 'conf' of\n # maximum\n # determine transition FWHM\n fwhm = 2 * pg[-1] * np.sqrt(2 * np.log(2))\n # apply on_mult or off_mult, as appropriate.\n if tp:\n lim = np.array([-fwhm, fwhm]) * np.array(on_mult) + pg[1]\n else:\n lim = np.array([-fwhm, fwhm]) * np.array(off_mult) + pg[1]\n\n tran.append(lim)\n except:\n warnings.warn((\"\\nSample {:s}: \".format(self.sample) +\n \"Transition identification at \" +\n \"{:.1f} failed.\".format(self.Time[z]) +\n \"\\nPlease check the data plots and make sure \" +\n \"everything is OK.\\n(Run \" +\n \"'trace_plots(ranges=True)'\"),\n UserWarning)\n pass # if it fails for any reason, warn and skip it!\n\n # remove the transition regions from the signal and background ids.\n for t in tran:\n self.bkg[(self.Time > t[0]) & (self.Time < t[1])] = False\n self.sig[(self.Time > t[0]) & (self.Time < t[1])] = False\n\n self.trn = ~self.bkg & ~self.sig\n\n self.mkrngs()\n\n # final check to catch missed transitions\n # calculate average transition width\n tr = self.Time[self.trn ^ np.roll(self.trn, 1)]\n tr = np.reshape(tr, [tr.size // 2, 2])\n self.trnrng = tr\n trw = np.mean(np.diff(tr, axis=1))\n\n corr = False\n for b in self.bkgrng.flat:\n if (self.sigrng - b < 0.3 * trw).any():\n self.bkg[(self.Time >= b - trw / 2) &\n (self.Time <= b + trw / 2)] = False\n self.sig[(self.Time >= b - trw / 2) &\n (self.Time <= b + trw / 2)] = False\n corr = True\n\n if corr:\n self.mkrngs()\n\n # number the signal regions (used for statistics and standard matching)\n n = 1\n for i in range(len(self.sig) - 1):\n if self.sig[i]:\n self.ns[i] = n\n if self.sig[i] and ~self.sig[i + 1]:\n n += 1\n self.n = int(max(self.ns)) # record number of traces\n\n return","def get_excess_smoothing_status(self) -> bool:\n return self._excess_smoothing_live.get()","def is_sampled(z):\n return True","def preprocessing(image, smooth_size, folder):\n from skimage.restoration import denoise_tv_chambolle\n \n dim = int(image.shape[0] / 50.)\n smoothed = rank.median(image, disk(smooth_size))\n #smoothed = denoise_tv_chambolle(image, weight=0.002)\n smoothed = rank.enhance_contrast(smoothed, disk(smooth_size))\n \n pl.subplot(2, 3, 1)\n pl.title(\"after median\")\n pl.imshow(smoothed)\n pl.gray()\n # If after smoothing the \"dot\" disappears\n # use the image value\n \n # TODO: wat do with thresh?\n try:\n im_max = smoothed.max()\n thresh = threshold_otsu(image)\n except:\n im_max = image.max()\n thresh = threshold_otsu(image)\n\n \n if im_max < thresh:\n labeled = np.zeros(smoothed.shape, dtype=np.int32)\n \n else:\n binary = smoothed > thresh\n \n # TODO: this array size is the fault of errors\n bin_open = binary_opening(binary, np.ones((dim, dim)), iterations=5)\n bin_close = binary_closing(bin_open, np.ones((5,5)), iterations=5)\n \n pl.subplot(2, 3, 2)\n pl.title(\"threshold\")\n pl.imshow(binary, interpolation='nearest')\n pl.subplot(2, 3, 3)\n pl.title(\"opening\")\n pl.imshow(bin_open, interpolation='nearest')\n pl.subplot(2, 3, 4)\n pl.title(\"closing\")\n pl.imshow(bin_close, interpolation='nearest')\n \n distance = ndimage.distance_transform_edt(bin_open)\n local_maxi = peak_local_max(distance,\n indices=False, labels=bin_open)\n \n markers = ndimage.label(local_maxi)[0]\n \n labeled = watershed(-distance, markers, mask=bin_open)\n pl.subplot(2, 3, 5)\n pl.title(\"label\")\n pl.imshow(labeled)\n #pl.show()\n pl.savefig(folder)\n pl.close('all')\n\n #misc.imsave(folder, labeled)\n# labels_rw = random_walker(bin_close, markers, mode='cg_mg')\n# \n# pl.imshow(labels_rw, interpolation='nearest')\n# pl.show()\n\n return labeled","def choose_to_stop_early(self):\n # return self.cumulated_num_tests > 10 # Limit to make 10 predictions\n # return np.random.rand() < self.early_stop_proba\n batch_size = 30 # See ingestion program: D_train.init(batch_size=30, repeat=True)\n num_examples = self.metadata_.size()\n num_epochs = self.cumulated_num_steps * batch_size / num_examples\n return num_epochs > self.num_epochs_we_want_to_train # Train for certain number of epochs then stop","def was_pig_caught(prize):\n if prize > 20:\n return True\n return False","def _compute_is_terminal(self):\n # by default the episode will terminate when all samples are labelled\n done = LalEnv._compute_is_terminal(self)\n # it also terminates when self.n_horizon datapoints were labelled\n if np.size(self.indeces_known) == self.n_horizon:\n done = True\n return done","def num_wet(self):\n return np.sum(self.array == 5)","def DetectPulseOnset(self, asig, fs, wMS):\n # the percentage of the maximal value of the slope sum function\n # to detect the onset\n AmplitudeRatio = .01\n\n # low pass filter\n sig = self.zpIIR(asig, 3, .1, 20, 5 * 2/fs)\n wSmp = int(np.round(wMS*fs/1000))\n\n BlankWindowRatio = .9\n\n # delta x\n diffsig = np.diff(sig)\n\n z = np.empty((sig.size - 1 - wSmp, 1))\n z[:] = np.NaN\n\n # calculate slope sum function\n for i in range(wSmp,sig.size-1):\n subsig = diffsig[i-wSmp:i]\n z[i-wSmp] = np.sum(subsig[subsig>0])\n\n z0 = np.mean(z)\n onset = [0]\n tPnt = []\n zThres = 0\n blankWin = int(np.round(400*fs/1000))\n subIdx = np.r_[onset[0]: onset[0] + 4*blankWin + 1]\n MedianArrayWinSize = 5\n\n # this value controls the final acceptance\n PrcofMaxAMP = .2\n SSFAmpArray = np.ones((MedianArrayWinSize,1))*(np.max(z) - np.min(z)) * PrcofMaxAMP\n # the percentage of maximal amplitude for threshold crossing\n DetectionThreshold = .2\n SSFCrossThresholdArray = np.ones((MedianArrayWinSize,1))*z0*DetectionThreshold\n idx = 1\n\n # Keep loop going while onsets detected\n while(1):\n\n # look for the first location where z > z0\n try:\n\n # Look in z[subIdx] (and make sure it doesn't go past z's size)\n # find first index where z > the mean of z\n tempIndex = np.trim_zeros(subIdx*(z.size>subIdx), 'b')\n ix = np.amin(np.where(z[tempIndex] > z0)[0])\n except:\n break\n\n ix = tempIndex[ix]\n tPnt.append(ix)\n srcWin = np.r_[np.maximum(0,ix - wSmp): ix + wSmp]\n #if the window has passed the length of the data, then exit\n if srcWin[-1] >= len(z):\n break\n\n # This section of code is to remove the initial zero-region in the SSF function before looking for onset (if such region exists)\n zPnt = np.where(z[srcWin] == 0)\n\n if zPnt[0].size != 0:\n zPnt = srcWin[zPnt[0]]\n\n if np.any(zPnt < ix):\n srcWin = np.r_[zPnt[np.max(np.where(zPnt < ix))]: ix + wSmp]\n\n # accept the window\n if ( np.max(z[srcWin]) - np.min(z[srcWin]) > zThres):\n\n # calculate the threshold for next cycle\n SSFAmp = (np.max(z[srcWin]) - np.min(z[srcWin])) * PrcofMaxAMP\n SSFAmpArray[np.remainder(idx, MedianArrayWinSize)] = SSFAmp\n zThres = np.median(SSFAmpArray)\n SSFCrossThresholdArray[np.remainder(idx, MedianArrayWinSize)] = np.mean(z[srcWin])*DetectionThreshold\n z0 = np.median(SSFCrossThresholdArray)\n minSSF = np.min(z[srcWin]) + SSFAmp *AmplitudeRatio\n a = srcWin[0] + np.min(np.where(z[srcWin] >= minSSF))\n onset.append(a)\n\n # adaptively determine analysis window for next cycle\n bw = blankWin\n subIdx = np.round(np.r_[a + bw: a + 3*bw])\n idx = idx + 1\n\n else:\n # no beat detected\n subIdx = np.round(subIdx + blankWin)\n\n return onset","def is_smelling(self,conc_array):\n if conc_array[int(self.x)][int(self.y)]>self.threshold:\n self.smell_timer = self.Timer(self.T,self.lamda)\n #Nav mode three and four need to know whether the moth is smelling\n #at a specific moment, for that reason they use Tfirst.\n self.Tfirst = self.T\n self.odor = True #this datum will be useful in the graphical functions\n return True\n elif self.turned_on:\n self.odor = False\n if self.smell_timer.is_running(self.T):\n return True #note - even though the there is no detection, the navigator stay in nav mode.\n else:\n self.odor = False\n return False","def _compute_is_terminal(self):\n new_score = self.episode_qualities[-1]\n # by default the episode will terminate when all samples are labelled\n done = LalEnv._compute_is_terminal(self)\n # it also terminates when a quality reaches a predefined level\n if new_score >= self.target_quality:\n done = True\n return done","def Continue():\n # adjust this to take as many steps as you need\n return warp.top.it <= 500","def is_over(self, state: StonehengeState) -> bool:\n total_result = state.hori_result + state.left_result + state.right_result\n total_line = len(total_result)\n p1_taken = 0\n p2_taken = 0\n # all_taken = True\n for item in total_result:\n if item == '1':\n p1_taken+=1\n elif item =='2':\n p2_taken += 1\n # else:\n # all_taken = False\n # print('p1 taken:' + str(p1_taken))\n # print('p2 taken:' + str(p2_taken))\n # print('p1_taken more than half?')\n # print(float(p1_taken) >= total_line/2)\n # print('p2_taken more than half?')\n # print(float(p2_taken) >= total_line/2)\n return float(p1_taken) >= total_line/2 or float(p2_taken) >= total_line/2","def win_condition(self):\n return self.wave == 8","def run_experiment() -> List[bool]:\n return [random.random() < 0.5 for _ in range(1000)]","def precondition(amp):\n n = len(amp)\n mean = np.mean(amp[:n/5])\n return -(amp-mean)","def test_next_window_time_sample_passed(self):\n test_window_scheme = WindowingScheme(self.window_test_filter, 3)\n # Value 15 will be filtered as it ranges between lower and upper bound limits\n filtered_value = test_window_scheme.filter(self.middle_value)\n self.assertEquals(filtered_value, self.middle_value)\n # Let next window time elapse\n time.sleep(4)\n filtered_value = test_window_scheme.filter(self.more_than_upper_bound)\n # None is expected as filtered value because at least one sample has been already passed and\n # value ranges outside lower and upper bound limits\n self.assertEquals(filtered_value, None)","def _step(self, a):\n obs, rew, done, info = super()._step(a)\n # rew = +1 if past int threshold for first time in episode\n # if self.robot.body_xyz[0] > self.threshold:\n # self.threshold += 1\n # rew = 1.0\n # else:\n # rew = 0.0\n # self.steps += 1\n # if self.steps > self.max_episode_steps:\n # done = True\n return obs, rew, done, info","def success_rate(x_tapes):\n return np.sum([is_success(x_tape) for x_tape in x_tapes]) / len(x_tapes)","def problem2():\n k = 4\n total_draws = 20\n total_balls = 50\n\n plt.figure()\n for _ in range(50):\n for num_samples in [10000]:\n experiment_results = []\n for samples in range(num_samples):\n N = np.random.randint(1, k, total_balls - 1)\n N = np.append(N, k)\n N = np.array(N).flatten()\n random.shuffle(N)\n draw = N[:total_draws]\n experiment_result = np.any(draw == 4)\n experiment_results.append(experiment_result)\n plt.plot(np.cumsum(experiment_results) / np.arange(1, num_samples + 1))\n old_result = experiment_results[:]\n\n plt.xlabel('Total Draws')\n plt.ylabel('Probability')\n plt.show()","def get_nsatpix( self, step ):\n \n return np.sum( self.get_image_step( step, divide_by_exptime=False ) >= 1.6e4 )","def get_sensor_bool_dryspot_runlevel(self, filename, threshold_min_counted_dryspots=5):\n f = h5py.File(filename, \"r\")\n meta_file = h5py.File(str(filename).replace(\"RESULT.erfh5\", \"meta_data.hdf5\"), 'r')\n\n try:\n single_states, set_of_states, useless_states = self.__get_dryspot_data(f, meta_file)\n multi_states = self.__get_pressure_data(f)\n multi_states = multi_states.squeeze()\n\n activated_sensors = np.count_nonzero(multi_states, axis=1)\n percentage_of_all_sensors = activated_sensors / 1140\n len_wanted_seq = 100\n current = 0\n sequence = np.zeros((len_wanted_seq, self.num_sensors))\n frame_labels = []\n\n if self.aux_info:\n original_frame_idxs = np.full(len_wanted_seq, np.nan, np.int16)\n frame_labels_aux = np.full(len_wanted_seq, np.nan, np.int8)\n sample_percentages = np.full(len_wanted_seq, np.nan)\n single_state_indices = np.full(len_wanted_seq, np.nan, np.int16)\n # flowfronts = np.zeros((len_wanted_seq, self.image_size[0], self.image_size[1]))\n # _coords, flat_fillings = self.__get_filling_data(f, single_states)\n\n for i, sample in enumerate(single_states):\n state_num = int(str(sample).replace(\"state\", \"0\"))\n try:\n sample_percentage = percentage_of_all_sensors[state_num - 1]\n if sample_percentage >= current / len_wanted_seq:\n data = multi_states[state_num - 1, :]\n data = np.log(np.add(data, 1)) # TODO make log optional\n if self.sensor_indizes != ((0, 1), (0, 1)):\n rect = data.reshape(38, 30)\n sel = rect[self.sensor_indizes[0][0]::self.sensor_indizes[0][1],\n self.sensor_indizes[1][0]::self.sensor_indizes[1][1]]\n data = sel.flatten()\n sequence[current, :] = data\n\n frame_label = 0\n if state_num in set_of_states:\n frame_label = 1\n frame_labels.append(frame_label)\n\n if self.aux_info:\n original_frame_idxs[current] = state_num\n frame_labels_aux[current] = frame_label\n sample_percentages[current] = sample_percentage\n single_state_indices[current] = i\n # flowfronts[current, :, :] = create_np_image(target_shape=self.image_size,\n # norm_coords=_coords, data=flat_fillings[i])\n current += 1\n except IndexError:\n continue\n\n # determine runlevel label using frame labels and threshold\n lens_of_runs_of_dryspots = [sum(1 for _ in group) for key, group in\n groupby(np.array(frame_labels) == 1) if key]\n max_len = 0 if len(lens_of_runs_of_dryspots) == 0 else max(lens_of_runs_of_dryspots)\n label = 0 if max_len < threshold_min_counted_dryspots else 1\n\n f.close()\n meta_file.close()\n\n if self.aux_info:\n # framelabels, original_frame_idx, original_num_frames, flowfronts, filling_percentage\n aux = {\"framelabel\": frame_labels_aux,\n \"original_frame_idx\": original_frame_idxs,\n \"original_num_multi_states\": len(multi_states),\n \"percent_of_sensors_filled\": sample_percentages,\n \"single_state_indices\": single_state_indices,\n }\n return [(sequence, label, aux)]\n\n return [(sequence, label)]\n except KeyError:\n f.close()\n meta_file.close()\n return None","def autorange(xvar, sig, gwin=7, swin=None, win=30,\n on_mult=(1.5, 1.), off_mult=(1., 1.5),\n nbin=10, transform='log', thresh=None):\n failed = []\n sig = np.asanyarray(sig)\n\n # smooth signal\n if swin is not None:\n sigs = fastsmooth(sig, swin)\n else:\n sigs = sig\n\n # transform signal\n if transform == 'log':\n tsigs = log_nozero(sigs)\n else:\n tsigs = sigs\n\n if thresh is None:\n if tsigs.ndim == 1:\n scale = False\n tsigs = tsigs.reshape(-1, 1)\n else:\n scale = True\n fsig = separate_signal(tsigs, scaleX=scale).astype(bool)\n else:\n if transform == 'log':\n thresh = np.log(thresh)\n fsig = tsigs > thresh\n fsig[0] = False # the first value must always be background\n fbkg = ~fsig\n\n # remove transitions by fitting a gaussian to the gradients of\n # each transition\n\n # 1. determine the approximate index of each transition\n zeros = bool_2_indices(fsig)\n \n if zeros is not None:\n zeros = zeros.flatten()\n if sigs.ndim > 1:\n sigs = sigs.sum(axis=1)\n\n # 2. calculate the absolute gradient of the target trace.\n grad = abs(fastgrad(sigs, gwin)) # gradient of untransformed data.\n\n for z in zeros: # for each approximate transition\n # isolate the data around the transition\n if z - win < 0:\n lo = gwin // 2\n hi = int(z + win)\n elif z + win > (len(sig) - gwin // 2):\n lo = int(z - win)\n hi = len(sig) - gwin // 2\n else:\n lo = int(z - win)\n hi = int(z + win)\n\n xs = xvar[lo:hi]\n ys = grad[lo:hi]\n\n # determine type of transition (on/off)\n mid = (hi + lo) // 2\n tp = sigs[mid + 3] > sigs[mid - 3] # True if 'on' transition.\n\n # fit a gaussian to the first derivative of each\n # transition. Initial guess parameters:\n # - A: maximum gradient in data\n # - mu: c\n # - width: 2 * time step\n # The 'sigma' parameter of curve_fit:\n # This weights the fit by distance from c - i.e. data closer\n # to c are more important in the fit than data further away\n # from c. This allows the function to fit the correct curve,\n # even if the data window has captured two independent\n # transitions (i.e. end of one ablation and start of next)\n # ablation are < win time steps apart).\n centre = xvar[z] # center of transition\n width = (xvar[1] - xvar[0]) * 2\n\n try:\n pg, _ = curve_fit(gauss, xs, ys,\n p0=(np.nanmax(ys),\n centre,\n width),\n sigma=(xs - centre)**2 + .01)\n # get the x positions when the fitted gaussian is at 'conf' of\n # maximum\n # determine transition FWHM\n fwhm = abs(2 * pg[-1] * np.sqrt(2 * np.log(2)))\n # apply on_mult or off_mult, as appropriate.\n if tp:\n lim = np.array([-fwhm, fwhm]) * on_mult + pg[1]\n else:\n lim = np.array([-fwhm, fwhm]) * off_mult + pg[1]\n\n fbkg[(xvar > lim[0]) & (xvar < lim[1])] = False\n fsig[(xvar > lim[0]) & (xvar < lim[1])] = False\n\n except RuntimeError:\n failed.append([centre, tp])\n pass\n\n ftrn = ~fbkg & ~fsig\n\n # if there are any failed transitions, exclude the mean transition width\n # either side of the failures\n if len(failed) > 0:\n trns = xvar[bool_2_indices(ftrn)]\n tr_mean = (trns[:, 1] - trns[:, 0]).mean() / 2\n for f, tp in failed:\n if tp:\n ind = (xvar >= f - tr_mean *\n on_mult[0]) & (xvar <= f + tr_mean * on_mult[0])\n else:\n ind = (xvar >= f - tr_mean *\n off_mult[0]) & (xvar <= f + tr_mean * off_mult[0])\n fsig[ind] = False\n fbkg[ind] = False\n ftrn[ind] = False\n\n return fbkg, fsig, ftrn, [f[0] for f in failed]","def close_to_exceeding(self) -> bool:\n mean = self.current / self.num_cuts\n if self.max_frames is not None:\n return self.current + mean > self.max_frames\n if self.max_samples is not None:\n return self.current + mean > self.max_samples\n if self.max_duration is not None:\n return self.current + mean > self.max_duration\n return False","def shaking_false_alarm_rate(individual, test_data, truth_data, name=None):\r\n test_data = np.array(test_data)\r\n truth_data = np.array(truth_data)\r\n total = 0\r\n num_wrong = 0\r\n for test_point, truth_point in zip(test_data, truth_data):\r\n # Nine represents a shaking event\r\n if truth_point != 9:\r\n if test_point > 8.5 and test_point <= 9.5:\r\n num_wrong += 1\r\n total += 1\r\n #if num_wrong == 0:\r\n # # Perfection implies overtraining\r\n # return 1.0\r\n #else:\r\n return float(num_wrong)/float(total)","def get_noise_thresholds(size_of_class=45, fakes='./data/CASIA1_fakes', originals='./data/CASIA1_originals', \n fakes_ela='./data/CASIA1_fakes_ela'):\n fakes_list = os.listdir(fakes)\n\n fakes = load_fakes(fakes_list, fakes, originals)\n\n noises = []\n for i, item in enumerate(fakes):\n image = cv2.imread(os.path.join(fakes_ela, item.path.split('\\\\')[-1]))\n image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)\n \n image = cv2.inRange(image, np.array([0,0,0]), np.array([180,255,60]))\n image = cv2.bitwise_not(image)\n noises.append(estimate_noise(image))\n\n fakes = np.array(fakes)\n noises = np.array(noises)\n idxs = noises.argsort()\n sorted_by_noise = fakes[idxs]\n\n for i, item in enumerate(sorted(noises)):\n if (i+1) % size_of_class == 0:\n print(\"####\", i+1, item)\n else:\n print(i+1, item)","def converged(self, nfactor=20):\n tau = self.sampler.get_autocorr_time(tol=0)\n converged = np.all(tau * nfactor < self.sampler.iteration)\n return converged","def _find_saturated_profiles(self) -> np.ndarray:\n n_gates, var_lim, _, _ = self.noise_params\n var = np.var(self.data['backscatter'][:, -n_gates:], axis=1)\n return var < var_lim","def check_background_SN(ramp_file='id1ketvxq_ramp.dat', show=False):\n from astropy.table import Table\n import matplotlib.pyplot as plt\n import numpy as np\n \n time, bg = np.loadtxt(ramp_file, unpack=True)\n t0 = np.diff(time)[0]\n time, bg = time[1:], bg[1:] # skip first 2.9 s read\n\n if len(bg) <= 2:\n return []\n \n dt = np.append(t0, np.diff(time))\n \n s = 1. # test count rate\n so = np.argsort(bg)\n \n NREAD = len(bg)\n reads = np.arange(NREAD)+1\n \n fluence = np.cumsum((s*dt)[so])\n rms = np.sqrt(np.cumsum((bg*dt)[so]))\n rms_optimal = np.sqrt(np.cumsum((bg[so][2]*dt)[so]))\n\n max_ix = np.argmax(fluence/rms)\n if max_ix < (NREAD-1):\n pop_reads = list(reads[so][max_ix+1:])\n else:\n pop_reads = []\n \n ### where observed rms < expected RMS for flat background\n other_bad = list(reads[so][rms/rms_optimal > 1.25])\n pop_reads = np.cast[int](np.unique(np.hstack((pop_reads, other_bad))))\n pop_reads = list(pop_reads)\n \n if len(pop_reads) > 0:\n # np.savetxt(ramp_file.replace('ramp.dat', 'ramp.pop.png'), pop_reads,\n # fmt='%d')\n fp = open('/tmp/'+ramp_file.replace('ramp.dat', 'ramp.pop.dat'),'w')\n for r in pop_reads:\n fp.write('%d\\n' %(r))\n fp.close()\n \n if show:\n plt.ioff()\n \n fig = plt.figure(figsize=[6,3])\n ax = fig.add_subplot(111)\n ax.plot(time, bg, color='0.8', linewidth=6, zorder=1)\n si = 60\n ax.scatter(time, bg, color='w', s=si, zorder=8)\n ax.scatter(time, bg, color='k', s=0.5*si, zorder=9)\n if len(pop_reads) > 0:\n ix = np.array(pop_reads)\n ax.scatter(time[ix-1], bg[ix-1], color='r', zorder=10, s=0.5*si)\n \n ax.grid()\n ax.set_title(ramp_file)\n ax.set_xlabel('time'), ax.set_ylabel('background')\n \n fig.tight_layout(pad=0.1)\n \n fig.savefig('/tmp/'+ramp_file.replace('.dat', '.pop.png'))\n plt.close()\n \n return pop_reads","def __call__(self, trainer):\n observation = trainer.observation\n summary = self._summary\n key = self._key\n if key in observation:\n summary.add({key: observation[key]})\n\n if not self._interval_trigger(trainer):\n return False\n\n if self._max_trigger(trainer):\n return True\n\n stats = summary.compute_mean()\n value = float(stats[key]) # copy to CPU\n self._init_summary()\n\n if not self._best_value or self._compare(self._best_value, value):\n self._best_value = value\n self._waited = 0\n return False\n elif self._waited >= self._patience:\n return True\n else:\n self._waited += 1\n if self._waited >= self._patience:\n return True\n else:\n return False","def _no_improve(self):\n improve = [p-f for (f,p),_ in self.population]\n return np.mean(improve) < 1.0","def run(self, date):\n\n out = self.nanoutput()\n\n for cs in config.stimuli():\n stimresp = self.analysis('stim_dff_alltrials_%s' % cs)\n dff_active = np.sum(stimresp > 0.025)/float(len(stimresp))\n out['good_%s' % cs] = dff_active > 0.05\n\n return out","def has_more_trials(self) -> bool:\r\n raise NotImplementedError","def eval_clicks(true_songs, predicted_songs, seeds):\n n_preds = len(predicted_songs)\n true_set = set(true_songs)\n for i, idx in enumerate(np.arange(0, n_preds, 10)):\n preds = predicted_songs[idx:idx+10]\n for p in preds:\n if p in true_set and p not in seeds:\n return i\n return float(\"inf\")","def setCaptured(self):\r\n total = 0\r\n for x in self.animals:\r\n if x.captured == True:\r\n total += 1\r\n self.captured = total","def run_experiment():\n return [random.random() < 0.5 for _ in range(1000)]","def run_experiment():\n return [random.random() < 0.5 for _ in range(1000)]","def run_experiment():\n return [random.random() < 0.5 for _ in range(1000)]","def run_experiment():\n return [random.random() < 0.5 for _ in range(1000)]","def check_if_stopping_criterion_is_met(original_training_data_values):\n if len(original_training_data_values)<23:\n return True\n else:\n target_column = original_training_data_values[:, -1]\n recipe_type, cupcake_muffin_count = np.unique(target_column, return_counts=True)\n cupcake_ratio = cupcake_muffin_count[0] / (cupcake_muffin_count.sum())\n muffin_ratio = cupcake_muffin_count[1] / (cupcake_muffin_count.sum())\n\n if cupcake_ratio >= 0.9 or muffin_ratio >= 0.9:\n return True\n else:\n return False","def _send_sampled_event(self):\n if not self.enabled:\n return False\n send_sample = False\n self.count += 1\n if self.actual_rate < self.statsd_sample_rate:\n self.monitored += 1\n send_sample = True\n self.actual_rate = float(self.monitored) / float(self.count)\n if self.count >= maxint or self.monitored >= maxint:\n self.count = 0\n self.monitored = 0\n return send_sample","def compute_sw_threshold(flanking_reads, paf_dict, fasta_dict, window_size):\n\n max_scores = []\n for query, target in itertools.product(flanking_reads, flanking_reads):\n\n if str(query + target) in paf_dict:\n overlap_info = paf_dict[query+target]\n elif str(target + query) in paf_dict:\n # get info and swap them\n overlap_info = paf_dict[target+query]\n query, target = target, query\n else:\n continue\n\n query_start = overlap_info['query_start']\n query_end = overlap_info['query_end']\n target_start = overlap_info['target_start']\n target_end = overlap_info['target_end']\n\n query_seq = fasta_dict[query][query_start:query_end]\n target_seq = fasta_dict[target][target_start:target_end]\n\n # Get scores for this pair; store in cur_scores\n cur_scores = []\n if window_size:\n # Use rolling window\n min_len = min(len(query_seq), len(target_seq))\n for start, end in utils.pairwise(range(0, min_len, window_size)):\n qs = query_seq[start:end]\n ts = target_seq[start:end]\n score = smith_waterman.smith_waterman(qs, ts)\n cur_scores.append(score)\n\n if cur_scores:\n score = max(cur_scores)\n max_scores.append(score)\n else:\n # No rolling window\n score = smith_waterman.smith_waterman(query_seq, target_seq)\n max_scores.append(score)\n\n threshold = 0.9 * max(max_scores)\n\n print(\"using {} as threshold\".format(threshold))\n\n plt.subplot(2, 3, 2)\n plt.hist(max_scores)\n plt.title(\"FLANKING READS\\nhistogram of num_gaps / len(aligned_sequence)\\nthreshold = {}\\nwindow_size = {}\\nshowing {} scores\"\n .format(threshold, window_size, len(max_scores)))\n\n\n\n return threshold","def is_sampling_for_minmax(self):\n return (self._level_change_time is not None) and \\\n (get_time() - self._level_change_time) < self._duration_in_sec","def compute_profiling_time(key, expected_num_spikes, rate, t_stop, n,\n winlen, binsize, num_rep=10):\n\n time_fast_fca = 0.\n time_fpgrowth = 0.\n for rep in range(num_rep):\n # Generating artificial data\n data = []\n for i in range(n):\n np.random.seed(0)\n data.append(stg.homogeneous_poisson_process(\n rate=rate, t_start=0*pq.s, t_stop=t_stop))\n\n # Extracting Closed Frequent Itemset with FP-Growth\n t0 = time.time()\n # Binning the data and clipping (binary matrix)\n binary_matrix = conv.BinnedSpikeTrain(data, binsize).to_bool_array()\n # Computing the context and the binary matrix encoding the relation\n # between objects (window positions) and attributes (spikes,\n # indexed with a number equal to neuron idx*winlen+bin idx)\n context, transactions, rel_matrix = spade._build_context(binary_matrix,\n winlen)\n # Applying FP-Growth\n fim_results = [i for i in spade._fpgrowth(\n transactions,\n rel_matrix=rel_matrix,\n winlen=winlen)]\n time_fpgrowth += time.time() - t0\n\n # Extracting Closed Frequent Itemset with Fast_fca\n t1 = time.time()\n # Binning the data and clipping (binary matrix)\n binary_matrix = conv.BinnedSpikeTrain(data, binsize).to_bool_array()\n # Computing the context and the binary matrix encoding the relation\n # between objects (window positions) and attributes (spikes,\n # indexed with a number equal to neuron idx*winlen+bin idx)\n context, transactions, rel_matrix = \\\n spade._build_context(binary_matrix, winlen)\n # Applying FP-Growth\n fim_results = spade._fast_fca(context, winlen=winlen)\n time_fast_fca += time.time() - t1\n\n time_profiles = {'fp_growth': time_fpgrowth/num_rep,\n 'fast_fca': time_fast_fca/num_rep}\n\n # Storing data\n res_path = '../results/{}/{}/'.format(key, expected_num_spikes)\n # Create path is not already existing\n path_temp = './'\n for folder in split_path(res_path):\n path_temp = path_temp + '/' + folder\n mkdirp(path_temp)\n\n np.save(res_path + '/profiling_results.npy', {'results': time_profiles,\n 'parameters': {'rate': rate, 't_stop': t_stop, 'n': n,\n 'winlen': winlen, 'binsize': binsize}})","def has_more_samples(self):\n return True","def has_more_samples(self):\n return True","def has_more_samples(self):\n return True","def is_exploring(self, step):\n return np.random.rand() < self._epsilon(step)","def reduction_size_one_autarkies(self):\n done = False\n while not done:\n current_N = self.A.shape[1]\n max_projection = self.A @ np.ones(current_N, dtype=int)\n inprods = self.A.transpose() @ max_projection\n A_y = self.A.transpose() @ self.y\n indices = []\n vals = []\n for i in range(current_N):\n if A_y[i] <= 0.5 * self.m:\n indices.append(i)\n vals.append(0)\n elif A_y[i] >= inprods[i] - 0.5 * self.m:\n indices.append(i)\n vals.append(1)\n no_reductions = len(indices)\n for i in range(no_reductions - 1, -1, -1): #reverse order\n self.problem_reduction_single(indices[i], vals[i])\n if no_reductions == 0:\n done = True","def can_sample(self, n_samples):\n return len(self) >= n_samples","def can_sample(self, n_samples):\n return len(self) >= n_samples","def can_sample(self, n_samples):\n return len(self) >= n_samples","def can_sample(self, n_samples):\n return len(self) >= n_samples","def noise_despiker(self, win=3, nlim=12.):\n if ~isinstance(win, int):\n win = int(win)\n if not hasattr(self, 'despiked'):\n self.data['despiked'] = {}\n for a, vo in self.focus.items():\n v = vo.copy()\n if 'time' not in a.lower():\n # calculate rolling mean using convolution\n kernel = np.ones(win) / win\n rmean = np.convolve(v, kernel, 'same')\n\n # with warnings.catch_warnings():\n # to catch 'empty slice' warnings\n # warnings.simplefilter(\"ignore\", category=RuntimeWarning)\n # rmean = \\\n # np.apply_along_axis(np.nanmean, 1,\n # rolling_window(v, win,\n # pad=np.nan))\n # rmean = \\\n # np.apply_along_axis(np.nanmean, 1,\n # rolling_window(v, win,\n # pad=np.nan))\n # calculate rolling standard deviation\n # (count statistics, so **0.5)\n rstd = rmean**0.5\n\n # find which values are over the threshold\n # (v > rmean + nlim * rstd)\n over = v > rmean + nlim * rstd\n if sum(over) > 0:\n # get adjacent values to over - limit values\n neighbours = \\\n np.hstack([v[np.roll(over, -1)][:, np.newaxis],\n v[np.roll(over, 1)][:, np.newaxis]])\n # calculate the mean of the neighbours\n replacements = np.apply_along_axis(np.nanmean, 1,\n neighbours)\n # and subsitite them in\n v[over] = replacements\n self.data['despiked'][a] = v\n self.setfocus('despiked')\n return","def _snr_preprocessing(self):\n if self.flux is None or self.fluxerr is None:\n return np.ones(len(self.stamps), dtype=bool)\n\n snrs = self.flux.astype(float) / self.fluxerr.astype(float)\n return snrs > self.snr_threshold","def weighted_estimation(self) -> bool:\n pass","def smooth_al(data):\n wd = 5\n optimize = True\n DW_min = 5\n while optimize == True:\n smooth = savgol_filter(data, wd, 2)\n DW = DW_cal(data, smooth)\n if abs(2 - DW) < DW_min:\n wd = wd + 2\n DW_min = abs(2 - DW)\n else:\n wd = wd - 2\n smooth = savgol_filter(data, wd, 2)\n DW = DW_cal(data, smooth)\n break\n return smooth, wd","def test_am_threshold(Simulator, plt, seed, rng):\n d = 64\n vocab = Vocabulary(d, pointer_gen=rng)\n vocab.populate('A; B; C; D')\n\n d2 = int(d / 2)\n vocab2 = Vocabulary(d2, pointer_gen=rng)\n vocab2.populate('A; B; C; D')\n\n def input_func(t):\n return '0.49 * A' if t < 0.1 else '0.8 * B'\n\n with spa.Network('model', seed=seed) as m:\n m.am = ThresholdingAssocMem(\n threshold=0.5, input_vocab=vocab, output_vocab=vocab2,\n function=filtered_step_fn, mapping='by-key')\n m.stimulus = spa.Transcode(input_func, output_vocab=vocab)\n m.stimulus >> m.am\n\n in_p = nengo.Probe(m.am.input)\n out_p = nengo.Probe(m.am.output, synapse=0.03)\n\n with Simulator(m) as sim:\n sim.run(0.3)\n t = sim.trange()\n below_th = t < 0.1\n above_th = t > 0.25\n\n plt.subplot(2, 1, 1)\n plt.plot(t, similarity(sim.data[in_p], vocab))\n plt.ylabel(\"Input\")\n plt.subplot(2, 1, 2)\n plt.plot(t, similarity(sim.data[out_p], vocab2))\n plt.plot(t[above_th], np.ones(t.shape)[above_th] * 0.9, c='g', lw=2)\n plt.ylabel(\"Output\")\n\n assert np.mean(sim.data[out_p][below_th]) < 0.01\n assert_sp_close(t, sim.data[out_p], vocab2['B'], skip=0.25, duration=0.05)","def goalReached(self, rewards):\n return len(rewards) >= 100 and np.mean(rewards[-100:]) >= 18","def over_sample(self) -> float:\n return self._over_sample","def over_sample(self) -> float:\n return self._over_sample","def is_over(self, state) -> bool:\n\n p1_count = 0\n p2_count = 0\n ley_line_total = (state.side_length + 1) * 3\n for itype in state.current_ley_lines:\n for line in itype:\n if line[0] == '1':\n p1_count += 1\n if line[0] == '2':\n p2_count += 1\n\n if p1_count >= ley_line_total/2 or p2_count >= ley_line_total/2:\n return True\n return False","def is_tentative(self):\n return self.state == TrackState.Tentative","def is_tentative(self):\n return self.state == TrackState.Tentative","def is_stationary(self) -> bool:\n ad_fuller_result = adfuller(self.y.dropna(), autolag='AIC')\n p_value = ad_fuller_result[1]\n return p_value <= 0.5","def scan_ap(self, cut_off = 3480, r_ap = 12, r_an = 3):\r\n for trial in range(self.dimension):\r\n max_count, max_rank = self.pick_largest(cut_off = cut_off)\r\n if max_count >= 0:\r\n y,x = self.rank_yx(max_rank)\r\n print(\"Scan pos\", y,x,\" scanning\",trial,\"counts\", max_count)\r\n count_in, count_out = self.fit_galaxy(y,x,r_ap, r_an)\r\n count_sum = []\r\n local_bg = []\r\n for c in range(len(count_in)):\r\n if count_in[c] >= cut_off:\r\n count_sum.append(count_in[c])\r\n for c in range(len(count_out)):\r\n if count_out[c] <= cut_off:\r\n local_bg.append(count_out[c])\r\n no_c = len(count_in)\r\n if len(count_sum) >= int(np.pi * (r_ap **2) / 2): # Make sure it is not noise\r\n count_sum = np.array(count_sum).sum()\r\n if len(local_bg) != 0:\r\n total = 0\r\n for c in range(len(local_bg)):\r\n if 3*13.8 <= abs(local_bg[c] - 3419):\r\n total += local_bg[c]\r\n local_bg = total / len(local_bg)\r\n else:\r\n local_bg = 3419\r\n print(\"galaxy founded at \", y, x)\r\n self.galaxies.append(galaxy(y, x, r_ap, count_sum, bg_galaxy=local_bg, no_count = no_c))\r\n \r\n elif max_count == -1:\r\n print(\"aperture scan completed, number of galaxies found is\", len(self.galaxies))\r\n break","def skip_test(n):\n return k > 0 and magic * n * k**0.5 >= t4_ref","def future_deceivedup(self, a): \n nfav, succfav = self.control[a.name]\n #f_n = n+1;\n # f_worldround = self.world.round+1\n f_successRate = float(a.success +1) / float(self.world.round+1)\n if hardrule:\n return (nfav+1 > 5) and ((self.world.round - nfav) > 5) and \\\n float(a.success+1-succfav)/(self.world.round+1 - nfav) > \\\n (float(succfav)/nfav) + epsilonD\n else:\n return nfav > 5 and (f_successRate > (float(succfav)/nfav) + epsilonD \\\n or f_successRate < epsilonD)","def _check_for_noise(self) -> None:\n safety_stop = 5\n while self._has_noise() and safety_stop > 0:\n self.filter(size=3)\n safety_stop -= 1","def runcount(test_keys, sigma, sigma_max, sigma_step,\n npoints_min, npoints_max, npoints_step):\n run = 1\n for key in test_keys:\n if key:\n while sigma < sigma_max:\n npoints = npoints_min\n while npoints < npoints_max:\n npoints += npoints_step\n run += 1\n sigma += sigma_step\n return run","def n_pos(self):\n running_total = 0\n for i in range(self.prob.num):\n if self.alphas[i] > 1e-5 > self.prob.C - self.deltas[i] and self.prob.Y[i] == 1:\n running_total += 1\n return running_total if running_total > 0 else 1","def n_pos(self):\n running_total = 0\n for i in range(self.prob.num):\n if self.alphas[i] > 1e-5 > self.prob.C - self.deltas[i] and self.prob.Y[i] == 1:\n running_total += 1\n return running_total if running_total > 0 else 1","def isPlayed(self):\n return bool(self.viewedLeafCount == self.leafCount)","def isPlayed(self):\n return bool(self.viewedLeafCount == self.leafCount)","def classify(self, testInstance):\n return self.fire(testInstance) > 0.5","def burn_in_finished():\n global trials\n if trials <= 0:\n return True\n trials -= 1\n return False","def early_stopping(cost, opt_cost, threshold, patience, count):\n booly = False\n if cost >= opt_cost - threshold:\n count += 1\n if count == patience:\n return True, count\n else:\n booly = False\n count = 0\n return booly, count","def _compute_is_terminal(self):\n # self.n_actions contains a number of unlabelled datapoints that is left\n if self.n_actions==1:\n # print('We ran out of samples!')\n done = True\n else:\n done = False\n return done","def greedy(self):\n n_step_t = self.filter['n_step_t']\n n_traj = self.filter['n_traj']\n traj = self.filter['traj']\n steps = [0 for i in xrange(n_step_t)]\n for i in xrange(n_traj):\n n_step = traj[i]['n_step']\n for j in xrange(n_step):\n steps[j] += 1\n self.filter['steps'] = steps\n \n return","def __call__(self, *args, **kwargs):\n out = super().__call__(*args, **kwargs)\n out **= 2\n self._debug.append(out)\n out = int(out > self.threshold_value)\n if out and self.since_last_peak > self._num_of_taps:\n self.since_last_peak = -1\n else:\n out = 0\n self.since_last_peak += 1\n return out","def trial_atr(trial, omit_missing_frames=True):\n frames = trial.HMM_MLE\n if omit_missing_frames:\n frames = frames[frames >= 0]\n\n runs = calc_run_lengths(trial.HMM_MLE)\n return_times = []\n current_return_time = 0\n for run in runs:\n if run.object == 0:\n return_times.append(current_return_time/60)\n current_return_time = 0\n else:\n current_return_time += run.length\n return np.mean(return_times)","def finished(self):\n hit_max_evals = len(self.rounds) >= self.max_evals\n\n if len(self.rounds) < self.conv_check_iters:\n hit_conv = False\n else:\n last_rounds = self.rounds[-self.conv_check_iters:]\n a = zip(*last_rounds)[1]\n a_sd = np.std(a, axis=0)\n hit_conv = (a_sd < self.conv_action_eps).all()\n\n hit_max_time = self.duration > self.max_time\n\n return hit_max_evals or hit_conv or hit_max_time","def pull(self):\n chance = np.random.uniform()\n return chance < self.winning_prob","def test_next_window_time_no_sample_passed(self):\n test_window_scheme = WindowingScheme(self.window_test_filter, 3)\n time.sleep(4)\n collected_value = test_window_scheme.filter(self.more_than_upper_bound)\n self.assertEquals(collected_value, self.more_than_upper_bound)","def run_adfuller_test(preprocessed_data, alpha=0.05, wanted_fraction=0.95):\n inds = list(np.ndindex(preprocessed_data.shape[:-1]))\n\n def return_adfuller_pval(this_ind): return adfuller(\n preprocessed_data[this_ind])[1]\n pval_list = np.array(parallelize(return_adfuller_pval, inds, n_jobs=30))\n alpha = 0.05\n threshold = alpha/len(pval_list)\n wanted_fraction = 0.95\n if np.sum(pval_list < threshold) > wanted_fraction * len(pval_list):\n print('Data is stationary')\n else:\n raise ValueError('Data is not stationary')","def should_average(self):\n return self._should_average","def check_stimOn_delays(data, **_):\n metric = np.nan_to_num(data[\"stimOn_times\"] - data[\"stimOnTrigger_times\"], nan=np.inf)\n passed = (metric <= 0.15) & (metric > 0)\n assert data[\"intervals\"].shape[0] == len(metric) == len(passed)\n return metric, passed","def is_recording(self) -> bool:\n return self.elastic_span.transaction.is_sampled and not self.elastic_span.ended_time","def single_iteration_condition(args):\n return np.logical_and(\n np.greater(args[-3], acceptance_ratio),\n np.less(args[-2], max_iteration))","def _episode_success(self, observations):\n dist = self._env.get_metrics()[\"object_to_goal_distance\"]\n if (\n abs(dist) > self._success_distance\n or observations[\"gripped_object_id\"] != -1\n ):\n return False\n return True","def process_trace(n_tr, tr, sta, orig_time, cmps, cfg):\n cmp = tr.stats.channel[2:3]\n sta[cmp] = {}\n sta[cmp][\"times\"] = tr.times(reftime=orig_time)\n\n sta[cmp][\"tr_results\"] = np.zeros(\n (len(cfg.picking.FILT_WINS[\"P\"]), sta[\"lenD\"])\n )\n sta[cmp][\"f1_results\"] = np.zeros(\n (len(cfg.picking.FILT_WINS[\"P\"]), len(cfg.picking.KURT_WINS),\n sta[\"lenD\"])\n )\n sta[cmp][\"f1_mean\"] = np.zeros(sta[\"lenD\"])\n sta[cmp][\"f3_results\"] = np.zeros(\n (len(cfg.picking.FILT_WINS[\"P\"]),\n len(cfg.picking.KURT_WINS), sta[\"lenD\"])\n )\n sta[cmp][\"f3_mean_smooth\"] = np.zeros(\n (len(cfg.picking.CF_MEAN_SMOOTH_WIND), sta[\"lenD\"])\n )\n sta[cmp][\"f4_all\"] = np.zeros((len(cfg.picking.CF_MEAN_SMOOTH_WIND),\n sta[\"lenD\"]))\n sta[cmp][\"f1_mean_smooth\"] = np.zeros(sta[\"lenD\"])\n # Get suitable filters (exclude those fully outside Nyquist freq.)\n for phase in [\"P\", \"S\"]:\n if cmp in cmps[phase]:\n sta[\"picks\"][\"poss_obs\"][phase][cmp] = {}\n sta[cmp][\"filtwins_check\"] = [\n filt_win for filt_win in cfg.picking.FILT_WINS[phase]\n if filt_win[0] < sta[\"samplerate\"] / 2\n ]\n if cfg.picking.INTEGRATE_S is True:\n tr.integrate()\n\n for n_filt, filt in enumerate(sta[cmp][\"filtwins_check\"]):\n # Ensure that filter covers sample rate / 2\n if (tr.stats.sampling_rate / 2) <= filt[0]:\n print(\"Skipping this Kurtosis run due to sample rate/2<f\")\n continue\n tr.filter(\"bandpass\", freqmin=filt[0], freqmax=filt[1])\n try:\n sta[cmp][\"tr_results\"][n_filt] = tr.data\n except ValueError: # If input array length is inconsistent\n continue\n # Loop over kurtosis windows\n for n_kurt, kurt_win_s in enumerate(cfg.picking.KURT_WINS):\n f1 = CF_kurtosis(kurt_win_s, tr)\n sta[cmp][\"f1_results\"][n_filt, n_kurt] = f1 # Needed for weights\n f2 = kurt_transform_f2(f1, kurt_win_s, tr)\n f3 = kurt_transform_f3(f2, kurt_win_s, tr)\n\n sta[cmp][\"f3_results\"][n_filt, n_kurt] = f3\n sta[cmp][\"f1_mean\"] = np.nanmean(sta[cmp][\"f1_results\"], axis=0)[0]\n sta[cmp][\"f1_mean_smooth\"] = do_smooth(\n sta[cmp][\"f1_mean\"], cfg.picking.CF_MEAN_SMOOTH_WIND[0],\n tr.stats.sampling_rate\n )\n # ^ Throws up a warning first time due to NaN slices\n # Compute mean CF and final kurtosis transform\n f3_mean = np.nanmean(sta[cmp][\"f3_results\"], axis=0)[0]\n\n for nsm, smooth_wind in enumerate(cfg.picking.CF_MEAN_SMOOTH_WIND):\n sta[cmp][\"f3_mean_smooth\"][nsm] = do_smooth(\n f3_mean, smooth_wind, tr.stats.sampling_rate\n )\n f4 = kurt_transform_f4(sta[cmp][\"f3_mean_smooth\"][nsm],\n np.max(cfg.picking.KURT_WINS), tr)\n sta[cmp][\"f4_all\"][nsm] = f4\n\n # Now pick (avoiding end and beginning of signal)\n # Pick the P-waves\n if cmp in cmps[\"P\"]:\n sta[\"picks\"][\"poss_obs\"][\"P\"][cmp][nsm] = []\n # Find points where Kurt<0 & doesn't look like S-wave\n p_cands = np.argwhere((f4 < 0.0))\n for idx in p_cands.tolist():\n kurt_wgt = np.min(np.where(np.array(\n cfg.picking.KURT2WGHT[\"P\"]\n <= sta[cmp][\"f1_mean_smooth\"][idx])))\n sta[\"picks\"][\"poss_obs\"][\"P\"][cmp][nsm].append([\n orig_time+sta[cmp][\"times\"][idx][0], f4[idx][0],\n tr.stats.channel, kurt_wgt, idx,\n sta[cmp][\"times\"][idx][0]\n ])\n # Pick the S-waves\n if cmp in cmps[\"S\"]:\n sta[\"picks\"][\"poss_obs\"][\"S\"][cmp][nsm] = []\n\n # Find points where Kurt<0 & doesn't look like S-wave\n s_cands = np.argwhere((f4 < 0.0))\n for idx in s_cands.tolist():\n kurt_wgt = np.min(np.where(np.array(cfg.picking.KURT2WGHT[\"S\"]\n <= sta[cmp][\"f1_mean_smooth\"][idx]))\n )\n sta[\"picks\"][\"poss_obs\"][\"S\"][cmp][nsm].append([\n orig_time+sta[cmp][\"times\"][idx][0], f4[idx][0],\n tr.stats.channel, kurt_wgt, idx,\n sta[cmp][\"times\"][idx][0]\n ])\n return(sta)","def _collect_induced_spikes(spikes, input_targeted_times, trial_length_ms, targeted_gid):\n inter_induction_wins = spt.make_windows(input_targeted_times, (0, trial_length_ms))\n inter_induction_wins = spt.ExclusiveWindows(inter_induction_wins)\n targeted_spikes = spikes[spikes.gid == targeted_gid]\n targeted_spikes = inter_induction_wins.classify_spikes(targeted_spikes)\n\n targeted_spikes = targeted_spikes[targeted_spikes['delay'] < 10.]\n induced_spk_idcs = targeted_spikes.groupby('win_idx')['delay'].idxmin().values\n\n is_induced = pd.Series(np.zeros(len(spikes), dtype=np.bool_), index=spikes.index)\n is_induced.loc[induced_spk_idcs] = True\n\n return is_induced","def _step(self, a):\n obs, rew, done, info = super()._step(a)\n # if self.robot.body_xyz[0] > self.threshold:\n # rew = 1.0\n # self.threshold += 1\n # else:\n # rew = 0.0\n # self.steps += 1\n # if self.steps > self.max_episode_steps:\n # done = True\n return obs, rew, done, info"],"string":"[\n \"def punches(self):\\n #:TODO Need to parameterize n\\n # Initialize smoothing function\\n # Also because I can't take the second derivitive\\n\\n n = 3\\n assert (len(self.averages)==len(self.timestamps))\\n size = len(self.averages)\\n slopes = []\\n for t in [0,size-n]:\\n averages = np.asarray(self.averages[t:size])\\n timestamps = np.asarray(self.timestamps[t:size])\\n \\\"\\\"\\\"\\n slope = np.absolute((np.corrcoef(averages,\\n timestamps))*np.std(averages)/np.std(timestamps))\\n \\\"\\\"\\\"\\n slope = np.absolute(np.polyfit(timestamps, averages, 1)[0])*1000000\\n #plt.scatter(timestamps, averages)\\n slopes.append(slope)\\n # If you were punching you are likely still punching need to set a weighting factor to this somehow\\n # print(slopes[1])\\n self.smoothing_queue.pop(0)\\n if self.SIG_DELTA_AVERAGE < slopes[1]:\\n self.smoothing_queue.append(1)\\n else:\\n self.smoothing_queue.append(0)\\n if self.smoothing_queue.count(1) > len(self.smoothing_queue)/2:\\n punching = True\\n else: punching = False\\n # print(self.smoothing_queue)\\n\\n return punching\\n #self.counter +=1\\n \\\"\\\"\\\"\\n if self.counter==self.timing:\\n self.counter == 0\\n else:\\n \\\"\\\"\\\"\",\n \"def is_SNP(count):\\n counts = sum(count)\\n return counts and float(counts - max(count)) / counts > MAX_NOISE\",\n \"def stationarity(self, nfactor=20):\\n \\n tau = self.sampler.get_autocorr_time(tol=0)\\n converged = np.all(tau * nfactor < self.sampler.iteration)\\n return converged\",\n \"def stop_on_low_ais_ess(trial_id, result):\\n return result[\\\"ais_effective_sample_size\\\"] < 0.1\",\n \"def current_threshold_hit(self):\\n\\n\\t\\tnew_current = self.robot.pdp.getCurrent(const.CARGO_PDP_ID)\\n\\n\\t\\tself._current_samples.append(new_current)\\n\\n\\t\\tif len(self._current_samples) > 10:\\n\\t\\t\\tself._current_samples.pop(0)\\n\\n\\t\\t# Calculate new running average\\n\\t\\tnew_avg = sum(self._current_samples) / len(self._current_samples)\\n\\n\\t\\treturn new_avg > const.CARGO_INTAKE_THRESHOLD\",\n \"def is_artificial(self):\\n\\t\\treturn 0\",\n \"def epidemic_finish(states, iteration):\\n return np.sum(states) == 0 and iteration > 10\",\n \"def autorange(self, analyte=None, gwin=11, win=40, smwin=5,\\n conf=0.01, on_mult=(1., 1.), off_mult=(1., 1.), d_mult=1.2):\\n\\n if analyte is None:\\n analyte = self.internal_standard\\n\\n bins = 50 # determine automatically? As a function of bkg rms noise?\\n\\n v = self.focus[analyte] # get trace data\\n vl = np.log10(v[v > 1]) # remove zeros from value\\n x = np.linspace(vl.min(), vl.max(), bins) # define bin limits\\n\\n n, _ = np.histogram(vl, x) # make histogram of sample\\n kde = gaussian_kde(vl)\\n yd = kde.pdf(x) # calculate gaussian_kde of sample\\n\\n mins = self.findmins(x, yd) # find minima in kde\\n\\n vs = fastsmooth(v, gwin)\\n bkg = vs < 10**(d_mult * mins[0]) # set background as lowest distribution\\n if not bkg[0]:\\n bkg[0] = True\\n\\n # assign rough background and signal regions based on kde minima\\n self.bkg = bkg\\n self.sig = ~bkg\\n\\n # remove transitions by fitting a gaussian to the gradients of\\n # each transition\\n # 1. calculate the absolute gradient of the target trace.\\n g = abs(fastgrad(v, gwin))\\n # 2. determine the approximate index of each transition\\n zeros = bool_2_indices(bkg).flatten()\\n if zeros[0] == 0:\\n zeros = zeros[1:]\\n if zeros[-1] == bkg.size:\\n zeros = zeros[:-1]\\n tran = [] # initialise empty list for transition pairs\\n\\n for z in zeros: # for each approximate transition\\n # isolate the data around the transition\\n if z - win > 0:\\n xs = self.Time[z - win:z + win]\\n ys = g[z - win:z + win]\\n # determine type of transition (on/off)\\n # checkes whether first - last value in window is\\n # positive ('on') or negative ('off')\\n tp = np.diff(v[z - win:z + win][[0, -1]]) > 0\\n\\n else:\\n xs = self.Time[:z + win]\\n ys = g[:z + win]\\n # determine type of transition (on/off)\\n tp = np.diff(v[:z + win][[0, -1]]) > 0\\n # determine location of maximum gradient\\n c = self.Time[z] # xs[ys == np.nanmax(ys)]\\n try: # in case some of them don't work...\\n # fit a gaussian to the first derivative of each\\n # transition. Initial guess parameters are determined\\n # by:\\n # - A: maximum gradient in data\\n # - mu: c\\n # - sigma: half the exponential decay coefficient used\\n # for despiking OR 1., if there is no exponent.\\n try:\\n width = 0.5 * abs(self.despike_params['exponent'])\\n except:\\n width = 1.\\n # The 'sigma' parameter of curve_fit:\\n # This weights the fit by distance from c - i.e. data closer\\n # to c are more important in the fit than data further away\\n # from c. This allows the function to fit the correct curve,\\n # even if the data window has captured two independent\\n # transitions (i.e. end of one ablation and start of next)\\n # ablation are < win time steps apart).\\n pg, _ = curve_fit(gauss, xs, ys,\\n p0=(np.nanmax(ys),\\n c,\\n width),\\n sigma=abs(xs - c) + .1)\\n # get the x positions when the fitted gaussian is at 'conf' of\\n # maximum\\n # determine transition FWHM\\n fwhm = 2 * pg[-1] * np.sqrt(2 * np.log(2))\\n # apply on_mult or off_mult, as appropriate.\\n if tp:\\n lim = np.array([-fwhm, fwhm]) * np.array(on_mult) + pg[1]\\n else:\\n lim = np.array([-fwhm, fwhm]) * np.array(off_mult) + pg[1]\\n\\n tran.append(lim)\\n except:\\n warnings.warn((\\\"\\\\nSample {:s}: \\\".format(self.sample) +\\n \\\"Transition identification at \\\" +\\n \\\"{:.1f} failed.\\\".format(self.Time[z]) +\\n \\\"\\\\nPlease check the data plots and make sure \\\" +\\n \\\"everything is OK.\\\\n(Run \\\" +\\n \\\"'trace_plots(ranges=True)'\\\"),\\n UserWarning)\\n pass # if it fails for any reason, warn and skip it!\\n\\n # remove the transition regions from the signal and background ids.\\n for t in tran:\\n self.bkg[(self.Time > t[0]) & (self.Time < t[1])] = False\\n self.sig[(self.Time > t[0]) & (self.Time < t[1])] = False\\n\\n self.trn = ~self.bkg & ~self.sig\\n\\n self.mkrngs()\\n\\n # final check to catch missed transitions\\n # calculate average transition width\\n tr = self.Time[self.trn ^ np.roll(self.trn, 1)]\\n tr = np.reshape(tr, [tr.size // 2, 2])\\n self.trnrng = tr\\n trw = np.mean(np.diff(tr, axis=1))\\n\\n corr = False\\n for b in self.bkgrng.flat:\\n if (self.sigrng - b < 0.3 * trw).any():\\n self.bkg[(self.Time >= b - trw / 2) &\\n (self.Time <= b + trw / 2)] = False\\n self.sig[(self.Time >= b - trw / 2) &\\n (self.Time <= b + trw / 2)] = False\\n corr = True\\n\\n if corr:\\n self.mkrngs()\\n\\n # number the signal regions (used for statistics and standard matching)\\n n = 1\\n for i in range(len(self.sig) - 1):\\n if self.sig[i]:\\n self.ns[i] = n\\n if self.sig[i] and ~self.sig[i + 1]:\\n n += 1\\n self.n = int(max(self.ns)) # record number of traces\\n\\n return\",\n \"def get_excess_smoothing_status(self) -> bool:\\n return self._excess_smoothing_live.get()\",\n \"def is_sampled(z):\\n return True\",\n \"def preprocessing(image, smooth_size, folder):\\n from skimage.restoration import denoise_tv_chambolle\\n \\n dim = int(image.shape[0] / 50.)\\n smoothed = rank.median(image, disk(smooth_size))\\n #smoothed = denoise_tv_chambolle(image, weight=0.002)\\n smoothed = rank.enhance_contrast(smoothed, disk(smooth_size))\\n \\n pl.subplot(2, 3, 1)\\n pl.title(\\\"after median\\\")\\n pl.imshow(smoothed)\\n pl.gray()\\n # If after smoothing the \\\"dot\\\" disappears\\n # use the image value\\n \\n # TODO: wat do with thresh?\\n try:\\n im_max = smoothed.max()\\n thresh = threshold_otsu(image)\\n except:\\n im_max = image.max()\\n thresh = threshold_otsu(image)\\n\\n \\n if im_max < thresh:\\n labeled = np.zeros(smoothed.shape, dtype=np.int32)\\n \\n else:\\n binary = smoothed > thresh\\n \\n # TODO: this array size is the fault of errors\\n bin_open = binary_opening(binary, np.ones((dim, dim)), iterations=5)\\n bin_close = binary_closing(bin_open, np.ones((5,5)), iterations=5)\\n \\n pl.subplot(2, 3, 2)\\n pl.title(\\\"threshold\\\")\\n pl.imshow(binary, interpolation='nearest')\\n pl.subplot(2, 3, 3)\\n pl.title(\\\"opening\\\")\\n pl.imshow(bin_open, interpolation='nearest')\\n pl.subplot(2, 3, 4)\\n pl.title(\\\"closing\\\")\\n pl.imshow(bin_close, interpolation='nearest')\\n \\n distance = ndimage.distance_transform_edt(bin_open)\\n local_maxi = peak_local_max(distance,\\n indices=False, labels=bin_open)\\n \\n markers = ndimage.label(local_maxi)[0]\\n \\n labeled = watershed(-distance, markers, mask=bin_open)\\n pl.subplot(2, 3, 5)\\n pl.title(\\\"label\\\")\\n pl.imshow(labeled)\\n #pl.show()\\n pl.savefig(folder)\\n pl.close('all')\\n\\n #misc.imsave(folder, labeled)\\n# labels_rw = random_walker(bin_close, markers, mode='cg_mg')\\n# \\n# pl.imshow(labels_rw, interpolation='nearest')\\n# pl.show()\\n\\n return labeled\",\n \"def choose_to_stop_early(self):\\n # return self.cumulated_num_tests > 10 # Limit to make 10 predictions\\n # return np.random.rand() < self.early_stop_proba\\n batch_size = 30 # See ingestion program: D_train.init(batch_size=30, repeat=True)\\n num_examples = self.metadata_.size()\\n num_epochs = self.cumulated_num_steps * batch_size / num_examples\\n return num_epochs > self.num_epochs_we_want_to_train # Train for certain number of epochs then stop\",\n \"def was_pig_caught(prize):\\n if prize > 20:\\n return True\\n return False\",\n \"def _compute_is_terminal(self):\\n # by default the episode will terminate when all samples are labelled\\n done = LalEnv._compute_is_terminal(self)\\n # it also terminates when self.n_horizon datapoints were labelled\\n if np.size(self.indeces_known) == self.n_horizon:\\n done = True\\n return done\",\n \"def num_wet(self):\\n return np.sum(self.array == 5)\",\n \"def DetectPulseOnset(self, asig, fs, wMS):\\n # the percentage of the maximal value of the slope sum function\\n # to detect the onset\\n AmplitudeRatio = .01\\n\\n # low pass filter\\n sig = self.zpIIR(asig, 3, .1, 20, 5 * 2/fs)\\n wSmp = int(np.round(wMS*fs/1000))\\n\\n BlankWindowRatio = .9\\n\\n # delta x\\n diffsig = np.diff(sig)\\n\\n z = np.empty((sig.size - 1 - wSmp, 1))\\n z[:] = np.NaN\\n\\n # calculate slope sum function\\n for i in range(wSmp,sig.size-1):\\n subsig = diffsig[i-wSmp:i]\\n z[i-wSmp] = np.sum(subsig[subsig>0])\\n\\n z0 = np.mean(z)\\n onset = [0]\\n tPnt = []\\n zThres = 0\\n blankWin = int(np.round(400*fs/1000))\\n subIdx = np.r_[onset[0]: onset[0] + 4*blankWin + 1]\\n MedianArrayWinSize = 5\\n\\n # this value controls the final acceptance\\n PrcofMaxAMP = .2\\n SSFAmpArray = np.ones((MedianArrayWinSize,1))*(np.max(z) - np.min(z)) * PrcofMaxAMP\\n # the percentage of maximal amplitude for threshold crossing\\n DetectionThreshold = .2\\n SSFCrossThresholdArray = np.ones((MedianArrayWinSize,1))*z0*DetectionThreshold\\n idx = 1\\n\\n # Keep loop going while onsets detected\\n while(1):\\n\\n # look for the first location where z > z0\\n try:\\n\\n # Look in z[subIdx] (and make sure it doesn't go past z's size)\\n # find first index where z > the mean of z\\n tempIndex = np.trim_zeros(subIdx*(z.size>subIdx), 'b')\\n ix = np.amin(np.where(z[tempIndex] > z0)[0])\\n except:\\n break\\n\\n ix = tempIndex[ix]\\n tPnt.append(ix)\\n srcWin = np.r_[np.maximum(0,ix - wSmp): ix + wSmp]\\n #if the window has passed the length of the data, then exit\\n if srcWin[-1] >= len(z):\\n break\\n\\n # This section of code is to remove the initial zero-region in the SSF function before looking for onset (if such region exists)\\n zPnt = np.where(z[srcWin] == 0)\\n\\n if zPnt[0].size != 0:\\n zPnt = srcWin[zPnt[0]]\\n\\n if np.any(zPnt < ix):\\n srcWin = np.r_[zPnt[np.max(np.where(zPnt < ix))]: ix + wSmp]\\n\\n # accept the window\\n if ( np.max(z[srcWin]) - np.min(z[srcWin]) > zThres):\\n\\n # calculate the threshold for next cycle\\n SSFAmp = (np.max(z[srcWin]) - np.min(z[srcWin])) * PrcofMaxAMP\\n SSFAmpArray[np.remainder(idx, MedianArrayWinSize)] = SSFAmp\\n zThres = np.median(SSFAmpArray)\\n SSFCrossThresholdArray[np.remainder(idx, MedianArrayWinSize)] = np.mean(z[srcWin])*DetectionThreshold\\n z0 = np.median(SSFCrossThresholdArray)\\n minSSF = np.min(z[srcWin]) + SSFAmp *AmplitudeRatio\\n a = srcWin[0] + np.min(np.where(z[srcWin] >= minSSF))\\n onset.append(a)\\n\\n # adaptively determine analysis window for next cycle\\n bw = blankWin\\n subIdx = np.round(np.r_[a + bw: a + 3*bw])\\n idx = idx + 1\\n\\n else:\\n # no beat detected\\n subIdx = np.round(subIdx + blankWin)\\n\\n return onset\",\n \"def is_smelling(self,conc_array):\\n if conc_array[int(self.x)][int(self.y)]>self.threshold:\\n self.smell_timer = self.Timer(self.T,self.lamda)\\n #Nav mode three and four need to know whether the moth is smelling\\n #at a specific moment, for that reason they use Tfirst.\\n self.Tfirst = self.T\\n self.odor = True #this datum will be useful in the graphical functions\\n return True\\n elif self.turned_on:\\n self.odor = False\\n if self.smell_timer.is_running(self.T):\\n return True #note - even though the there is no detection, the navigator stay in nav mode.\\n else:\\n self.odor = False\\n return False\",\n \"def _compute_is_terminal(self):\\n new_score = self.episode_qualities[-1]\\n # by default the episode will terminate when all samples are labelled\\n done = LalEnv._compute_is_terminal(self)\\n # it also terminates when a quality reaches a predefined level\\n if new_score >= self.target_quality:\\n done = True\\n return done\",\n \"def Continue():\\n # adjust this to take as many steps as you need\\n return warp.top.it <= 500\",\n \"def is_over(self, state: StonehengeState) -> bool:\\n total_result = state.hori_result + state.left_result + state.right_result\\n total_line = len(total_result)\\n p1_taken = 0\\n p2_taken = 0\\n # all_taken = True\\n for item in total_result:\\n if item == '1':\\n p1_taken+=1\\n elif item =='2':\\n p2_taken += 1\\n # else:\\n # all_taken = False\\n # print('p1 taken:' + str(p1_taken))\\n # print('p2 taken:' + str(p2_taken))\\n # print('p1_taken more than half?')\\n # print(float(p1_taken) >= total_line/2)\\n # print('p2_taken more than half?')\\n # print(float(p2_taken) >= total_line/2)\\n return float(p1_taken) >= total_line/2 or float(p2_taken) >= total_line/2\",\n \"def win_condition(self):\\n return self.wave == 8\",\n \"def run_experiment() -> List[bool]:\\n return [random.random() < 0.5 for _ in range(1000)]\",\n \"def precondition(amp):\\n n = len(amp)\\n mean = np.mean(amp[:n/5])\\n return -(amp-mean)\",\n \"def test_next_window_time_sample_passed(self):\\n test_window_scheme = WindowingScheme(self.window_test_filter, 3)\\n # Value 15 will be filtered as it ranges between lower and upper bound limits\\n filtered_value = test_window_scheme.filter(self.middle_value)\\n self.assertEquals(filtered_value, self.middle_value)\\n # Let next window time elapse\\n time.sleep(4)\\n filtered_value = test_window_scheme.filter(self.more_than_upper_bound)\\n # None is expected as filtered value because at least one sample has been already passed and\\n # value ranges outside lower and upper bound limits\\n self.assertEquals(filtered_value, None)\",\n \"def _step(self, a):\\n obs, rew, done, info = super()._step(a)\\n # rew = +1 if past int threshold for first time in episode\\n # if self.robot.body_xyz[0] > self.threshold:\\n # self.threshold += 1\\n # rew = 1.0\\n # else:\\n # rew = 0.0\\n # self.steps += 1\\n # if self.steps > self.max_episode_steps:\\n # done = True\\n return obs, rew, done, info\",\n \"def success_rate(x_tapes):\\n return np.sum([is_success(x_tape) for x_tape in x_tapes]) / len(x_tapes)\",\n \"def problem2():\\n k = 4\\n total_draws = 20\\n total_balls = 50\\n\\n plt.figure()\\n for _ in range(50):\\n for num_samples in [10000]:\\n experiment_results = []\\n for samples in range(num_samples):\\n N = np.random.randint(1, k, total_balls - 1)\\n N = np.append(N, k)\\n N = np.array(N).flatten()\\n random.shuffle(N)\\n draw = N[:total_draws]\\n experiment_result = np.any(draw == 4)\\n experiment_results.append(experiment_result)\\n plt.plot(np.cumsum(experiment_results) / np.arange(1, num_samples + 1))\\n old_result = experiment_results[:]\\n\\n plt.xlabel('Total Draws')\\n plt.ylabel('Probability')\\n plt.show()\",\n \"def get_nsatpix( self, step ):\\n \\n return np.sum( self.get_image_step( step, divide_by_exptime=False ) >= 1.6e4 )\",\n \"def get_sensor_bool_dryspot_runlevel(self, filename, threshold_min_counted_dryspots=5):\\n f = h5py.File(filename, \\\"r\\\")\\n meta_file = h5py.File(str(filename).replace(\\\"RESULT.erfh5\\\", \\\"meta_data.hdf5\\\"), 'r')\\n\\n try:\\n single_states, set_of_states, useless_states = self.__get_dryspot_data(f, meta_file)\\n multi_states = self.__get_pressure_data(f)\\n multi_states = multi_states.squeeze()\\n\\n activated_sensors = np.count_nonzero(multi_states, axis=1)\\n percentage_of_all_sensors = activated_sensors / 1140\\n len_wanted_seq = 100\\n current = 0\\n sequence = np.zeros((len_wanted_seq, self.num_sensors))\\n frame_labels = []\\n\\n if self.aux_info:\\n original_frame_idxs = np.full(len_wanted_seq, np.nan, np.int16)\\n frame_labels_aux = np.full(len_wanted_seq, np.nan, np.int8)\\n sample_percentages = np.full(len_wanted_seq, np.nan)\\n single_state_indices = np.full(len_wanted_seq, np.nan, np.int16)\\n # flowfronts = np.zeros((len_wanted_seq, self.image_size[0], self.image_size[1]))\\n # _coords, flat_fillings = self.__get_filling_data(f, single_states)\\n\\n for i, sample in enumerate(single_states):\\n state_num = int(str(sample).replace(\\\"state\\\", \\\"0\\\"))\\n try:\\n sample_percentage = percentage_of_all_sensors[state_num - 1]\\n if sample_percentage >= current / len_wanted_seq:\\n data = multi_states[state_num - 1, :]\\n data = np.log(np.add(data, 1)) # TODO make log optional\\n if self.sensor_indizes != ((0, 1), (0, 1)):\\n rect = data.reshape(38, 30)\\n sel = rect[self.sensor_indizes[0][0]::self.sensor_indizes[0][1],\\n self.sensor_indizes[1][0]::self.sensor_indizes[1][1]]\\n data = sel.flatten()\\n sequence[current, :] = data\\n\\n frame_label = 0\\n if state_num in set_of_states:\\n frame_label = 1\\n frame_labels.append(frame_label)\\n\\n if self.aux_info:\\n original_frame_idxs[current] = state_num\\n frame_labels_aux[current] = frame_label\\n sample_percentages[current] = sample_percentage\\n single_state_indices[current] = i\\n # flowfronts[current, :, :] = create_np_image(target_shape=self.image_size,\\n # norm_coords=_coords, data=flat_fillings[i])\\n current += 1\\n except IndexError:\\n continue\\n\\n # determine runlevel label using frame labels and threshold\\n lens_of_runs_of_dryspots = [sum(1 for _ in group) for key, group in\\n groupby(np.array(frame_labels) == 1) if key]\\n max_len = 0 if len(lens_of_runs_of_dryspots) == 0 else max(lens_of_runs_of_dryspots)\\n label = 0 if max_len < threshold_min_counted_dryspots else 1\\n\\n f.close()\\n meta_file.close()\\n\\n if self.aux_info:\\n # framelabels, original_frame_idx, original_num_frames, flowfronts, filling_percentage\\n aux = {\\\"framelabel\\\": frame_labels_aux,\\n \\\"original_frame_idx\\\": original_frame_idxs,\\n \\\"original_num_multi_states\\\": len(multi_states),\\n \\\"percent_of_sensors_filled\\\": sample_percentages,\\n \\\"single_state_indices\\\": single_state_indices,\\n }\\n return [(sequence, label, aux)]\\n\\n return [(sequence, label)]\\n except KeyError:\\n f.close()\\n meta_file.close()\\n return None\",\n \"def autorange(xvar, sig, gwin=7, swin=None, win=30,\\n on_mult=(1.5, 1.), off_mult=(1., 1.5),\\n nbin=10, transform='log', thresh=None):\\n failed = []\\n sig = np.asanyarray(sig)\\n\\n # smooth signal\\n if swin is not None:\\n sigs = fastsmooth(sig, swin)\\n else:\\n sigs = sig\\n\\n # transform signal\\n if transform == 'log':\\n tsigs = log_nozero(sigs)\\n else:\\n tsigs = sigs\\n\\n if thresh is None:\\n if tsigs.ndim == 1:\\n scale = False\\n tsigs = tsigs.reshape(-1, 1)\\n else:\\n scale = True\\n fsig = separate_signal(tsigs, scaleX=scale).astype(bool)\\n else:\\n if transform == 'log':\\n thresh = np.log(thresh)\\n fsig = tsigs > thresh\\n fsig[0] = False # the first value must always be background\\n fbkg = ~fsig\\n\\n # remove transitions by fitting a gaussian to the gradients of\\n # each transition\\n\\n # 1. determine the approximate index of each transition\\n zeros = bool_2_indices(fsig)\\n \\n if zeros is not None:\\n zeros = zeros.flatten()\\n if sigs.ndim > 1:\\n sigs = sigs.sum(axis=1)\\n\\n # 2. calculate the absolute gradient of the target trace.\\n grad = abs(fastgrad(sigs, gwin)) # gradient of untransformed data.\\n\\n for z in zeros: # for each approximate transition\\n # isolate the data around the transition\\n if z - win < 0:\\n lo = gwin // 2\\n hi = int(z + win)\\n elif z + win > (len(sig) - gwin // 2):\\n lo = int(z - win)\\n hi = len(sig) - gwin // 2\\n else:\\n lo = int(z - win)\\n hi = int(z + win)\\n\\n xs = xvar[lo:hi]\\n ys = grad[lo:hi]\\n\\n # determine type of transition (on/off)\\n mid = (hi + lo) // 2\\n tp = sigs[mid + 3] > sigs[mid - 3] # True if 'on' transition.\\n\\n # fit a gaussian to the first derivative of each\\n # transition. Initial guess parameters:\\n # - A: maximum gradient in data\\n # - mu: c\\n # - width: 2 * time step\\n # The 'sigma' parameter of curve_fit:\\n # This weights the fit by distance from c - i.e. data closer\\n # to c are more important in the fit than data further away\\n # from c. This allows the function to fit the correct curve,\\n # even if the data window has captured two independent\\n # transitions (i.e. end of one ablation and start of next)\\n # ablation are < win time steps apart).\\n centre = xvar[z] # center of transition\\n width = (xvar[1] - xvar[0]) * 2\\n\\n try:\\n pg, _ = curve_fit(gauss, xs, ys,\\n p0=(np.nanmax(ys),\\n centre,\\n width),\\n sigma=(xs - centre)**2 + .01)\\n # get the x positions when the fitted gaussian is at 'conf' of\\n # maximum\\n # determine transition FWHM\\n fwhm = abs(2 * pg[-1] * np.sqrt(2 * np.log(2)))\\n # apply on_mult or off_mult, as appropriate.\\n if tp:\\n lim = np.array([-fwhm, fwhm]) * on_mult + pg[1]\\n else:\\n lim = np.array([-fwhm, fwhm]) * off_mult + pg[1]\\n\\n fbkg[(xvar > lim[0]) & (xvar < lim[1])] = False\\n fsig[(xvar > lim[0]) & (xvar < lim[1])] = False\\n\\n except RuntimeError:\\n failed.append([centre, tp])\\n pass\\n\\n ftrn = ~fbkg & ~fsig\\n\\n # if there are any failed transitions, exclude the mean transition width\\n # either side of the failures\\n if len(failed) > 0:\\n trns = xvar[bool_2_indices(ftrn)]\\n tr_mean = (trns[:, 1] - trns[:, 0]).mean() / 2\\n for f, tp in failed:\\n if tp:\\n ind = (xvar >= f - tr_mean *\\n on_mult[0]) & (xvar <= f + tr_mean * on_mult[0])\\n else:\\n ind = (xvar >= f - tr_mean *\\n off_mult[0]) & (xvar <= f + tr_mean * off_mult[0])\\n fsig[ind] = False\\n fbkg[ind] = False\\n ftrn[ind] = False\\n\\n return fbkg, fsig, ftrn, [f[0] for f in failed]\",\n \"def close_to_exceeding(self) -> bool:\\n mean = self.current / self.num_cuts\\n if self.max_frames is not None:\\n return self.current + mean > self.max_frames\\n if self.max_samples is not None:\\n return self.current + mean > self.max_samples\\n if self.max_duration is not None:\\n return self.current + mean > self.max_duration\\n return False\",\n \"def shaking_false_alarm_rate(individual, test_data, truth_data, name=None):\\r\\n test_data = np.array(test_data)\\r\\n truth_data = np.array(truth_data)\\r\\n total = 0\\r\\n num_wrong = 0\\r\\n for test_point, truth_point in zip(test_data, truth_data):\\r\\n # Nine represents a shaking event\\r\\n if truth_point != 9:\\r\\n if test_point > 8.5 and test_point <= 9.5:\\r\\n num_wrong += 1\\r\\n total += 1\\r\\n #if num_wrong == 0:\\r\\n # # Perfection implies overtraining\\r\\n # return 1.0\\r\\n #else:\\r\\n return float(num_wrong)/float(total)\",\n \"def get_noise_thresholds(size_of_class=45, fakes='./data/CASIA1_fakes', originals='./data/CASIA1_originals', \\n fakes_ela='./data/CASIA1_fakes_ela'):\\n fakes_list = os.listdir(fakes)\\n\\n fakes = load_fakes(fakes_list, fakes, originals)\\n\\n noises = []\\n for i, item in enumerate(fakes):\\n image = cv2.imread(os.path.join(fakes_ela, item.path.split('\\\\\\\\')[-1]))\\n image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)\\n \\n image = cv2.inRange(image, np.array([0,0,0]), np.array([180,255,60]))\\n image = cv2.bitwise_not(image)\\n noises.append(estimate_noise(image))\\n\\n fakes = np.array(fakes)\\n noises = np.array(noises)\\n idxs = noises.argsort()\\n sorted_by_noise = fakes[idxs]\\n\\n for i, item in enumerate(sorted(noises)):\\n if (i+1) % size_of_class == 0:\\n print(\\\"####\\\", i+1, item)\\n else:\\n print(i+1, item)\",\n \"def converged(self, nfactor=20):\\n tau = self.sampler.get_autocorr_time(tol=0)\\n converged = np.all(tau * nfactor < self.sampler.iteration)\\n return converged\",\n \"def _find_saturated_profiles(self) -> np.ndarray:\\n n_gates, var_lim, _, _ = self.noise_params\\n var = np.var(self.data['backscatter'][:, -n_gates:], axis=1)\\n return var < var_lim\",\n \"def check_background_SN(ramp_file='id1ketvxq_ramp.dat', show=False):\\n from astropy.table import Table\\n import matplotlib.pyplot as plt\\n import numpy as np\\n \\n time, bg = np.loadtxt(ramp_file, unpack=True)\\n t0 = np.diff(time)[0]\\n time, bg = time[1:], bg[1:] # skip first 2.9 s read\\n\\n if len(bg) <= 2:\\n return []\\n \\n dt = np.append(t0, np.diff(time))\\n \\n s = 1. # test count rate\\n so = np.argsort(bg)\\n \\n NREAD = len(bg)\\n reads = np.arange(NREAD)+1\\n \\n fluence = np.cumsum((s*dt)[so])\\n rms = np.sqrt(np.cumsum((bg*dt)[so]))\\n rms_optimal = np.sqrt(np.cumsum((bg[so][2]*dt)[so]))\\n\\n max_ix = np.argmax(fluence/rms)\\n if max_ix < (NREAD-1):\\n pop_reads = list(reads[so][max_ix+1:])\\n else:\\n pop_reads = []\\n \\n ### where observed rms < expected RMS for flat background\\n other_bad = list(reads[so][rms/rms_optimal > 1.25])\\n pop_reads = np.cast[int](np.unique(np.hstack((pop_reads, other_bad))))\\n pop_reads = list(pop_reads)\\n \\n if len(pop_reads) > 0:\\n # np.savetxt(ramp_file.replace('ramp.dat', 'ramp.pop.png'), pop_reads,\\n # fmt='%d')\\n fp = open('/tmp/'+ramp_file.replace('ramp.dat', 'ramp.pop.dat'),'w')\\n for r in pop_reads:\\n fp.write('%d\\\\n' %(r))\\n fp.close()\\n \\n if show:\\n plt.ioff()\\n \\n fig = plt.figure(figsize=[6,3])\\n ax = fig.add_subplot(111)\\n ax.plot(time, bg, color='0.8', linewidth=6, zorder=1)\\n si = 60\\n ax.scatter(time, bg, color='w', s=si, zorder=8)\\n ax.scatter(time, bg, color='k', s=0.5*si, zorder=9)\\n if len(pop_reads) > 0:\\n ix = np.array(pop_reads)\\n ax.scatter(time[ix-1], bg[ix-1], color='r', zorder=10, s=0.5*si)\\n \\n ax.grid()\\n ax.set_title(ramp_file)\\n ax.set_xlabel('time'), ax.set_ylabel('background')\\n \\n fig.tight_layout(pad=0.1)\\n \\n fig.savefig('/tmp/'+ramp_file.replace('.dat', '.pop.png'))\\n plt.close()\\n \\n return pop_reads\",\n \"def __call__(self, trainer):\\n observation = trainer.observation\\n summary = self._summary\\n key = self._key\\n if key in observation:\\n summary.add({key: observation[key]})\\n\\n if not self._interval_trigger(trainer):\\n return False\\n\\n if self._max_trigger(trainer):\\n return True\\n\\n stats = summary.compute_mean()\\n value = float(stats[key]) # copy to CPU\\n self._init_summary()\\n\\n if not self._best_value or self._compare(self._best_value, value):\\n self._best_value = value\\n self._waited = 0\\n return False\\n elif self._waited >= self._patience:\\n return True\\n else:\\n self._waited += 1\\n if self._waited >= self._patience:\\n return True\\n else:\\n return False\",\n \"def _no_improve(self):\\n improve = [p-f for (f,p),_ in self.population]\\n return np.mean(improve) < 1.0\",\n \"def run(self, date):\\n\\n out = self.nanoutput()\\n\\n for cs in config.stimuli():\\n stimresp = self.analysis('stim_dff_alltrials_%s' % cs)\\n dff_active = np.sum(stimresp > 0.025)/float(len(stimresp))\\n out['good_%s' % cs] = dff_active > 0.05\\n\\n return out\",\n \"def has_more_trials(self) -> bool:\\r\\n raise NotImplementedError\",\n \"def eval_clicks(true_songs, predicted_songs, seeds):\\n n_preds = len(predicted_songs)\\n true_set = set(true_songs)\\n for i, idx in enumerate(np.arange(0, n_preds, 10)):\\n preds = predicted_songs[idx:idx+10]\\n for p in preds:\\n if p in true_set and p not in seeds:\\n return i\\n return float(\\\"inf\\\")\",\n \"def setCaptured(self):\\r\\n total = 0\\r\\n for x in self.animals:\\r\\n if x.captured == True:\\r\\n total += 1\\r\\n self.captured = total\",\n \"def run_experiment():\\n return [random.random() < 0.5 for _ in range(1000)]\",\n \"def run_experiment():\\n return [random.random() < 0.5 for _ in range(1000)]\",\n \"def run_experiment():\\n return [random.random() < 0.5 for _ in range(1000)]\",\n \"def run_experiment():\\n return [random.random() < 0.5 for _ in range(1000)]\",\n \"def check_if_stopping_criterion_is_met(original_training_data_values):\\n if len(original_training_data_values)<23:\\n return True\\n else:\\n target_column = original_training_data_values[:, -1]\\n recipe_type, cupcake_muffin_count = np.unique(target_column, return_counts=True)\\n cupcake_ratio = cupcake_muffin_count[0] / (cupcake_muffin_count.sum())\\n muffin_ratio = cupcake_muffin_count[1] / (cupcake_muffin_count.sum())\\n\\n if cupcake_ratio >= 0.9 or muffin_ratio >= 0.9:\\n return True\\n else:\\n return False\",\n \"def _send_sampled_event(self):\\n if not self.enabled:\\n return False\\n send_sample = False\\n self.count += 1\\n if self.actual_rate < self.statsd_sample_rate:\\n self.monitored += 1\\n send_sample = True\\n self.actual_rate = float(self.monitored) / float(self.count)\\n if self.count >= maxint or self.monitored >= maxint:\\n self.count = 0\\n self.monitored = 0\\n return send_sample\",\n \"def compute_sw_threshold(flanking_reads, paf_dict, fasta_dict, window_size):\\n\\n max_scores = []\\n for query, target in itertools.product(flanking_reads, flanking_reads):\\n\\n if str(query + target) in paf_dict:\\n overlap_info = paf_dict[query+target]\\n elif str(target + query) in paf_dict:\\n # get info and swap them\\n overlap_info = paf_dict[target+query]\\n query, target = target, query\\n else:\\n continue\\n\\n query_start = overlap_info['query_start']\\n query_end = overlap_info['query_end']\\n target_start = overlap_info['target_start']\\n target_end = overlap_info['target_end']\\n\\n query_seq = fasta_dict[query][query_start:query_end]\\n target_seq = fasta_dict[target][target_start:target_end]\\n\\n # Get scores for this pair; store in cur_scores\\n cur_scores = []\\n if window_size:\\n # Use rolling window\\n min_len = min(len(query_seq), len(target_seq))\\n for start, end in utils.pairwise(range(0, min_len, window_size)):\\n qs = query_seq[start:end]\\n ts = target_seq[start:end]\\n score = smith_waterman.smith_waterman(qs, ts)\\n cur_scores.append(score)\\n\\n if cur_scores:\\n score = max(cur_scores)\\n max_scores.append(score)\\n else:\\n # No rolling window\\n score = smith_waterman.smith_waterman(query_seq, target_seq)\\n max_scores.append(score)\\n\\n threshold = 0.9 * max(max_scores)\\n\\n print(\\\"using {} as threshold\\\".format(threshold))\\n\\n plt.subplot(2, 3, 2)\\n plt.hist(max_scores)\\n plt.title(\\\"FLANKING READS\\\\nhistogram of num_gaps / len(aligned_sequence)\\\\nthreshold = {}\\\\nwindow_size = {}\\\\nshowing {} scores\\\"\\n .format(threshold, window_size, len(max_scores)))\\n\\n\\n\\n return threshold\",\n \"def is_sampling_for_minmax(self):\\n return (self._level_change_time is not None) and \\\\\\n (get_time() - self._level_change_time) < self._duration_in_sec\",\n \"def compute_profiling_time(key, expected_num_spikes, rate, t_stop, n,\\n winlen, binsize, num_rep=10):\\n\\n time_fast_fca = 0.\\n time_fpgrowth = 0.\\n for rep in range(num_rep):\\n # Generating artificial data\\n data = []\\n for i in range(n):\\n np.random.seed(0)\\n data.append(stg.homogeneous_poisson_process(\\n rate=rate, t_start=0*pq.s, t_stop=t_stop))\\n\\n # Extracting Closed Frequent Itemset with FP-Growth\\n t0 = time.time()\\n # Binning the data and clipping (binary matrix)\\n binary_matrix = conv.BinnedSpikeTrain(data, binsize).to_bool_array()\\n # Computing the context and the binary matrix encoding the relation\\n # between objects (window positions) and attributes (spikes,\\n # indexed with a number equal to neuron idx*winlen+bin idx)\\n context, transactions, rel_matrix = spade._build_context(binary_matrix,\\n winlen)\\n # Applying FP-Growth\\n fim_results = [i for i in spade._fpgrowth(\\n transactions,\\n rel_matrix=rel_matrix,\\n winlen=winlen)]\\n time_fpgrowth += time.time() - t0\\n\\n # Extracting Closed Frequent Itemset with Fast_fca\\n t1 = time.time()\\n # Binning the data and clipping (binary matrix)\\n binary_matrix = conv.BinnedSpikeTrain(data, binsize).to_bool_array()\\n # Computing the context and the binary matrix encoding the relation\\n # between objects (window positions) and attributes (spikes,\\n # indexed with a number equal to neuron idx*winlen+bin idx)\\n context, transactions, rel_matrix = \\\\\\n spade._build_context(binary_matrix, winlen)\\n # Applying FP-Growth\\n fim_results = spade._fast_fca(context, winlen=winlen)\\n time_fast_fca += time.time() - t1\\n\\n time_profiles = {'fp_growth': time_fpgrowth/num_rep,\\n 'fast_fca': time_fast_fca/num_rep}\\n\\n # Storing data\\n res_path = '../results/{}/{}/'.format(key, expected_num_spikes)\\n # Create path is not already existing\\n path_temp = './'\\n for folder in split_path(res_path):\\n path_temp = path_temp + '/' + folder\\n mkdirp(path_temp)\\n\\n np.save(res_path + '/profiling_results.npy', {'results': time_profiles,\\n 'parameters': {'rate': rate, 't_stop': t_stop, 'n': n,\\n 'winlen': winlen, 'binsize': binsize}})\",\n \"def has_more_samples(self):\\n return True\",\n \"def has_more_samples(self):\\n return True\",\n \"def has_more_samples(self):\\n return True\",\n \"def is_exploring(self, step):\\n return np.random.rand() < self._epsilon(step)\",\n \"def reduction_size_one_autarkies(self):\\n done = False\\n while not done:\\n current_N = self.A.shape[1]\\n max_projection = self.A @ np.ones(current_N, dtype=int)\\n inprods = self.A.transpose() @ max_projection\\n A_y = self.A.transpose() @ self.y\\n indices = []\\n vals = []\\n for i in range(current_N):\\n if A_y[i] <= 0.5 * self.m:\\n indices.append(i)\\n vals.append(0)\\n elif A_y[i] >= inprods[i] - 0.5 * self.m:\\n indices.append(i)\\n vals.append(1)\\n no_reductions = len(indices)\\n for i in range(no_reductions - 1, -1, -1): #reverse order\\n self.problem_reduction_single(indices[i], vals[i])\\n if no_reductions == 0:\\n done = True\",\n \"def can_sample(self, n_samples):\\n return len(self) >= n_samples\",\n \"def can_sample(self, n_samples):\\n return len(self) >= n_samples\",\n \"def can_sample(self, n_samples):\\n return len(self) >= n_samples\",\n \"def can_sample(self, n_samples):\\n return len(self) >= n_samples\",\n \"def noise_despiker(self, win=3, nlim=12.):\\n if ~isinstance(win, int):\\n win = int(win)\\n if not hasattr(self, 'despiked'):\\n self.data['despiked'] = {}\\n for a, vo in self.focus.items():\\n v = vo.copy()\\n if 'time' not in a.lower():\\n # calculate rolling mean using convolution\\n kernel = np.ones(win) / win\\n rmean = np.convolve(v, kernel, 'same')\\n\\n # with warnings.catch_warnings():\\n # to catch 'empty slice' warnings\\n # warnings.simplefilter(\\\"ignore\\\", category=RuntimeWarning)\\n # rmean = \\\\\\n # np.apply_along_axis(np.nanmean, 1,\\n # rolling_window(v, win,\\n # pad=np.nan))\\n # rmean = \\\\\\n # np.apply_along_axis(np.nanmean, 1,\\n # rolling_window(v, win,\\n # pad=np.nan))\\n # calculate rolling standard deviation\\n # (count statistics, so **0.5)\\n rstd = rmean**0.5\\n\\n # find which values are over the threshold\\n # (v > rmean + nlim * rstd)\\n over = v > rmean + nlim * rstd\\n if sum(over) > 0:\\n # get adjacent values to over - limit values\\n neighbours = \\\\\\n np.hstack([v[np.roll(over, -1)][:, np.newaxis],\\n v[np.roll(over, 1)][:, np.newaxis]])\\n # calculate the mean of the neighbours\\n replacements = np.apply_along_axis(np.nanmean, 1,\\n neighbours)\\n # and subsitite them in\\n v[over] = replacements\\n self.data['despiked'][a] = v\\n self.setfocus('despiked')\\n return\",\n \"def _snr_preprocessing(self):\\n if self.flux is None or self.fluxerr is None:\\n return np.ones(len(self.stamps), dtype=bool)\\n\\n snrs = self.flux.astype(float) / self.fluxerr.astype(float)\\n return snrs > self.snr_threshold\",\n \"def weighted_estimation(self) -> bool:\\n pass\",\n \"def smooth_al(data):\\n wd = 5\\n optimize = True\\n DW_min = 5\\n while optimize == True:\\n smooth = savgol_filter(data, wd, 2)\\n DW = DW_cal(data, smooth)\\n if abs(2 - DW) < DW_min:\\n wd = wd + 2\\n DW_min = abs(2 - DW)\\n else:\\n wd = wd - 2\\n smooth = savgol_filter(data, wd, 2)\\n DW = DW_cal(data, smooth)\\n break\\n return smooth, wd\",\n \"def test_am_threshold(Simulator, plt, seed, rng):\\n d = 64\\n vocab = Vocabulary(d, pointer_gen=rng)\\n vocab.populate('A; B; C; D')\\n\\n d2 = int(d / 2)\\n vocab2 = Vocabulary(d2, pointer_gen=rng)\\n vocab2.populate('A; B; C; D')\\n\\n def input_func(t):\\n return '0.49 * A' if t < 0.1 else '0.8 * B'\\n\\n with spa.Network('model', seed=seed) as m:\\n m.am = ThresholdingAssocMem(\\n threshold=0.5, input_vocab=vocab, output_vocab=vocab2,\\n function=filtered_step_fn, mapping='by-key')\\n m.stimulus = spa.Transcode(input_func, output_vocab=vocab)\\n m.stimulus >> m.am\\n\\n in_p = nengo.Probe(m.am.input)\\n out_p = nengo.Probe(m.am.output, synapse=0.03)\\n\\n with Simulator(m) as sim:\\n sim.run(0.3)\\n t = sim.trange()\\n below_th = t < 0.1\\n above_th = t > 0.25\\n\\n plt.subplot(2, 1, 1)\\n plt.plot(t, similarity(sim.data[in_p], vocab))\\n plt.ylabel(\\\"Input\\\")\\n plt.subplot(2, 1, 2)\\n plt.plot(t, similarity(sim.data[out_p], vocab2))\\n plt.plot(t[above_th], np.ones(t.shape)[above_th] * 0.9, c='g', lw=2)\\n plt.ylabel(\\\"Output\\\")\\n\\n assert np.mean(sim.data[out_p][below_th]) < 0.01\\n assert_sp_close(t, sim.data[out_p], vocab2['B'], skip=0.25, duration=0.05)\",\n \"def goalReached(self, rewards):\\n return len(rewards) >= 100 and np.mean(rewards[-100:]) >= 18\",\n \"def over_sample(self) -> float:\\n return self._over_sample\",\n \"def over_sample(self) -> float:\\n return self._over_sample\",\n \"def is_over(self, state) -> bool:\\n\\n p1_count = 0\\n p2_count = 0\\n ley_line_total = (state.side_length + 1) * 3\\n for itype in state.current_ley_lines:\\n for line in itype:\\n if line[0] == '1':\\n p1_count += 1\\n if line[0] == '2':\\n p2_count += 1\\n\\n if p1_count >= ley_line_total/2 or p2_count >= ley_line_total/2:\\n return True\\n return False\",\n \"def is_tentative(self):\\n return self.state == TrackState.Tentative\",\n \"def is_tentative(self):\\n return self.state == TrackState.Tentative\",\n \"def is_stationary(self) -> bool:\\n ad_fuller_result = adfuller(self.y.dropna(), autolag='AIC')\\n p_value = ad_fuller_result[1]\\n return p_value <= 0.5\",\n \"def scan_ap(self, cut_off = 3480, r_ap = 12, r_an = 3):\\r\\n for trial in range(self.dimension):\\r\\n max_count, max_rank = self.pick_largest(cut_off = cut_off)\\r\\n if max_count >= 0:\\r\\n y,x = self.rank_yx(max_rank)\\r\\n print(\\\"Scan pos\\\", y,x,\\\" scanning\\\",trial,\\\"counts\\\", max_count)\\r\\n count_in, count_out = self.fit_galaxy(y,x,r_ap, r_an)\\r\\n count_sum = []\\r\\n local_bg = []\\r\\n for c in range(len(count_in)):\\r\\n if count_in[c] >= cut_off:\\r\\n count_sum.append(count_in[c])\\r\\n for c in range(len(count_out)):\\r\\n if count_out[c] <= cut_off:\\r\\n local_bg.append(count_out[c])\\r\\n no_c = len(count_in)\\r\\n if len(count_sum) >= int(np.pi * (r_ap **2) / 2): # Make sure it is not noise\\r\\n count_sum = np.array(count_sum).sum()\\r\\n if len(local_bg) != 0:\\r\\n total = 0\\r\\n for c in range(len(local_bg)):\\r\\n if 3*13.8 <= abs(local_bg[c] - 3419):\\r\\n total += local_bg[c]\\r\\n local_bg = total / len(local_bg)\\r\\n else:\\r\\n local_bg = 3419\\r\\n print(\\\"galaxy founded at \\\", y, x)\\r\\n self.galaxies.append(galaxy(y, x, r_ap, count_sum, bg_galaxy=local_bg, no_count = no_c))\\r\\n \\r\\n elif max_count == -1:\\r\\n print(\\\"aperture scan completed, number of galaxies found is\\\", len(self.galaxies))\\r\\n break\",\n \"def skip_test(n):\\n return k > 0 and magic * n * k**0.5 >= t4_ref\",\n \"def future_deceivedup(self, a): \\n nfav, succfav = self.control[a.name]\\n #f_n = n+1;\\n # f_worldround = self.world.round+1\\n f_successRate = float(a.success +1) / float(self.world.round+1)\\n if hardrule:\\n return (nfav+1 > 5) and ((self.world.round - nfav) > 5) and \\\\\\n float(a.success+1-succfav)/(self.world.round+1 - nfav) > \\\\\\n (float(succfav)/nfav) + epsilonD\\n else:\\n return nfav > 5 and (f_successRate > (float(succfav)/nfav) + epsilonD \\\\\\n or f_successRate < epsilonD)\",\n \"def _check_for_noise(self) -> None:\\n safety_stop = 5\\n while self._has_noise() and safety_stop > 0:\\n self.filter(size=3)\\n safety_stop -= 1\",\n \"def runcount(test_keys, sigma, sigma_max, sigma_step,\\n npoints_min, npoints_max, npoints_step):\\n run = 1\\n for key in test_keys:\\n if key:\\n while sigma < sigma_max:\\n npoints = npoints_min\\n while npoints < npoints_max:\\n npoints += npoints_step\\n run += 1\\n sigma += sigma_step\\n return run\",\n \"def n_pos(self):\\n running_total = 0\\n for i in range(self.prob.num):\\n if self.alphas[i] > 1e-5 > self.prob.C - self.deltas[i] and self.prob.Y[i] == 1:\\n running_total += 1\\n return running_total if running_total > 0 else 1\",\n \"def n_pos(self):\\n running_total = 0\\n for i in range(self.prob.num):\\n if self.alphas[i] > 1e-5 > self.prob.C - self.deltas[i] and self.prob.Y[i] == 1:\\n running_total += 1\\n return running_total if running_total > 0 else 1\",\n \"def isPlayed(self):\\n return bool(self.viewedLeafCount == self.leafCount)\",\n \"def isPlayed(self):\\n return bool(self.viewedLeafCount == self.leafCount)\",\n \"def classify(self, testInstance):\\n return self.fire(testInstance) > 0.5\",\n \"def burn_in_finished():\\n global trials\\n if trials <= 0:\\n return True\\n trials -= 1\\n return False\",\n \"def early_stopping(cost, opt_cost, threshold, patience, count):\\n booly = False\\n if cost >= opt_cost - threshold:\\n count += 1\\n if count == patience:\\n return True, count\\n else:\\n booly = False\\n count = 0\\n return booly, count\",\n \"def _compute_is_terminal(self):\\n # self.n_actions contains a number of unlabelled datapoints that is left\\n if self.n_actions==1:\\n # print('We ran out of samples!')\\n done = True\\n else:\\n done = False\\n return done\",\n \"def greedy(self):\\n n_step_t = self.filter['n_step_t']\\n n_traj = self.filter['n_traj']\\n traj = self.filter['traj']\\n steps = [0 for i in xrange(n_step_t)]\\n for i in xrange(n_traj):\\n n_step = traj[i]['n_step']\\n for j in xrange(n_step):\\n steps[j] += 1\\n self.filter['steps'] = steps\\n \\n return\",\n \"def __call__(self, *args, **kwargs):\\n out = super().__call__(*args, **kwargs)\\n out **= 2\\n self._debug.append(out)\\n out = int(out > self.threshold_value)\\n if out and self.since_last_peak > self._num_of_taps:\\n self.since_last_peak = -1\\n else:\\n out = 0\\n self.since_last_peak += 1\\n return out\",\n \"def trial_atr(trial, omit_missing_frames=True):\\n frames = trial.HMM_MLE\\n if omit_missing_frames:\\n frames = frames[frames >= 0]\\n\\n runs = calc_run_lengths(trial.HMM_MLE)\\n return_times = []\\n current_return_time = 0\\n for run in runs:\\n if run.object == 0:\\n return_times.append(current_return_time/60)\\n current_return_time = 0\\n else:\\n current_return_time += run.length\\n return np.mean(return_times)\",\n \"def finished(self):\\n hit_max_evals = len(self.rounds) >= self.max_evals\\n\\n if len(self.rounds) < self.conv_check_iters:\\n hit_conv = False\\n else:\\n last_rounds = self.rounds[-self.conv_check_iters:]\\n a = zip(*last_rounds)[1]\\n a_sd = np.std(a, axis=0)\\n hit_conv = (a_sd < self.conv_action_eps).all()\\n\\n hit_max_time = self.duration > self.max_time\\n\\n return hit_max_evals or hit_conv or hit_max_time\",\n \"def pull(self):\\n chance = np.random.uniform()\\n return chance < self.winning_prob\",\n \"def test_next_window_time_no_sample_passed(self):\\n test_window_scheme = WindowingScheme(self.window_test_filter, 3)\\n time.sleep(4)\\n collected_value = test_window_scheme.filter(self.more_than_upper_bound)\\n self.assertEquals(collected_value, self.more_than_upper_bound)\",\n \"def run_adfuller_test(preprocessed_data, alpha=0.05, wanted_fraction=0.95):\\n inds = list(np.ndindex(preprocessed_data.shape[:-1]))\\n\\n def return_adfuller_pval(this_ind): return adfuller(\\n preprocessed_data[this_ind])[1]\\n pval_list = np.array(parallelize(return_adfuller_pval, inds, n_jobs=30))\\n alpha = 0.05\\n threshold = alpha/len(pval_list)\\n wanted_fraction = 0.95\\n if np.sum(pval_list < threshold) > wanted_fraction * len(pval_list):\\n print('Data is stationary')\\n else:\\n raise ValueError('Data is not stationary')\",\n \"def should_average(self):\\n return self._should_average\",\n \"def check_stimOn_delays(data, **_):\\n metric = np.nan_to_num(data[\\\"stimOn_times\\\"] - data[\\\"stimOnTrigger_times\\\"], nan=np.inf)\\n passed = (metric <= 0.15) & (metric > 0)\\n assert data[\\\"intervals\\\"].shape[0] == len(metric) == len(passed)\\n return metric, passed\",\n \"def is_recording(self) -> bool:\\n return self.elastic_span.transaction.is_sampled and not self.elastic_span.ended_time\",\n \"def single_iteration_condition(args):\\n return np.logical_and(\\n np.greater(args[-3], acceptance_ratio),\\n np.less(args[-2], max_iteration))\",\n \"def _episode_success(self, observations):\\n dist = self._env.get_metrics()[\\\"object_to_goal_distance\\\"]\\n if (\\n abs(dist) > self._success_distance\\n or observations[\\\"gripped_object_id\\\"] != -1\\n ):\\n return False\\n return True\",\n \"def process_trace(n_tr, tr, sta, orig_time, cmps, cfg):\\n cmp = tr.stats.channel[2:3]\\n sta[cmp] = {}\\n sta[cmp][\\\"times\\\"] = tr.times(reftime=orig_time)\\n\\n sta[cmp][\\\"tr_results\\\"] = np.zeros(\\n (len(cfg.picking.FILT_WINS[\\\"P\\\"]), sta[\\\"lenD\\\"])\\n )\\n sta[cmp][\\\"f1_results\\\"] = np.zeros(\\n (len(cfg.picking.FILT_WINS[\\\"P\\\"]), len(cfg.picking.KURT_WINS),\\n sta[\\\"lenD\\\"])\\n )\\n sta[cmp][\\\"f1_mean\\\"] = np.zeros(sta[\\\"lenD\\\"])\\n sta[cmp][\\\"f3_results\\\"] = np.zeros(\\n (len(cfg.picking.FILT_WINS[\\\"P\\\"]),\\n len(cfg.picking.KURT_WINS), sta[\\\"lenD\\\"])\\n )\\n sta[cmp][\\\"f3_mean_smooth\\\"] = np.zeros(\\n (len(cfg.picking.CF_MEAN_SMOOTH_WIND), sta[\\\"lenD\\\"])\\n )\\n sta[cmp][\\\"f4_all\\\"] = np.zeros((len(cfg.picking.CF_MEAN_SMOOTH_WIND),\\n sta[\\\"lenD\\\"]))\\n sta[cmp][\\\"f1_mean_smooth\\\"] = np.zeros(sta[\\\"lenD\\\"])\\n # Get suitable filters (exclude those fully outside Nyquist freq.)\\n for phase in [\\\"P\\\", \\\"S\\\"]:\\n if cmp in cmps[phase]:\\n sta[\\\"picks\\\"][\\\"poss_obs\\\"][phase][cmp] = {}\\n sta[cmp][\\\"filtwins_check\\\"] = [\\n filt_win for filt_win in cfg.picking.FILT_WINS[phase]\\n if filt_win[0] < sta[\\\"samplerate\\\"] / 2\\n ]\\n if cfg.picking.INTEGRATE_S is True:\\n tr.integrate()\\n\\n for n_filt, filt in enumerate(sta[cmp][\\\"filtwins_check\\\"]):\\n # Ensure that filter covers sample rate / 2\\n if (tr.stats.sampling_rate / 2) <= filt[0]:\\n print(\\\"Skipping this Kurtosis run due to sample rate/2<f\\\")\\n continue\\n tr.filter(\\\"bandpass\\\", freqmin=filt[0], freqmax=filt[1])\\n try:\\n sta[cmp][\\\"tr_results\\\"][n_filt] = tr.data\\n except ValueError: # If input array length is inconsistent\\n continue\\n # Loop over kurtosis windows\\n for n_kurt, kurt_win_s in enumerate(cfg.picking.KURT_WINS):\\n f1 = CF_kurtosis(kurt_win_s, tr)\\n sta[cmp][\\\"f1_results\\\"][n_filt, n_kurt] = f1 # Needed for weights\\n f2 = kurt_transform_f2(f1, kurt_win_s, tr)\\n f3 = kurt_transform_f3(f2, kurt_win_s, tr)\\n\\n sta[cmp][\\\"f3_results\\\"][n_filt, n_kurt] = f3\\n sta[cmp][\\\"f1_mean\\\"] = np.nanmean(sta[cmp][\\\"f1_results\\\"], axis=0)[0]\\n sta[cmp][\\\"f1_mean_smooth\\\"] = do_smooth(\\n sta[cmp][\\\"f1_mean\\\"], cfg.picking.CF_MEAN_SMOOTH_WIND[0],\\n tr.stats.sampling_rate\\n )\\n # ^ Throws up a warning first time due to NaN slices\\n # Compute mean CF and final kurtosis transform\\n f3_mean = np.nanmean(sta[cmp][\\\"f3_results\\\"], axis=0)[0]\\n\\n for nsm, smooth_wind in enumerate(cfg.picking.CF_MEAN_SMOOTH_WIND):\\n sta[cmp][\\\"f3_mean_smooth\\\"][nsm] = do_smooth(\\n f3_mean, smooth_wind, tr.stats.sampling_rate\\n )\\n f4 = kurt_transform_f4(sta[cmp][\\\"f3_mean_smooth\\\"][nsm],\\n np.max(cfg.picking.KURT_WINS), tr)\\n sta[cmp][\\\"f4_all\\\"][nsm] = f4\\n\\n # Now pick (avoiding end and beginning of signal)\\n # Pick the P-waves\\n if cmp in cmps[\\\"P\\\"]:\\n sta[\\\"picks\\\"][\\\"poss_obs\\\"][\\\"P\\\"][cmp][nsm] = []\\n # Find points where Kurt<0 & doesn't look like S-wave\\n p_cands = np.argwhere((f4 < 0.0))\\n for idx in p_cands.tolist():\\n kurt_wgt = np.min(np.where(np.array(\\n cfg.picking.KURT2WGHT[\\\"P\\\"]\\n <= sta[cmp][\\\"f1_mean_smooth\\\"][idx])))\\n sta[\\\"picks\\\"][\\\"poss_obs\\\"][\\\"P\\\"][cmp][nsm].append([\\n orig_time+sta[cmp][\\\"times\\\"][idx][0], f4[idx][0],\\n tr.stats.channel, kurt_wgt, idx,\\n sta[cmp][\\\"times\\\"][idx][0]\\n ])\\n # Pick the S-waves\\n if cmp in cmps[\\\"S\\\"]:\\n sta[\\\"picks\\\"][\\\"poss_obs\\\"][\\\"S\\\"][cmp][nsm] = []\\n\\n # Find points where Kurt<0 & doesn't look like S-wave\\n s_cands = np.argwhere((f4 < 0.0))\\n for idx in s_cands.tolist():\\n kurt_wgt = np.min(np.where(np.array(cfg.picking.KURT2WGHT[\\\"S\\\"]\\n <= sta[cmp][\\\"f1_mean_smooth\\\"][idx]))\\n )\\n sta[\\\"picks\\\"][\\\"poss_obs\\\"][\\\"S\\\"][cmp][nsm].append([\\n orig_time+sta[cmp][\\\"times\\\"][idx][0], f4[idx][0],\\n tr.stats.channel, kurt_wgt, idx,\\n sta[cmp][\\\"times\\\"][idx][0]\\n ])\\n return(sta)\",\n \"def _collect_induced_spikes(spikes, input_targeted_times, trial_length_ms, targeted_gid):\\n inter_induction_wins = spt.make_windows(input_targeted_times, (0, trial_length_ms))\\n inter_induction_wins = spt.ExclusiveWindows(inter_induction_wins)\\n targeted_spikes = spikes[spikes.gid == targeted_gid]\\n targeted_spikes = inter_induction_wins.classify_spikes(targeted_spikes)\\n\\n targeted_spikes = targeted_spikes[targeted_spikes['delay'] < 10.]\\n induced_spk_idcs = targeted_spikes.groupby('win_idx')['delay'].idxmin().values\\n\\n is_induced = pd.Series(np.zeros(len(spikes), dtype=np.bool_), index=spikes.index)\\n is_induced.loc[induced_spk_idcs] = True\\n\\n return is_induced\",\n \"def _step(self, a):\\n obs, rew, done, info = super()._step(a)\\n # if self.robot.body_xyz[0] > self.threshold:\\n # rew = 1.0\\n # self.threshold += 1\\n # else:\\n # rew = 0.0\\n # self.steps += 1\\n # if self.steps > self.max_episode_steps:\\n # done = True\\n return obs, rew, done, info\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5619866","0.5553437","0.5524997","0.53908414","0.5296018","0.5253825","0.5213897","0.52011967","0.51841336","0.5176683","0.51282734","0.5120962","0.51179755","0.5112065","0.50441957","0.50383514","0.503653","0.50297564","0.4981896","0.4948819","0.49382964","0.49352995","0.4923914","0.4913876","0.488362","0.486648","0.4865212","0.4859857","0.4845986","0.4844091","0.48335487","0.4819243","0.48095194","0.48041978","0.47951248","0.47886539","0.478849","0.4785646","0.4783216","0.47796804","0.47752506","0.47694692","0.47645342","0.47645342","0.47645342","0.47645342","0.4762756","0.4756849","0.47488472","0.47456446","0.47444832","0.47362223","0.47362223","0.47362223","0.47357813","0.47310227","0.47287056","0.47287056","0.47287056","0.47287056","0.47241643","0.4723517","0.47211432","0.47138724","0.4713607","0.47126657","0.4711587","0.4711587","0.47075152","0.47024995","0.47024995","0.46926537","0.46907163","0.46892238","0.4671544","0.46609223","0.46589068","0.4656004","0.4656004","0.46545446","0.46545446","0.46504384","0.46458313","0.46405274","0.4635777","0.46324214","0.462278","0.46170834","0.4615073","0.46128902","0.46109375","0.46103176","0.46103162","0.46102574","0.46064585","0.46045214","0.46032125","0.45825028","0.45821914","0.45736486"],"string":"[\n \"0.5619866\",\n \"0.5553437\",\n \"0.5524997\",\n \"0.53908414\",\n \"0.5296018\",\n \"0.5253825\",\n \"0.5213897\",\n \"0.52011967\",\n \"0.51841336\",\n \"0.5176683\",\n \"0.51282734\",\n \"0.5120962\",\n \"0.51179755\",\n \"0.5112065\",\n \"0.50441957\",\n \"0.50383514\",\n \"0.503653\",\n \"0.50297564\",\n \"0.4981896\",\n \"0.4948819\",\n \"0.49382964\",\n \"0.49352995\",\n \"0.4923914\",\n \"0.4913876\",\n \"0.488362\",\n \"0.486648\",\n \"0.4865212\",\n \"0.4859857\",\n \"0.4845986\",\n \"0.4844091\",\n \"0.48335487\",\n \"0.4819243\",\n \"0.48095194\",\n \"0.48041978\",\n \"0.47951248\",\n \"0.47886539\",\n \"0.478849\",\n \"0.4785646\",\n \"0.4783216\",\n \"0.47796804\",\n \"0.47752506\",\n \"0.47694692\",\n \"0.47645342\",\n \"0.47645342\",\n \"0.47645342\",\n \"0.47645342\",\n \"0.4762756\",\n \"0.4756849\",\n \"0.47488472\",\n \"0.47456446\",\n \"0.47444832\",\n \"0.47362223\",\n \"0.47362223\",\n \"0.47362223\",\n \"0.47357813\",\n \"0.47310227\",\n \"0.47287056\",\n \"0.47287056\",\n \"0.47287056\",\n \"0.47287056\",\n \"0.47241643\",\n \"0.4723517\",\n \"0.47211432\",\n \"0.47138724\",\n \"0.4713607\",\n \"0.47126657\",\n \"0.4711587\",\n \"0.4711587\",\n \"0.47075152\",\n \"0.47024995\",\n \"0.47024995\",\n \"0.46926537\",\n \"0.46907163\",\n \"0.46892238\",\n \"0.4671544\",\n \"0.46609223\",\n \"0.46589068\",\n \"0.4656004\",\n \"0.4656004\",\n \"0.46545446\",\n \"0.46545446\",\n \"0.46504384\",\n \"0.46458313\",\n \"0.46405274\",\n \"0.4635777\",\n \"0.46324214\",\n \"0.462278\",\n \"0.46170834\",\n \"0.4615073\",\n \"0.46128902\",\n \"0.46109375\",\n \"0.46103176\",\n \"0.46103162\",\n \"0.46102574\",\n \"0.46064585\",\n \"0.46045214\",\n \"0.46032125\",\n \"0.45825028\",\n \"0.45821914\",\n \"0.45736486\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7172721"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":8799,"cells":{"query":{"kind":"string","value":"This test should not be run as a part of the normal test suite. This is a resource test only! Nose2 will find it. Unittest will not."},"document":{"kind":"string","value":"def test_will_get_nwis_return_response():\n\n expected = 200\n response = hf.get_nwis('01585200', 'dv', '2001-01-01', '2001-01-02')\n actual = response.status_code\n assert expected == actual\n print('NWIS is up and running!')"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def test_subsystems(self):\n pass","def test_create_system_entire(self):\n pass","def unitary_test():","def test(self):\n pass","def test_create_run(self):\n pass","def test_4_4_1_1(self):\n pass","def _test(self):\n pass","def _test(self):\n pass","def _test(self):\n pass","def test_package(self):\n pass","def _test(self):","def _test(self):","def _test(self):","def _test(self):","def _test(self):","def test_require():","def test_get_run(self):\n pass","def test_basic_execution(self):","def test_create_namespaced_resource_access_review(self):\n pass","def test_create_from_pear(self):\n pass","def test_create_unexpected_problem(self):\n pass","def runtest(self):","def test_create_namespaced_local_resource_access_review(self):\n pass","def test_module(self):\n pass","def test_households_in_admin_unit(self):","def test_get(self):\n pass","def test(self):\n raise NotImplementedError","def setUp(self):","def setUp(self):","def setUp(self):","def setUp(self):","def setUp(self):","def setUp(self):","def setUp(self):","def setUp(self):","def setUp(self):","def setUp(self):","def setUp(self):","def setUp(self):","def setUp(self):","def setUp(self):","def setUp(self):","def setUp(self):","def setUp(self):","def setUp(self):","def setUp(self):","def setUp(self):","def setUp(self):","def setUp(self):","def setUp(self):","def setUp(self):","def setUp(self):","def test(self):","def test(self):","def testApi(self):","def test_alien_data(self):","def test_stub(self):\n pass","def test_get_system(self):\n pass","def test_loading_document(self):","def tests():","def test_let(self):","def test_create_scenario1(self):\n pass","def test_for_client():","def runTest(self):\r\n self.setUp()\r\n self.test_CreateROI1()","def test_install(self):\n pass","def setUp(self):\n self","def setUp(self):\n self","def test_01_Init(self):\n pass","def test_get_insumo(self):","def test_doc():\n pass","def test_get2(self):\n pass","def test_begin(self):","def test_create(self):\n pass","def test_get_scenario(self):\n pass","def setUp(self):\r\n pass # nothing required by all\r","def test():\n pass","def setUp(self):\n \n \n pass","def setUp(self):\n \n \n pass","def setUp(self):\n \n \n pass","def setUp(self):\n \n \n pass","def setUp(self):\n \n \n pass","def setUp(self):\n \n \n pass","def setUp(self):\n \n \n pass","def setUp(self):\n \n \n pass","def setUp(self):\n \n \n pass","def test_create_client(self):\n pass","def test_download2(self):\n pass","def test_client_retrieve(self):\n pass","def test_get_software(self):\n pass","def test_document_retrieval(self):","def test_nothing(self):","def test_untar(self):","def test_T01():","def test_meme_get(self):\n pass","def test_get1(self):\n pass","def test_create10(self):\n pass","def runTest(self):\r\n self.setUp()\r\n self.test_sceneImport24281()","def test_new(self):","def test_new(self):","def test_get_client(self):\n pass","def setUp(self):\r\n pass"],"string":"[\n \"def test_subsystems(self):\\n pass\",\n \"def test_create_system_entire(self):\\n pass\",\n \"def unitary_test():\",\n \"def test(self):\\n pass\",\n \"def test_create_run(self):\\n pass\",\n \"def test_4_4_1_1(self):\\n pass\",\n \"def _test(self):\\n pass\",\n \"def _test(self):\\n pass\",\n \"def _test(self):\\n pass\",\n \"def test_package(self):\\n pass\",\n \"def _test(self):\",\n \"def _test(self):\",\n \"def _test(self):\",\n \"def _test(self):\",\n \"def _test(self):\",\n \"def test_require():\",\n \"def test_get_run(self):\\n pass\",\n \"def test_basic_execution(self):\",\n \"def test_create_namespaced_resource_access_review(self):\\n pass\",\n \"def test_create_from_pear(self):\\n pass\",\n \"def test_create_unexpected_problem(self):\\n pass\",\n \"def runtest(self):\",\n \"def test_create_namespaced_local_resource_access_review(self):\\n pass\",\n \"def test_module(self):\\n pass\",\n \"def test_households_in_admin_unit(self):\",\n \"def test_get(self):\\n pass\",\n \"def test(self):\\n raise NotImplementedError\",\n \"def setUp(self):\",\n \"def setUp(self):\",\n \"def setUp(self):\",\n \"def setUp(self):\",\n \"def setUp(self):\",\n \"def setUp(self):\",\n \"def setUp(self):\",\n \"def setUp(self):\",\n \"def setUp(self):\",\n \"def setUp(self):\",\n \"def setUp(self):\",\n \"def setUp(self):\",\n \"def setUp(self):\",\n \"def setUp(self):\",\n \"def setUp(self):\",\n \"def setUp(self):\",\n \"def setUp(self):\",\n \"def setUp(self):\",\n \"def setUp(self):\",\n \"def setUp(self):\",\n \"def setUp(self):\",\n \"def setUp(self):\",\n \"def setUp(self):\",\n \"def setUp(self):\",\n \"def setUp(self):\",\n \"def test(self):\",\n \"def test(self):\",\n \"def testApi(self):\",\n \"def test_alien_data(self):\",\n \"def test_stub(self):\\n pass\",\n \"def test_get_system(self):\\n pass\",\n \"def test_loading_document(self):\",\n \"def tests():\",\n \"def test_let(self):\",\n \"def test_create_scenario1(self):\\n pass\",\n \"def test_for_client():\",\n \"def runTest(self):\\r\\n self.setUp()\\r\\n self.test_CreateROI1()\",\n \"def test_install(self):\\n pass\",\n \"def setUp(self):\\n self\",\n \"def setUp(self):\\n self\",\n \"def test_01_Init(self):\\n pass\",\n \"def test_get_insumo(self):\",\n \"def test_doc():\\n pass\",\n \"def test_get2(self):\\n pass\",\n \"def test_begin(self):\",\n \"def test_create(self):\\n pass\",\n \"def test_get_scenario(self):\\n pass\",\n \"def setUp(self):\\r\\n pass # nothing required by all\\r\",\n \"def test():\\n pass\",\n \"def setUp(self):\\n \\n \\n pass\",\n \"def setUp(self):\\n \\n \\n pass\",\n \"def setUp(self):\\n \\n \\n pass\",\n \"def setUp(self):\\n \\n \\n pass\",\n \"def setUp(self):\\n \\n \\n pass\",\n \"def setUp(self):\\n \\n \\n pass\",\n \"def setUp(self):\\n \\n \\n pass\",\n \"def setUp(self):\\n \\n \\n pass\",\n \"def setUp(self):\\n \\n \\n pass\",\n \"def test_create_client(self):\\n pass\",\n \"def test_download2(self):\\n pass\",\n \"def test_client_retrieve(self):\\n pass\",\n \"def test_get_software(self):\\n pass\",\n \"def test_document_retrieval(self):\",\n \"def test_nothing(self):\",\n \"def test_untar(self):\",\n \"def test_T01():\",\n \"def test_meme_get(self):\\n pass\",\n \"def test_get1(self):\\n pass\",\n \"def test_create10(self):\\n pass\",\n \"def runTest(self):\\r\\n self.setUp()\\r\\n self.test_sceneImport24281()\",\n \"def test_new(self):\",\n \"def test_new(self):\",\n \"def test_get_client(self):\\n pass\",\n \"def setUp(self):\\r\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.71541893","0.713073","0.71006393","0.7076272","0.70147574","0.69360954","0.6920686","0.6920686","0.6920686","0.6887088","0.6876075","0.6876075","0.6876075","0.6876075","0.6876075","0.6841704","0.6797133","0.67678326","0.67677563","0.675755","0.6699573","0.66841465","0.6679246","0.6677635","0.6600168","0.65922755","0.65915775","0.658401","0.658401","0.658401","0.658401","0.658401","0.658401","0.658401","0.658401","0.658401","0.658401","0.658401","0.658401","0.658401","0.658401","0.658401","0.658401","0.658401","0.658401","0.658401","0.658401","0.658401","0.658401","0.658401","0.658401","0.658401","0.65839434","0.65839434","0.65820664","0.6575808","0.6569613","0.65605456","0.6553227","0.65527874","0.65374625","0.65199053","0.65195346","0.65128857","0.65076923","0.650164","0.650164","0.6488903","0.64883745","0.648301","0.6477642","0.64773005","0.64763623","0.6467402","0.6458281","0.64442104","0.6444016","0.6444016","0.6444016","0.6444016","0.6444016","0.6444016","0.6444016","0.6444016","0.6444016","0.64312583","0.6421439","0.64190257","0.6418158","0.6414663","0.6408392","0.63910073","0.6389432","0.6359039","0.6355904","0.63555336","0.6354709","0.6353834","0.6353834","0.6349538","0.6345929"],"string":"[\n \"0.71541893\",\n \"0.713073\",\n \"0.71006393\",\n \"0.7076272\",\n \"0.70147574\",\n \"0.69360954\",\n \"0.6920686\",\n \"0.6920686\",\n \"0.6920686\",\n \"0.6887088\",\n \"0.6876075\",\n \"0.6876075\",\n \"0.6876075\",\n \"0.6876075\",\n \"0.6876075\",\n \"0.6841704\",\n \"0.6797133\",\n \"0.67678326\",\n \"0.67677563\",\n \"0.675755\",\n \"0.6699573\",\n \"0.66841465\",\n \"0.6679246\",\n \"0.6677635\",\n \"0.6600168\",\n \"0.65922755\",\n \"0.65915775\",\n \"0.658401\",\n \"0.658401\",\n \"0.658401\",\n \"0.658401\",\n \"0.658401\",\n \"0.658401\",\n \"0.658401\",\n \"0.658401\",\n \"0.658401\",\n \"0.658401\",\n \"0.658401\",\n \"0.658401\",\n \"0.658401\",\n \"0.658401\",\n \"0.658401\",\n \"0.658401\",\n \"0.658401\",\n \"0.658401\",\n \"0.658401\",\n \"0.658401\",\n \"0.658401\",\n \"0.658401\",\n \"0.658401\",\n \"0.658401\",\n \"0.658401\",\n \"0.65839434\",\n \"0.65839434\",\n \"0.65820664\",\n \"0.6575808\",\n \"0.6569613\",\n \"0.65605456\",\n \"0.6553227\",\n \"0.65527874\",\n \"0.65374625\",\n \"0.65199053\",\n \"0.65195346\",\n \"0.65128857\",\n \"0.65076923\",\n \"0.650164\",\n \"0.650164\",\n \"0.6488903\",\n \"0.64883745\",\n \"0.648301\",\n \"0.6477642\",\n \"0.64773005\",\n \"0.64763623\",\n \"0.6467402\",\n \"0.6458281\",\n \"0.64442104\",\n \"0.6444016\",\n \"0.6444016\",\n \"0.6444016\",\n \"0.6444016\",\n \"0.6444016\",\n \"0.6444016\",\n \"0.6444016\",\n \"0.6444016\",\n \"0.6444016\",\n \"0.64312583\",\n \"0.6421439\",\n \"0.64190257\",\n \"0.6418158\",\n \"0.6414663\",\n \"0.6408392\",\n \"0.63910073\",\n \"0.6389432\",\n \"0.6359039\",\n \"0.6355904\",\n \"0.63555336\",\n \"0.6354709\",\n \"0.6353834\",\n \"0.6353834\",\n \"0.6349538\",\n \"0.6345929\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":87,"numItemsPerPage":100,"numTotalItems":95772,"offset":8700,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc3NDI5MDEyNCwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3NzQyOTM3MjQsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.ACglPCWeNHocmCLmJ7vefe89XjxeGhmOGPt9XZzhWSo3Oj7FTG98lNr7ZwUmzsnfJ5ISEpZcRmGA5D1ncBqvCA","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 |
|---|---|---|---|---|---|---|
this function serves to initialize the ROS node | def startNode():
# init node
rospy.init_node("resize_and_repub")
rospy.loginfo("resize_and_repub node started")
# setup subcribers
rospy.Subscriber(leftArmCamTopic, Image, leftArmImageCallback)
rospy.Subscriber(headCamTopic, Image, headImageCallback)
rospy.Subscriber(primaryCamTopic, String, primaryCamCallback)
rospy.Subscriber(secondaryCamTopic, String, secondayCamCallback)
rospy.loginfo("all subscribers initialized, entering publishing loop...")
# start repub thread
thread = threading.Thread(target=resizeAndRepubThread)
thread.start()
rospy.spin() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def init_ros_node(self): #pylint: disable=no-self-use\n print(\"rospy init node\")\n rospy.init_node('ispy_ROS_receiver', anonymous = True)",
"def initNode():\n\n # 0) General Setup\n #initialize listener node!\n rospy.init_node('main', anonymous=True)\n\n #Create instances of subscribe... | [
"0.8261381",
"0.7474935",
"0.73012865",
"0.7279841",
"0.6911988",
"0.6786043",
"0.67791384",
"0.67517745",
"0.6729871",
"0.6711965",
"0.66651976",
"0.66531044",
"0.66189027",
"0.6601425",
"0.6570407",
"0.6547083",
"0.6542969",
"0.65383095",
"0.65187514",
"0.65016264",
"0.6483... | 0.6678193 | 10 |
Checkout code for CESM If sandbox exists, check that the right tag has been checkedout. Otherwise, download the code, checkout the tag and run manage_externals. The scripts don't seem to like multiple applications of manage_externals. | def code_checkout(cesm_repo, coderoot, tag):
sandbox = os.path.split(coderoot)[-1]
if os.path.exists(coderoot):
print('Check for right tag: '+coderoot)
p = Popen('git status', shell=True, cwd=coderoot, stdout=PIPE, stderr=PIPE)
stdout, stderr = p.communicate()
stdout = stdout.decode('UTF-8')
stderr = stderr.decode('UTF-8')
print(stdout)
print(stderr)
if tag not in stdout.split('\n')[0]:
raise ValueError('tag does not match')
else:
stat = check_call(['mkdir', '-p', coderoot])
if stat != 0: sys.exit(1)
# clone the repo
p = Popen('git clone '+cesm_repo+' '+sandbox, shell=True,
cwd=coderoot+'/..', stdout=PIPE, stderr=PIPE)
stdout, stderr = p.communicate()
if stdout:
print(stdout)
if stderr:
print(stderr)
if p.returncode != 0:
raise Exception('git error')
# check out the right tag
p = Popen('git checkout %s'%tag, shell=True, cwd=coderoot)
stdout, stderr = p.communicate()
if stdout:
print(stdout)
if stderr:
print(stderr)
if p.returncode != 0:
raise Exception('git error')
# check out externals
p = Popen('./manage_externals/checkout_externals -v', shell=True, cwd=coderoot)
stdout, stderr = p.communicate()
if stdout:
print(stdout)
if stderr:
print(stderr)
if p.returncode != 0:
raise Exception('git error') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n sandbox = create_sandbox()\n directory = download_package_to_sandbox(\n sandbox,\n 'https://pypi.python.org/packages/source/c/checkmyreqs/checkmyreqs-0.1.6.tar.gz'\n )\n print(directory)\n destroy_sandbox(sandbox)",
"def checked_out_MPS():\n\n checked_out_packages = ... | [
"0.57098264",
"0.5443898",
"0.52824104",
"0.5211898",
"0.50929743",
"0.5078513",
"0.5051536",
"0.50458026",
"0.5009098",
"0.50035506",
"0.49857637",
"0.49795955",
"0.490863",
"0.4892152",
"0.4889629",
"0.4881726",
"0.48687592",
"0.48336747",
"0.4761207",
"0.47558445",
"0.4754... | 0.6543128 | 0 |
Test adding basic InputNode | def test0_init(self):
print("\nTest 0: Initialization")
builder = StaticBuilder()
in1_name = builder.addInput(10)
in1 = builder.input_nodes[in1_name]
print('Node keys in builder:', list(builder.input_nodes.keys()))
self.assertEqual(in1.label, 0, "The label has not been assigned correctly")
self.assertEqual(builder.num_nodes, 1, "The number of nodes has not been "
"assigned correctly")
self.assertEqual(in1.num_declared_outputs, 0, "The number of outputs of "
"the InputNode has not been assigned correctly")
self.assertEqual(in1.num_declared_inputs, 0, "The number of outputs of "
"the InputNode has not been assigned correctly") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def testInputDesc(self):\n\n self.assertTrue(\n hasattr(self.node, 'input_desc')\n )\n\n self.assertEqual(\n None,\n self.node.input_desc\n )",
"def test_addOutput(self):\n print(\"\\nTest 2: Adding OutputNode\")\n builder = StaticBuilder()\n ... | [
"0.6525281",
"0.6475737",
"0.6424497",
"0.6410956",
"0.6354569",
"0.63182724",
"0.62617815",
"0.62125105",
"0.61966574",
"0.60417753",
"0.6039684",
"0.60300416",
"0.59842473",
"0.59750694",
"0.5963595",
"0.59632045",
"0.59500754",
"0.59398043",
"0.58992374",
"0.58532447",
"0.... | 0.6362094 | 4 |
Test adding basic Deterministic InnerNode. | def test_addInner(self):
print("\nTest 1: Adding InnerNode")
try:
builder = StaticBuilder()
builder.addInput(10, name="In")
enc_name = builder.addInner(3, name="In")
except AttributeError:
print("\nCAUGHT! Trying to assign the same name to two nodes! "
"AttributeError exception\n")
builder = StaticBuilder()
builder.addInput(10, name="In")
enc_name = builder.addInner(3, name="Det")
enc1 = builder.nodes[enc_name]
print('\nNode keys in builder:', list(builder.nodes.keys()))
print("This node's key:", enc_name)
self.assertEqual(enc1.label, 1, "The label has not been assigned correctly")
self.assertEqual(builder.num_nodes, 2, "The number of nodes has not been "
"assigned correctly")
self.assertEqual(enc1.num_declared_outputs, 0, "The number of outputs of the "
"DeterministicNode has not been assigned correctly")
self.assertEqual(enc1.num_declared_inputs, 0, "The number of inputs of the "
"DeterministicNode has not been assigned correctly") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_add_znode(self):\n z = self.test_start_empty()\n self.test_start_one_value(z)",
"def test_add_new_child(self):\n root = netapp_api.NaElement('root')\n self.mock_object(netapp_api.NaElement,\n '_convert_entity_refs',\n return_val... | [
"0.634626",
"0.61077243",
"0.60818183",
"0.6013245",
"0.5986549",
"0.597251",
"0.595647",
"0.58965737",
"0.5876589",
"0.5845326",
"0.5809255",
"0.5755622",
"0.5737071",
"0.5720968",
"0.5700372",
"0.5690431",
"0.56798387",
"0.56767136",
"0.56564647",
"0.5654355",
"0.56480926",... | 0.751408 | 0 |
Test adding basic OutputNode | def test_addOutput(self):
print("\nTest 2: Adding OutputNode")
builder = StaticBuilder()
builder.addInput(10, name="In")
builder.addInner(3, name="Det")
o_name = builder.addOutput(name="Out")
o1 = builder.nodes[o_name]
print("\nNode keys in builder:", list(builder.nodes.keys()))
print("This node's key:", o_name)
self.assertEqual(o1.label, 2, "The label has not been assigned correctly")
self.assertEqual(builder.num_nodes, 3, "The number of nodes has not been "
"assigned correctly")
self.assertEqual(o1.num_declared_outputs, 0, "The number of outputs of the "
"OutputNode has not been assigned correctly")
self.assertEqual(o1.num_declared_inputs, 0, "The number of inputs of the "
"OutputNode has not been assigned correctly") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_node_outputs(self):\n pass",
"def addOutputsNode():\n return render_template(\"addOutputsNode.html\")",
"def testNewOutputModule(self):\n manager.OutputManager.RegisterOutput(TestOutput)\n\n output_module = manager.OutputManager.NewOutputModule('test_output')\n self.assertIsInst... | [
"0.75490946",
"0.666691",
"0.63000286",
"0.6119677",
"0.6104275",
"0.6039189",
"0.59738773",
"0.5940442",
"0.5934479",
"0.5925732",
"0.5917337",
"0.5912333",
"0.5910766",
"0.58941495",
"0.5879698",
"0.5866728",
"0.5860062",
"0.5858629",
"0.58093554",
"0.5797671",
"0.57790154"... | 0.78752226 | 0 |
Test building the simplest model possible. | def test_BuildModel0(self):
print("\nTest 4: Building a Basic Model")
builder = StaticBuilder(scope="Basic")
in_name = builder.addInput(10)
enc_name = builder.addInner(3)
out_name = builder.addOutput()
builder.addDirectedLink(in_name, enc_name)
builder.addDirectedLink(enc_name, out_name)
self.assertEqual(builder.num_nodes, 3, "The number of nodes has not been "
"assigned correctly")
builder.build()
inn, enc, out = ( builder.nodes[in_name], builder.nodes[enc_name],
builder.nodes[out_name] )
self.assertEqual(inn._oslot_to_otensor[0].shape.as_list()[-1],
enc._islot_to_itensor[0].shape.as_list()[-1],
"The input tensors have not been assigned correctly")
self.assertEqual(enc._oslot_to_otensor[0].shape.as_list()[-1],
out._islot_to_itensor[0].shape.as_list()[-1],
"The input tensors have not been assigned correctly") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_build_model(arguments):\n ...",
"def test_quick_build(self):\n pass",
"def test_quick_build1(self):\n pass",
"def test_simple_creation():\n # Get model file\n create.main(\"mlp\", \"10:12:8\", \"model_test.tar\")",
"def test_model():\n pass",
"def test_BuildModel3(self)... | [
"0.74242914",
"0.7226327",
"0.705865",
"0.70076",
"0.70002264",
"0.6796702",
"0.6709102",
"0.6660882",
"0.656199",
"0.6525237",
"0.6459824",
"0.6387487",
"0.63846844",
"0.635007",
"0.63139594",
"0.63126516",
"0.630687",
"0.62744576",
"0.6251773",
"0.6231023",
"0.62173486",
... | 0.70569456 | 3 |
Test building a model with 2 outputs. Test Cloning an output | def test_BuildModel1(self):
print("\nTest 5: Building a Model with cloning")
builder = StaticBuilder("Clone")
in1 = builder.addInput(10)
enc1 = builder.addInner(3)
out1 = builder.addOutput(name="Out1")
out2 = builder.addOutput(name="Out2")
builder.addDirectedLink(in1, enc1)
builder.addDirectedLink(enc1, out1)
builder.addDirectedLink(enc1, out2)
builder.build() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_default_output_2():\n #input_file = os.path.join('.', 'test_files', 'test.input')\n actual = os.path.join('.', 'test_files', 'rc_actual.out')\n times = list(range(0, 30, 5))\n inputs = {\"names\": ['V'],\n \"values\": [\n [1],\n [0],\n ... | [
"0.6694175",
"0.6504223",
"0.63788325",
"0.6321789",
"0.6308089",
"0.6245688",
"0.6215992",
"0.61850905",
"0.6116955",
"0.6110523",
"0.609222",
"0.6081803",
"0.60653377",
"0.6058217",
"0.6056005",
"0.6037613",
"0.60202926",
"0.5977124",
"0.5976717",
"0.59375304",
"0.59170985"... | 0.7202675 | 0 |
Builds a model with 2 inputs. Test ConcatNode | def test_BuildModel2(self):
print("\nTest 6: Building a Model with Concat")
builder = StaticBuilder("Concat")
in1 = builder.addInput(10)
in2 = builder.addInput(20)
enc1 = builder.addInner(3, num_islots=2)
out1 = builder.addOutput()
builder.addDirectedLink(in1, enc1, islot=0)
builder.addDirectedLink(in2, enc1, islot=1)
builder.addDirectedLink(enc1, out1)
builder.build() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def concat_model():\n x = tf.keras.Input(shape=[10, 10, 3, ])\n x1 = tf.keras.layers.Conv2D(5, (2, 2))(x)\n x2 = tf.keras.layers.Conv2D(6, (2, 2))(x)\n x3 = tf.keras.layers.Conv2D(7, (2, 2))(x)\n z = tf.keras.layers.concatenate([x2, x1, x3], axis=-1)\n z1 = tf.keras.layers.Conv2D(10, (2, 2))(z)\n... | [
"0.6844526",
"0.6768665",
"0.66675013",
"0.65246445",
"0.6511792",
"0.6232399",
"0.6185943",
"0.61621577",
"0.60782385",
"0.60532033",
"0.6042736",
"0.6000108",
"0.5988612",
"0.59775037",
"0.5974451",
"0.5970998",
"0.59662324",
"0.59449714",
"0.59398437",
"0.58934414",
"0.588... | 0.77477473 | 0 |
Try to break it, the algorithm... !! Guess not mdrfkr. | def test_BuildModel3(self):
print("\nTest 7: Building a more complicated Model")
builder = StaticBuilder("BreakIt")
in1 = builder.addInput(10)
in2 = builder.addInput(20)
enc1 = builder.addInner(3)
enc2 = builder.addInner(5, num_islots=2)
out1 = builder.addOutput()
out2 = builder.addOutput()
builder.addDirectedLink(in1, enc1)
builder.addDirectedLink(in2, enc2, islot=0)
builder.addDirectedLink(enc1, enc2, islot=1)
builder.addDirectedLink(enc1, out1)
builder.addDirectedLink(enc2, out2)
builder.build() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_guessing(self):\n self.classifier.guess(self.message)",
"def play(self):\n print(\"Game is starting!!\")\n self.generate_secret_number()\n while True:\n self.get_guess_from_user()\n self.ans = self.compare_results()\n if self.ans:\n ... | [
"0.6238723",
"0.62207544",
"0.5964192",
"0.594622",
"0.5904978",
"0.5902772",
"0.585103",
"0.581829",
"0.5811916",
"0.57857025",
"0.5780752",
"0.57535255",
"0.57274103",
"0.5718406",
"0.57046616",
"0.5671099",
"0.5660733",
"0.5626499",
"0.56193167",
"0.56131303",
"0.5610858",... | 0.0 | -1 |
Given the IP ADDRESS of the camera, to which you are connected and ACQUISITION MODE into which you want to put the camera, this command will send the according request to the camera. | def command(mode, ip, log):
logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', level=logging_config[log])
# Using the default dict to get a valid format string no matter what
phantom_socket = PhantomSocket(ip)
phantom_socket.connect()
click.echo('CONNECTED TO THE PHANTOM CAMERA')
mode_identifier = _modes[mode]
phantom_socket.set_mode(mode_identifier)
click.echo('PHANTOM WILL TRANSIT INTO THE MODE "%s" NOW!' % mode_identifier)
click.echo('THIS WILL CAUSE A REBOOT OF THE CAMERA, SO PLEASE HAVE PATIENCE')
click.echo('IN CASE A CONNECTION CANNOT BE ESTABLISHED EVEN AFTER SOME TIME, HARD RESET THE CAMERA')
click.echo('AFTER THE HARD RESET, THE MODE SHOULD BE CHANGED')
phantom_socket.disconnect() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def camera_control(camera_host, camera_port, camera_user, camera_pass, q):\n\n try:\n camera = IPCamera(camera_host, camera_port, camera_user, camera_pass)\n q.put(camera.get_rtsp_url())\n except RuntimeError as exc:\n q.put(exc)\n\n try:\n while True:\n camera.move_... | [
"0.657208",
"0.59614706",
"0.5739002",
"0.5577688",
"0.5528365",
"0.5405239",
"0.54035485",
"0.5352449",
"0.5316245",
"0.53074706",
"0.5200834",
"0.5174972",
"0.51566505",
"0.51535857",
"0.50904423",
"0.50857383",
"0.50825894",
"0.5082426",
"0.507766",
"0.5062548",
"0.5052165... | 0.689005 | 0 |
Attempts to insert the supplied genome. If the genome is inserted, this method will return True, otherwise it will return False. | def try_insert_genome(self, genome):
raise Exception("called abstract insert_genome method") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def inserted(self):\n return True",
"def insert(self, row):\n if not self.loaded:\n print(\"Database is not loaded\")\n return False\n\n self.rows.append(row)\n return True",
"def _can_insert(self, index, value):\n return not bool(self._insert_callback(i... | [
"0.6346422",
"0.6159592",
"0.60494566",
"0.57980555",
"0.578149",
"0.57695425",
"0.5667096",
"0.56136864",
"0.5602667",
"0.5582492",
"0.5562881",
"0.5556916",
"0.55056053",
"0.54988134",
"0.54925364",
"0.54842436",
"0.5480843",
"0.547767",
"0.54687303",
"0.54569113",
"0.54469... | 0.8167088 | 0 |
list of necessary ciphers objects | def ciphers_obj(self):
if self.esp_enc_alg == "ENCR_AES_GCM_16_IIV":
## BEGIN code to update
return [ AES.new(self.esp_enc_key,AES.MODE_GCM, nonce=self.nonce)]
## END code to update
raise UnsupportedEncAlgError(sa.esp_enc_alg, "unsupported") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_all_cipher():\n return OpenSSL.cipher_algo.keys()",
"def ciphers(self):\n return self._ciphers",
"def ciphers(self) -> Sequence[str]:\n return pulumi.get(self, \"ciphers\")",
"def ciphers(self) -> Sequence[str]:\n return pulumi.get(self, \"ciphers\")",
"def list_ciphers(... | [
"0.7565985",
"0.7461285",
"0.7372469",
"0.7372469",
"0.7340704",
"0.66134185",
"0.6335098",
"0.63059235",
"0.60204273",
"0.59899426",
"0.58400655",
"0.5778174",
"0.57402366",
"0.5726471",
"0.5650689",
"0.56054634",
"0.56048346",
"0.5511376",
"0.55048597",
"0.5406176",
"0.5400... | 0.7322964 | 5 |
Creates useful information compiled from protein dictionary | def __init__(self, proteins_dict):
self.proteins_dict = proteins_dict
self.proteins = list(proteins_dict.keys()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def define_info_dict():\n\n d = {\n \"PRED\": {\n \"COLUMN\": [\"predicted_class\"],\n \"Number\": \"1\",\n \"Type\": \"String\",\n \"Description\": \"Predicted class: somatic, germline, artifact\",\n },\n \"PROB\": {\n \"COLUMN\": [\"p... | [
"0.65818685",
"0.61850566",
"0.6020124",
"0.58721864",
"0.5824307",
"0.5692058",
"0.56518245",
"0.5619209",
"0.55818576",
"0.5551026",
"0.553083",
"0.5518843",
"0.5459129",
"0.54217863",
"0.5413675",
"0.54074",
"0.5400768",
"0.5389365",
"0.53707016",
"0.53672904",
"0.53651774... | 0.0 | -1 |
A little shared protein creater from aligned sequences | def shared(self, aligned_a, aligned_b):
return "".join([self.delta(aligned_a, aligned_b, i) for i in range(len(aligned_a))]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def proteins_align(self, protein_a, protein_b):\n # Set variables\n first = Seq(self.proteins_dict[protein_a][\"protein\"])\n second = Seq(self.proteins_dict[protein_b][\"protein\"])\n \n # Align proteins\n align = pairwise2.align.globalxx(first, second, one_alignment_only... | [
"0.6774844",
"0.6548914",
"0.6453903",
"0.63102025",
"0.62329227",
"0.62122506",
"0.62016445",
"0.6198148",
"0.61716217",
"0.61462194",
"0.6104765",
"0.60956174",
"0.6076317",
"0.605018",
"0.6017549",
"0.60125715",
"0.60021424",
"0.5987413",
"0.598054",
"0.59300274",
"0.59269... | 0.0 | -1 |
Aligns to proteins with BioPython | def proteins_align(self, protein_a, protein_b):
# Set variables
first = Seq(self.proteins_dict[protein_a]["protein"])
second = Seq(self.proteins_dict[protein_b]["protein"])
# Align proteins
align = pairwise2.align.globalxx(first, second, one_alignment_only=True)
aligned_a = align[0].seqA
aligned_b = align[0].seqB
# Calculate shared string
shared = self.shared(aligned_a, aligned_b)
# Returns dictionary of shared terms
return {protein_a: aligned_a,
protein_b: aligned_b,
"shared": shared,
"shared_count": Counter([x for x in shared.split("-") if x != ""]),
"percent_simalarity": align[0].score / len(align[0].seqA),
"score": align[0].score,
"levenshtein_distance": l_dist(str(first), str(second))} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _annotate(reads, mirbase_ref, precursors):\n for r in reads:\n for p in reads[r].precursors:\n start = reads[r].precursors[p].start + 1 # convert to 1base\n end = start + len(reads[r].sequence)\n for mature in mirbase_ref[p]:\n mi = mirbase_ref[p][matu... | [
"0.5886286",
"0.578243",
"0.5694541",
"0.55110466",
"0.54499483",
"0.5421526",
"0.5384452",
"0.5378168",
"0.53772914",
"0.5373772",
"0.5367927",
"0.5356481",
"0.52636886",
"0.5250715",
"0.52294004",
"0.521091",
"0.5200446",
"0.5192469",
"0.5176645",
"0.5132264",
"0.5124896",
... | 0.52686924 | 12 |
Instantiate a evaluator class. | def build_evaluator(cfg: CfgNode) -> EvaluatorBase:
name = cfg["name"]
evaluator = simple_build(name, cfg, EVALUATORS)
return evaluator | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def evaluator(self, evaluator):\n self.__evaluator = evaluator",
"def _create_evaluators(self):\n pass",
"def build_evaluator(cls, cfg, dataset_name, output_folder=None):\n if output_folder is None:\n output_folder = os.path.join(cfg.OUTPUT_DIR, \"inference\")\n evaluator... | [
"0.66867024",
"0.6603871",
"0.6451372",
"0.644928",
"0.6330437",
"0.6274948",
"0.61652106",
"0.6148524",
"0.6130907",
"0.5967345",
"0.58819443",
"0.5654034",
"0.56327844",
"0.56159383",
"0.55843073",
"0.5571741",
"0.5563956",
"0.5515962",
"0.5513957",
"0.5500064",
"0.5477984"... | 0.68942183 | 0 |
Instantiate a evaluate helper class. | def build_evaluate_helper(cfg: CfgNode) -> EvaluateHelper:
evaluator = build_evaluator(cfg.evaluator)
helper = EvaluateHelper(evaluator)
return helper | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _create_evaluators(self):\n pass",
"def evaluator(evaluate):\r\n @functools.wraps(evaluate)\r\n def ecspy_evaluator(candidates, args):\r\n fitness = []\r\n for candidate in candidates:\r\n fitness.append(evaluate(candidate, args))\r\n return fitness\r\n ecspy_e... | [
"0.64568245",
"0.6257798",
"0.6237631",
"0.6131028",
"0.6065035",
"0.60551",
"0.60094994",
"0.5996954",
"0.59962183",
"0.59601563",
"0.59601563",
"0.59439415",
"0.5902795",
"0.589313",
"0.5882588",
"0.58795404",
"0.58464766",
"0.5829064",
"0.5801519",
"0.5770252",
"0.57448375... | 0.70881444 | 0 |
Plot x and y axis of dfs in common graph. | def plot(x, y, *dfs):
ax = None
for df in dfs:
ax = df[[x, y]].set_index(x).plot(kind='line', ylim=(0, None), xlim=(0, None), ax=ax) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def draw_plot(ax, dfs, legend, x, y, xscale, yaxis_max):\n xticks = dfs_all_values(dfs, x)\n # loop over all pandas.DataFrame objects\n for df in dfs:\n # setting the x-column as an index is required to draw the y-column\n # as a function of x argument\n df = df.set_index(x)\n ... | [
"0.7042768",
"0.64889604",
"0.6424103",
"0.62358296",
"0.62245584",
"0.6214347",
"0.6187972",
"0.61645967",
"0.6090626",
"0.6083194",
"0.60742915",
"0.60631174",
"0.6021211",
"0.60032755",
"0.5985849",
"0.5971447",
"0.59706855",
"0.5946714",
"0.59466743",
"0.593274",
"0.59300... | 0.7176058 | 0 |
8 microed stepping by faking distance twice as long. | def micro_8(steps, a):
df = pd.DataFrame(index=np.arange(0, steps * 16), columns=('v', 's', 'd', 't'))
t = 0.0
m = 8 # micro level
d = d0 = math.sqrt(1/a/m) # faster accel since distance is longer
s = 0 # steps
p = 0 # position
p_d = 1/m # position delta
for s in range(800):
if s == 0:
d = d0 * 0.676
else:
d -= d * 2 / (4 * s + 1)
s += 1
p += p_d
t += d
df.loc[s] = [1/d/m, p, d, t]
# m = 1
# p_d = 1/m
# d = d * 8
# for s in range(100, 200):
# if s == 0:
# d = d0 * 0.676
# else:
# d -= d * 2 / (4 * s + 1)
# s += 1
# p += p_d
# t += d
# df.loc[s] = [1/d/m, p, d, t]
return df.dropna() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def drive_eight(n):\n # Variables for the go_diff function\n fast_speed = 80 \n slow_speed = 25\n # Half a lap time, this is the time the robot turns in a direction before switching\n half_lap_time =6.2 \n # To avoid having tu manually stop the robot we set it to drive continuously for x amount of seconds.\n... | [
"0.6142764",
"0.5769263",
"0.57421744",
"0.5703275",
"0.5681504",
"0.5650031",
"0.5599577",
"0.5527048",
"0.55249375",
"0.55100065",
"0.55055285",
"0.549204",
"0.54680324",
"0.5440701",
"0.54385084",
"0.54321384",
"0.5418194",
"0.54137677",
"0.54083496",
"0.5375917",
"0.53658... | 0.6169425 | 0 |
Return the result of an elasticsearch query as a pandas DataFrame. | def _ES_res_to_pandas(self, res, columns, thresh=None):
sources = [x['hits']['hits'][0]['_source'] for x in res['responses']]
if columns is not None:
if isinstance(columns, list):
sources = [{key: val for key, val in x.items() if key in columns} for x in sources]
elif callable(columns):
sources = [{key: val for key, val in x.items() if columns(key)} for x in sources]
assert sources
columns = list(sources[0].keys())
else:
raise TypeError('Variable "columns" should be list or callable or None.')
dtype = {col: self._choose_dtype(col) for col in columns}
ids = [x['hits']['hits'][0]['_id'] for x in res['responses']]
tab = pd.DataFrame(sources, index=ids)[columns]
# Workaround for pandas bug: https://stackoverflow.com/a/38750433/7856919
for k, v in dtype.items():
if v == bool:
tab[k] = tab[k].astype(str) == 'True'
else:
tab[k] = tab[k].astype(v)
if thresh is not None:
# Select rows that are not above the threshold
sel = ~(tab['__CONFIDENCE'] >= thresh)
columns_to_remove = [x for x in tab.columns if '__' in x]
tab.loc[sel, columns_to_remove] = pd.np.nan
# Dirty fix for np.nan that transforms dtype bool into float.
tab['__IS_MATCH'].fillna(False, inplace=True)
tab['__IS_MATCH'] = tab['__IS_MATCH'].astype(bool)
return tab | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_pandas(self):\n return pd.DataFrame(self.results)",
"def parse_query_result(self):\n results = self.jsonData['results']\n\n df = pd.DataFrame(results)\n df.drop(['rootSource', 'uri'], axis=1, inplace=True)\n\n return df",
"def parse_query_result(self):\n result... | [
"0.74036556",
"0.70324427",
"0.70324427",
"0.7026997",
"0.6755308",
"0.66402763",
"0.65239024",
"0.6453229",
"0.6447718",
"0.641856",
"0.63828397",
"0.63794637",
"0.63329643",
"0.6315638",
"0.63023823",
"0.62740153",
"0.6256019",
"0.6252512",
"0.61707205",
"0.616961",
"0.6168... | 0.59003174 | 47 |
Load or generate pandas DataFrame from the ES associated to the project. | def from_ES(self, columns=None, chunksize=None, thresh=None):
num_rows = ic.stats(self.index_name)['_all']['total']['docs']['count']
if chunksize is None:
res = self.fetch_by_id(size=num_rows, from_=0)
return self._ES_res_to_pandas(res, columns, thresh)
else:
# Return a generator. Code has to be separate to allow returning pandas.DataFrame
return self._from_ES_gen(num_rows, columns, chunksize, thresh) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load(\n self, index_col: str = \"operator\", date_cols: list = [\"updated\", \"created\"]\n ) -> pd.DataFrame:\n df = pd.read_json(self.fspath, convert_dates=date_cols)\n try:\n df = df.set_index(index_col)\n except KeyError:\n raise KeyError(\n ... | [
"0.6643909",
"0.6490127",
"0.6398309",
"0.63942033",
"0.6390223",
"0.6387757",
"0.6322727",
"0.6301943",
"0.62897563",
"0.62897563",
"0.6250521",
"0.62502694",
"0.6227685",
"0.62009954",
"0.6197437",
"0.6136766",
"0.6132035",
"0.60477877",
"0.60312194",
"0.6027194",
"0.602561... | 0.60417974 | 18 |
Add the elements in ref_gen to an existing index. | def update_index(self, ref_gen):
testing = True
logging.warning('Updating index')
es_insert.index(es, ref_gen, self.index_name, testing, action="update")
logging.warning('Finished updating') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _add_to_index( env, meta_dict, file_str, logger ):\n global adapter_glob\n if adapter_glob is not None:\n adapter = adapter_glob\n else:\n logger.warning( u\"Connecting to index...\" )\n adapter = adapter_file.adapter(env)\n adapter_glob = adapter\n doc = document(\n ... | [
"0.6223327",
"0.6165989",
"0.6162208",
"0.6124569",
"0.5892641",
"0.5827929",
"0.5818835",
"0.5818835",
"0.5806102",
"0.57331675",
"0.5731806",
"0.57138515",
"0.57138515",
"0.569752",
"0.5685238",
"0.5673912",
"0.56449544",
"0.5584928",
"0.5584928",
"0.55495024",
"0.5501107",... | 0.7487727 | 0 |
Create new CSP crossword generate. | def __init__(self, crossword):
self.crossword = crossword
self.domains = {
var: self.crossword.words.copy()
for var in self.crossword.variables
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate():",
"def create_word(self):\r\n\r\n template = self.word_constructions.get()\r\n word = \"\"\r\n for c in template:\r\n if c == \"v\":\r\n letter = self.get_letter(100)\r\n else:\r\n letter = self.get_letter(0)\r\n ... | [
"0.61295784",
"0.57595176",
"0.57502925",
"0.5485153",
"0.5463034",
"0.5440735",
"0.54096925",
"0.5384929",
"0.5324468",
"0.52978784",
"0.52702993",
"0.5268702",
"0.52018815",
"0.51922834",
"0.51729023",
"0.51533055",
"0.5123092",
"0.5111853",
"0.5078365",
"0.5064279",
"0.506... | 0.5178984 | 16 |
Return 2D array representing a given assignment. | def letter_grid(self, assignment):
letters = [
[None for _ in range(self.crossword.width)]
for _ in range(self.crossword.height)
]
for variable, word in assignment.items():
direction = variable.direction
for k in range(len(word)):
i = variable.i + (k if direction == Variable.DOWN else 0)
j = variable.j + (k if direction == Variable.ACROSS else 0)
letters[i][j] = word[k]
return letters | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getArray2d(self):\n\t\treturn self.array2d",
"def _make_2x2(self, A11, A12, A21, A22, dtype=float):\n array = np.empty((2,2), dtype=dtype)\n array[0,0] = A11\n array[0,1] = A12\n array[1,0] = A21\n array[1,1] = A22\n return array",
"def to_2d_array(self):\n ... | [
"0.606624",
"0.5862392",
"0.55966055",
"0.5584392",
"0.54055727",
"0.5379813",
"0.5306427",
"0.52944845",
"0.52937496",
"0.5269656",
"0.52278423",
"0.52027124",
"0.51681507",
"0.5129247",
"0.5119349",
"0.5079877",
"0.50548553",
"0.50341636",
"0.50252825",
"0.5023556",
"0.4997... | 0.5062015 | 17 |
Print crossword assignment to the terminal. | def print(self, assignment):
letters = self.letter_grid(assignment)
for i in range(self.crossword.height):
for j in range(self.crossword.width):
if self.crossword.structure[i][j]:
print(letters[i][j] or " ", end="")
else:
print("█", end="")
print() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def draw_word_scheme(self) -> None:\n print(\"\".join(self.word2))",
"def print(self):\n\n def format_guessed_word(word):\n return ' '.join(list(word))\n\n def format_blank_word(word):\n return ' '.join(list('_' * len(word)))\n\n print('\\n' + \"Board\" + '=' * 7... | [
"0.6418134",
"0.6091784",
"0.60144675",
"0.5868591",
"0.58374834",
"0.5763381",
"0.5702663",
"0.56456727",
"0.56032985",
"0.5602622",
"0.5599726",
"0.55596346",
"0.5540012",
"0.55338246",
"0.5492764",
"0.54739493",
"0.5469291",
"0.5463655",
"0.54530674",
"0.54021096",
"0.5400... | 0.72022206 | 1 |
Save crossword assignment to an image file. | def save(self, assignment, filename):
from PIL import Image, ImageDraw, ImageFont
cell_size = 100
cell_border = 2
interior_size = cell_size - 2 * cell_border
letters = self.letter_grid(assignment)
# Create a blank canvas
img = Image.new(
"RGBA",
(self.crossword.width * cell_size,
self.crossword.height * cell_size),
"black"
)
font = ImageFont.truetype("assets/fonts/OpenSans-Regular.ttf", 80)
draw = ImageDraw.Draw(img)
for i in range(self.crossword.height):
for j in range(self.crossword.width):
rect = [
(j * cell_size + cell_border,
i * cell_size + cell_border),
((j + 1) * cell_size - cell_border,
(i + 1) * cell_size - cell_border)
]
if self.crossword.structure[i][j]:
draw.rectangle(rect, fill="white")
if letters[i][j]:
w, h = draw.textsize(letters[i][j], font=font)
draw.text(
(rect[0][0] + ((interior_size - w) / 2),
rect[0][1] + ((interior_size - h) / 2) - 10),
letters[i][j], fill="black", font=font
)
img.save(filename) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save(self, filename):\n print(\"Saving...\", end=\"\\r\")\n canvas = self.canvas[self.N:self.S,self.W:self.E]\n cv2.imwrite(\"./Output/\"+filename, canvas)\n print(\"Saved:\",filename)",
"def save_detection(self, image):\n\t\timg = self.visualize_detection(image)\n\t\timg = cv2.cv... | [
"0.65461063",
"0.6395748",
"0.63688743",
"0.6313389",
"0.62285316",
"0.61451906",
"0.6133265",
"0.6110629",
"0.61080384",
"0.60995334",
"0.6096377",
"0.60782754",
"0.60167956",
"0.60059804",
"0.59735614",
"0.5961569",
"0.5951604",
"0.5941784",
"0.591758",
"0.5905942",
"0.5890... | 0.78399444 | 1 |
Enforce node and arc consistency, and then solve the CSP. | def solve(self):
self.enforce_node_consistency()
self.ac3()
return self.backtrack(dict()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def solve_csp(nodes, arcs, max_steps):\n\n nodes = list(nodes)\n print 'nodes:', nodes\n\n node_values_dict = dict(zip(nodes, '2'*len(set(nodes))))\n print 'initial random assignment', node_values_dict\n indexes = np.arange(len(nodes))\n\n graph = {}\n for arc in arcs:\n if not arc[0] i... | [
"0.64042765",
"0.6084755",
"0.60748124",
"0.57520914",
"0.5737966",
"0.56193435",
"0.55433697",
"0.53763986",
"0.5332282",
"0.526332",
"0.5261379",
"0.5261379",
"0.52395386",
"0.52281404",
"0.52064234",
"0.5187962",
"0.5164979",
"0.5130408",
"0.5113685",
"0.5096188",
"0.50758... | 0.54098696 | 8 |
Update `self.domains` such that each variable is nodeconsistent. (Remove any values that are inconsistent with a variable's unary constraints; in this case, the length of the word.) | def enforce_node_consistency(self):
# print("Entered enforce_node_consistency Function")
# print("self.domains")
# print(self.domains)
for mystery in self.domains:
# print("!!!!!!!!!!!!")
# print(mystery)
# print(self.domains[mystery])
keep_list = set()
while self.domains[mystery]:
word = self.domains[mystery].pop()
if(len(word) == mystery.length):
keep_list.add(word)
for word in keep_list:
self.domains[mystery].add(word)
# print(self.domains[mystery])
# raise NotImplementedError | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def enforce_node_consistency(self):\n # Loop over each variable (space for word) in the crossword\n # Use copy to prevent domains from being modified while looping\n for var in self.domains.copy():\n # Get all unary constraints for this variable\n for value in self.domain... | [
"0.80468005",
"0.69576985",
"0.6794537",
"0.63951313",
"0.63650477",
"0.6052798",
"0.5844512",
"0.58284026",
"0.5795998",
"0.5759449",
"0.5712677",
"0.5712677",
"0.56901187",
"0.5685086",
"0.5629894",
"0.5607322",
"0.55948013",
"0.55813795",
"0.5536879",
"0.5519875",
"0.54945... | 0.673076 | 3 |
Make variable `x` arc consistent with variable `y`. To do so, remove values from `self.domains[x]` for which there is no possible corresponding value for `y` in `self.domains[y]`. Return True if a revision was made to the domain of `x`; return False if no revision was made. | def revise(self, x, y):
# print("Entered revise Function")
keep_list_x = set()
keep_list_y = set()
domain_x = self.domains[x].copy()
domain_y = self.domains[y].copy()
overlaps = self.crossword.overlaps
overlap = overlaps[(x, y)]
# print(self.domains[x].copy)
revision = False
if overlap is not None:
while domain_x:
word_x = domain_x.pop()
# print(word_x)
while domain_y:
word_y = domain_y.pop()
# print(word_y)
keep_list_y.add(word_y)
if word_x[overlap[0]] != word_y[overlap[1]]:
keep_list_x.add(word_x)
for word in keep_list_y:
domain_y.add(word)
remove_list = self.domains[x].difference(keep_list_x)
# print("DOMAIN")
# print(self.domains[x])
# print("KEEP")
# print(keep_list_x)
# print("REMOVE")
# print(remove_list)
for word in remove_list:
self.domains[x].remove(word)
revision = True
return revision
# raise NotImplementedError | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def revise(self, x, y):\n # return set a default return value of False\n ret_val = False\n # define a tuple of the two variables without their domains\n var_tup = (x, y)\n # define lists of the variable's domains\n x_values = self.domains[x].copy()\n y_values = self... | [
"0.7254103",
"0.62908906",
"0.567439",
"0.5597688",
"0.53487086",
"0.5329222",
"0.5265961",
"0.51735663",
"0.5155395",
"0.5139437",
"0.51281583",
"0.5127078",
"0.50768644",
"0.49855748",
"0.49679717",
"0.49677834",
"0.49434954",
"0.49179846",
"0.4910346",
"0.48950416",
"0.488... | 0.61482406 | 2 |
Update `self.domains` such that each variable is arc consistent. If `arcs` is None, begin with initial list of all arcs in the problem. Otherwise, use `arcs` as the initial list of arcs to make consistent. Return True if arc consistency is enforced and no domains are empty; return False if one or more domains end up empty. | def ac3(self, arcs=None):
# print("Entered ac3 Function")
revise = False
if arcs is None:
arcs = set()
for arc in self.crossword.overlaps:
arcs.add(arc)
while arcs:
arc = arcs.pop()
# print("arc")
# print(arc)
revise = self.revise(arc[0], arc[1])
if revise:
arcs.update(self.crossword.neighbors(arc[0]))
if (self.domains[arc[0]] is None):
return False
# print("revise")
# print(revise)
# print("arc")
# print(arc)
# input()
# print("")
# print("")
# print("arcs")
# print(arcs)
# print("")
# print("")
return True
# raise NotImplementedError | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ac3(self, arcs=None):\n if arcs == None:\n #creates a queue of arcs to update\n arcs= []\n for node1 in self.domains:\n for node2 in self.domains:\n if node1 != node2:\n #for each pair of nodes that intersect, add ... | [
"0.7341803",
"0.69774306",
"0.6603775",
"0.58208483",
"0.5818385",
"0.55777776",
"0.55287546",
"0.5475581",
"0.5416812",
"0.53949845",
"0.5291726",
"0.5171484",
"0.51074433",
"0.5098393",
"0.5090242",
"0.5040056",
"0.49685684",
"0.49068654",
"0.48768777",
"0.48698935",
"0.486... | 0.6537715 | 3 |
Return True if `assignment` is complete (i.e., assigns a value to each crossword variable); return False otherwise. | def assignment_complete(self, assignment):
# print("Entered assignment_complete Function")
for var in assignment:
if assignment[var] is None:
return False
return self.consistent(assignment)
# raise NotImplementedError | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def assignment_complete(self, assignment):\n # for each variable in the crossword\n for variable in self.crossword.variables:\n # if the variable is not assigned a value\n if variable not in assignment:\n # the crossword is not complete\n return Fal... | [
"0.8660917",
"0.7774996",
"0.7236496",
"0.715314",
"0.6777561",
"0.67663616",
"0.6716149",
"0.6668017",
"0.6563448",
"0.65057194",
"0.64147335",
"0.6396104",
"0.6369181",
"0.63129765",
"0.63119334",
"0.6073311",
"0.6054601",
"0.603511",
"0.6031876",
"0.5906102",
"0.5893759",
... | 0.81902444 | 1 |
Return True if `assignment` is consistent (i.e., words fit in crossword puzzle without conflicting characters); return False otherwise. | def consistent(self, assignment):
# print("Entered consistent Function")
# print("assignment")
# print(assignment)
overlaps = self.crossword.overlaps
value_set = set()
for variable in assignment:
#checking overlaps with neighbors
neighbors = self.crossword.neighbors(variable)
for neighbor in neighbors:
overlap = overlaps[(variable, neighbor)]
if (neighbor in assignment):
# print("var 1 overlap letter")
# print(assignment[variable][overlap[0]])
# print("var 2 overlap letter")
# print(assignment[neighbor][overlap[1]])
if (assignment[variable][overlap[0]] is not assignment[neighbor][overlap[1]]):
return False
# print("neighbors")
# print(neighbors)
#checking that the assignment is the correct length for the variable
if (variable.length != len(assignment[variable])):
return False
#the set to check for distinct variables later
value_set.add(assignment[variable])
#Checking that all variables are distinct
#these should be the same length unless two or more variables share an value
if( len(value_set) is not len(assignment)):
return False
return True
# raise NotImplementedError | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def consistent(self, assignment):\n # for each of the current assignments\n for word in assignment:\n # if the word does not fit in the gaps\n if len(assignment[word]) != word.length:\n # reject attempt\n return False\n # if the word is a... | [
"0.8402212",
"0.8299707",
"0.702421",
"0.6465896",
"0.64497894",
"0.6389745",
"0.6059358",
"0.6028566",
"0.58353883",
"0.5827617",
"0.5789568",
"0.5764622",
"0.57099473",
"0.5694708",
"0.5602207",
"0.55700195",
"0.5525498",
"0.5517784",
"0.5466885",
"0.546393",
"0.54609096",
... | 0.83261746 | 1 |
Return a list of values in the domain of `var`, in order by the number of values they rule out for neighboring variables. The first value in the list, for example, should be the one that rules out the fewest values among the neighbors of `var`. | def order_domain_values(self, var, assignment):
# print("Entered order_domain_values Function")
ordered_variables = []
# print("Var")
# print(var)
# print("self.domains[var]")
# print(self.domains[var])
# print("self.crossword.neighbor(var)")
# print(self.crossword.neighbors(var))
neighbors_to_check = self.crossword.neighbors(var).difference(assignment.keys())
for word in self.domains[var]:
n = 0
for neighbor in neighbors_to_check:
overlap = self.crossword.overlaps[(var, neighbor)]
for neighbor_word in self.domains[neighbor]:
if ( word[overlap[0]] is not neighbor_word[overlap[1]] or word is neighbor_word):
n += 1
ordered_variables.append( (word, n) )
ordered_variables.sort(key=self.orderFunc)
# print("ordered_variables")
# print(ordered_variables)
# input()
return ordered_variables
# raise NotImplementedError | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def eliminate_from_neighbors(csp, var) :\n reduced = []\n val = csp.get_assigned_value(var)\n replacement = []\n for constraint in csp.constraints_between(var,None):\n var2 = constraint.var2\n domainCopy = csp.domains[var2][:]\n numLeft = len(domainCopy)\n if (val!=None):\n ... | [
"0.65513057",
"0.6346596",
"0.62824583",
"0.6041415",
"0.60353327",
"0.6032189",
"0.5999635",
"0.58770275",
"0.5836044",
"0.57163435",
"0.55799633",
"0.5501954",
"0.5491494",
"0.5456138",
"0.54167825",
"0.53648853",
"0.53506935",
"0.5325021",
"0.53222",
"0.5308232",
"0.529167... | 0.54332227 | 14 |
Return an unassigned variable not already part of `assignment`. Choose the variable with the minimum number of remaining values in its domain. If there is a tie, choose the variable with the highest degree. If there is a tie, any of the tied variables are acceptable return values. | def select_unassigned_variable(self, assignment):
# print("Entered select_unassigned_variable Function")
# print("Assignment")
# print(assignment)
variables = set()
variables.update(self.domains.keys())
unassigned_variables = set()
unassigned_variables.update(variables.difference(assignment.keys()))
# print("All Variables")
# print(variables)
# print("Unassigned Variables")
# print(unassigned_variables)
# This chooses the variables with the smallest domain from this list (unassigned_variables)
var_list = []
for variable in unassigned_variables:
var_list.append( (variable, len(self.domains[variable]), len(self.crossword.neighbors(variable)) ) )
var_list.sort(key = self.sort_by_domain)
var_list.sort(reverse=True, key = self.sort_by_neighbors)
# print("var_list")
# print(var_list)
return var_list[0][0]
# raise NotImplementedError | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def select_unassigned_variable(self, assignment):\n var_list= []\n #add unassigned variabled to a list along with the number of words left in its domain\n for var in self.domains:\n if var not in assignment:\n var_list.append((var, len(self.domains[var])))\n #s... | [
"0.80119693",
"0.7859947",
"0.76820076",
"0.7355518",
"0.71462846",
"0.703895",
"0.703833",
"0.6703648",
"0.6678851",
"0.65556186",
"0.6266142",
"0.61606276",
"0.6047509",
"0.6028325",
"0.5978296",
"0.5843578",
"0.5655437",
"0.56006765",
"0.55530095",
"0.5532206",
"0.55234164... | 0.77794665 | 2 |
Using Backtracking Search, take as input a partial assignment for the crossword and return a complete assignment if possible to do so. `assignment` is a mapping from variables (keys) to words (values). If no assignment is possible, return None. | def backtrack(self, assignment):
# print("Entered backtrack Function")
# Check if assignment is complete
if len(assignment) == len(self.domains):
return assignment
# Try a new variable
var = self.select_unassigned_variable(assignment)
word_list = self.order_domain_values(var, assignment)
for word in word_list:
new_assignment = assignment.copy()
new_assignment[var] = word[0]
if self.consistent(new_assignment):
result = self.backtrack(new_assignment)
if result is not None:
return result
return None
# raise NotImplementedError | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def backtrack(self, assignment):\n # if the assignment is complete\n if self.assignment_complete(assignment):\n # return the assignment, crossword is complete\n return assignment\n # pick a variable to try to assign\n var = self.select_unassigned_variable(assignmen... | [
"0.7360267",
"0.70080864",
"0.6352615",
"0.62211263",
"0.6217823",
"0.6217823",
"0.5960085",
"0.59551066",
"0.5912701",
"0.58554476",
"0.5837058",
"0.5765993",
"0.57650095",
"0.5723373",
"0.55428743",
"0.5452668",
"0.5425594",
"0.5342919",
"0.53365654",
"0.5329358",
"0.532841... | 0.70967716 | 1 |
Loads data for a specific game map level. | def load_data(self, map_name, grid_name, tp_name):
self.map= TiledMap(path.join(self.map_folder, map_name))
self.map_img = self.map.make_map()
self.map_img2 = self.map_img
#self.noisy_map_img = noisy("gauss", pg.surfarray.array3d(self.map_img))
self.noisy_map_img = make_noisy(pg.surfarray.array3d(self.map_img))
self.map_rect = self.map_img.get_rect()
with open(path.join(self.map_folder, tp_name), 'rt') as f:
# destinations is a dict mapping each tilemap teleport coordinate to
# the destination tilemap coordinate
self.destinations = eval(f.read())
self.grid= OccupancyGrid(self, path.join(self.map_folder, grid_name)) #down here because it needs destinations
self.graph = self.grid.make_graph()
#sounds
self.wall_channel=pg.mixer.Channel(0)
self.wall_sound=pg.mixer.Sound(WALL_THUD_SOUND)
self.teleport_channel=pg.mixer.Channel(1)
self.teleport_sound=pg.mixer.Sound(TELEPORT_SOUND) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_map(self):\n # ask for a new level(str)\n answer = simpledialog.askstring(\"Input\", \"Please input a level\",\n parent=self._master)\n if answer is not None:\n if answer in self._level_dic.keys(): # ensure the level exist\n ... | [
"0.74006486",
"0.6749682",
"0.62063956",
"0.6168153",
"0.597027",
"0.59682465",
"0.58968747",
"0.5858254",
"0.57994854",
"0.57971156",
"0.57004493",
"0.5693509",
"0.56794953",
"0.5672299",
"0.5622653",
"0.5604859",
"0.56037986",
"0.5574898",
"0.5534123",
"0.5477678",
"0.54526... | 0.59912586 | 4 |
Initialize and setup a new maze level. | def new(self):
#groups for drawing
self.moving_sprites = pg.sprite.LayeredUpdates()
self.static_sprites = pg.sprite.LayeredUpdates()
#other groups
self.walls = pg.sprite.Group()
self.teleports = pg.sprite.Group()
self.win = pg.sprite.Group()
self.threat = pg.sprite.Group()
self.hearts= pg.sprite.Group()
for tile_object in self.map.tmxdata.objects:
if tile_object.name == "player":
self.player = Player(self, tile_object.x, tile_object.y)
if tile_object.name == "monster":
self.monster = Monster(self, tile_object.x, tile_object.y)
if tile_object.name == "wall":
Obstacle(self, tile_object.x, tile_object.y, tile_object.width, tile_object.height)
if tile_object.name == "mirror":
Mirror(self, tile_object.x, tile_object.y, tile_object.width, tile_object.height, self.destinations)
if tile_object.name == "pentagram":
self.goal=Pentagram(self, tile_object.x, tile_object.y, tile_object.width, tile_object.height)
self.camera = Camera(self.map.width, self.map.height)
#static sprites
self.flashlight=Flashlight(self, int(WIDTH/2), int(HEIGHT/2))
self.darkness=Darkness(self, int(WIDTH/2), int(HEIGHT/2))
if self.minimap_name != None:
self.minimap=Minimap(self, self.minimap_name)
for i in range(int(PLAYERHEALTH/10)):
Heart(self, 726-37*(2-i), 20)
self.battery= Battery(self, 726, 52)
self.draw_debug = False
self.teleport_list=[]
for tele in self.teleports:
self.teleport_list.append(tele) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def init_position():\n __maze.init_position()",
"def setUp(self):\n\n self.m=Maze()",
"def __init__(self, maze, population_size):\n self.maze = maze\n self.population_size = population_size",
"def setupLevel(self):\n\n self.state = GameState.SETUP\n\n # vado a leggere il... | [
"0.7217811",
"0.7040007",
"0.6914307",
"0.68994147",
"0.6807719",
"0.67093295",
"0.67023313",
"0.6577321",
"0.6552819",
"0.6521437",
"0.651588",
"0.634067",
"0.6334667",
"0.6277603",
"0.62732935",
"0.6267083",
"0.62319756",
"0.6219",
"0.6209007",
"0.6164258",
"0.6150346",
"... | 0.0 | -1 |
Runs the Mazescape game. | def run(self):
#game loop set self.playing to False to end game
self.playing = True
while self.playing:
self.dt = self.clock.tick(FPS) / 1000
self.events()
self.update()
self.draw()
self.losing_sequence() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n g = Game(800, 600)\n g.start()",
"def main():\n g = DemoGame(800, 600)\n g.start()",
"def main():\n game = RiichiMahjongApp()\n game.run()",
"def run(self):\n print(\"WELCOME TO MINESWEEPER!\")\n\n\n while True:\n\n self.get_input()\n start_... | [
"0.6874502",
"0.6857758",
"0.68047696",
"0.6561532",
"0.6534774",
"0.64771336",
"0.64398795",
"0.63985527",
"0.638074",
"0.63475657",
"0.6324274",
"0.6295392",
"0.6273534",
"0.62623614",
"0.6261345",
"0.62363064",
"0.6226019",
"0.621045",
"0.61986893",
"0.6194582",
"0.6194038... | 0.0 | -1 |
Quits the Mazescape game | def quit_game(self):
pg.quit()
sys.exit() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _quit(self) -> None:\n self._show_bag(True)\n print(\"Thanks for playing!\")\n exit()",
"def qpressed(): #QUITTNG FUNCTION\n #print(\"q pressed\")\n sys.exit()",
"def __quit(self):\n self.clear_screen()\n self.__print_logo()\n print('\\n'*3)\n self.coo... | [
"0.6897181",
"0.6780871",
"0.6693137",
"0.65562737",
"0.65255046",
"0.6351009",
"0.6307511",
"0.6168882",
"0.61455756",
"0.61273867",
"0.61242676",
"0.61096215",
"0.60773265",
"0.60688776",
"0.6056135",
"0.6048833",
"0.6048833",
"0.6048833",
"0.6034417",
"0.6029101",
"0.60159... | 0.62268347 | 7 |
Catches all gamerelated events | def events(self):
# catch all events here
for event in pg.event.get():
if event.type == pg.QUIT:
self.quit_game()
if event.type == pg.KEYDOWN:
if event.key == pg.K_ESCAPE:
menu.paused = True
menu.pause_menu() #code gets stuck in this call until a button is pressed in the pause menu
self.clock=pg.time.Clock()
if event.key == pg.K_h:
self.draw_debug = not self.draw_debug
if event.key == pg.K_o:
if self.flashlight.on:#turning off flashlight
self.darkness.on = True
self.battery.duration-=pg.time.get_ticks()-self.battery.last_update
self.flashlight.on=False
else: #turning on flashlight
self.darkness.on = False
self.battery.last_update=pg.time.get_ticks()
self.flashlight.on=True
#darkness condition
if self.transition:
self.darkness_transition(self.player)
self.kidnap(self.player)
# win condition
if pg.sprite.spritecollide(self.player, self.win, False, collide_hit_rect):
menu.win_menu()
#got hit condition
hit=pg.sprite.spritecollide(self.player, self.threat, False, collide_hit2_rect)
if hit:
self.hit(self.player, hit[0])
#mirror
self.portal(self.player)
self.portal(self.monster) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __handle_events(self):\r\n for event in pygame.event.get():\r\n self.controller.handle_event(event)",
"def process_events(self):\n gameevents = copy.copy(self.gameevents)\n del self.gameevents[:]\n while len(gameevents) > 0:\n currentevent = gameevents.pop(0)... | [
"0.68227965",
"0.6619201",
"0.65891063",
"0.64815664",
"0.641884",
"0.6384413",
"0.616646",
"0.6130458",
"0.6088237",
"0.6078368",
"0.60664743",
"0.60335886",
"0.60190856",
"0.59726304",
"0.59557456",
"0.59455985",
"0.5929909",
"0.59173644",
"0.59143096",
"0.5911435",
"0.5911... | 0.54172313 | 66 |
Updates the frame of the game | def update(self):
self.moving_sprites.update()
self.static_sprites.update()
self.camera.update(self.player) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_display(self):\r\n\r\n # The display.update() Updates the screen, making the new frame replace the old one. \r\n pg.display.update()\r\n \r\n # clock.tick sets a framerate for the game.\r\n # This is to make the game run at a stable fps \r\n self.clock.tick(cng.... | [
"0.75599945",
"0.74793476",
"0.7177903",
"0.7115879",
"0.70343995",
"0.6902082",
"0.6901963",
"0.6897741",
"0.6863001",
"0.6841528",
"0.681301",
"0.68126184",
"0.6780625",
"0.6780625",
"0.67711943",
"0.6767823",
"0.67476755",
"0.6745845",
"0.6714142",
"0.6668295",
"0.6652482"... | 0.638703 | 52 |
Draws a grid onto the map | def draw_grid(self):
for x in range(0, WIDTH, TILESIZE):
pg.draw.line(self.screen, LIGHTGREY, (x, 0), (x, HEIGHT))
for y in range(0, HEIGHT, TILESIZE):
pg.draw.line(self.screen, LIGHTGREY, (0, y), (WIDTH, y)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def drawGrid(self):\n\n if self.orientation == \"isometric\":\n for vline in range(0, self.map_array.shape[0]):\n line = self.canvas.create_line(iso(vline*self.cell_width, 0),\n iso(vline*self.cell_width, self.map_array.shape[0]*self.ce... | [
"0.8058154",
"0.78003556",
"0.76907337",
"0.76755744",
"0.75905925",
"0.7454775",
"0.7441136",
"0.73149663",
"0.7275913",
"0.7247664",
"0.719331",
"0.71902335",
"0.7187785",
"0.7140632",
"0.71196425",
"0.7098102",
"0.70582795",
"0.7006399",
"0.70051944",
"0.69672275",
"0.6918... | 0.7732143 | 2 |
Draws the given map level by layering all the sprites. | def draw(self):
pg.display.set_caption("{:.2f}".format(self.clock.get_fps()))
if distance(self.player.pos, self.monster.pos)<MONSTER_BUBBLE_DISTANCE:
now=pg.time.get_ticks()
if self.fuzz:
wait=NOISE_DURATION
else:
wait=NOISE_TIMESTEP #change to a function of distance to monster
if now - self.last_update_noise>wait:
self.last_update_noise=now
if self.fuzz:
self.map_img2=self.map_img
else:
self.map_img2=self.noisy_map_img
#make static sound
self.fuzz=not self.fuzz
else:
self.map_img2=self.map_img
self.fuzz=False
self.screen.blit(self.map_img2, self.camera.apply_rect(self.map_rect))
# Layer player and monsters on map
for sprite in self.moving_sprites:
self.screen.blit(sprite.image, self.camera.apply(sprite))
if self.draw_debug:
pg.draw.rect(self.screen, LIGHTBLUE, self.camera.apply_rect(sprite.hit_rect), 1)
if self.draw_debug:
for wall in self.walls:
pg.draw.rect(self.screen, LIGHTBLUE, self.camera.apply_rect(wall.rect), 1)
for mirror in self.teleports:
pg.draw.rect(self.screen, LIGHTBLUE, self.camera.apply_rect(mirror.rect), 1)
for goal in self.win:
pg.draw.rect(self.screen, LIGHTBLUE, self.camera.apply_rect(goal.rect), 1)
dest=(self.monster.next_step[0]*TILESIZE, self.monster.next_step[1]*TILESIZE)
next_step=pg.Rect(0, 0, 20, 20)
next_step.center=dest
pg.draw.rect(self.screen, LIGHTBLUE, self.camera.apply_rect(next_step), 1)
for sprite in self.static_sprites:
self.screen.blit(sprite.image, sprite.rect)
pg.display.flip() #update the full display surface to the screen | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def draw_level(self):\r\n self.level_surface.blit(self.map_image, self.viewport, self.viewport)\r\n self.level_surface.blit(self.title_box, self.title_rect)",
"def render(self):\n\n self.baseMap.beginDraw()\n self.baseMap.background(255)\n self.baseMap.endDraw()\n\n numC... | [
"0.7113351",
"0.67336434",
"0.6681045",
"0.666561",
"0.6655747",
"0.66555613",
"0.6489397",
"0.6463894",
"0.63418233",
"0.63139254",
"0.6242701",
"0.6222603",
"0.6166904",
"0.61456466",
"0.6123982",
"0.61208385",
"0.6078546",
"0.6004719",
"0.5968714",
"0.5968446",
"0.5951832"... | 0.5628971 | 44 |
Draws text onto a given surface. | def draw_text(self, text, font, color, surface, x, y): #use for narrative in end sequence
text_obj = font.render(text, True, color)
text_rect = text_obj.get_rect()
text_rect.center = (x, y)
surface.blit(text_obj, text_rect) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def draw_text(screen, font, text, surfacewidth, surfaceheight):\n\tfw, fh = font.size(text) # fw: font width, fh: font height\n\tsurface = font.render(text, True, (0, 0, 255))\n\t# // makes integer division in python3 \n\tscreen.blit(surface, (0,0))",
"def drawText(text, font, surface, x, y, textcolour):\r\n ... | [
"0.8523884",
"0.8420744",
"0.82012075",
"0.81627655",
"0.80817306",
"0.7885264",
"0.78392565",
"0.78264725",
"0.7806616",
"0.77619326",
"0.77171636",
"0.7670391",
"0.7642468",
"0.7597258",
"0.7542746",
"0.7457794",
"0.745692",
"0.7357429",
"0.7349292",
"0.7319174",
"0.729991"... | 0.85818034 | 0 |
Split the file and save chunks to separate files | def split(self):
print 'Splitting file', self.__filename
print 'Number of chunks', self.__numchunks, '\n'
try:
f = open(self.__filename, 'rb')
except (OSError, IOError), e:
raise FileSplitterException, str(e)
bname = (os.path.split(self.__filename))[1]
# Get the file size
fsize = os.path.getsize(self.__filename)
# Get size of each chunk
self.__chunksize = int(float(fsize)/float(self.__numchunks))
chunksz = self.__chunksize
total_bytes = 0
for x in range(self.__numchunks):
chunkfilename = bname + '-' + str(x+1) + self.__postfix
# if reading the last section, calculate correct
# chunk size.
if x == self.__numchunks - 1:
chunksz = fsize - total_bytes
try:
print 'Writing file',chunkfilename
data = f.read(chunksz)
total_bytes += len(data)
chunkf = file(chunkfilename, 'wb')
chunkf.write(data)
chunkf.close()
except (OSError, IOError), e:
print e
continue
except EOFError, e:
print e
break
print 'Done.' | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def split_file(self, input_file):\r\n file_list = [] \r\n with open(input_file, 'r', encoding='GB18030', errors='ignore') as f_in:\r\n data = f_in.readlines()\r\n lines_num = len(data)\r\n size = lines_num // self.num_workers # lines splitted in a chunk\r\n ... | [
"0.73668265",
"0.70914865",
"0.7090537",
"0.7067825",
"0.7001469",
"0.68641955",
"0.67107993",
"0.65979683",
"0.65870893",
"0.6580552",
"0.6572284",
"0.65702844",
"0.6551708",
"0.64280057",
"0.6383532",
"0.6352524",
"0.63487375",
"0.629163",
"0.62073165",
"0.6201502",
"0.6150... | 0.745905 | 0 |
Combine existing chunks to recreate the file. The chunks must be present in the cwd. The new file will be written to cwd. | def combine(self):
import re
print 'Creating file', self.__filename
bname = (os.path.split(self.__filename))[1]
bname2 = bname
# bugfix: if file contains characters like +,.,[]
# properly escape them, otherwise re will fail to match.
for a, b in zip(['+', '.', '[', ']','$', '(', ')'],
['\+','\.','\[','\]','\$', '\(', '\)']):
bname2 = bname2.replace(a, b)
chunkre = re.compile(bname2 + '-' + '[0-9]+')
chunkfiles = []
for f in os.listdir("."):
print f
if chunkre.match(f):
chunkfiles.append(f)
print 'Number of chunks', len(chunkfiles), '\n'
chunkfiles.sort(self.sort_index)
data=''
for f in chunkfiles:
try:
print 'Appending chunk', os.path.join(".", f)
data += open(f, 'rb').read()
except (OSError, IOError, EOFError), e:
print e
continue
try:
f = open(bname, 'wb')
f.write(data)
f.close()
except (OSError, IOError, EOFError), e:
raise FileSplitterException, str(e)
print 'Wrote file', bname | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def merge_vcf_chunks(out_dir, path_name, path_size, chunks, overwrite):\n vcf_path = os.path.join(out_dir, path_name + \".vcf\")\n if overwrite or not os.path.isfile(vcf_path):\n first = True\n for chunk_i, chunk in enumerate(chunks):\n clip_path = chunk_base_name(path_name, out_dir,... | [
"0.65807515",
"0.6522695",
"0.5830749",
"0.56331223",
"0.5603233",
"0.55737466",
"0.5561251",
"0.5557075",
"0.5543502",
"0.55282074",
"0.5523479",
"0.55110836",
"0.547458",
"0.54524946",
"0.5427168",
"0.54180014",
"0.5275911",
"0.5269838",
"0.52052176",
"0.5198629",
"0.518618... | 0.6982434 | 0 |
Returns an OAuth2 authorization token or None in case of errors. This is the flow for nonweb clients. | def get_token(client_id, client_secret, username, password):
try:
if oauth2db.check_client(client_id, client_secret):
if oauth2db.check_user(username, password):
token, refresh = oauth2db.generate_token(client_id, username)
res = { "token": token }
except:
res = { "error": "" }
if 'token' in res:
return res['token']
else:
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate_auth():\n try:\n token = oidc.get_access_token()\n except TypeError:\n # raised when the token isn't accessible to the oidc lib\n raise Unauthorized(\"missing auth token\")\n\n if not oidc.validate_token(token):\n terminate_session()\n raise Unauthorized(\"i... | [
"0.6736975",
"0.672694",
"0.6723241",
"0.667107",
"0.66542256",
"0.66330796",
"0.6596639",
"0.6589812",
"0.6496207",
"0.6487768",
"0.64865583",
"0.6483437",
"0.64788604",
"0.6448414",
"0.6448318",
"0.6448318",
"0.6439682",
"0.641158",
"0.6389883",
"0.63766307",
"0.63674885",
... | 0.64407897 | 16 |
Returns a new valid token or None, in case of error. | def refresh_token(refresh_token):
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_token(self):\n if not self.is_valid():\n logger.warn(\"TokenWall form data is not valid.\")\n return None\n \n tt = self.cleaned_data['token']\n logger.debug(\"Looking for token '%s'\"%tt)\n return Token.objects.get(value=tt)",
"def token(self) -> Toke... | [
"0.68337315",
"0.6518242",
"0.63705957",
"0.63319176",
"0.6099937",
"0.6092421",
"0.60620815",
"0.6054427",
"0.60395783",
"0.60344374",
"0.5973788",
"0.59650373",
"0.5948255",
"0.5936152",
"0.5906422",
"0.5888766",
"0.5868331",
"0.58436376",
"0.5830226",
"0.58285004",
"0.5814... | 0.0 | -1 |
two keras Model instances are equal enough | def assert_models_equal(first, second):
# layer names and settings
assert first.get_config() == second.get_config()
# model weights
assert len(first.get_weights()) == len(second.get_weights())
for w1, w2 in zip(first.get_weights(), second.get_weights()):
np.testing.assert_array_equal(w1, w2)
# optimizer
assert first.optimizer.get_config() == second.optimizer.get_config() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_second_keras_model_created():\n X, _, _, _ = get_data()\n tf.random.set_seed(12345)\n initializer = tf.keras.initializers.Zeros()\n input_data = Input(shape=X[0].shape)\n xx = Dense(128, activation=\"relu\", kernel_initializer=initializer)(input_data)\n xx = Dense(128, activation=\"relu\... | [
"0.72829473",
"0.72438365",
"0.7227518",
"0.7076971",
"0.6773338",
"0.6756114",
"0.6642388",
"0.6548654",
"0.6545828",
"0.6540332",
"0.65398526",
"0.6519682",
"0.65037364",
"0.6483842",
"0.64417934",
"0.64361674",
"0.6423497",
"0.636907",
"0.6350753",
"0.63441813",
"0.6334493... | 0.7113716 | 3 |
two BaseWrapper instances are equal enough | def assert_wrappers_equal(first, second):
assert first.sk_params == second.sk_params
assert first.history_ == second.history_
if not first.model_ or not second.model_:
assert first.model_ == second.model_
else:
assert_models_equal(first.model, second.model) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_inheritedClassesEquality(self):\n self.assertTrue(Record(1, 2) == DerivedRecord(1, 2))\n self.assertFalse(Record(1, 2) == DerivedRecord(1, 3))\n self.assertFalse(Record(1, 2) == DerivedRecord(2, 2))\n self.assertFalse(Record(1, 2) == DerivedRecord(3, 4))",
"def test_identical... | [
"0.6653726",
"0.6650997",
"0.65729487",
"0.64894223",
"0.6444425",
"0.64114064",
"0.63375264",
"0.63026255",
"0.6292803",
"0.6269224",
"0.6257633",
"0.6256101",
"0.62419796",
"0.62266093",
"0.6213192",
"0.6190846",
"0.6179785",
"0.6126253",
"0.61250675",
"0.6109466",
"0.60955... | 0.67075044 | 0 |
two BaseWrapper instances return same predictions | def assert_predictions_equal(first, second, x):
preds1 = first.predict(x, batch_size=batch_size)
preds2 = second.predict(x, batch_size=batch_size)
np.testing.assert_array_equal(preds1, preds2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def assert_wrappers_equal(first, second):\n assert first.sk_params == second.sk_params\n assert first.history_ == second.history_\n if not first.model_ or not second.model_:\n assert first.model_ == second.model_\n else:\n assert_models_equal(first.model, second.model)",
"def predict(se... | [
"0.5750074",
"0.57188416",
"0.5443609",
"0.5316026",
"0.52933276",
"0.5275967",
"0.52627426",
"0.5258058",
"0.5199715",
"0.51438063",
"0.5142573",
"0.51336676",
"0.51235074",
"0.5116406",
"0.5077794",
"0.5052014",
"0.50518346",
"0.50518346",
"0.50518346",
"0.5041546",
"0.5040... | 0.5298379 | 4 |
The name of the variable in which the list of all arguments to the function is stored | def name(self):
return self._name | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_arg_name(self, arg, variable_name):",
"def _name(self):\n return self.arguments[0].split('(')[0]",
"def _name(self):\n return self._arguments[0].split('(')[0]",
"def func_var_names(func):\n names = func.__code__.co_varnames[:func.__code__.co_argcount]\n return names",
"def ... | [
"0.74990004",
"0.69113594",
"0.6881187",
"0.67148364",
"0.6657547",
"0.6623787",
"0.6606068",
"0.6556822",
"0.65215355",
"0.6428388",
"0.64085597",
"0.63898975",
"0.6327654",
"0.6321967",
"0.63197297",
"0.6268201",
"0.6252624",
"0.6248424",
"0.6245552",
"0.6207349",
"0.620119... | 0.0 | -1 |
The names of the arguments to the function which are contained in the PyArgKeywords list | def arg_names(self):
return self._arg_names | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def names(self):\n result = []\n result.extend(self.positional_arguments)\n if self.arbitary_positional_arguments is not None:\n result.append(self.arbitary_positional_arguments)\n if self.arbitary_keyword_arguments is not None:\n result.append(self.arbitary_keywor... | [
"0.7080962",
"0.69528246",
"0.6950511",
"0.6814684",
"0.68055576",
"0.67487407",
"0.6712614",
"0.6712274",
"0.6702668",
"0.6666874",
"0.6628423",
"0.66158634",
"0.6563383",
"0.64373004",
"0.64143133",
"0.6394061",
"0.6304303",
"0.6285481",
"0.6278419",
"0.6258944",
"0.6256494... | 0.6993237 | 1 |
Return the needed flag to parse or build value | def get_pytype(self, c_arg, parse_arg):
if isinstance(c_arg, FunctionAddress):
return 'O'
else:
try:
return pytype_parse_registry[(parse_arg.dtype, parse_arg.precision)]
except KeyError as e:
raise NotImplementedError("Type not implemented for argument collection : "+str(type(parse_arg))) from e | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getOption(arg):\n return (False, \"\", \"\")",
"def get_parsed_flags():\n return Flags.parsed_args",
"def _parse_env_value(val):\n if val.lower() == \"false\":\n return False\n elif val.lower() == \"true\":\n return True\n try:\n return int(val)\n except ValueError:\n ... | [
"0.6345531",
"0.62959224",
"0.6244244",
"0.6242397",
"0.6095011",
"0.60254776",
"0.5950006",
"0.5894679",
"0.58870685",
"0.5881222",
"0.5880513",
"0.57614744",
"0.57475334",
"0.57326",
"0.5719314",
"0.5702136",
"0.5597625",
"0.55545485",
"0.55461335",
"0.55367213",
"0.5492313... | 0.0 | -1 |
The variable containing all positional arguments passed to the function | def pyarg(self):
return self._pyarg | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getPositionalArgs():",
"def get_args(self):\r\n return self.args",
"def punkte(self):\n return self.args",
"def args(self) -> tuple[Basic, ...]:\n return self._args",
"def args(self):\n return self._args",
"def args(self):\n return self._args",
"def args(self):\n ... | [
"0.785117",
"0.7138741",
"0.7081171",
"0.6903433",
"0.6763262",
"0.6763262",
"0.6763262",
"0.6745838",
"0.67380923",
"0.6622345",
"0.65949064",
"0.65869516",
"0.65081775",
"0.64930344",
"0.64645815",
"0.6435059",
"0.6429822",
"0.6423793",
"0.6422557",
"0.6418105",
"0.6416629"... | 0.61285037 | 62 |
The variable containing all keyword arguments passed to the function | def pykwarg(self):
return self._pykwarg | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_kwargs():\n\treturn get_kwargs_raw(sys.argv)",
"def get_used_kwargs(self):\n return self._used_kwargs",
"def get_keyword_args(function):\n argspec = inspect.getargspec(function)\n kwargs = argspec.args[len(argspec.args) - len(argspec.defaults):]\n kwargs = {arg: value for arg, value in ... | [
"0.6939219",
"0.6754662",
"0.66321796",
"0.659612",
"0.6564183",
"0.64470226",
"0.64470226",
"0.64356077",
"0.6427776",
"0.64146596",
"0.63882744",
"0.63835824",
"0.6379224",
"0.6308331",
"0.62969697",
"0.62953955",
"0.62880987",
"0.62775856",
"0.62775856",
"0.6273936",
"0.62... | 0.6603397 | 3 |
The flags indicating the types of the objects to be collected from the python arguments passed to the function | def flags(self):
return self._flags | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_check_types():",
"def format_flags(self):\n flags = []\n if self.is_unique:\n flags.append('Unique')\n if self.is_weak:\n flags.append('Weak')\n if self.is_ctor:\n flags.append('Constructor')\n if self.is_warning:\n flags.appe... | [
"0.5989417",
"0.5906855",
"0.5896243",
"0.5705391",
"0.5656125",
"0.5627852",
"0.55817276",
"0.5562059",
"0.5550938",
"0.5473497",
"0.5464566",
"0.5436748",
"0.5415903",
"0.54050153",
"0.53860885",
"0.53617835",
"0.53323925",
"0.5305332",
"0.53010184",
"0.5295375",
"0.5273713... | 0.0 | -1 |
The arguments into which the python args and kwargs are collected | def args(self):
return self._parse_args | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def preprocess_arguments(self, *args, **kwargs):\n return (args, kwargs)",
"def get_all_arguments(self):\n args, varargs, keyword, defaults = inspect.getargspec(self.exec_obj)\n if args.count('self') > 0:\n args.remove('self')\n return args",
"def args(self):\n ret... | [
"0.7451631",
"0.72647053",
"0.72190857",
"0.7194664",
"0.71847206",
"0.71847206",
"0.71847206",
"0.7184045",
"0.71487767",
"0.697183",
"0.6968741",
"0.69624984",
"0.69224155",
"0.6873307",
"0.68517804",
"0.68445677",
"0.6818598",
"0.68127906",
"0.6803711",
"0.6803707",
"0.677... | 0.7118921 | 9 |
The PyArgKeywords object which contains all the names of the function's arguments | def arg_names(self):
return self._arg_names | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_keyword_args(function):\n argspec = inspect.getargspec(function)\n kwargs = argspec.args[len(argspec.args) - len(argspec.defaults):]\n kwargs = {arg: value for arg, value in zip(kwargs, argspec.defaults)}\n return kwargs",
"def names(self):\n result = []\n result.extend(self.pos... | [
"0.6879302",
"0.6823232",
"0.6740888",
"0.6619218",
"0.6581217",
"0.6491079",
"0.64394325",
"0.6434128",
"0.63784575",
"0.6353484",
"0.6328109",
"0.6305639",
"0.6271534",
"0.62503344",
"0.61853814",
"0.61465836",
"0.61248285",
"0.60984993",
"0.60940886",
"0.6034932",
"0.60102... | 0.660815 | 4 |
Create FunctionDef responsible for casting python argument to C | def Python_to_C(c_object):
try :
cast_function = py_to_c_registry[(c_object.dtype, c_object.precision)]
except KeyError:
errors.report(PYCCEL_RESTRICTION_TODO, symbol=c_object.dtype,severity='fatal')
cast_func = FunctionDef(name = cast_function,
body = [],
arguments = [Variable(dtype=PyccelPyObject(), name = 'o', is_pointer=True)],
results = [Variable(dtype=c_object.dtype, name = 'v', precision = c_object.precision)])
return cast_func | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def C_to_Python(c_object):\n try :\n cast_function = c_to_py_registry[(c_object.dtype, c_object.precision)]\n except KeyError:\n errors.report(PYCCEL_RESTRICTION_TODO, symbol=c_object.dtype,severity='fatal')\n\n cast_func = FunctionDef(name = cast_function,\n body ... | [
"0.70022583",
"0.67676306",
"0.6716482",
"0.65700346",
"0.6408847",
"0.6320961",
"0.6177105",
"0.61178625",
"0.609686",
"0.60915",
"0.6037971",
"0.60285324",
"0.5978813",
"0.5958597",
"0.59014344",
"0.58797467",
"0.58504516",
"0.58494455",
"0.5848168",
"0.5846862",
"0.5815121... | 0.7423723 | 0 |
Create FunctionDef responsible for casting c argument to python | def C_to_Python(c_object):
try :
cast_function = c_to_py_registry[(c_object.dtype, c_object.precision)]
except KeyError:
errors.report(PYCCEL_RESTRICTION_TODO, symbol=c_object.dtype,severity='fatal')
cast_func = FunctionDef(name = cast_function,
body = [],
arguments = [Variable(dtype=c_object.dtype, name = 'v', precision = c_object.precision)],
results = [Variable(dtype=PyccelPyObject(), name = 'o', is_pointer=True)])
return cast_func | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Python_to_C(c_object):\n try :\n cast_function = py_to_c_registry[(c_object.dtype, c_object.precision)]\n except KeyError:\n errors.report(PYCCEL_RESTRICTION_TODO, symbol=c_object.dtype,severity='fatal')\n cast_func = FunctionDef(name = cast_function,\n body = ... | [
"0.72192234",
"0.68052465",
"0.6632314",
"0.64130855",
"0.6358928",
"0.63258225",
"0.6155145",
"0.6139662",
"0.60484755",
"0.60477465",
"0.60254824",
"0.6015706",
"0.59863913",
"0.59403557",
"0.58158",
"0.57880235",
"0.57846373",
"0.5784282",
"0.5761604",
"0.57465273",
"0.573... | 0.69464856 | 1 |
Generate function Call of c/python api PyErr_SetString | def PyErr_SetString(exception, message):
func = FunctionDef(name = 'PyErr_SetString',
body = [],
arguments = [Variable(dtype = PyccelPyObject(), name = 'o'),
Variable(dtype = NativeString(), name = 's')],
results = [])
exception = Variable(PyccelPyObject(), name = exception)
return FunctionCall(func, [exception, message]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def failure_code(sub):\r\n return '''{\r\n %(failure_var)s = %(id)s;\r\n if (!PyErr_Occurred()) {\r\n PyErr_SetString(PyExc_RuntimeError,\r\n \"Unexpected error in an Op's C code. \"\r\n \"No Python exception was set.\");\r\n }\r\n goto __... | [
"0.60588336",
"0.5961557",
"0.58332723",
"0.5556526",
"0.55433345",
"0.54902726",
"0.5450629",
"0.5449993",
"0.5403903",
"0.53904366",
"0.53624654",
"0.533152",
"0.53102547",
"0.529605",
"0.52905834",
"0.52848315",
"0.52823675",
"0.5257808",
"0.5237709",
"0.52302915",
"0.5175... | 0.7551365 | 0 |
Generate TypeError exception from the variable information (datatype, precision) | def generate_datatype_error(variable):
dtype = variable.dtype
if isinstance(dtype, NativeBool):
precision = ''
if isinstance(dtype, NativeComplex):
precision = '{} bit '.format(variable.precision * 2 * 8)
else:
precision = '{} bit '.format(variable.precision * 8)
message = '"Argument must be {precision}{dtype}"'.format(
precision = precision,
dtype = variable.dtype)
return PyErr_SetString('PyExc_TypeError', message) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_value_error_for_computing_missing_type():\n with pytest.raises(ValueError):\n compute_type(\"missing_type\", {})",
"def test_type_error(self):\n self._error_test(TypeError)",
"def test_invalid_expression_type(self, parse_input_mocked_metadata):\n with pytest.raises(TypeError, m... | [
"0.6931209",
"0.6566379",
"0.6381943",
"0.63050914",
"0.62194294",
"0.61516786",
"0.6136856",
"0.61005616",
"0.60737664",
"0.60367274",
"0.60167736",
"0.6010583",
"0.6010164",
"0.5982661",
"0.59672403",
"0.59668577",
"0.59405553",
"0.5933665",
"0.5899024",
"0.5894452",
"0.588... | 0.81578225 | 0 |
Create FunctionCall responsible for checking python argument data type | def scalar_object_check(py_object, c_object):
try :
check_type = check_type_registry[c_object.dtype, c_object.precision]
except KeyError:
errors.report(PYCCEL_RESTRICTION_TODO, symbol=c_object.dtype,severity='fatal')
check_func = FunctionDef(name = check_type,
body = [],
arguments = [Variable(dtype=PyccelPyObject(), name = 'o', is_pointer=True)],
results = [Variable(dtype=NativeBool(), name = 'r')])
return FunctionCall(check_func, [py_object]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def CheckType(self, *args, **kwargs):\n pass",
"def check_input_type(func):\n @functools.wraps(func)\n def wrapper_check_input_type(*args):\n new_args = []\n for X in list(args):\n new_args.append(_check_type(X))\n return func(*new_args)\n return wrapper_check_inpu... | [
"0.69113696",
"0.6676271",
"0.66149634",
"0.6469016",
"0.63755065",
"0.63459605",
"0.632837",
"0.63063824",
"0.62952715",
"0.629278",
"0.6274046",
"0.6262766",
"0.6187069",
"0.6174713",
"0.6169088",
"0.61163473",
"0.61155474",
"0.60963315",
"0.6094568",
"0.6088186",
"0.608336... | 0.6071258 | 22 |
copes with positions with no values | def test_get_logo_missing(self):
data = [
[0.1, 0.3, 0.5, 0.1],
[0.05, 0.8, 0.05, 0.1],
[0, 0, 0, 0],
[0.7, 0.1, 0.1, 0.1],
[0.6, 0.15, 0.05, 0.2],
]
data = DictArrayTemplate(5, "ACGT").wrap(data)
get_logo(data) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def filled_positions(self):\n return [x for x in assignable_positions if self.grid[x][0]]",
"def no_empty_positions(self):\n clauses = []\n\n for position in range(0,self.graph.num_vertices):\n clause = []\n for vertex in range(0,self.graph.num_vertices):\n ... | [
"0.6175911",
"0.5931269",
"0.5778021",
"0.5594402",
"0.54442143",
"0.54219913",
"0.54111654",
"0.53869516",
"0.53672886",
"0.5318788",
"0.53052735",
"0.52933586",
"0.52916795",
"0.52916795",
"0.52916795",
"0.5270822",
"0.5251649",
"0.5251649",
"0.52438754",
"0.5243215",
"0.52... | 0.0 | -1 |
copes with positions with no values | def test_get_logo_alt_input_type(self):
data = [
{"A": 0.1, "C": 0.3, "G": 0.5, "T": 0.1},
{"A": 0.05, "C": 0.8, "G": 0.05, "T": 0.1},
{"A": 0.0, "C": 0.0, "G": 0.0, "T": 0.0},
{"A": 0.7, "C": 0.1, "G": 0.1, "T": 0.1},
{"A": 0.6, "C": 0.15, "G": 0.05, "T": 0.2},
]
get_logo(data)
data[-2] = {}
get_logo(data) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def filled_positions(self):\n return [x for x in assignable_positions if self.grid[x][0]]",
"def no_empty_positions(self):\n clauses = []\n\n for position in range(0,self.graph.num_vertices):\n clause = []\n for vertex in range(0,self.graph.num_vertices):\n ... | [
"0.6175911",
"0.5931269",
"0.5778021",
"0.5594402",
"0.54442143",
"0.54219913",
"0.54111654",
"0.53869516",
"0.53672886",
"0.5318788",
"0.53052735",
"0.52933586",
"0.52916795",
"0.52916795",
"0.52916795",
"0.5270822",
"0.5251649",
"0.5251649",
"0.52438754",
"0.5243215",
"0.52... | 0.0 | -1 |
exercising some Letter methods | def test_letter_methods(self):
# shift
l = get_character("G")
self.assertEqual(l.x, 0)
self.assertEqual(l.y, 0)
l.shift(2, 2)
self.assertEqual(l.x, 2)
self.assertEqual(l.y, 2)
# scale adjusts the scale attributes
orig_width = l.scale_x
orig_height = l.scale_y
l.scale(x=0.5, y=2)
self.assertEqual(l.scale_x, orig_width / 2)
self.assertEqual(l.scale_y, orig_height * 2)
# invert changes the degree attr
l.rotate(180)
self.assertEqual(l.degrees, 180) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def display_letters(word, guesses):\n pass",
"def letter_for(label):\n return \"ABCDEFGHIJ\"[label]",
"def init_letters():\n return ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',\n 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',\n 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',\n ... | [
"0.68726075",
"0.6728515",
"0.6708404",
"0.6602445",
"0.6602445",
"0.6602445",
"0.6595359",
"0.65413225",
"0.6491447",
"0.64886683",
"0.6447457",
"0.64450705",
"0.64275444",
"0.63569146",
"0.63441706",
"0.627932",
"0.6252092",
"0.62292844",
"0.6165212",
"0.6158538",
"0.613655... | 0.68069106 | 1 |
correctly convert a series of dicts or a DictArray to lists | def test_input_conversion(self):
data = [dict(A=0.1, C=0.2), dict(A=0.1, C=0.2)]
base = [("A", 0.1), ("C", 0.2)]
expect = [base, base]
got = _char_hts_as_lists(data)
self.assertEqual(got, expect)
#
data = [dict(A=0.1, C=0.2), {}]
base = [("A", 0.1), ("C", 0.2)]
expect = [base, None]
got = _char_hts_as_lists(data)
self.assertEqual(got, expect)
data = [dict(A=0.1, C=0.2), None]
base = [("A", 0.1), ("C", 0.2)]
expect = [base, None]
got = _char_hts_as_lists(data)
self.assertEqual(got, expect) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dict_array_values_as_list(self, dict_object: dict()) -> []:\n new_list = []\n for val in dict_object.values():\n new_list = new_list + val\n return new_list",
"def __dict_to_list(dict):\n\n max_val = 1\n for k,v in dict.items():\n if type(v) is list:\n... | [
"0.65203464",
"0.6443881",
"0.64112335",
"0.62288743",
"0.62244505",
"0.62078065",
"0.61272603",
"0.60739225",
"0.60704356",
"0.60704356",
"0.6049034",
"0.5973778",
"0.59609526",
"0.5909848",
"0.5888783",
"0.5881044",
"0.58610386",
"0.5849552",
"0.5837635",
"0.5829828",
"0.58... | 0.0 | -1 |
Load an image from a specific path. | def parse_img(image_path):
image = tf.read_file(image_path)
image = tf.image.decode_image(image)
image = tf.reshape(image, [INITIAL_RES, INITIAL_RES, 3])
image = tf.image.resize_images(image, [OUTPUT_RES, OUTPUT_RES])
#image = image[:, :, ::-1] # BGE -> RGB conversion if needed?
#image = tf.image.rgb_to_grayscale(image)
#image = tf.image.convert_image_dtype(image, tf.float32) # In neuralNet.py
image = image.eval() # Convert from tensor to Numpy array for Keras
return image | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load(path) -> Image:\n return Image.open(path)",
"def load_image(self, path):\n if path:\n self.original_image = cv2.imread(path, 1)\n self.prepare_images()",
"def load_image(file_path):\r\n return Image.open(file_path)",
"def load_image(path_to_image, image_name):\... | [
"0.82594067",
"0.8017533",
"0.7872266",
"0.7861384",
"0.7613008",
"0.7607398",
"0.7584714",
"0.75568944",
"0.7168932",
"0.7154638",
"0.70918506",
"0.70681524",
"0.6985307",
"0.6985266",
"0.69554704",
"0.6927727",
"0.6898096",
"0.68906724",
"0.6875575",
"0.686947",
"0.68326443... | 0.0 | -1 |
Loads all images from ../img folder, split into training and test data. | def load_data(train_test_ratio = 0.8, class_range = 8, randomised = True):
# Get image filenames, labels, and the number of classification classes
filenames = glob.glob("../img/*.png")
if randomised:
random.shuffle(filenames)
img_labels = []
for filename in filenames:
label = int(filename.split("-d",1)[1].split('-',1)[0])
label = max(0, (label - 1) // (class_range))
img_labels.append(label)
num_classes = max(img_labels) + 1 # E.g. max label 5 -> 0-5 inclusive
num_total_samples = len(filenames)
num_train_samples = int(num_total_samples * train_test_ratio)
num_test_samples = num_total_samples - num_train_samples
training_images = np.empty(
(num_train_samples, OUTPUT_RES, OUTPUT_RES, 3), dtype='uint8'
)
training_labels = np.asarray(img_labels[:num_train_samples], dtype='uint8')
for i in range(0, num_train_samples):
training_images[i] = parse_img(filenames[i])
test_images = np.empty(
(num_test_samples, OUTPUT_RES, OUTPUT_RES, 3), dtype='uint8'
)
test_labels = np.asarray(img_labels[num_train_samples:], dtype='uint8')
for i in range(0, num_test_samples):
test_images[i] = parse_img(filenames[i + num_train_samples])
return ((training_images, training_labels),
(test_images, test_labels),
num_classes) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_images(test_data_dir, image_size = (300, 300)):\n # loop over the input images\n images_data = []\n labels = []\n imagePaths = sorted(list(paths.list_images(test_data_dir)))\n for imagePath in imagePaths:\n # load the image, pre-process it, and store it in the data list\n imag... | [
"0.7594195",
"0.7443144",
"0.74420106",
"0.7436539",
"0.7346392",
"0.73275924",
"0.725564",
"0.7240028",
"0.7179599",
"0.7174112",
"0.71509814",
"0.7121513",
"0.7118166",
"0.7098444",
"0.7097929",
"0.70875955",
"0.7087226",
"0.7081254",
"0.70765895",
"0.70688915",
"0.70635",
... | 0.6661814 | 54 |
Test the retrieval of the actual rows for "select from HumanResources.Department" | def test_query_subset_response_AdventureWorks2014(self):
with open(self.get_test_baseline(u'select_from_humanresources_department_adventureworks2014.txt'), u'r+b', buffering=0) as response_file:
request_stream = io.BytesIO()
rpc_client = json_rpc_client.JsonRpcClient(
request_stream, response_file)
rpc_client.start()
# Submit a dummy request.
parameters = {u'OwnerUri': u'connectionservicetest',
u'BatchIndex': 0,
u'ResultSetIndex': 0,
u'RowsStartIndex': 0,
u'RowCount': 16}
request = queryservice.QuerySubsetRequest(
3, rpc_client, parameters)
self.verify_subset_response(request=request)
rpc_client.shutdown() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def testSQLString(self): \n val = selectAllSQLStr()\n self.assertEqual(val,\"SELECT * FROM bookStore\")",
"def test_get_records(self):\n pass",
"def test_query(rgd):\n data = rgd.query(\"test\")\n assert isinstance(data, pd.DataFrame)\n assert data.iloc[0][\"name\"] == \"vm1\... | [
"0.6264874",
"0.6200702",
"0.61946857",
"0.60861903",
"0.605207",
"0.60488313",
"0.6044188",
"0.6007789",
"0.58853686",
"0.5846672",
"0.5814985",
"0.5803768",
"0.5793906",
"0.5727903",
"0.5715468",
"0.5707922",
"0.57078373",
"0.570377",
"0.56463915",
"0.5636926",
"0.5601166",... | 0.0 | -1 |
Helper method to get baseline file. | def get_test_baseline(self, file_name):
return os.path.abspath(
os.path.join(
os.path.abspath(__file__),
u'..',
u'baselines',
file_name)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _GetBaseline(self, filename, directory, upstream_only = False):\n\n local_filename = os.path.join(directory, filename)\n local_directory = local_filename[:local_filename.rfind(\"/\")]\n if upstream_only:\n last_index = local_filename.rfind(\".\")\n if last_index > -1:\n local_filename... | [
"0.72251785",
"0.66584283",
"0.65599346",
"0.6401578",
"0.6180834",
"0.60123277",
"0.5969603",
"0.5948323",
"0.59022737",
"0.5869274",
"0.583606",
"0.5801047",
"0.5801047",
"0.5801047",
"0.57897425",
"0.57875085",
"0.56959826",
"0.56877124",
"0.56490695",
"0.56345946",
"0.563... | 0.79847074 | 0 |
self,x_cells, self.y_cells = np.meshgrid(x_spacings, y_spacings, sparse=True) | def __init__(self, x_spacings, y_spacings):
self.x_spacings = x_spacings.astype(np.float32)
self.y_spacings = y_spacings.astype(np.float32)
self.nx = len(x_spacings)
self.ny = len(y_spacings)
self.n_cells = self.nx * self.ny | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _create_meshgrid(self):\n x = np.linspace(self.limits[0], self.limits[1], self.resolution)\n y = np.linspace(self.limits[2], self.limits[3], self.resolution)\n X, Y = np.meshgrid(x, y)\n return X, Y",
"def make_meshgrid(x_min,x_max,y_min,y_max, h=.02):\n xx, yy = np.meshgrid(np... | [
"0.75481325",
"0.7334674",
"0.7334674",
"0.72951424",
"0.72951424",
"0.7236079",
"0.72319734",
"0.72218466",
"0.7145317",
"0.7145317",
"0.7145317",
"0.7145317",
"0.71451616",
"0.71191305",
"0.704927",
"0.7037136",
"0.7016178",
"0.6942421",
"0.68876344",
"0.68683",
"0.68584913... | 0.69724435 | 17 |
Convert two dimensional index to 1d. | def one_dim_index(self, i, j):
return int(i + j * self.nx) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index_to_ijk(self, index):\n return self.indices_to_ijk_array([index])[0]",
"def to_sparse(a):\n flat = a.flatten()\n indices = np.nonzero(flat)\n values = flat[indices]\n return indices[0], values",
"def from_2D_to_1D(constant):\n if isinstance(constant, np.ndarray) and constant.ndim... | [
"0.63026196",
"0.6043091",
"0.6035447",
"0.5884787",
"0.5873872",
"0.58113074",
"0.58112794",
"0.5807854",
"0.5798596",
"0.5788235",
"0.576793",
"0.57582265",
"0.5724153",
"0.5716051",
"0.57072705",
"0.5707207",
"0.57035434",
"0.5701338",
"0.56998104",
"0.5698102",
"0.5695544... | 0.59991854 | 3 |
Converts a one dimensional index to 2d. | def two_dim_index(self, k):
ind_x = k % self.nx
ind_y = (k - ind_x) / self.nx
return (int(ind_y), int(ind_x)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index2d(src, idx):\n broadcast_to = P.BroadcastTo(idx.shape)\n offs = broadcast_to(P.range(Tensor(0, mindspore.int32),\n Tensor(idx.shape[0], mindspore.int32),\n Tensor(1, mindspore.int32))[:, None])\n idx = idx + (offs()) * idx.shape[1]\n\... | [
"0.67064077",
"0.6169856",
"0.60942876",
"0.60095567",
"0.5960693",
"0.5943522",
"0.59234434",
"0.5917022",
"0.58836246",
"0.58741325",
"0.5864474",
"0.58585775",
"0.58431876",
"0.58389384",
"0.5818341",
"0.5752824",
"0.5739784",
"0.5734386",
"0.57313216",
"0.57089096",
"0.56... | 0.550443 | 35 |
Return a list of all the cells in the grid. We start increasing x first, i.e. 0th cell is the first cell, 1cell is the one with the next x in the list and y unchanged, .... Return array An array of size n_cells n_dims. | def cells_list(self):
xx, yy = np.meshgrid(self.x_spacings, self.y_spacings)
return np.vstack([yy.ravel(), xx.ravel()]).transpose() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_cells_from_dims(num_verts_x: int, num_verts_y: int):\n num_cells_x = num_verts_x - 1\n num_cells_y = num_verts_y - 1\n num_cells = num_cells_x*num_cells_y\n cell_array = np.zeros((num_cells, 4), dtype=int)\n cell_num = 0\n\n # I am sure this could be done in a more efficient way.\n ... | [
"0.7313377",
"0.70912474",
"0.70496106",
"0.70136446",
"0.70017177",
"0.69983876",
"0.6967043",
"0.6942949",
"0.69047695",
"0.6899912",
"0.6888806",
"0.6857896",
"0.68333375",
"0.6820522",
"0.6802178",
"0.6766183",
"0.66904247",
"0.66788596",
"0.6637702",
"0.66127455",
"0.660... | 0.77503717 | 0 |
Calculates silence threshold per sound interval for chunking. | def get_silence_threshold(sound, lower_quantile):
soundint = sound.to_intensity()
max_intensity = call(soundint, 'Get quantile', 0.0, 0.0, 1)
sil_intensity = call(soundint, 'Get quantile', 0.0, 0.0, lower_quantile)
return sil_intensity - max_intensity | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def determine_silence_threshold(self):\n loudest_sound_cohort_size = 0.2 # Top 20% are counted in the loudest sound group.\n silence_threshold_multiplier = 1.6 # Sounds must be at least 1.6x as loud as the loudest silence\n\n rospy.loginfo(\"Getting intensity values from mic.\")\n sel... | [
"0.7811607",
"0.7448463",
"0.6895357",
"0.6664065",
"0.6417837",
"0.6375742",
"0.6263973",
"0.61554515",
"0.6127289",
"0.60519105",
"0.60171616",
"0.5937067",
"0.5910318",
"0.5892728",
"0.58905584",
"0.5843424",
"0.58425045",
"0.5808453",
"0.57665783",
"0.5759342",
"0.5737877... | 0.6908193 | 2 |
Wrapper to run Praat 'To Textgrid (silences)' function. | def detect_silences(sound, sil_threshold, sil_duration):
textgrid = call(sound, 'To TextGrid (silences)', 100, 0.0, sil_threshold, sil_duration, 0.1, 'silence', 'speech')
return textgrid | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__ (self,win,text='Press a key to continue',**kwargs):\n\n self.win = win\n \n self.text = visual.TextStim(win,text=text,**kwargs)",
"def __init__ (self,win,text='Press a key to continue',**kwargs):\n\n self.win = win\n \n self.text = visual.TextStim(win,text=t... | [
"0.5339875",
"0.5339875",
"0.52565366",
"0.5225016",
"0.5224651",
"0.52221847",
"0.52040446",
"0.5149263",
"0.50935054",
"0.509346",
"0.50882745",
"0.50577587",
"0.50410724",
"0.50378585",
"0.5034093",
"0.5024333",
"0.5018697",
"0.50046563",
"0.4991087",
"0.49812207",
"0.4980... | 0.59195006 | 0 |
Saves chunked speech intervals as WAV file. | def save_chunks(chunk_sound, out_path, video_id):
chunk_start_ms = int(chunk_sound.get_start_time()*1000)
chunk_end_ms = int(chunk_sound.get_end_time()*1000)
chunk_duration = chunk_end_ms - chunk_start_ms
chunk_fn = '{0}_{1}_{2}.wav'.format(video_id, chunk_start_ms, chunk_end_ms)
chunk_file_path = path.join(out_path, chunk_fn)
chunk_sound.save(chunk_file_path, 'WAV')
return {'filename': chunk_fn, 'video_id': video_id, 'start_time': chunk_start_ms, 'end_time': chunk_end_ms, 'duration': chunk_duration} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_wav(file_name, signal, fs):\n wavfile.write(file_name, fs, np.int16(signal/np.max(np.abs(signal)) * (2**(16)/2-1)))",
"def save_audio(self, name=DEFAULT_OUT_NAME):\n print(\"Saving...\")\n wf = wave.open(name+'.wav', 'wb')\n wf.setnchannels(DEFAULT_CHANNELS)\n wf.setsampwi... | [
"0.6919104",
"0.6847627",
"0.672993",
"0.6697336",
"0.66271955",
"0.6598934",
"0.65593815",
"0.65480053",
"0.65218306",
"0.6511665",
"0.64606607",
"0.6440448",
"0.63984156",
"0.6338785",
"0.63294864",
"0.6315476",
"0.63118845",
"0.63059294",
"0.6304708",
"0.6291267",
"0.62757... | 0.6976282 | 0 |
Selects which value to return. | def _return(*args):
to_return = ()
for arg in args:
cond, value = arg
if cond:
to_return += (value,)
if len(to_return) == 1:
return to_return[0]
return to_return | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getValue(name, default=None):",
"def get_value(self):",
"def getValue(self,value):\n if value in self.header.keys():\n return self.header[value]\n if value in self.subintinfo.keys():\n return self.subintinfo[value][-1]\n if self.params is None:\n return... | [
"0.6543452",
"0.6478195",
"0.64064497",
"0.6406406",
"0.640156",
"0.6355146",
"0.6348945",
"0.634662",
"0.634554",
"0.6221234",
"0.6221234",
"0.6220085",
"0.6185762",
"0.61845344",
"0.6182689",
"0.61672604",
"0.61638516",
"0.61610883",
"0.6157245",
"0.6145623",
"0.614436",
... | 0.0 | -1 |
Fetches data and metadata from an URL. | def get_content(url, etag=None, use_http_compression=True, return_etag=False, return_status_code=False, return_datetime=False, return_response=False):
error_msg = 'HTTP GET %s' % (url,)
# Sets the headers.
headers = {}
if etag:
headers['If-None-Match'] = etag
if not use_http_compression:
headers['Accept-Encoding'] = ''
downloaded_date = (return_datetime and [timezone.now()] or [None])[0]
# Makes the request.
try:
response = requests.get(url, headers=headers)
except StandardError as e:
raise RequestsModuleError('%s - Requests module error\n%s' % (error_msg, e))
data = response.content
etag = (return_etag and [response.headers.get('ETag', None)] or [None])[0]
status_code = response.status_code
return _return((True, data), (return_etag, etag), (return_status_code, status_code), (return_datetime, downloaded_date), (return_response, response)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __fetch_from_url(url: str) -> Any:\n song_information: Any = None\n try:\n # Send the request and load the returned contents.\n req = request.Request(url, headers={\n 'User-Agent': Config.Config.get_user_agent()\n })\n response = request.... | [
"0.7141515",
"0.68348056",
"0.67148185",
"0.6683118",
"0.6625893",
"0.6613337",
"0.6553073",
"0.6546756",
"0.6502782",
"0.6493208",
"0.6449416",
"0.6427715",
"0.6386104",
"0.6324223",
"0.6319196",
"0.63145965",
"0.6295364",
"0.6295271",
"0.6283739",
"0.6245581",
"0.6242461",
... | 0.0 | -1 |
Takes input ends of all feed pipes and feeds odd numbers starting from low until high both inclusive. in a round robin fashion. process ends by feeding 1 to all pipes. 1 is a sentinel value. | def distributor(ls_feed_pipe_open,low,high):
def getNumber(low,high):
i = low
if i%2 == 0: #if i is even, then start from i+1 odd.
i += 1
while i<=high:
yield i
i+=2 #no need to check for even numbers, so skip it here at begining
yield -1 #when generator yields -1, it reached high, so terminate
next_pipe = 0
number = getNumber(low,high)
while True:
msg = next(number)
if msg == -1: #to check when generator reached high.
break
else:
#feed pipes in a round robin fashion,
#so that over time each generatePrime process experiences same load.
ls_feed_pipe_open[next_pipe].send(msg)
next_pipe += 1
if next_pipe == len(ls_feed_pipe_open):
next_pipe = 0
for p in ls_feed_pipe_open:
p.send(-1) #-1 is sentinel value for all generatePrime processs
return 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def odd():\n num = 0\n while True:\n yield num * (num & 1)\n num += 1",
"def infinite_odd_generator():\n current = 1\n while True:\n yield current\n current = current + 2",
"def input_pipe():\n x = ''\n while True:\n x = yield x\n yiel... | [
"0.5789352",
"0.5761657",
"0.5741719",
"0.564393",
"0.52422297",
"0.51917",
"0.50984246",
"0.50861835",
"0.5054945",
"0.50331575",
"0.50145054",
"0.5011917",
"0.50026035",
"0.49603093",
"0.49603093",
"0.4935153",
"0.49219003",
"0.49094537",
"0.4875977",
"0.4841634",
"0.483971... | 0.68875015 | 0 |
will take numbers sequentially from feed_pipe, verify if it is prime. any primes found will be returned as a dict to main process. dict contains only one key value pair. val is always a list. | def generatePrime(ls_primes, feed_pipe,return_dict):
local_primes = []
while True:
n = feed_pipe.recv()
if n == -1: # sentinel given by distributor.
break
else:
is_prime = True
##check for divisibility
## no need to check for 2 since all are odd numbers
for prime in ls_primes[1:]:
if n%prime == 0:
is_prime = False
break
##if the number is prime, append to global list
if is_prime:
local_primes.append(n)
if len(local_primes) >0:
return_dict[os.getpid()] = local_primes
return return_dict
return 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def worker(nums, outdict):\n for n in nums:\n outdict[n] = primes2(n)",
"def primes():\n D = {} # map composite integers to primes witnessing their compositeness\n q = 2 # first integer to test for primality\n while True:\n if q not in D:\n yield q # not mar... | [
"0.62043977",
"0.60420763",
"0.6040586",
"0.59742284",
"0.5961007",
"0.59362507",
"0.5920342",
"0.5811969",
"0.5799837",
"0.57528454",
"0.5740674",
"0.5735719",
"0.5734782",
"0.5734576",
"0.5731913",
"0.5719384",
"0.5716878",
"0.5673636",
"0.5661564",
"0.56440914",
"0.5617547... | 0.78329885 | 0 |
Reject unsuported chain parts | def _select_simple_chainparts(chain_parts):
for cp in chain_parts:
if reject_substr_res.search(cp['chainPartName']):
return False
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate_chain():",
"def reject(self):\n pass",
"def test_blind_sig_chain_wrong_intermediary(self): # pylint: disable=too-many-locals\n\n test_levels = 4\n msg = os.urandom(1024)\n wrong_level = 2\n\n ca = ECCBlind()\n signer_obj = ca\n fake_intermediary = ... | [
"0.67994744",
"0.5958347",
"0.5583729",
"0.5497606",
"0.54252285",
"0.54134977",
"0.53917265",
"0.53915894",
"0.53751105",
"0.53494143",
"0.53485787",
"0.5343248",
"0.5343216",
"0.53384286",
"0.5323294",
"0.5297185",
"0.5291411",
"0.52887464",
"0.5273759",
"0.5243703",
"0.523... | 0.6198813 | 1 |
Marshal information deom the selected chainParts to create a | def _make_simple_label(chain_parts):
if not _select_simple_chainparts(chain_parts):
msg = 'Jet Configuration error: '\
'chain fails substring selection: not "simple" '
raise NotImplementedError(msg)
label = 'simple(['
for cp in chain_parts:
smcstr = str(cp['smc'])
jvtstr = str(cp['jvt'])
if smcstr == 'nosmc':
smcstr = ''
for i in range(int(cp['multiplicity'])):
# condition_str = '(%set,%s,%s)' % (str(cp['threshold']),
# str(cp['etaRange']),
# smcstr,)
condition_str = '(%set,%s' % (str(cp['threshold']),
str(cp['etaRange']),)
if smcstr: # Run 2 chains have "INF" in the SMC substring
condition_str += ',%s)' % smcstr.replace('INF','')
elif jvtstr:
condition_str += ',%s)' % jvtstr
else:
condition_str += ')'
label += condition_str
label += '])'
return label | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def makeBinaryChains():\n\t\n\t# retrieve the binding partner specifications\n\t(maxsize,types) = getTypes()\n\t\n\t# Do some basic argument checking for this model\n\tif (len(types) < 2):\n\t\tprint \"Number of defined types must equal two for binary chain calculations.\"\n\t\treturn\n\tif (maxsize == 0):\n\t\tpr... | [
"0.5191058",
"0.516895",
"0.5164095",
"0.5164095",
"0.50821406",
"0.5015414",
"0.50149983",
"0.49796292",
"0.49461022",
"0.49153453",
"0.48709112",
"0.48381686",
"0.483411",
"0.48162767",
"0.48084295",
"0.4796053",
"0.4777216",
"0.4726833",
"0.4726833",
"0.47081837",
"0.46883... | 0.0 | -1 |
Marshal information deom the selected chainParts to create a 'simple_partition' label. | def _make_simple_partition_label(chain_dict):
cps = chain_dict['chainParts']
if not (_select_simple_chainparts(cps)):
raise NotImplementedError(
'chain fails substring selection: not "simple": %s' % (
chain_dict['chainName']))
label = 'simplepartition(['
for cp in cps:
smcstr = str(cp['smc'])
if smcstr == 'nosmc':
smcstr = ''
for i in range(int(cp['multiplicity'])):
# condition_str = '(%set,%s,%s)' % (str(cp['threshold']),
# str(cp['etaRange']),
# smcstr,)
condition_str = '(%set,%s' % (str(cp['threshold']),
str(cp['etaRange']),)
if smcstr:
condition_str += ',%s)'
else:
condition_str += ')'
label += condition_str
label += '])'
return label | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _make_partitionsTest_label(chain_parts):\n\n assert len(chain_parts) == 1\n scenario = chain_parts[0]['hypoScenario']\n \n assert scenario == 'partitionsTest'\n\n \n\n return \"\"\"\n partgen(\n [(20et, 0eta320)]\n \n simple([(40et, 0eta320) (50et, 0eta320)])\n ... | [
"0.65343463",
"0.53522164",
"0.52719545",
"0.52471644",
"0.51894504",
"0.5177348",
"0.5096431",
"0.5087608",
"0.4973218",
"0.4973218",
"0.4970022",
"0.4951215",
"0.49493623",
"0.49468526",
"0.49310818",
"0.492718",
"0.49157664",
"0.49112102",
"0.49103266",
"0.48851392",
"0.48... | 0.6581646 | 0 |
Marshal information deom the selected chainParts to create a | def _make_simple_comb_label(chain_dict):
cps = chain_dict['chainParts']
if not (_select_simple_chainparts(cps)):
raise NotImplementedError(
'chain fails substring selection: not "simple": %s' % (
chain_dict['chainName']))
simple_strs = []
for cp in cps:
print(cp)
simple_strs.append(_make_simple_label([cp]))
label = 'combgen([(%d)]' % len(cps)
for s in simple_strs:
label += ' %s ' % s
label += ')'
return label | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def makeBinaryChains():\n\t\n\t# retrieve the binding partner specifications\n\t(maxsize,types) = getTypes()\n\t\n\t# Do some basic argument checking for this model\n\tif (len(types) < 2):\n\t\tprint \"Number of defined types must equal two for binary chain calculations.\"\n\t\treturn\n\tif (maxsize == 0):\n\t\tpr... | [
"0.51896733",
"0.5168605",
"0.51672775",
"0.51672775",
"0.50873256",
"0.5012869",
"0.50128603",
"0.49828157",
"0.49484867",
"0.49205998",
"0.48682296",
"0.48377433",
"0.48344752",
"0.4816704",
"0.48074743",
"0.47946405",
"0.47819698",
"0.47307587",
"0.47307587",
"0.470948",
"... | 0.0 | -1 |
Marshal information from the selected chainParts to create a vbenf label. Use a Reducer for elimination of unusable jets | def _make_vbenf_label(chain_parts):
# toy label for development: run simple and dijet independently.
# simple makes Et cuts on two jets. Independently (sharing possible)
# of jets choosean by simple, the dijet
# scenario requires a dijet of mass > 900, and opening angle in phi > 2.6
assert len(chain_parts) == 1
scenario = chain_parts[0]['hypoScenario']
assert scenario.startswith('vbenf')
args = _args_from_scenario(scenario)
if not args:
return 'and([]simple([(50et)(70et)])combgen([(2)] dijet([(900djmass, 26djdphi)])))'
arg_res = [
re.compile(r'(?P<lo>\d*)(?P<key>fbet)(?P<hi>\d*)'),
re.compile(r'(?P<lo>\d*)(?P<key>mass)(?P<hi>\d*)'),
re.compile(r'(?P<lo>\d*)(?P<key>et)(?P<hi>\d*)'),
]
defaults = {
'et': ('101', 'inf'),
'mass': ('800', 'inf'),
'fbet': ('501', 'inf'),
}
argvals = {}
while args:
assert len(args) == len(arg_res)
arg = args.pop()
for r in arg_res:
m = r.match(arg)
if m is not None:
arg_res.remove(r)
gd = m.groupdict()
key = gd['key']
try:
lo = float(gd['lo'])
except ValueError:
lo = defaults[key][0]
argvals[key+'lo'] = lo
try:
hi = float(gd['hi'])
except ValueError:
hi = defaults[key][1]
argvals[key+'hi'] = hi
assert len(args) == len(arg_res)
assert len(args) == 0
return """
and
(
[]
simple
(
[(%(etlo).0fet, 500neta)(%(etlo).0fet, peta500)]
)
combgen
(
[(10et, 0eta320)]
dijet
(
[(%(masslo).0fdjmass, 26djdphi)]
)
simple
(
[(10et, 0eta320)(20et, 0eta320)]
)
)
)""" % argvals | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def chainDict2jetLabel(chain_dict):\n\n # suported scenarios \n router = {\n 'simple': _make_simple_label,\n 'HT': _make_ht_label,\n 'vbenf': _make_vbenf_label,\n 'dijet': _make_dijet_label,\n 'combinationsTest': _make_combinationsTest_label,\n 'partitionsTest': _mak... | [
"0.53284836",
"0.52070326",
"0.50032526",
"0.4924041",
"0.48997957",
"0.48227805",
"0.4819547",
"0.4782699",
"0.47695082",
"0.4746857",
"0.4743185",
"0.47308764",
"0.4726845",
"0.46611047",
"0.46597615",
"0.463954",
"0.46242067",
"0.46234703",
"0.45942166",
"0.45858887",
"0.4... | 0.61593163 | 0 |
dijet label. supports dijet cuts, and cuts on particpating jets | def _make_dijet_label(chain_parts):
assert len(chain_parts) == 1
scenario = chain_parts[0]['hypoScenario']
assert scenario.startswith('dijet')
arg_res = [
re.compile(r'^(?P<lo>\d*)(?P<key>djmass)(?P<hi>\d*)$'),
re.compile(r'^(?P<lo>\d*)(?P<key>j1et)(?P<hi>\d*)$'),
re.compile(r'^(?P<lo>\d*)(?P<key>j1eta)(?P<hi>\d*)$'),
re.compile(r'^(?P<lo>\d*)(?P<key>j2et)(?P<hi>\d*)$'),
re.compile(r'^(?P<lo>\d*)(?P<key>j2eta)(?P<hi>\d*)$'),
]
defaults = {
'j1et': ('100', 'inf'),
'j2et': ('100', 'inf'),
'j1eta': ('0', '320'),
'j2eta': ('0', '320'),
'djmass': ('1000', 'inf'),
}
args = _args_from_scenario(scenario)
argvals = {}
while args:
assert len(args) == len(arg_res)
arg = args.pop()
for r in arg_res:
m = r.match(arg)
if m is not None:
arg_res.remove(r)
gd = m.groupdict()
key = gd['key']
try:
lo = float(gd['lo'])
except ValueError:
lo = defaults[key][0]
argvals[key+'lo'] = lo
try:
hi = float(gd['hi'])
except ValueError:
hi = defaults[key][1]
argvals[key+'hi'] = hi
assert len(args) == len(arg_res)
assert len(args) == 0
return """
combgen(
[(2)(%(j1etlo).0fet, %(j1etalo).0feta%(j1etahi).0f)
(%(j1etlo).0fet, %(j1etalo).0feta%(j1etahi).0f)
]
dijet(
[(%(djmasslo).0fdjmass)])
simple([(%(j1etlo).0fet, %(j1etalo).0feta%(j1etahi).0f)
(%(j2etlo).0fet, %(j2etalo).0feta%(j2etahi).0f)])
)""" % argvals | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def extract_info(config, cut, label):\n cfg = filter(lambda c: c['name'] == cut, config['physics']['cuts'])[0]\n text = \"\"\n if 'max' not in cfg:\n text += \"#geq \"\n text += str(cfg['min'])\n if 'max' in cfg and cfg['max'] != cfg['min']:\n text += '-' + str(cfg['max']) + ' ' + labe... | [
"0.5650385",
"0.54846936",
"0.54270923",
"0.5375306",
"0.53342646",
"0.5226105",
"0.5209129",
"0.51919734",
"0.51784825",
"0.5173263",
"0.5163355",
"0.51560795",
"0.5154937",
"0.51164854",
"0.5109441",
"0.5093374",
"0.50911057",
"0.5076122",
"0.50540954",
"0.50480634",
"0.504... | 0.6397082 | 0 |
ht label. ht cuts, and cuts on particpating jets | def _make_ht_label(chain_parts):
assert len(chain_parts) == 1, '_make_ht_label, no. of chain parts != 1'
scenario = chain_parts[0]['hypoScenario']
assert scenario.startswith('HT'), '_make_ht_label(): scenario does not start with HT'
arg_res = [
re.compile(r'^(?P<lo>\d*)(?P<key>ht)(?P<hi>\d*)$'),
re.compile(r'^(?P<lo>\d*)(?P<key>et)(?P<hi>\d*)$'),
re.compile(r'^(?P<lo>\d*)(?P<key>eta)(?P<hi>\d*)$'),
]
defaults = {
'ht': ('0', 'inf'),
'et': ('0', 'inf'),
'eta': ('0', 'inf'),
}
args = _args_from_scenario(scenario)
argvals = {}
nargs = len(args)
assert len(args) <= len(arg_res), 'bad num of args %d, expected < %d' % (len(args),
len(arg_res))
# obtain argument values frrom scenario
while args:
arg = args.pop()
for r in arg_res:
m = r.match(arg)
if m is not None:
arg_res.remove(r)
gd = m.groupdict()
key = gd['key']
try:
lo = float(gd['lo'])
except ValueError:
lo = float(defaults[key][0])
argvals[key+'lo'] = lo
try:
hi = float(gd['hi'])
except ValueError:
hi = float(defaults[key][1])
argvals[key+'hi'] = hi
print (argvals)
assert len(argvals) == 2*nargs, 'no of args: %d, expected %d' % (len(argvals), 2*nargs)
print ('sent 100')
result = """
ht([(%(htlo).0fht)
(%(etlo).0fet)
(%(etalo).0feta%(etahi).0f)
])""" % argvals
print (result)
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def label_thin(self, orig_label):\n pil_thin = thin(orig_label)\n # Keep the original label and set non-thinning label as 0\n orig_label[~pil_thin] = 0\n\n return orig_label",
"def kohonen():\n# plb.close('all')\n \n dim = 28*28\n data_range = 255.0\n \n # load in da... | [
"0.5253033",
"0.5244755",
"0.5173087",
"0.51096773",
"0.5103869",
"0.50852627",
"0.5053167",
"0.4967331",
"0.49329308",
"0.4927268",
"0.4886447",
"0.4883699",
"0.48704627",
"0.48665786",
"0.48657504",
"0.48568624",
"0.484965",
"0.48423848",
"0.48153552",
"0.4808797",
"0.47966... | 0.5767312 | 0 |
make test label for combinations helper with two simple children. | def _make_combinationsTest_label(chain_parts):
assert len(chain_parts) == 1
scenario = chain_parts[0]['hypoScenario']
assert scenario == 'combinationsTest'
return """
combgen(
[(2)(20et, 0eta320)]
simple([(40et, 0eta320) (50et, 0eta320)])
simple([(35et, 0eta240) (55et, 0eta240)])
)""" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_sums():\n assert label_parent(1, 2) == 3\n assert label_parent (1, 4) == 8\n # Should ignore arg order\n assert label_parent(4, 1) == 8",
"def _make_partitionsTest_label(chain_parts):\n\n assert len(chain_parts) == 1\n scenario = chain_parts[0]['hypoScenario']\n \n assert scenari... | [
"0.6137433",
"0.6108757",
"0.60195917",
"0.5986544",
"0.5936767",
"0.58589",
"0.5759686",
"0.56950617",
"0.5624841",
"0.55902916",
"0.55750483",
"0.5560212",
"0.5554626",
"0.55542696",
"0.5553175",
"0.5553175",
"0.55467266",
"0.5503819",
"0.5457172",
"0.5451371",
"0.54313546"... | 0.6972838 | 0 |
make test label for combinations helper with two simple children. | def _make_partitionsTest_label(chain_parts):
assert len(chain_parts) == 1
scenario = chain_parts[0]['hypoScenario']
assert scenario == 'partitionsTest'
return """
partgen(
[(20et, 0eta320)]
simple([(40et, 0eta320) (50et, 0eta320)])
simple([(35et, 0eta240) (55et, 0eta240)])
)""" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _make_combinationsTest_label(chain_parts):\n\n assert len(chain_parts) == 1\n scenario = chain_parts[0]['hypoScenario']\n \n assert scenario == 'combinationsTest'\n\n \n\n return \"\"\"\n combgen(\n [(2)(20et, 0eta320)]\n \n simple([(40et, 0eta320) (50et, 0eta320)])... | [
"0.6972838",
"0.6137433",
"0.60195917",
"0.5986544",
"0.5936767",
"0.58589",
"0.5759686",
"0.56950617",
"0.5624841",
"0.55902916",
"0.55750483",
"0.5560212",
"0.5554626",
"0.55542696",
"0.5553175",
"0.5553175",
"0.55467266",
"0.5503819",
"0.5457172",
"0.5451371",
"0.54313546"... | 0.6108757 | 2 |
Entry point to this Module. Return a chain label according to the value of cp['hypoScenario'], where cp is an element of list/ chainDict['chainPart'] | def chainDict2jetLabel(chain_dict):
# suported scenarios
router = {
'simple': _make_simple_label,
'HT': _make_ht_label,
'vbenf': _make_vbenf_label,
'dijet': _make_dijet_label,
'combinationsTest': _make_combinationsTest_label,
'partitionsTest': _make_partitionsTest_label,
}
# chain_part - scenario association
cp_sorter = {}
for k in router: cp_sorter[k] = []
for cp in chain_dict['chainParts']:
if cp['signature'] != 'Jet' and cp['signature'] != 'Bjet':
continue
for k in cp_sorter:
if cp['hypoScenario'].startswith(k):
cp_sorter[k].append(cp)
break
# obtain labels by scenario.
labels = []
for k, chain_parts in cp_sorter.items():
if chain_parts: labels.append(router[k](chain_parts))
assert labels
nlabels = len(labels)
if nlabels == 1: return labels[0]
if nlabels == 2:
alabel = """\
and([]
%s
%s)""" % (tuple(labels))
return alabel
# more than 2 labels is not expected
assert False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _make_ht_label(chain_parts):\n\n assert len(chain_parts) == 1, '_make_ht_label, no. of chain parts != 1'\n scenario = chain_parts[0]['hypoScenario']\n \n assert scenario.startswith('HT'), '_make_ht_label(): scenario does not start with HT'\n\n arg_res = [\n re.compile(r'^(?P<lo>\\d*)(?P<k... | [
"0.67336076",
"0.6324823",
"0.5675857",
"0.56554145",
"0.5556557",
"0.54489195",
"0.5372017",
"0.53109175",
"0.5194049",
"0.509463",
"0.50940394",
"0.49333954",
"0.49087635",
"0.4816282",
"0.47896782",
"0.47874323",
"0.4760651",
"0.47558823",
"0.47320828",
"0.47163337",
"0.46... | 0.6201193 | 2 |
(Set, float, float, int, str) > list Filters a set of Products according to the parameters. This function is responsible to determine if filtering with tags should be applied or not. | def get_matching_products(products, lat, lng, radius, tags):
if tags:
tag_list = tags.split(',')
return list([
product for product in products
if is_matching_product_with_tags(
product,
lat,
lng,
radius,
tag_list
)
])
else:
return list([
product for product in products
if is_matching_product(
product,
lat,
lng,
radius
)
]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def filter_generic(products, listings, result=None):\n print \"Apply Generic Filtering \"\n if result == None:\n result = {}\n matched_listings = []\n for alist in listings:\n manufacturer, renamed_manufacturer = find_manufacturer(products, alist)\n if manufacturer == False:\n ... | [
"0.66341794",
"0.6542159",
"0.63417774",
"0.6290791",
"0.61444324",
"0.61051065",
"0.5993559",
"0.5917431",
"0.5875063",
"0.5852951",
"0.578841",
"0.5734029",
"0.57259727",
"0.5694228",
"0.5673258",
"0.565935",
"0.5637606",
"0.56313235",
"0.5576161",
"0.5563928",
"0.5539448",... | 0.6570375 | 1 |
(Product, float, float, radius) > boolean Check if the coordinates of a shop is within a radius (in meters) using the Vincenty's formulae. | def is_matching_product(product, lat, lng, radius):
return vincenty(
(lat, lng),
(product.shop.lat, product.shop.lng)
).meters <= radius | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_matching_product_with_tags(product, lat, lng, radius, tags):\n return vincenty(\n (lat, lng),\n (product.shop.lat, product.shop.lng)\n ).meters <= radius and any(tag in product.shop.tags for tag in tags)",
"def __contains__(self, position):\n return sum([(c1... | [
"0.64729494",
"0.59081954",
"0.5859355",
"0.58463377",
"0.5835103",
"0.5793143",
"0.5749297",
"0.5747117",
"0.571432",
"0.5694992",
"0.5625121",
"0.55783933",
"0.5532883",
"0.5531398",
"0.55265725",
"0.5519289",
"0.54891366",
"0.5458684",
"0.54542017",
"0.5451329",
"0.5381592... | 0.7570688 | 0 |
(Product, float, float, radius, list) > boolean Check if the coordinates of a shop is within a radius (in meters) using the Vincenty's formulae and if the shop contains any of the tags provided. | def is_matching_product_with_tags(product, lat, lng, radius, tags):
return vincenty(
(lat, lng),
(product.shop.lat, product.shop.lng)
).meters <= radius and any(tag in product.shop.tags for tag in tags) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_matching_product(product, lat, lng, radius):\n return vincenty(\n (lat, lng),\n (product.shop.lat, product.shop.lng)\n ).meters <= radius",
"def shops_within_radius(self, lat, lng, radius, tags=None):\n center_point = geoindex.GeoPoint(lat, lng)\n poi... | [
"0.7254775",
"0.61709523",
"0.5765121",
"0.57588995",
"0.5667875",
"0.5657872",
"0.5615331",
"0.5498272",
"0.54953516",
"0.5392794",
"0.5387623",
"0.5384196",
"0.53837055",
"0.5313938",
"0.52996296",
"0.5263196",
"0.5251948",
"0.5240129",
"0.5167428",
"0.51551384",
"0.5082203... | 0.78412956 | 0 |
Create a copy of a facemap proc file, but pointing to a new video. By default, the new proc file is created in the same folder as the new videofile and named videofile_proc.npy. | def copy_facemap_roi(procfile, videofile, outputfile=None):
videodata = np.load(procfile, allow_pickle=True).item()
videodata['filenames'] = [[videofile]]
if outputfile is None:
outputfile = os.path.splitext(videofile)[0]+'_proc.npy'
if os.path.isfile(outputfile):
print(f'File {outputfile} exists. It will not be overwritten.')
return None
np.save(outputfile, videodata)
return outputfile | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_video(input_file, output_file):\n input_video = VideoFileClip(input_file)\n output_video = input_video.fl_image(detect_lane.fit_and_plot)\n output_video.write_videofile(output_file, audio=False)",
"def process_video(lane, fname, output):\n\tclip = VideoFileClip(fname)\n\toutput_name = output\... | [
"0.6444913",
"0.6132553",
"0.6021357",
"0.6021357",
"0.5793323",
"0.575927",
"0.56994724",
"0.5620519",
"0.5565024",
"0.5488642",
"0.54845893",
"0.5479945",
"0.5418265",
"0.5404724",
"0.53233945",
"0.5318268",
"0.5299321",
"0.5261676",
"0.52610755",
"0.51977015",
"0.51628315"... | 0.8082349 | 0 |
Find the onsets in the array representing the synchronization light. This function assumes the onsets are periodic (with randomness within 0.5T and 1.5T). The function can also fix missing onsets. | def find_sync_light_onsets(sync_light, invert=True, fixmissing=False):
# -- Find changes in synch light --
sync_light_diff = np.diff(sync_light, prepend=0)
if invert:
sync_light_diff = -sync_light_diff
sync_light_diff[sync_light_diff < 0] = 0
sync_light_threshold = 0.2*sync_light_diff.max()
sync_light_onset = sync_light_diff > sync_light_threshold
# -- Find period of sync_light_onset --
sync_light_onset_ind = np.where(sync_light_onset)[0]
sync_light_onset_diff = np.diff(sync_light_onset_ind) # In units of frames
expected_onset_period = np.median(sync_light_onset_diff) # In units of (float) frames
# -- Remove repeated onsets --
onset_freq_upper_threshold = int(1.5 * expected_onset_period)
onset_freq_lower_threshold = int(0.5 * expected_onset_period)
repeated_onsets = sync_light_onset_diff < onset_freq_lower_threshold
repeated_onsets_ind = np.where(repeated_onsets)[0]
fixed_sync_light_onset = sync_light_onset.copy()
fixed_sync_light_onset[sync_light_onset_ind[repeated_onsets_ind+1]] = False
# -- Fix missing onsets --
if fixmissing:
missing_next_onsets = sync_light_onset_diff > onset_freq_upper_threshold
missing_next_onsets_ind = np.where(missing_next_onsets)[0]
for indm, missing_onset_ind in enumerate(missing_next_onsets_ind):
onset_diff = sync_light_onset_diff[missing_onset_ind]
n_missing = int(np.round(onset_diff / expected_onset_period))-1
#print(n_missing)
last_onset_ind = sync_light_onset_ind[missing_onset_ind]
next_onset_ind = sync_light_onset_ind[missing_onset_ind+1]
period_missing = (next_onset_ind - last_onset_ind)//(n_missing+1)
new_onset_inds = last_onset_ind + np.arange(1, n_missing+1)*period_missing
#print([last_onset_ind, next_onset_ind])
#print(new_onset_inds)
fixed_sync_light_onset[new_onset_inds] = True
return fixed_sync_light_onset | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_onsets(self):\n get_onsets = ess.OnsetRate()\n # onset_times is np array\n self.onset_times, onset_rate = get_onsets(self.audio)\n # Onset as sample number in the audio signal\n index2delete = []\n previous_time = -9999999\n for index, itime in enumerate(se... | [
"0.6857784",
"0.6249284",
"0.58837444",
"0.5452273",
"0.53577805",
"0.5303218",
"0.52744794",
"0.52505463",
"0.51989776",
"0.51802486",
"0.51636773",
"0.50905186",
"0.507182",
"0.5051442",
"0.5007559",
"0.50056607",
"0.49910834",
"0.4961425",
"0.4949146",
"0.493811",
"0.49135... | 0.7570172 | 0 |
Estimate whether the animal was running during each trial. This function first smooths the running trace according to smoothsize (noncausal), it then uses the average of N presamples before the onset to to estimate whether running was higher than the threshold. | def estimate_running_each_trial(running_trace, trial_onset, smoothsize=10, presamples=4,
threshold=3, showfig=False):
smoothwin = np.ones(smoothsize)/(smoothsize)
running_trace_smooth = np.convolve(running_trace, smoothwin, mode='same')
trial_onset_ind = np.where(trial_onset)[0]
presamples_inds = np.arange(-presamples, 0) + trial_onset_ind[:, np.newaxis]
pretrial_avg = running_trace_smooth[presamples_inds].mean(axis=1)
running_each_trial = pretrial_avg > threshold
if showfig:
plt.cla()
plt.plot(running_trace_smooth, '0.8')
plt.plot(trial_onset_ind, pretrial_avg, 'xg')
plt.plot(trial_onset_ind, running_each_trial*running_trace_smooth.max(), 'og')
plt.axhline(threshold, color='k')
plt.legend(['running_trace_smooth', 'pretrial_avg', 'running_each_trial'],
loc='upper right')
plt.show()
return running_each_trial, running_trace_smooth | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def punches(self):\n #:TODO Need to parameterize n\n # Initialize smoothing function\n # Also because I can't take the second derivitive\n\n n = 3\n assert (len(self.averages)==len(self.timestamps))\n size = len(self.averages)\n slopes = []\n for t in [0,size... | [
"0.5619866",
"0.5553437",
"0.5524997",
"0.53908414",
"0.5296018",
"0.5253825",
"0.5213897",
"0.52011967",
"0.51841336",
"0.5176683",
"0.51282734",
"0.5120962",
"0.51179755",
"0.5112065",
"0.50441957",
"0.50383514",
"0.503653",
"0.50297564",
"0.4981896",
"0.4948819",
"0.493829... | 0.7172721 | 0 |
This test should not be run as a part of the normal test suite. This is a resource test only! Nose2 will find it. Unittest will not. | def test_will_get_nwis_return_response():
expected = 200
response = hf.get_nwis('01585200', 'dv', '2001-01-01', '2001-01-02')
actual = response.status_code
assert expected == actual
print('NWIS is up and running!') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_subsystems(self):\n pass",
"def test_create_system_entire(self):\n pass",
"def unitary_test():",
"def test(self):\n pass",
"def test_create_run(self):\n pass",
"def test_4_4_1_1(self):\n pass",
"def _test(self):\n pass",
"def _test(self):\n pa... | [
"0.71541893",
"0.713073",
"0.71006393",
"0.7076272",
"0.70147574",
"0.69360954",
"0.6920686",
"0.6920686",
"0.6920686",
"0.6887088",
"0.6876075",
"0.6876075",
"0.6876075",
"0.6876075",
"0.6876075",
"0.6841704",
"0.6797133",
"0.67678326",
"0.67677563",
"0.675755",
"0.6699573",... | 0.0 | -1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.