Datasets:

Jackmin108

/

code_search_le512

like 0

def show_slug_with_level(context, page, lang=None, fallback=True): if not lang: lang = context.get('lang', pages_settings.PAGE_DEFAULT_LANGUAGE) page = get_page_from_string_or_id(page, lang) if not page: return '' return {'content': page.slug_with_level(lang)}

Display slug with level by language.

def show_revisions(context, page, content_type, lang=None): if not pages_settings.PAGE_CONTENT_REVISION: return {'revisions': None} revisions = Content.objects.filter(page=page, language=lang, type=content_type).order_by('-creation_date') if len(revisions) < 2: return {'revisions': None} return {'revisions': revisions[0:10]}

Render the last 10 revisions of a page content with a list using the ``pages/revisions.html`` template

def do_videoplaceholder(parser, token): name, params = parse_placeholder(parser, token) return VideoPlaceholderNode(name, **params)

Method that parse the imageplaceholder template tag.

def do_get_pages_with_tag(parser, token): bits = token.split_contents() if 4 != len(bits): raise TemplateSyntaxError('%r expects 2 arguments' % bits[0]) if bits[-2] != 'as': raise TemplateSyntaxError( '%r expects "as" as the second last argument' % bits[0]) varname = bits[-1] tag = parser.compile_filter(bits[1]) varname = bits[-1] return GetPagesWithTagNode(tag, varname)

Return Pages with given tag Syntax:: {% get_pages_with_tag <tag name> as <varname> %} Example use: {% get_pages_with_tag "footer" as pages %}

def fix_raw_path(path): double_path_separator = PATH_SEPARATOR + PATH_SEPARATOR while path.find( double_path_separator) >= 0: # there are double separators path = path.replace(double_path_separator, PATH_SEPARATOR) # remove double path separator if is_folder(path) and not path.endswith("/"): path = path + "/" return path

Prettify name of path :param path: path to fix :return: Good name for path

def remove_year(name): for i in range(len( name) - 3): # last index is length - 3 - 1 = length - 4 if name[i: i + 4].isdigit(): name = name[:i] + name[i + 4:] return remove_year( name) # if there is a removal, start again return name

Removes year from input :param name: path to edit :return: inputs with no years

def remove_brackets(name): name = re.sub( r"([(\[]).*?([)\]])", r"\g<1>\g<2>", name ) # remove anything in between brackets brackets = "()[]{}" # list of brackets for bracket in brackets: name = name.replace(bracket, "") return name

Removes brackets form input :param name: path to fix :return: inputs with no brackets

def extract_name_max_chars(name, max_chars=64, blank=" "): new_name = name.strip() if len(new_name) > max_chars: new_name = new_name[:max_chars] # get at most 64 chars if new_name.rfind(blank) > 0: new_name = new_name[:new_name.rfind(blank)] # nearest word return new_name

Extracts max chars in name truncated to nearest word :param name: path to edit :param max_chars: max chars of new name :param blank: char that represents the blank between words :return: Name edited to contain at most max_chars

def prettify(name, blank=" "): if name.startswith("."): # remove starting name = name[1:] for bad_char in BAD_CHARS: name = name.replace(bad_char, blank) # remove token name = String(name).remove_all(blank) for i in range(1, len(name) - 2): try: are_blanks = name[i - 1] == blank and name[i + 1] == blank if are_blanks and name[i] in BAD_CHARS: name = name[:i - 1] + name[i + 2:] except: # out of bounds pass if name.startswith(blank): name = name[1:] if name.endswith(blank): # remove ending replacement name = name[:-1] return name

Prettify name of path :param name: path Name: to edit :param blank: default blanks in name :return: Prettier name from given one: replace bad chars with good ones

def get_parent_folder_name(file_path): return os.path.split(os.path.split(os.path.abspath(file_path))[0])[-1]

Finds parent folder of file :param file_path: path :return: Name of folder container

def ls_dir(path, include_hidden=False): lst = [] for file in os.listdir(path): hidden_file = FileSystem(file).is_hidden() if (hidden_file and include_hidden) or (not hidden_file): lst.append(os.path.join(path, file)) return list(set(lst))

Finds content of folder :param path: directory to get list of files and folders :param include_hidden: True iff include hidden files in list :return: List of paths in given directory

def ls_recurse(path, include_hidden=False): lst = [] for file in os.listdir(path): hidden_file = FileSystem(file).is_hidden() if (hidden_file and include_hidden) or (not hidden_file): lst.append(os.path.join(path, file)) if is_folder(os.path.join(path, file)): lst += ls_recurse( os.path.join(path, file), include_hidden=include_hidden ) # get list of files in directory return list(set(lst))

Finds content of folder recursively :param path: directory to get list of files and folders :param include_hidden: True iff include hidden files in list :return: List of paths in given directory recursively

def list_content(path, recurse, include_hidden=False): if recurse: return ls_recurse(path, include_hidden=include_hidden) return ls_dir(path, include_hidden=include_hidden)

Finds content of folder (recursively) :param path: directory to get list of files and folders :param recurse: True iff recurse into subdirectories or not :param include_hidden: True iff include hidden files in list :return: List of paths in given directory recursively

def is_russian(self): russian_chars = 0 for char in RUSSIAN_CHARS: if char in self.name: russian_chars += 1 # found a russian char return russian_chars > len(RUSSIAN_CHARS) / 2.0

Checks if file path is russian :return: True iff document has a russian name

def rename(self, new_path): rename_path = fix_raw_path(new_path) if is_folder(self.path): os.rename(self.path, rename_path) else: os.renames(self.path, rename_path)

Renames to new path :param new_path: new path to use

def setClass(self, factoryclass): self.factoryclass = factoryclass self.setText(str(factoryclass.name))

Sets the constructor for the component type this label is to represent :param factoryclass: a class that, when called, results in an instance of the desired class :type factoryclass: callable

def mouseMoveEvent(self, event): if (event.pos() - self.dragStartPosition).manhattanLength() < 10: return QtGui.QApplication.setOverrideCursor(QtGui.QCursor(QtCore.Qt.ClosedHandCursor)) factory = self.factoryclass() mimeData = QtCore.QMimeData() try: mimeData.setData("application/x-protocol", factory.serialize()) except: mimeData.setData("application/x-protocol", cPickle.dumps(factory)) drag = QtGui.QDrag(self) drag.setMimeData(mimeData) pixmap = QtGui.QPixmap() pixmap = pixmap.grabWidget(self, self.frameRect()) # below makes the pixmap half transparent # painter = QtGui.QPainter(pixmap) # painter.setCompositionMode(painter.CompositionMode_DestinationIn) # painter.fillRect(pixmap.rect(), QtGui.QColor(0, 0, 0, 127)) # painter.end() drag.setPixmap(pixmap) drag.setHotSpot(QtCore.QPoint(pixmap.width()/2, pixmap.height()/2)) drag.setPixmap(pixmap) self.dragActive.emit(True) result = drag.exec_(QtCore.Qt.MoveAction) QtGui.QApplication.restoreOverrideCursor()

Determines if a drag is taking place, and initiates it

def columnclean(column): cleanedcolumn = str(column) \ .replace('%', 'percent') \ .replace('(', '_') \ .replace(')', '') \ .replace('As', 'Adenosines') \ .replace('Cs', 'Cytosines') \ .replace('Gs', 'Guanines') \ .replace('Ts', 'Thymines') \ .replace('Ns', 'Unknowns') \ .replace('index', 'adapterIndex') return cleanedcolumn

Modifies column header format to be importable into a database :param column: raw column header :return: cleanedcolumn: reformatted column header

def getLabel(self, key): axisItem = self.getPlotItem().axes[key]['item'] return axisItem.label.toPlainText()

Gets the label assigned to an axes :param key:??? :type key: str

def updateData(self, axeskey, x, y): if axeskey == 'stim': self.stimPlot.setData(x,y) # call manually to ajust placement of signal ranges = self.viewRange() self.rangeChange(self, ranges) if axeskey == 'response': self.clearTraces() if self._traceUnit == 'A': y = y * self._ampScalar if self.zeroAction.isChecked(): start_avg = np.mean(y[5:25]) y = y - start_avg self.tracePlot.setData(x,y*self._polarity)

Replaces the currently displayed data :param axeskey: name of data plot to update. Valid options are 'stim' or 'response' :type axeskey: str :param x: index values associated with y to plot :type x: numpy.ndarray :param y: values to plot at x :type y: numpy.ndarray

def appendData(self, axeskey, bins, ypoints): if axeskey == 'raster' and len(bins) > 0: x, y = self.rasterPlot.getData() # don't plot overlapping points bins = np.unique(bins) # adjust repetition number to response scale ypoints = np.ones_like(bins)*self.rasterYslots[ypoints[0]] x = np.append(x, bins) y = np.append(y, ypoints) self.rasterPlot.setData(x, y)

Appends data to existing plotted data :param axeskey: name of data plot to update. Valid options are 'stim' or 'response' :type axeskey: str :param bins: bins to plot a point for :type bin: numpy.ndarray :param ypoints: iteration number of raster, *should* match bins dimension, but really takes the first value in array for iteration number and plot row at proper place for included bins :type ypoints: numpy.ndarray

def setThreshold(self, threshold): self.threshLine.setValue(threshold) self.threshold_field.setValue(threshold)

Sets the current threshold :param threshold: the y value to set the threshold line at :type threshold: float

def setRasterBounds(self, lims): self.rasterBottom = lims[0] self.rasterTop = lims[1] self.updateRasterBounds()

Sets the raster plot y-axis bounds, where in the plot the raster will appear between :param lims: the (min, max) y-values for the raster plot to be placed between :type lims: (float, float)

def updateRasterBounds(self): yrange = self.viewRange()[1] yrange_size = yrange[1] - yrange[0] rmax = self.rasterTop*yrange_size + yrange[0] rmin = self.rasterBottom*yrange_size + yrange[0] self.rasterYslots = np.linspace(rmin, rmax, self.nreps) self.rasterBoundsUpdated.emit((self.rasterBottom, self.rasterTop), self.getTitle())

Updates the y-coordinate slots where the raster points are plotted, according to the current limits of the y-axis

def askRasterBounds(self): dlg = RasterBoundsDialog(bounds= (self.rasterBottom, self.rasterTop)) if dlg.exec_(): bounds = dlg.values() self.setRasterBounds(bounds)

Prompts the user to provide the raster bounds with a dialog. Saves the bounds to be applied to the plot

def rangeChange(self, pw, ranges): if hasattr(ranges, '__iter__'): # adjust the stim signal so that it falls in the correct range yrange_size = ranges[1][1] - ranges[1][0] stim_x, stim_y = self.stimPlot.getData() if stim_y is not None: stim_height = yrange_size*STIM_HEIGHT # take it to 0 stim_y = stim_y - np.amin(stim_y) # normalize if np.amax(stim_y) != 0: stim_y = stim_y/np.amax(stim_y) # scale for new size stim_y = stim_y*stim_height # raise to right place in plot stim_y = stim_y + (ranges[1][1] - (stim_height*1.1 + (stim_height*0.2))) self.stimPlot.setData(stim_x, stim_y) # rmax = self.rasterTop*yrange_size + ranges[1][0] # rmin = self.rasterBottom*yrange_size + ranges[1][0] self.updateRasterBounds()

Adjusts the stimulus signal to keep it at the top of a plot, after any ajustment to the axes ranges takes place. This is a slot for the undocumented pyqtgraph signal sigRangeChanged. From what I can tell the arguments are: :param pw: reference to the emitting object (plot widget in my case) :type pw: object :param ranges: I am only interested when this turns out to be a nested list of axis bounds :type ranges: object

def update_thresh(self): thresh_val = self.threshLine.value() self.threshold_field.setValue(thresh_val) self.thresholdUpdated.emit(thresh_val, self.getTitle())

Emits a Qt signal thresholdUpdated with the current threshold value

def fromFile(self, fname): spec, f, bins, dur = audiotools.spectrogram(fname, **self.specgramArgs) self.updateImage(spec, bins, f) return dur

Displays a spectrogram of an audio file. Supported formats see :func:`sparkle.tools.audiotools.audioread` :param fname: file path of the audiofile to display :type fname: str :returns: float -- duration of audio recording (seconds)

def updateImage(self, imgdata, xaxis=None, yaxis=None): imgdata = imgdata.T self.img.setImage(imgdata) if xaxis is not None and yaxis is not None: xscale = 1.0/(imgdata.shape[0]/xaxis[-1]) yscale = 1.0/(imgdata.shape[1]/yaxis[-1]) self.resetScale() self.img.scale(xscale, yscale) self.imgScale = (xscale, yscale) self.imageArray = np.fliplr(imgdata) self.updateColormap()

Updates the Widget image directly. :type imgdata: numpy.ndarray, see :meth:`pyqtgraph:pyqtgraph.ImageItem.setImage` :param xaxis: x-axis values, length should match dimension 1 of imgdata :param yaxis: y-axis values, length should match dimension 0 of imgdata

def resetScale(self): self.img.scale(1./self.imgScale[0], 1./self.imgScale[1]) self.imgScale = (1.,1.)

Resets the scale on this image. Correctly aligns time scale, undoes manual scaling

def updateData(self, signal, fs): # use a separate thread to calculate spectrogram so UI doesn't lag t = threading.Thread(target=_doSpectrogram, args=(self.spec_done, (fs, signal),), kwargs=self.specgramArgs) t.start()

Displays a spectrogram of the provided signal :param signal: 1-D signal of audio :type signal: numpy.ndarray :param fs: samplerate of signal :type fs: int

def setSpecArgs(**kwargs): for key, value in kwargs.items(): if key == 'colormap': SpecWidget.imgArgs['lut'] = value['lut'] SpecWidget.imgArgs['levels'] = value['levels'] SpecWidget.imgArgs['state'] = value['state'] for w in SpecWidget.instances: w.updateColormap() else: SpecWidget.specgramArgs[key] = value

Sets optional arguments for the spectrogram appearance. Available options: :param nfft: size of FFT window to use :type nfft: int :param overlap: percent overlap of window :type overlap: number :param window: Type of window to use, choices are hanning, hamming, blackman, bartlett or none (rectangular) :type window: string :param colormap: Gets set by colormap editor. Holds the information to generate the colormap. Items: :meth:`lut<pyqtgraph:pyqtgraph.ImageItem.setLookupTable>`, :meth:`levels<pyqtgraph:pyqtgraph.ImageItem.setLevels>`, state (info for editor) :type colormap: dict

def clearImg(self): self.img.setImage(np.array([[0]])) self.img.image = None

Clears the current image

def editColormap(self): self.editor = pg.ImageView() # remove the ROI and Norm buttons self.editor.ui.roiBtn.setVisible(False) self.editor.ui.menuBtn.setVisible(False) self.editor.setImage(self.imageArray) if self.imgArgs['state'] is not None: self.editor.getHistogramWidget().item.gradient.restoreState(self.imgArgs['state']) self.editor.getHistogramWidget().item.setLevels(*self.imgArgs['levels']) self.editor.closeEvent = self._editor_close self.editor.setWindowModality(QtCore.Qt.ApplicationModal) self.editor.show()

Prompts the user with a dialog to change colormap

def updateColormap(self): if self.imgArgs['lut'] is not None: self.img.setLookupTable(self.imgArgs['lut']) self.img.setLevels(self.imgArgs['levels'])

Updates the currently colormap accoring to stored settings

def appendData(self, xdata, ydata, color='b', legendstr=None): item = self.plot(xdata, ydata, pen=color) if legendstr is not None: self.legend.addItem(item, legendstr) return item

Adds the data to the plot :param xdata: index values for data, plotted on x-axis :type xdata: numpy.ndarray :param ydata: value data to plot, dimension must match xdata :type ydata: numpy.ndarray

def setLabels(self, xlabel=None, ylabel=None, title=None, xunits=None, yunits=None): if xlabel is not None: self.setLabel('bottom', xlabel, units=xunits) if ylabel is not None: self.setLabel('left', ylabel, units=yunits) if title is not None: self.setTitle(title)

Sets the plot labels :param xlabel: X-axis label (do not include units) :type xlabel: str :param ylabel: Y-axis label (do not include units) :type ylabel: str :param title: Plot title :type title: str :param xunit: SI units for the x-axis. An appropriate label will be appended according to scale :type xunit: str :param yunit: SI units for the y-axis. An appropriate label will be appended according to scale :type yunit: str

def setPoint(self, x, group, y): if x == -1: # silence window self.plot([0],[y], symbol='o') else: yindex = self.groups.index(group) xdata, ydata = self.lines[yindex].getData() if ydata is None: xdata = [x] ydata = [y] else: xdata = np.append(xdata, x) ydata = np.append(ydata, y) self.lines[yindex].setData(xdata, ydata)

Sets the given point, connects line to previous point in group :param x: x value of point :type x: float :param group: group which plot point for :type group: float :param y: y value of point :type y: float

def setLabels(self, name): if name == "calibration": self.setWindowTitle("Calibration Curve") self.setTitle("Calibration Curve") self.setLabel('bottom', "Frequency", units='Hz') self.setLabel('left', 'Recorded Intensity (dB SPL)') elif name == "tuning": self.setWindowTitle("Tuning Curve") self.setTitle("Tuning Curve") self.setLabel('bottom', "Frequency", units="Hz") self.setLabel('left', "Spike Count (mean)") else: self.setWindowTitle("Spike Counts") self.setTitle("Spike Counts") self.setLabel('bottom', "Test Number", units='') self.setLabel('left', "Spike Count (mean)", units='')

Sets plot labels, according to predefined options :param name: The type of plot to create labels for. Options: calibration, tuning, anything else labels for spike counts :type name: str

def loadCurve(data, groups, thresholds, absvals, fs, xlabels): xlims = (xlabels[0], xlabels[-1]) pw = ProgressWidget(groups, xlims) spike_counts = [] # skip control for itrace in range(data.shape[0]): count = 0 for ichan in range(data.shape[2]): flat_reps = data[itrace,:,ichan,:].flatten() count += len(spikestats.spike_times(flat_reps, thresholds[ichan], fs, absvals[ichan])) spike_counts.append(count/(data.shape[1]*data.shape[2])) #mean spikes per rep i = 0 for g in groups: for x in xlabels: pw.setPoint(x, g, spike_counts[i]) i +=1 return pw

Accepts a data set from a whole test, averages reps and re-creates the progress plot as the same as it was during live plotting. Number of thresholds must match the size of the channel dimension

def setBins(self, bins): self._bins = bins self._counts = np.zeros_like(self._bins) bar_width = bins[0]*1.5 self.histo.setOpts(x=bins, height=self._counts, width=bar_width) self.setXlim((0, bins[-1]))

Sets the bin centers (x values) :param bins: time bin centers :type bins: numpy.ndarray

def clearData(self): self._counts = np.zeros_like(self._bins) self.histo.setOpts(height=self._counts)

Clears all histograms (keeps bins)

def appendData(self, bins, repnum=None): # only if the last sample was above threshold, but last-1 one wasn't bins[bins >= len(self._counts)] = len(self._counts) -1 bin_totals = np.bincount(bins) self._counts[:len(bin_totals)] += bin_totals self.histo.setOpts(height=np.array(self._counts))

Increases the values at bins (indexes) :param bins: bin center values to increment counts for, to increment a time bin more than once include multiple items in list with that bin center value :type bins: numpy.ndarray

def processData(self, times, response, test_num, trace_num, rep_num): # invert polarity affects spike counting response = response * self._polarity if rep_num == 0: # reset self.spike_counts = [] self.spike_latencies = [] self.spike_rates = [] fs = 1./(times[1] - times[0]) # process response; calculate spike times spike_times = spikestats.spike_times(response, self._threshold, fs) self.spike_counts.append(len(spike_times)) if len(spike_times) > 0: self.spike_latencies.append(spike_times[0]) else: self.spike_latencies.append(np.nan) self.spike_rates.append(spikestats.firing_rate(spike_times, times)) binsz = self._bins[1] - self._bins[0] response_bins = spikestats.bin_spikes(spike_times, binsz) # self.putnotify('spikes_found', (response_bins, rep_num)) self.appendData(response_bins, rep_num)

Calulate spike times from raw response data

def setSr(self, fs): self.tracePlot.setSr(fs) self.stimPlot.setSr(fs)

Sets the samplerate of the input operation being plotted

def setWindowSize(self, winsz): self.tracePlot.setWindowSize(winsz) self.stimPlot.setWindowSize(winsz)

Sets the size of scroll window

def addPlot(self, xdata, ydata, xlabel=None, ylabel=None, title=None, xunits=None, yunits=None): p = SimplePlotWidget(xdata, ydata) p.setLabels(xlabel, ylabel, title, xunits, yunits) # self.plots.append(p) self.stacker.addWidget(p)

Adds a new plot for the given set of data and/or labels, Generates a SimplePlotWidget :param xdata: index values for data, plotted on x-axis :type xdata: numpy.ndarray :param ydata: value data to plot, dimension must match xdata :type ydata: numpy.ndarray

def addSpectrogram(self, ydata, fs, title=None): p = SpecWidget() p.updateData(ydata, fs) if title is not None: p.setTitle(title) self.stacker.addWidget(p)

Adds a new spectorgram plot for the given image. Generates a SpecWidget :param ydata: 2-D array of the image to display :type ydata: numpy.ndarray :param fs: the samplerate of the signal in the image, used to set time/ frequency scale :type fs: int :param title: Plot title :type title: str

def nextPlot(self): if self.stacker.currentIndex() < self.stacker.count(): self.stacker.setCurrentIndex(self.stacker.currentIndex()+1)

Moves the displayed plot to the next one

def prevPlot(self): if self.stacker.currentIndex() > 0: self.stacker.setCurrentIndex(self.stacker.currentIndex()-1)

Moves the displayed plot to the previous one

def most_even_chunk(string, group): counts = [0] + most_even(len(string), group) indices = accumulate(counts) slices = window(indices, 2) return [string[slice(*one)] for one in slices]

Divide a string into a list of strings as even as possible.

def most_even(number, group): count, rest = divmod(number, group) counts = zip_longest([count] * group, [1] * rest, fillvalue=0) chunks = [sum(one) for one in counts] logging.debug('chunks: %s', chunks) return chunks

Divide a number into a list of numbers as even as possible.

def window(seq, count=2): iseq = iter(seq) result = tuple(islice(iseq, count)) if len(result) == count: yield result for elem in iseq: result = result[1:] + (elem,) yield result

Slide window.

def _get_modules(path): lst = [] folder_contents = os.listdir(path) is_python_module = "__init__.py" in folder_contents if is_python_module: for file in folder_contents: full_path = os.path.join(path, file) if is_file(full_path): lst.append(full_path) if is_folder(full_path): lst += _get_modules(full_path) # recurse in folder return list(set(lst))

Finds modules in folder recursively :param path: directory :return: list of modules

def get_modules(folder, include_meta=False): files = [ file for file in _get_modules(folder) if is_file(file) # just files ] if not include_meta: files = [ file for file in files if not Document(file).name.startswith("__") ] return files

Finds modules (recursively) in folder :param folder: root folder :param include_meta: whether include meta files like (__init__ or __version__) :return: list of modules

def _parse(self): with open(self.path, "rt") as reader: return ast.parse(reader.read(), filename=self.path)

Parses file contents :return: Tree hierarchy of file

def _find_package(self, root_package): package = self.path.replace(root_package, "") if package.endswith(".py"): package = package[:-3] package = package.replace(os.path.sep, MODULE_SEP) root_package = get_folder_name(root_package) package = root_package + package # add root return package

Finds package name of file :param root_package: root package :return: package name

def _get_instances(self, instance): return [ x for x in self.tree.body if isinstance(x, instance) ]

Finds all instances of instance in tree :param instance: type of object :return: list of objects in tree of same instance

def get_classes(self): instances = self._get_instances(ast.ClassDef) instances = [ PyClass(instance, self.package) for instance in instances ] return instances

Finds classes in file :return: list of top-level classes

def get_functions(self): instances = self._get_instances(ast.FunctionDef) instances = [ PyFunction(instance, self.package) for instance in instances ] return instances

Finds top-level functions in file :return: list of top-level functions

def get_functions(self, include_meta=False): instances = self._get_instances(ast.FunctionDef) instances = [ PyFunction(instance, self.full_package) # fix package name for instance in instances ] if not include_meta: instances = [ instance # fix package name for instance in instances if not instance.get_name().startswith("__") ] return instances

Finds top-level functions in file :param include_meta: whether include meta functions like (__init__) :return: list of top-level functions

def reads(err_log): # Initialise variables num_reads = 0 paired_reads = 0 # Open the log file with open(err_log, 'r') as error_log: # Extract the necessary information for line in error_log: if 'Pairs:' in line: num_reads = line.split('\t')[-1].rstrip() elif 'Joined:' in line: paired_reads = line.split('\t')[-2].rstrip() return num_reads, paired_reads

Parse the outputs from bbmerge to extract the total number of reads, as well as the number of reads that could be paired :param err_log: bbmerge outputs the stats in the error file :return: num_reads, the total number of reads, paired_reads, number of paired readds

def best_assemblyfile(self): for sample in self.metadata: try: # Set the name of the filtered assembly file filtered_outputfile = os.path.join(self.path, 'raw_assemblies', '{}.fasta'.format(sample.name)) # Set the name of the unfiltered spades assembly output file if os.path.isfile(sample.general.assemblyfile): size = os.path.getsize(sample.general.assemblyfile) # Ensure that the assembly isn't just an empty file if size == 0: sample.general.bestassemblyfile = 'NA' else: sample.general.bestassemblyfile = sample.general.assemblyfile shutil.copyfile(sample.general.bestassemblyfile, filtered_outputfile) else: sample.general.bestassemblyfile = 'NA' # Add the name and path of the filtered file to the metadata sample.general.filteredfile = filtered_outputfile except AttributeError: sample.general.assemblyfile = 'NA' sample.general.bestassemblyfile = 'NA'

Determine whether the contigs.fasta output file from the assembler is present. If not, set the .bestassembly attribute to 'NA'

def groups(self): if not self._groups: self._groups = ComponentGroups(self.api_client) return self._groups

Component groups Special property which point to a :class:`~pylls.cachet.ComponentGroups` instance for convenience. This instance is initialized on first call.

def get(self, component_id=None, **kwargs): path = 'components' if component_id is not None: path += '/%s' % component_id return self.paginate_get(path, data=kwargs)

Get components :param component_id: Component ID (optional) :return: Components data (:class:`Generator`) Additional named arguments may be passed and are directly transmitted to API. It is useful to use the API search features. .. seealso:: https://docs.cachethq.io/reference#get-components .. seealso:: https://docs.cachethq.io/docs/advanced-api-usage

def create(self, name, status, description="", link="", order=0, group_id=0, enabled=True): data = ApiParams() data['name'] = name data['status'] = status data['description'] = description data['link'] = link data['order'] = order data['group_id'] = group_id data['enabled'] = enabled return self._post('components', data=data)['data']

Create a new component :param str name: Name of the component :param int status: Status of the component; 1-4 :param str description: Description of the component (optional) :param str link: A hyperlink to the component (optional) :param int order: Order of the component (optional) :param int group_id: The group ID of the component (optional) :param bool enabled: Whether the component is enabled (optional) :return: Created component data (:class:`dict`) .. seealso:: https://docs.cachethq.io/reference#components .. seealso:: https://docs.cachethq.io/docs/component-statuses

def update(self, component_id, name=None, status=None, description=None, link=None, order=None, group_id=None, enabled=True): data = ApiParams() data['component'] = component_id data['name'] = name data['status'] = status data['description'] = description data['link'] = link data['order'] = order data['group_id'] = group_id data['enabled'] = enabled return self._put('components/%s' % component_id, data=data)['data']

Update a component :param int component_id: Component ID :param str name: Name of the component (optional) :param int status: Status of the component; 1-4 :param str description: Description of the component (optional) :param str link: A hyperlink to the component (optional) :param int order: Order of the component (optional) :param int group_id: The group ID of the component (optional) :param bool enabled: Whether the component is enabled (optional) :return: Updated component data (:class:`dict`) .. seealso:: https://docs.cachethq.io/reference#components .. seealso:: https://docs.cachethq.io/docs/component-statuses

def get(self, group_id=None, **kwargs): path = 'components/groups' if group_id is not None: path += '/%s' % group_id return self.paginate_get(path, data=kwargs)

Get component groups :param group_id: Component group ID (optional) :return: Component groups data (:class:`dict`) Additional named arguments may be passed and are directly transmitted to API. It is useful to use the API search features. .. seealso:: https://docs.cachethq.io/reference#get-componentgroups .. seealso:: https://docs.cachethq.io/docs/advanced-api-usage

def create(self, name, order=None, collapsed=None): data = ApiParams() data['name'] = name data['order'] = order data['collapsed'] = collapsed return self._post('components/groups', data=data)['data']

Create a new Component Group :param str name: Name of the component group :param int order: Order of the component group :param int collapsed: Collapse the group? 0-2 :return: Created component group data (:class:`dict`) .. seealso:: https://docs.cachethq.io/reference#post-componentgroups

def update(self, group_id, name=None, order=None, collapsed=None): data = ApiParams() data['group'] = group_id data['name'] = name data['order'] = order data['collapsed'] = collapsed return self._put('components/groups/%s' % group_id, data=data)['data']

Update a Component Group :param int group_id: Component Group ID :param str name: Name of the component group :param int order: Order of the group :param int collapsed: Collapse the group? :return: Updated component group data (:class:`dict`) .. seealso:: https://docs.cachethq.io/reference#put-component-group

def get(self, incident_id=None, **kwargs): path = 'incidents' if incident_id is not None: path += '/%s' % incident_id return self.paginate_get(path, data=kwargs)

Get incidents :param int incident_id: :return: Incidents data (:class:`dict`) Additional named arguments may be passed and are directly transmitted to API. It is useful to use the API search features. .. seealso:: https://docs.cachethq.io/reference#get-incidents .. seealso:: https://docs.cachethq.io/docs/advanced-api-usage

def create(self, name, message, status, visible, component_id=None, component_status=None, notify=None, created_at=None, template=None, tplvars=None): data = ApiParams() data['name'] = name data['message'] = message data['status'] = status data['visible'] = visible data['component_id'] = component_id data['component_status'] = component_status data['notify'] = notify data['created_at'] = created_at data['template'] = template data['vars'] = tplvars return self._post('incidents', data=data)['data']

Create a new Incident :param str name: Name of the incident :param str message: Incident explanation message :param int status: Status of the incident :param int visible: Whether the incident is publicly visible :param int component_id: Component to update :param int component_status: The status to update the given component :param bool notify: Whether to notify subscribers :param str created_at: When the incident was created :param str template: The template slug to use :param list tplvars: The variables to pass to the template :return: Created incident data (:class:`dict`) .. seealso:: https://docs.cachethq.io/reference#incidents

def update(self, incident_id, name=None, message=None, status=None, visible=None, component_id=None, component_status=None, notify=None, created_at=None, template=None, tpl_vars=None): data = ApiParams() data['name'] = name data['message'] = message data['status'] = status data['visible'] = visible data['component_id'] = component_id data['component_status'] = component_status data['notify'] = notify data['created_at'] = created_at data['template'] = template data['vars'] = tpl_vars return self._put('incidents/%s' % incident_id, data=data)['data']

Update an Incident :param int incident_id: Incident ID :param str name: Name of the incident :param str message: Incident explanation message :param int status: Status of the incident :param int visible: Whether the incident is publicly visible :param int component_id: Component to update :param int component_status: The status to update the given component :param bool notify: Whether to notify subscribers :param str created_at: When the incident was created :param str template: The template slug to use :param list tpl_vars: The variables to pass to the template :return: Created incident data (:class:`dict`) .. seealso:: https://docs.cachethq.io/reference#update-an-incident

def points(self): if not self._points: self._points = MetricPoints(self.api_client) return self._points

Metric points Special property which point to a :class:`~pylls.cachet.MetricPoints` instance for convenience. This instance is initialized on first call.

def get(self, metric_id=None, **kwargs): path = 'metrics' if metric_id is not None: path += '/%s' % metric_id return self.paginate_get(path, data=kwargs)

Get metrics :param int metric_id: Metric ID :return: Metrics data (:class:`dict`) Additional named arguments may be passed and are directly transmitted to API. It is useful to use the API search features. .. seealso:: https://docs.cachethq.io/reference#get-metrics .. seealso:: https://docs.cachethq.io/docs/advanced-api-usage

def create(self, name, suffix, description, default_value, display=None): data = ApiParams() data['name'] = name data['suffix'] = suffix data['description'] = description data['default_value'] = default_value data['display'] = display return self._post('metrics', data=data)['data']

Create a new Metric :param str name: Name of metric :param str suffix: Metric unit :param str description: Description of what the metric is measuring :param int default_value: Default value to use when a point is added :param int display: Display the chart on the status page :return: Created metric data (:class:`dict`) .. seealso:: https://docs.cachethq.io/reference#metrics

def create(self, metric_id, value, timestamp=None): data = ApiParams() data['value'] = value data['timestamp'] = timestamp return self._post('metrics/%s/points' % metric_id, data=data)['data']

Add a Metric Point to a Metric :param int metric_id: Metric ID :param int value: Value to plot on the metric graph :param str timestamp: Unix timestamp of the point was measured :return: Created metric point data (:class:`dict`) .. seealso:: https://docs.cachethq.io/reference#post-metric-points

def create(self, email, verify=None, components=None): data = ApiParams() data['email'] = email data['verify'] = verify data['components'] = components return self._post('subscribers', data=data)['data']

Create a new subscriber :param str email: Email address to subscribe :param bool verify: Whether to send verification email :param list components: Components ID list, defaults to all :return: Created subscriber data (:class:`dict`) .. seealso:: https://docs.cachethq.io/reference#subscribers

def annotatedcore(self): logging.info('Calculating annotated core') # Determine the total number of core genes self.total_core() # Iterate through all the samples, and process all Escherichia for sample in self.metadata: if sample.general.bestassemblyfile != 'NA': # Create a set to store the names of all the core genes in this strain sample[self.analysistype].coreset = set() if sample.general.referencegenus == 'Escherichia': # Add the Escherichia sample to the runmetadata self.runmetadata.samples.append(sample) # Parse the BLAST report try: report = sample[self.analysistype].report self.blastparser(report=report, sample=sample, fieldnames=self.fieldnames) except KeyError: sample[self.analysistype].coreset = list() # Create the report self.reporter()

Calculates the core genome of organisms using custom databases

def total_core(self): corefile = os.path.join(self.reffilepath, self.analysistype, 'Escherichia', 'core_combined.fasta') for record in SeqIO.parse(corefile, 'fasta'): gene_name = record.id.split('-')[0] if gene_name not in self.coregenomes: self.coregenomes.append(gene_name)

Determine the total number of core genes present

def blastparser(self, report, sample, fieldnames): try: # Open the sequence profile file as a dictionary blastdict = DictReader(open(report), fieldnames=self.fieldnames, dialect='excel-tab') # Go through each BLAST result for row in blastdict: # Ignore the headers if row['query_id'].startswith(fieldnames[0]): pass else: # Calculate the percent identity and extract the bitscore from the row # Percent identity is the (length of the alignment - number of mismatches) / total subject length percentidentity = float('{:0.2f}'.format((float(row['positives']) - float(row['gaps'])) / float(row['subject_length']) * 100)) # Split off any | and - from the sample name target = row['subject_id'].split('|')[0].split('-')[0] # If the hit passes the cutoff threshold, add it to the set of core genes present if percentidentity >= self.cutoff: sample[self.analysistype].coreset.add(target) except FileNotFoundError: pass

Parse the number of core genes present in the strain from the BLAST outputs :param report: the name and path of the BLAST outputs :param sample: the sample object :param fieldnames: type LIST: List of fields used to in BLAST analyses

def reporter(self): with open(os.path.join(self.reportpath, 'Escherichia_core.csv'), 'w') as report: data = 'Strain,Genes Present/Total\n' for sample in self.runmetadata.samples: # Convert the set to a list for JSON serialization sample[self.analysistype].coreset = list(sample[self.analysistype].coreset) sample[self.analysistype].coreresults = '{cs}/{cg}'.format(cs=len(sample[self.analysistype].coreset), cg=len(self.coregenomes)) # Add strain name, the number of core genes present, and the number of total core genes to the string data += '{sn},{cr}\n'.format(sn=sample.name, cr=sample[self.analysistype].coreresults) report.write(data) for sample in self.metadata: # Remove the messy blast results and set/list of core genes from the object try: delattr(sample[self.analysistype], "blastresults") except AttributeError: pass try: delattr(sample[self.analysistype], 'coreset') except AttributeError: pass

Create a .csv file with the strain name, and the number of core genes present/the total number of core genes

def get_simple_output(self, stderr=STDOUT): args = shlex.split(self.cmd) proc = Popen(args, stdout=PIPE, stderr=stderr) return proc.communicate()[0].decode("utf8")

Executes a simple external command and get its output The command contains no pipes. Error messages are redirected to the standard output by default :param stderr: where to put stderr :return: output of command

def get_complex_output(self, stderr=STDOUT): proc = Popen(self.cmd, shell=True, stdout=PIPE, stderr=stderr) return proc.stdout.readlines()

Executes a piped command and get the lines of the output in a list :param stderr: where to put stderr :return: output of command

def get_output_from_pipe(self, input_file): args = shlex.split(self.cmd) p = Popen(args, stdout=PIPE, stdin=PIPE) # | grep es p.stdin.write(bytearray(input_file.encode("utf8"))) # echo test | return p.communicate()[0].decode("utf8")

Executes an external command and get its output. The command receives its input_file from the stdin through a pipe :param input_file: input file :return: output of command

def get_return_code(self, stderr=STDOUT): args = shlex.split(self.cmd) return call(args, stdout=PIPE, stderr=stderr)

Executes a simple external command and return its exit status :param stderr: where to put stderr :return: return code of command

def get_exit_code(self): args = shlex.split(self.cmd) proc = Popen(args, stdout=PIPE, stderr=PIPE) out, err = proc.communicate() out, err = out.decode("utf8"), err.decode("utf8") exitcode = proc.returncode # return exitcode, out, err

Executes the external command and get its exitcode, stdout and stderr :return: exit code of command

def execute_in_background(self): # http://stackoverflow.com/questions/1605520 args = shlex.split(self.cmd) p = Popen(args) return p.pid

Executes a (shell) command in the background :return: the process' pid

def keep_alive(self): while True: pid = self.execute_in_background() p = psutil.Process(pid) while p.is_running() and str(p.status) != 'zombie': os.system('sleep 5')

Keeps a process alive. If the process terminates, it will restart it The terminated processes become zombies. They die when their parent terminates

def get_free_mb(folder): if platform.system() == 'Windows': free_bytes = ctypes.c_ulonglong(0) ctypes.windll.kernel32.GetDiskFreeSpaceExW(ctypes.c_wchar_p(folder), None, None, ctypes.pointer(free_bytes)) return free_bytes.value/1024/1024 else: st = os.statvfs(folder) return st.f_bavail * st.f_frsize/1024/1024

Return folder/drive free space (in bytes)

def increment_title(title): count = re.search('\d+$', title).group(0) new_title = title[:-(len(count))] + str(int(count)+1) return new_title

Increments a string that ends in a number

def check_limit(self, limit): if limit > 0: self.limit = limit else: raise ValueError("Rule limit must be strictly > 0 ({0} given)" .format(limit)) return self

Checks if the given limit is valid. A limit must be > 0 to be considered valid. Raises ValueError when the *limit* is not > 0.

def build_filter(self, filter): try: self.filter = Filter.from_string(filter, self.limit) except ValueError: raise return self

Tries to build a :class:`filter.Filter` instance from the given filter. Raises ValueError if the :class:`filter.Filter` object can't be build from the given filter.

def build_action(self, action): try: self.action = Action.from_string(action) except ValueError: raise return self

Tries to build an :class:`action.Action` instance from the given action. Raises ValueError if the :class:`action.Action` object can't be build from the given action.

def get_args(): ap = argparse.ArgumentParser(description="Create frames for a movie that can be compiled using ffmpeg") ap.add_argument("start", help="date string as start time") ap.add_argument("end", help="date string as end time") ap.add_argument("step", type=float, help="fraction of a day to step by") ap.add_argument("--config", help="path to a config file", default="config.json") return ap.parse_args()

request the arguments for running

def make_three_color(data, time, step, config, shape=(1280, 1280), lower_val=(0, 0, 0), upper_val=(2.5, 2.5, 2.5)): order = {'red': 0, 'green': 1, 'blue': 2} three_color = np.zeros((shape[0], shape[1], 3)) channel_colors = {color: config.default[color] for color in ['red', 'green', 'blue']} for color, channel in channel_colors.items(): if data[channel][1] is None or \ abs((time - date_parser.parse(data[channel][0]['date-end'])).total_seconds()) > step.total_seconds()/2.0: return np.zeros((shape[0], shape[1], 3)) three_color[:, :, order[color]] = data[channel][1] # scale the image by the power three_color[:, :, order[color]] = np.power(three_color[:, :, order[color]], config.default["{}_power".format(color)]) # adjust the percentile thresholds lower = lower_val[order[color]] upper = upper_val[order[color]] three_color[np.where(three_color[:, :, order[color]] < lower)] = lower three_color[np.where(three_color[:, :, order[color]] > upper)] = upper # image values must be between (0,1) so scale image for color, index in order.items(): three_color[:, :, index] /= upper_val[order[color]] return three_color

create a three color image according to the config file :param data: a dictionary of fetched data where keys correspond to products :param config: a config object :param shape: the size of a composite image :param lower_val: a tuple of lower values for RGB, any value below this is set to the low value :param upper_val: a tuple of upper values for RGB, any value above this is set to the high value :return: a (m,n,3) numpy array for a three color image where all values are between 0 and 1

def main(): args = get_args() args.start = date_parser.parse(args.start) args.end = date_parser.parse(args.end) args.step = timedelta(args.step) config = Config(args.config) times = [args.start + i * args.step for i in range(int((args.end - args.start) / args.step))] for i, time in enumerate(times): make_plot(time, config, args.step)

process the main task

def overall(): return ZeroOrMore(Grammar.comment) + Dict(ZeroOrMore(Group( Grammar._section + ZeroOrMore(Group(Grammar.line))) ))

The overall grammer for pulling apart the main input files.

def file(): return ( Optional(Word(alphanums).setResultsName('alias') + Suppress(Literal('.'))) + Suppress(White()) + Word(approved_printables).setResultsName('filename') )

Grammar for files found in the overall input files.

def command_lines(): return ZeroOrMore(Group( Group(ZeroOrMore(Group(Grammar.comment))) + Grammar._non_comment_line ))

Grammar for commands found in the overall input files.