signature
stringlengths 8
3.44k
| body
stringlengths 0
1.41M
| docstring
stringlengths 1
122k
| id
stringlengths 5
17
|
|---|---|---|---|
def deleteBy(self, func): | oldrows = copy(self.rows)<EOL>oldidx = self.cursorRowIndex<EOL>ndeleted = <NUM_LIT:0><EOL>row = None <EOL>while oldidx < len(oldrows):<EOL><INDENT>if not func(oldrows[oldidx]):<EOL><INDENT>row = self.rows[oldidx]<EOL>break<EOL><DEDENT>oldidx += <NUM_LIT:1><EOL><DEDENT>self.rows.clear()<EOL>for r in Progress(oldrows, '<STR_LIT>'):<EOL><INDENT>if not func(r):<EOL><INDENT>self.rows.append(r)<EOL>if r is row:<EOL><INDENT>self.cursorRowIndex = len(self.rows)-<NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>ndeleted += <NUM_LIT:1><EOL><DEDENT><DEDENT>status('<STR_LIT>' % (ndeleted, self.rowtype))<EOL>return ndeleted<EOL> | Delete rows for which func(row) is true. Returns number of deleted rows. | f1802:c13:m13 |
@asyncthread<EOL><INDENT>def deleteSelected(self):<DEDENT> | ndeleted = self.deleteBy(self.isSelected)<EOL>nselected = len(self._selectedRows)<EOL>self._selectedRows.clear()<EOL>if ndeleted != nselected:<EOL><INDENT>error('<STR_LIT>' % nselected)<EOL><DEDENT> | Delete all selected rows. | f1802:c13:m14 |
@property<EOL><INDENT>def nVisibleRows(self):<DEDENT> | return self.vd.windowHeight-<NUM_LIT:2><EOL> | Number of visible rows at the current window height. | f1802:c13:m19 |
@property<EOL><INDENT>def cursorCol(self):<DEDENT> | return self.visibleCols[self.cursorVisibleColIndex]<EOL> | Current Column object. | f1802:c13:m20 |
@property<EOL><INDENT>def cursorRow(self):<DEDENT> | return self.rows[self.cursorRowIndex]<EOL> | The row object at the row cursor. | f1802:c13:m21 |
@property<EOL><INDENT>def visibleRows(self): <DEDENT> | return self.rows[self.topRowIndex:self.topRowIndex+self.nVisibleRows]<EOL> | List of rows onscreen. | f1802:c13:m22 |
@property<EOL><INDENT>@functools.lru_cache() <EOL>def visibleCols(self): <DEDENT> | return self.keyCols + [c for c in self.columns if not c.hidden and not c.keycol]<EOL> | List of `Column` which are not hidden. | f1802:c13:m23 |
@property<EOL><INDENT>@functools.lru_cache() <EOL>def keyCols(self):<DEDENT> | return [c for c in self.columns if c.keycol and not c.hidden]<EOL> | Cached list of visible key columns (Columns with .key=True) | f1802:c13:m25 |
@property<EOL><INDENT>def cursorColIndex(self):<DEDENT> | return self.columns.index(self.cursorCol)<EOL> | Index of current column into `columns`. Linear search; prefer `cursorCol` or `cursorVisibleColIndex`. | f1802:c13:m26 |
@property<EOL><INDENT>def nonKeyVisibleCols(self):<DEDENT> | return [c for c in self.columns if not c.hidden and c not in self.keyCols]<EOL> | All columns which are not keysList of unhidden non-key columns. | f1802:c13:m27 |
@property<EOL><INDENT>def keyColNames(self):<DEDENT> | return '<STR_LIT:U+0020>'.join(c.name for c in self.keyCols)<EOL> | String of key column names, for SheetsSheet convenience. | f1802:c13:m28 |
@property<EOL><INDENT>def cursorCell(self):<DEDENT> | return self.cursorCol.getCell(self.cursorRow)<EOL> | Displayed value (DisplayWrapper) at current row and column. | f1802:c13:m29 |
@property<EOL><INDENT>def cursorDisplay(self):<DEDENT> | return self.cursorCol.getDisplayValue(self.cursorRow)<EOL> | Displayed value (DisplayWrapper.display) at current row and column. | f1802:c13:m30 |
@property<EOL><INDENT>def cursorTypedValue(self):<DEDENT> | return self.cursorCol.getTypedValue(self.cursorRow)<EOL> | Typed value at current row and column. | f1802:c13:m31 |
@property<EOL><INDENT>def cursorValue(self):<DEDENT> | return self.cursorCol.getValue(self.cursorRow)<EOL> | Raw value at current row and column. | f1802:c13:m32 |
@property<EOL><INDENT>def statusLine(self):<DEDENT> | rowinfo = '<STR_LIT>' % (self.cursorRowIndex, self.nRows, len(self._selectedRows))<EOL>colinfo = '<STR_LIT>' % (self.cursorColIndex, self.nCols, len(self.visibleCols))<EOL>return '<STR_LIT>' % (rowinfo, colinfo)<EOL> | String of row and column stats. | f1802:c13:m33 |
@property<EOL><INDENT>def nRows(self):<DEDENT> | return len(self.rows)<EOL> | Number of rows on this sheet. | f1802:c13:m34 |
@property<EOL><INDENT>def nCols(self):<DEDENT> | return len(self.columns)<EOL> | Number of columns on this sheet. | f1802:c13:m35 |
@property<EOL><INDENT>def nVisibleCols(self):<DEDENT> | return len(self.visibleCols)<EOL> | Number of visible columns on this sheet. | f1802:c13:m36 |
def isSelected(self, row): | return id(row) in self._selectedRows<EOL> | True if given row is selected. O(log n). | f1802:c13:m37 |
@asyncthread<EOL><INDENT>def toggle(self, rows):<DEDENT> | for r in Progress(rows, '<STR_LIT>', total=len(self.rows)):<EOL><INDENT>if not self.unselectRow(r):<EOL><INDENT>self.selectRow(r)<EOL><DEDENT><DEDENT> | Toggle selection of given `rows`. | f1802:c13:m38 |
def selectRow(self, row): | self._selectedRows[id(row)] = row<EOL> | Select given row. O(log n) | f1802:c13:m39 |
def unselectRow(self, row): | if id(row) in self._selectedRows:<EOL><INDENT>del self._selectedRows[id(row)]<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT> | Unselect given row, return True if selected; else return False. O(log n) | f1802:c13:m40 |
@asyncthread<EOL><INDENT>def select(self, rows, status=True, progress=True):<DEDENT> | before = len(self._selectedRows)<EOL>if options.bulk_select_clear:<EOL><INDENT>self._selectedRows.clear()<EOL><DEDENT>for r in (Progress(rows, '<STR_LIT>') if progress else rows):<EOL><INDENT>self.selectRow(r)<EOL><DEDENT>if status:<EOL><INDENT>if options.bulk_select_clear:<EOL><INDENT>msg = '<STR_LIT>' % (len(self._selectedRows), self.rowtype, '<STR_LIT>' if before > <NUM_LIT:0> else '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>msg = '<STR_LIT>' % (len(self._selectedRows)-before, '<STR_LIT>' if before > <NUM_LIT:0> else '<STR_LIT>', self.rowtype)<EOL><DEDENT>vd.status(msg)<EOL><DEDENT> | Bulk select given rows. Don't show progress if progress=False; don't show status if status=False. | f1802:c13:m41 |
@asyncthread<EOL><INDENT>def unselect(self, rows, status=True, progress=True):<DEDENT> | before = len(self._selectedRows)<EOL>for r in (Progress(rows, '<STR_LIT>') if progress else rows):<EOL><INDENT>self.unselectRow(r)<EOL><DEDENT>if status:<EOL><INDENT>vd().status('<STR_LIT>' % (before-len(self._selectedRows), before, self.rowtype))<EOL><DEDENT> | Unselect given rows. Don't show progress if progress=False; don't show status if status=False. | f1802:c13:m42 |
def selectByIdx(self, rowIdxs): | self.select((self.rows[i] for i in rowIdxs), progress=False)<EOL> | Select given row indexes, without progress bar. | f1802:c13:m43 |
def unselectByIdx(self, rowIdxs): | self.unselect((self.rows[i] for i in rowIdxs), progress=False)<EOL> | Unselect given row indexes, without progress bar. | f1802:c13:m44 |
def gatherBy(self, func): | for i in rotate_range(len(self.rows), self.cursorRowIndex):<EOL><INDENT>try:<EOL><INDENT>r = self.rows[i]<EOL>if func(r):<EOL><INDENT>yield r<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT><DEDENT> | Generate only rows for which the given func returns True. | f1802:c13:m45 |
@property<EOL><INDENT>def selectedRows(self):<DEDENT> | if len(self._selectedRows) <= <NUM_LIT:1>:<EOL><INDENT>return list(self._selectedRows.values())<EOL><DEDENT>return [r for r in self.rows if id(r) in self._selectedRows]<EOL> | List of selected rows in sheet order. [O(nRows*log(nSelected))] | f1802:c13:m47 |
def cursorDown(self, n=<NUM_LIT:1>): | self.cursorRowIndex += n<EOL> | Move cursor down `n` rows (or up if `n` is negative). | f1802:c13:m48 |
def cursorRight(self, n=<NUM_LIT:1>): | self.cursorVisibleColIndex += n<EOL>self.calcColLayout()<EOL> | Move cursor right `n` visible columns (or left if `n` is negative). | f1802:c13:m49 |
def pageLeft(self): | targetIdx = self.leftVisibleColIndex <EOL>firstNonKeyVisibleColIndex = self.visibleCols.index(self.nonKeyVisibleCols[<NUM_LIT:0>])<EOL>while self.rightVisibleColIndex != targetIdx and self.leftVisibleColIndex > firstNonKeyVisibleColIndex:<EOL><INDENT>self.cursorVisibleColIndex -= <NUM_LIT:1><EOL>self.leftVisibleColIndex -= <NUM_LIT:1><EOL>self.calcColLayout() <EOL><DEDENT>if self.rightVisibleColIndex == self.nVisibleCols-<NUM_LIT:1>:<EOL><INDENT>while self.leftVisibleColIndex > <NUM_LIT:0>:<EOL><INDENT>rightcol = self.visibleCols[self.rightVisibleColIndex]<EOL>if rightcol.width > self.visibleColLayout[self.rightVisibleColIndex][<NUM_LIT:1>]:<EOL><INDENT>self.cursorVisibleColIndex += <NUM_LIT:1><EOL>self.leftVisibleColIndex += <NUM_LIT:1><EOL>break<EOL><DEDENT>else:<EOL><INDENT>self.cursorVisibleColIndex -= <NUM_LIT:1><EOL>self.leftVisibleColIndex -= <NUM_LIT:1><EOL>self.calcColLayout()<EOL><DEDENT><DEDENT><DEDENT> | Redraw page one screen to the left.
Note: keep the column cursor in the same general relative position:
- if it is on the furthest right column, then it should stay on the
furthest right column if possible
- likewise on the left or in the middle
So really both the `leftIndex` and the `cursorIndex` should move in
tandem until things are correct. | f1802:c13:m50 |
def addColumn(self, col, index=None): | if col:<EOL><INDENT>if index is None:<EOL><INDENT>index = len(self.columns)<EOL><DEDENT>col.sheet = self<EOL>self.columns.insert(index, col)<EOL>return col<EOL><DEDENT> | Insert column at given index or after all columns. | f1802:c13:m51 |
def rowkey(self, row): | return tuple(c.getTypedValueOrException(row) for c in self.keyCols)<EOL> | returns a tuple of the key for the given row | f1802:c13:m55 |
def checkCursor(self): | <EOL>if self.nRows == <NUM_LIT:0> or self.cursorRowIndex <= <NUM_LIT:0>:<EOL><INDENT>self.cursorRowIndex = <NUM_LIT:0><EOL><DEDENT>elif self.cursorRowIndex >= self.nRows:<EOL><INDENT>self.cursorRowIndex = self.nRows-<NUM_LIT:1><EOL><DEDENT>if self.cursorVisibleColIndex <= <NUM_LIT:0>:<EOL><INDENT>self.cursorVisibleColIndex = <NUM_LIT:0><EOL><DEDENT>elif self.cursorVisibleColIndex >= self.nVisibleCols:<EOL><INDENT>self.cursorVisibleColIndex = self.nVisibleCols-<NUM_LIT:1><EOL><DEDENT>if self.topRowIndex <= <NUM_LIT:0>:<EOL><INDENT>self.topRowIndex = <NUM_LIT:0><EOL><DEDENT>elif self.topRowIndex > self.nRows-<NUM_LIT:1>:<EOL><INDENT>self.topRowIndex = self.nRows-<NUM_LIT:1><EOL><DEDENT>x = self.cursorVisibleColIndex - self.leftVisibleColIndex<EOL>y = self.cursorRowIndex - self.topRowIndex + <NUM_LIT:1> <EOL>if y < <NUM_LIT:1>:<EOL><INDENT>self.topRowIndex = self.cursorRowIndex<EOL><DEDENT>elif y > self.nVisibleRows:<EOL><INDENT>self.topRowIndex = self.cursorRowIndex-self.nVisibleRows+<NUM_LIT:1><EOL><DEDENT>if x <= <NUM_LIT:0>:<EOL><INDENT>self.leftVisibleColIndex = self.cursorVisibleColIndex<EOL><DEDENT>else:<EOL><INDENT>while True:<EOL><INDENT>if self.leftVisibleColIndex == self.cursorVisibleColIndex: <EOL><INDENT>break<EOL><DEDENT>self.calcColLayout()<EOL>mincolidx, maxcolidx = min(self.visibleColLayout.keys()), max(self.visibleColLayout.keys())<EOL>if self.cursorVisibleColIndex < mincolidx:<EOL><INDENT>self.leftVisibleColIndex -= max((self.cursorVisibleColIndex - mincolid)//<NUM_LIT:2>, <NUM_LIT:1>)<EOL>continue<EOL><DEDENT>elif self.cursorVisibleColIndex > maxcolidx:<EOL><INDENT>self.leftVisibleColIndex += max((maxcolidx - self.cursorVisibleColIndex)//<NUM_LIT:2>, <NUM_LIT:1>)<EOL>continue<EOL><DEDENT>cur_x, cur_w = self.visibleColLayout[self.cursorVisibleColIndex]<EOL>if cur_x+cur_w < self.vd.windowWidth: <EOL><INDENT>break<EOL><DEDENT>self.leftVisibleColIndex += <NUM_LIT:1><EOL><DEDENT><DEDENT> | Keep cursor in bounds of data and screen. | f1802:c13:m56 |
def calcColLayout(self): | minColWidth = len(options.disp_more_left)+len(options.disp_more_right)<EOL>sepColWidth = len(options.disp_column_sep)<EOL>winWidth = self.vd.windowWidth<EOL>self.visibleColLayout = {}<EOL>x = <NUM_LIT:0><EOL>vcolidx = <NUM_LIT:0><EOL>for vcolidx in range(<NUM_LIT:0>, self.nVisibleCols):<EOL><INDENT>col = self.visibleCols[vcolidx]<EOL>if col.width is None and len(self.visibleRows) > <NUM_LIT:0>:<EOL><INDENT>col.width = col.getMaxWidth(self.visibleRows)+minColWidth<EOL>if vcolidx != self.nVisibleCols-<NUM_LIT:1>: <EOL><INDENT>col.width = min(col.width, options.default_width)<EOL><DEDENT><DEDENT>width = col.width if col.width is not None else options.default_width<EOL>if col in self.keyCols:<EOL><INDENT>width = max(width, <NUM_LIT:1>) <EOL><DEDENT>if col in self.keyCols or vcolidx >= self.leftVisibleColIndex: <EOL><INDENT>self.visibleColLayout[vcolidx] = [x, min(width, winWidth-x)]<EOL>x += width+sepColWidth<EOL><DEDENT>if x > winWidth-<NUM_LIT:1>:<EOL><INDENT>break<EOL><DEDENT><DEDENT>self.rightVisibleColIndex = vcolidx<EOL> | Set right-most visible column, based on calculation. | f1802:c13:m57 |
def drawColHeader(self, scr, y, vcolidx): | col = self.visibleCols[vcolidx]<EOL>sepattr = colors.color_column_sep<EOL>hdrattr = self.colorize(col, None)<EOL>if vcolidx == self.cursorVisibleColIndex:<EOL><INDENT>hdrattr = hdrattr.update_attr(colors.color_current_hdr, <NUM_LIT:2>)<EOL><DEDENT>C = options.disp_column_sep<EOL>if (self.keyCols and col is self.keyCols[-<NUM_LIT:1>]) or vcolidx == self.rightVisibleColIndex:<EOL><INDENT>C = options.disp_keycol_sep<EOL><DEDENT>x, colwidth = self.visibleColLayout[vcolidx]<EOL>T = getType(col.type).icon<EOL>if T is None: <EOL><INDENT>T = '<STR_LIT:?>'<EOL><DEDENT>N = '<STR_LIT:U+0020>' + col.name <EOL>if len(N) > colwidth-<NUM_LIT:1>:<EOL><INDENT>N = N[:colwidth-len(options.disp_truncator)] + options.disp_truncator<EOL><DEDENT>clipdraw(scr, y, x, N, hdrattr.attr, colwidth)<EOL>clipdraw(scr, y, x+colwidth-len(T), T, hdrattr.attr, len(T))<EOL>vd.onMouse(scr, y, x, <NUM_LIT:1>, colwidth, BUTTON3_RELEASED='<STR_LIT>')<EOL>if vcolidx == self.leftVisibleColIndex and col not in self.keyCols and self.nonKeyVisibleCols.index(col) > <NUM_LIT:0>:<EOL><INDENT>A = options.disp_more_left<EOL>scr.addstr(y, x, A, sepattr)<EOL><DEDENT>if C and x+colwidth+len(C) < self.vd.windowWidth:<EOL><INDENT>scr.addstr(y, x+colwidth, C, sepattr)<EOL><DEDENT> | Compose and draw column header for given vcolidx. | f1802:c13:m58 |
def isVisibleIdxKey(self, vcolidx): | return self.visibleCols[vcolidx] in self.keyCols<EOL> | Return boolean: is given column index a key column? | f1802:c13:m59 |
def draw(self, scr): | numHeaderRows = <NUM_LIT:1><EOL>scr.erase() <EOL>vd().refresh()<EOL>if not self.columns:<EOL><INDENT>return<EOL><DEDENT>color_current_row = CursesAttr(colors.color_current_row, <NUM_LIT:5>)<EOL>disp_column_sep = options.disp_column_sep<EOL>rowattrs = {} <EOL>colattrs = {} <EOL>isNull = isNullFunc()<EOL>self.rowLayout = {}<EOL>self.calcColLayout()<EOL>vcolidx = <NUM_LIT:0><EOL>rows = list(self.rows[self.topRowIndex:self.topRowIndex+self.nVisibleRows])<EOL>for vcolidx, colinfo in sorted(self.visibleColLayout.items()):<EOL><INDENT>x, colwidth = colinfo<EOL>col = self.visibleCols[vcolidx]<EOL>if x < self.vd.windowWidth: <EOL><INDENT>headerRow = <NUM_LIT:0><EOL>self.drawColHeader(scr, headerRow, vcolidx)<EOL>y = headerRow + numHeaderRows<EOL>for rowidx in range(<NUM_LIT:0>, min(len(rows), self.nVisibleRows)):<EOL><INDENT>dispRowIdx = self.topRowIndex + rowidx<EOL>if dispRowIdx >= self.nRows:<EOL><INDENT>break<EOL><DEDENT>self.rowLayout[dispRowIdx] = y<EOL>row = rows[rowidx]<EOL>cellval = col.getCell(row, colwidth-<NUM_LIT:1>)<EOL>try:<EOL><INDENT>if isNull(cellval.value):<EOL><INDENT>cellval.note = options.disp_note_none<EOL>cellval.notecolor = '<STR_LIT>'<EOL><DEDENT><DEDENT>except TypeError:<EOL><INDENT>pass<EOL><DEDENT>attr = self.colorize(col, row, cellval)<EOL>rowattr = rowattrs.get(rowidx)<EOL>if rowattr is None:<EOL><INDENT>rowattr = rowattrs[rowidx] = self.colorize(None, row)<EOL><DEDENT>sepattr = rowattr<EOL>if dispRowIdx == self.cursorRowIndex:<EOL><INDENT>attr = attr.update_attr(color_current_row)<EOL>sepattr = sepattr.update_attr(color_current_row)<EOL><DEDENT>note = getattr(cellval, '<STR_LIT>', None)<EOL>if note:<EOL><INDENT>noteattr = attr.update_attr(colors.get_color(cellval.notecolor), <NUM_LIT:10>)<EOL>clipdraw(scr, y, x+colwidth-len(note), note, noteattr.attr, len(note))<EOL><DEDENT>clipdraw(scr, y, x, disp_column_fill+cellval.display, attr.attr, colwidth-(<NUM_LIT:1> if note else <NUM_LIT:0>))<EOL>vd.onMouse(scr, y, x, <NUM_LIT:1>, colwidth, BUTTON3_RELEASED='<STR_LIT>')<EOL>sepchars = disp_column_sep<EOL>if (self.keyCols and col is self.keyCols[-<NUM_LIT:1>]) or vcolidx == self.rightVisibleColIndex:<EOL><INDENT>sepchars = options.disp_keycol_sep<EOL><DEDENT>if x+colwidth+len(sepchars) <= self.vd.windowWidth:<EOL><INDENT>scr.addstr(y, x+colwidth, sepchars, sepattr.attr)<EOL><DEDENT>y += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>if vcolidx+<NUM_LIT:1> < self.nVisibleCols:<EOL><INDENT>scr.addstr(headerRow, self.vd.windowWidth-<NUM_LIT:2>, options.disp_more_right, colors.color_column_sep)<EOL><DEDENT>catchapply(self.checkCursor)<EOL> | Draw entire screen onto the `scr` curses object. | f1802:c13:m60 |
def editCell(self, vcolidx=None, rowidx=None, **kwargs): | if vcolidx is None:<EOL><INDENT>vcolidx = self.cursorVisibleColIndex<EOL><DEDENT>x, w = self.visibleColLayout.get(vcolidx, (<NUM_LIT:0>, <NUM_LIT:0>))<EOL>col = self.visibleCols[vcolidx]<EOL>if rowidx is None:<EOL><INDENT>rowidx = self.cursorRowIndex<EOL><DEDENT>if rowidx < <NUM_LIT:0>: <EOL><INDENT>y = <NUM_LIT:0><EOL>currentValue = col.name<EOL><DEDENT>else:<EOL><INDENT>y = self.rowLayout.get(rowidx, <NUM_LIT:0>)<EOL>currentValue = col.getDisplayValue(self.rows[self.cursorRowIndex])<EOL><DEDENT>editargs = dict(value=currentValue,<EOL>fillchar=options.disp_edit_fill,<EOL>truncchar=options.disp_truncator)<EOL>editargs.update(kwargs) <EOL>r = self.vd.editText(y, x, w, **editargs)<EOL>if rowidx >= <NUM_LIT:0>: <EOL><INDENT>r = col.type(r) <EOL><DEDENT>return r<EOL> | Call `editText` at its place on the screen. Returns the new value, properly typed | f1802:c13:m61 |
def __lt__(self, x): | return True<EOL> | maintain sortability; wrapped objects are always least | f1802:c14:m3 |
def recalc(self, sheet=None): | if self._cachedValues:<EOL><INDENT>self._cachedValues.clear()<EOL><DEDENT>if sheet:<EOL><INDENT>self.sheet = sheet<EOL><DEDENT>self.name = self._name<EOL> | reset column cache, attach to sheet, and reify name | f1802:c16:m3 |
def format(self, typedval): | if typedval is None:<EOL><INDENT>return None<EOL><DEDENT>if isinstance(typedval, (list, tuple)):<EOL><INDENT>return '<STR_LIT>' % len(typedval)<EOL><DEDENT>if isinstance(typedval, dict):<EOL><INDENT>return '<STR_LIT>' % len(typedval)<EOL><DEDENT>if isinstance(typedval, bytes):<EOL><INDENT>typedval = typedval.decode(options.encoding, options.encoding_errors)<EOL><DEDENT>return getType(self.type).formatter(self.fmtstr, typedval)<EOL> | Return displayable string of `typedval` according to `Column.fmtstr` | f1802:c16:m8 |
@property<EOL><INDENT>def hidden(self):<DEDENT> | if self.width is None:<EOL><INDENT>return False<EOL><DEDENT>return self.width <= <NUM_LIT:0><EOL> | A column is hidden if its width <= 0. (width==None means not-yet-autocomputed). | f1802:c16:m10 |
def getValueRows(self, rows): | f = isNullFunc()<EOL>for r in Progress(rows, '<STR_LIT>'):<EOL><INDENT>try:<EOL><INDENT>v = self.getTypedValue(r)<EOL>if not f(v):<EOL><INDENT>yield v, r<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT><DEDENT> | Generate (val, row) for the given `rows` at this Column, excluding errors and nulls. | f1802:c16:m11 |
def getTypedValue(self, row): | return wrapply(self.type, wrapply(self.getValue, row))<EOL> | Returns the properly-typed value for the given row at this column. | f1802:c16:m14 |
def getTypedValueOrException(self, row): | return wrapply(self.type, wrapply(self.getValue, row))<EOL> | Returns the properly-typed value for the given row at this column, or an Exception object. | f1802:c16:m15 |
def getTypedValueNoExceptions(self, row): | return wrapply(self.type, wrapply(self.getValue, row))<EOL> | Returns the properly-typed value for the given row at this column.
Returns the type's default value if either the getter or the type conversion fails. | f1802:c16:m16 |
def getValue(self, row): | if self._cachedValues is None:<EOL><INDENT>return self.calcValue(row)<EOL><DEDENT>k = id(row)<EOL>if k in self._cachedValues:<EOL><INDENT>return self._cachedValues[k]<EOL><DEDENT>ret = self.calcValue(row)<EOL>self._cachedValues[k] = ret<EOL>cachesize = options.col_cache_size<EOL>if cachesize > <NUM_LIT:0> and len(self._cachedValues) > cachesize:<EOL><INDENT>self._cachedValues.popitem(last=False)<EOL><DEDENT>return ret<EOL> | Memoize calcValue with key id(row) | f1802:c16:m17 |
def getCell(self, row, width=None): | cellval = wrapply(self.getValue, row)<EOL>typedval = wrapply(self.type, cellval)<EOL>if isinstance(typedval, TypedWrapper):<EOL><INDENT>if isinstance(cellval, TypedExceptionWrapper): <EOL><INDENT>exc = cellval.exception<EOL>if cellval.forwarded:<EOL><INDENT>dispval = str(cellval) <EOL><DEDENT>else:<EOL><INDENT>dispval = options.disp_error_val<EOL><DEDENT>return DisplayWrapper(cellval.val, error=exc.stacktrace,<EOL>display=dispval,<EOL>note=options.note_getter_exc,<EOL>notecolor='<STR_LIT>')<EOL><DEDENT>elif typedval.val is None: <EOL><INDENT>return DisplayWrapper(None, display='<STR_LIT>', <EOL>note=options.disp_note_none,<EOL>notecolor='<STR_LIT>')<EOL><DEDENT>elif isinstance(typedval, TypedExceptionWrapper): <EOL><INDENT>return DisplayWrapper(typedval.val, display=str(cellval),<EOL>error=typedval.exception.stacktrace,<EOL>note=options.note_type_exc,<EOL>notecolor='<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>return DisplayWrapper(typedval.val, display=str(typedval.val),<EOL>note=options.note_type_exc,<EOL>notecolor='<STR_LIT>')<EOL><DEDENT><DEDENT>elif isinstance(typedval, threading.Thread):<EOL><INDENT>return DisplayWrapper(None,<EOL>display=options.disp_pending,<EOL>note=options.note_pending,<EOL>notecolor='<STR_LIT>')<EOL><DEDENT>dw = DisplayWrapper(cellval)<EOL>try:<EOL><INDENT>dw.display = self.format(typedval) or '<STR_LIT>'<EOL>if width and isNumeric(self):<EOL><INDENT>dw.display = dw.display.rjust(width-<NUM_LIT:1>)<EOL><DEDENT>if self.type is anytype and type(cellval) is not str:<EOL><INDENT>typedesc = typemap.get(type(cellval), None)<EOL>dw.note = typedesc.icon if typedesc else options.note_unknown_type<EOL>dw.notecolor = '<STR_LIT>'<EOL><DEDENT><DEDENT>except Exception as e: <EOL><INDENT>e.stacktrace = stacktrace()<EOL>dw.error = e<EOL>try:<EOL><INDENT>dw.display = str(cellval)<EOL><DEDENT>except Exception as e:<EOL><INDENT>dw.display = str(e)<EOL><DEDENT>dw.note = options.note_format_exc<EOL>dw.notecolor = '<STR_LIT>'<EOL><DEDENT>return dw<EOL> | Return DisplayWrapper for displayable cell value. | f1802:c16:m18 |
def setValue(self, row, value): | return self.setter(self, row, value)<EOL> | Set our column value on row. defaults to .setter; override in Column subclass. no type checking | f1802:c16:m20 |
def setValueSafe(self, row, value): | try:<EOL><INDENT>return self.setValue(row, value)<EOL><DEDENT>except Exception as e:<EOL><INDENT>exceptionCaught(e)<EOL><DEDENT> | setValue and ignore exceptions | f1802:c16:m21 |
def setValues(self, rows, *values): | for r, v in zip(rows, itertools.cycle(values)):<EOL><INDENT>self.setValueSafe(r, v)<EOL><DEDENT>self.recalc()<EOL>return status('<STR_LIT>' % (len(rows), len(values)))<EOL> | Set our column value for given list of rows to `value`. | f1802:c16:m22 |
def setValuesTyped(self, rows, *values): | for r, v in zip(rows, itertools.cycle(self.type(val) for val in values)):<EOL><INDENT>self.setValueSafe(r, v)<EOL><DEDENT>self.recalc()<EOL>return status('<STR_LIT>' % (len(rows), len(values)))<EOL> | Set values on this column for rows, coerced to the column type. will stop on first exception in type(). | f1802:c16:m23 |
def getMaxWidth(self, rows): | w = <NUM_LIT:0><EOL>if len(rows) > <NUM_LIT:0>:<EOL><INDENT>w = max(max(len(self.getDisplayValue(r)) for r in rows), len(self.name))+<NUM_LIT:2><EOL><DEDENT>return max(w, len(self.name))<EOL> | Return the maximum length of any cell in column or its header. | f1802:c16:m25 |
def toggleWidth(self, width): | if self.width != width:<EOL><INDENT>self.width = width<EOL><DEDENT>else:<EOL><INDENT>self.width = int(options.default_width)<EOL><DEDENT> | Change column width to either given `width` or default value. | f1802:c16:m26 |
def __getattr__(self, optname): | return self.get_color(optname).attr<EOL> | colors.color_foo returns colors[options.color_foo] | f1802:c25:m4 |
@functools.lru_cache()<EOL><INDENT>def resolve_colors(self, colorstack):<DEDENT> | attr = CursesAttr()<EOL>for coloropt in colorstack:<EOL><INDENT>c = self.get_color(coloropt)<EOL>attr = attr.update_attr(c)<EOL><DEDENT>return attr<EOL> | Returns the curses attribute for the colorstack, a list of color option names sorted highest-precedence color first. | f1802:c25:m5 |
def get_color(self, optname, precedence=<NUM_LIT:0>): | r = self.colorcache.get(optname, None)<EOL>if r is None:<EOL><INDENT>coloropt = options._get(optname)<EOL>colornamestr = coloropt.value if coloropt else optname<EOL>r = self.colorcache[optname] = self._colornames_to_attr(colornamestr, precedence)<EOL><DEDENT>return r<EOL> | colors.color_foo returns colors[options.color_foo] | f1802:c25:m7 |
def currency(s='<STR_LIT>'): | if isinstance(s, str):<EOL><INDENT>s = '<STR_LIT>'.join(ch for ch in s if ch in floatchars)<EOL><DEDENT>return float(s) if s else TypedWrapper(float, None)<EOL> | dirty float (strip non-numeric characters) | f1804:m0 |
def __new__(cls, s=None): | if s is None:<EOL><INDENT>r = datetime.datetime.now()<EOL><DEDENT>elif isinstance(s, int) or isinstance(s, float):<EOL><INDENT>r = datetime.datetime.fromtimestamp(s)<EOL><DEDENT>elif isinstance(s, str):<EOL><INDENT>r = dateutil.parser.parse(s)<EOL><DEDENT>elif isinstance(s, datetime.datetime):<EOL><INDENT>r = s<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>' % type(s).__name__)<EOL><DEDENT>t = r.timetuple()<EOL>return super().__new__(cls, *t[:<NUM_LIT:6>], microsecond=r.microsecond, tzinfo=r.tzinfo)<EOL> | datetime is immutable so needs __new__ instead of __init__ | f1804:c0:m0 |
def __add__(self, n): | if isinstance(n, (int, float)):<EOL><INDENT>n = datetime.timedelta(days=n)<EOL><DEDENT>return date(super().__add__(n))<EOL> | add n days (int or float) to the date | f1804:c0:m4 |
def __sub__(self, n): | if isinstance(n, (int, float)):<EOL><INDENT>n = datetime.timedelta(days=n)<EOL><DEDENT>elif isinstance(n, (date, datetime.datetime)):<EOL><INDENT>return datedelta(super().__sub__(n).total_seconds()/(<NUM_LIT>*<NUM_LIT>*<NUM_LIT>))<EOL><DEDENT>return super().__sub__(n)<EOL> | subtract n days (int or float) from the date. or subtract another date for a timedelta | f1804:c0:m5 |
def indexMatch(L, func): | for i, x in enumerate(L):<EOL><INDENT>if func(x):<EOL><INDENT>return i<EOL><DEDENT><DEDENT> | returns the smallest i for which func(L[i]) is true | f1805:m2 |
def removeSheet(self, vs): | self.rows = [r for r in self.rows if r.sheet != vs.name]<EOL>status('<STR_LIT>' % vs.name)<EOL> | Remove all traces of sheets named vs.name from the cmdlog. | f1805:c0:m2 |
def afterExecSheet(self, sheet, escaped, err): | if not self.currentActiveRow: <EOL><INDENT>return<EOL><DEDENT>if err:<EOL><INDENT>self.currentActiveRow[-<NUM_LIT:1>] += '<STR_LIT>' % err<EOL><DEDENT>if isLoggableSheet(sheet): <EOL><INDENT>if not escaped and isLoggableCommand(self.currentActiveRow.keystrokes, self.currentActiveRow.longname):<EOL><INDENT>self.addRow(self.currentActiveRow)<EOL>if options.cmdlog_histfile:<EOL><INDENT>if not getattr(vd(), '<STR_LIT>', None):<EOL><INDENT>vd().sessionlog = loadInternalSheet(CommandLog, Path(date().strftime(options.cmdlog_histfile)))<EOL><DEDENT>append_tsv_row(vd().sessionlog, self.currentActiveRow)<EOL><DEDENT><DEDENT><DEDENT>self.currentActiveRow = None<EOL> | Records currentActiveRow | f1805:c0:m5 |
def moveToReplayContext(self, r): | if not r.sheet:<EOL><INDENT>assert not r.col and not r.row<EOL> | set the sheet/row/col to the values in the replay row. return sheet | f1805:c0:m10 |
def delay(self, factor=<NUM_LIT:1>): | acquired = CommandLog.semaphore.acquire(timeout=options.replay_wait*factor if not self.paused else None)<EOL>return acquired or not self.paused<EOL> | returns True if delay satisfied | f1805:c0:m11 |
def replayOne(self, r): | CommandLog.currentReplayRow = r<EOL>longname = getattr(r, '<STR_LIT>', None)<EOL>if longname == '<STR_LIT>':<EOL><INDENT>try:<EOL><INDENT>options.set(r.row, r.input, options._opts.getobj(r.col))<EOL>escaped = False<EOL><DEDENT>except Exception as e:<EOL><INDENT>exceptionCaught(e)<EOL>escaped = True<EOL><DEDENT><DEDENT>else:<EOL><INDENT>vs = self.moveToReplayContext(r)<EOL>vd().keystrokes = r.keystrokes<EOL>escaped = vs.exec_command(vs.getCommand(longname if longname else r.keystrokes), keystrokes=r.keystrokes)<EOL><DEDENT>CommandLog.currentReplayRow = None<EOL>if escaped: <EOL><INDENT>warning('<STR_LIT>')<EOL><DEDENT>return escaped<EOL> | Replay the command in one given row. | f1805:c0:m12 |
def replay_sync(self, live=False): | self.cursorRowIndex = <NUM_LIT:0><EOL>CommandLog.currentReplay = self<EOL>with Progress(total=len(self.rows)) as prog:<EOL><INDENT>while self.cursorRowIndex < len(self.rows):<EOL><INDENT>if CommandLog.currentReplay is None:<EOL><INDENT>status('<STR_LIT>')<EOL>return<EOL><DEDENT>vd().statuses.clear()<EOL>try:<EOL><INDENT>if self.replayOne(self.cursorRow):<EOL><INDENT>self.cancel()<EOL>return<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>self.cancel()<EOL>exceptionCaught(e)<EOL>status('<STR_LIT>')<EOL>return<EOL><DEDENT>self.cursorRowIndex += <NUM_LIT:1><EOL>prog.addProgress(<NUM_LIT:1>)<EOL>sync(<NUM_LIT:1> if live else <NUM_LIT:0>) <EOL>while not self.delay():<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>status('<STR_LIT>')<EOL>CommandLog.currentReplay = None<EOL> | Replay all commands in log. | f1805:c0:m13 |
@asyncthread<EOL><INDENT>def replay(self):<DEDENT> | self.replay_sync(live=True)<EOL> | Inject commands into live execution with interface. | f1805:c0:m14 |
def getLastArgs(self): | if CommandLog.currentReplayRow:<EOL><INDENT>return CommandLog.currentReplayRow.input<EOL><DEDENT>return None<EOL> | Get user input for the currently playing command. | f1805:c0:m15 |
def setLastArgs(self, args): | <EOL>if self.currentActiveRow is not None:<EOL><INDENT>if not self.currentActiveRow.input:<EOL><INDENT>self.currentActiveRow.input = args<EOL><DEDENT><DEDENT> | Set user input on last command, if not already set. | f1805:c0:m16 |
def cancelThread(*threads, exception=EscapeException): | for t in threads:<EOL><INDENT>ctypes.pythonapi.PyThreadState_SetAsyncExc(ctypes.c_long(t.ident), ctypes.py_object(exception))<EOL><DEDENT> | Raise exception on another thread. | f1807:m0 |
def moveToNextRow(vs, func, reverse=False): | rng = range(vs.cursorRowIndex-<NUM_LIT:1>, -<NUM_LIT:1>, -<NUM_LIT:1>) if reverse else range(vs.cursorRowIndex+<NUM_LIT:1>, vs.nRows)<EOL>for i in rng:<EOL><INDENT>try:<EOL><INDENT>if func(vs.rows[i]):<EOL><INDENT>vs.cursorRowIndex = i<EOL>return True<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return False<EOL> | Move cursor to next (prev if reverse) row for which func returns True. Returns False if no row meets the criteria. | f1808:m0 |
def nextColRegex(sheet, colregex): | pivot = sheet.cursorVisibleColIndex<EOL>for i in itertools.chain(range(pivot+<NUM_LIT:1>, len(sheet.visibleCols)), range(<NUM_LIT:0>, pivot+<NUM_LIT:1>)):<EOL><INDENT>c = sheet.visibleCols[i]<EOL>if re.search(colregex, c.name, regex_flags()):<EOL><INDENT>return i<EOL><DEDENT><DEDENT>fail('<STR_LIT>' % colregex)<EOL> | Go to first visible column after the cursor matching `colregex`. | f1808:m1 |
def searchRegex(vd, sheet, moveCursor=False, reverse=False, **kwargs): | def findMatchingColumn(sheet, row, columns, func):<EOL><INDENT>'<STR_LIT>'<EOL>for c in columns:<EOL><INDENT>if func(c.getDisplayValue(row)):<EOL><INDENT>return c<EOL><DEDENT><DEDENT><DEDENT>vd.searchContext.update(kwargs)<EOL>regex = kwargs.get("<STR_LIT>")<EOL>if regex:<EOL><INDENT>vd.searchContext["<STR_LIT>"] = re.compile(regex, regex_flags()) or error('<STR_LIT>' % regex)<EOL><DEDENT>regex = vd.searchContext.get("<STR_LIT>") or fail("<STR_LIT>")<EOL>columns = vd.searchContext.get("<STR_LIT>")<EOL>if columns == "<STR_LIT>":<EOL><INDENT>columns = [sheet.cursorCol]<EOL><DEDENT>elif columns == "<STR_LIT>":<EOL><INDENT>columns = tuple(sheet.visibleCols)<EOL><DEDENT>elif isinstance(columns, Column):<EOL><INDENT>columns = [columns]<EOL><DEDENT>if not columns:<EOL><INDENT>error('<STR_LIT>')<EOL><DEDENT>searchBackward = vd.searchContext.get("<STR_LIT>")<EOL>if reverse:<EOL><INDENT>searchBackward = not searchBackward<EOL><DEDENT>matchingRowIndexes = <NUM_LIT:0><EOL>for r in rotate_range(len(sheet.rows), sheet.cursorRowIndex, reverse=searchBackward):<EOL><INDENT>c = findMatchingColumn(sheet, sheet.rows[r], columns, regex.search)<EOL>if c:<EOL><INDENT>if moveCursor:<EOL><INDENT>sheet.cursorRowIndex = r<EOL>sheet.cursorVisibleColIndex = sheet.visibleCols.index(c)<EOL>return<EOL><DEDENT>else:<EOL><INDENT>matchingRowIndexes += <NUM_LIT:1><EOL>yield r<EOL><DEDENT><DEDENT><DEDENT>status('<STR_LIT>' % (matchingRowIndexes, regex.pattern))<EOL> | Set row index if moveCursor, otherwise return list of row indexes. | f1808:m3 |
def namedlist(objname, fieldnames): | class NamedListTemplate(list):<EOL><INDENT>__name__ = objname<EOL>_fields = fieldnames<EOL>def __init__(self, L=None, **kwargs):<EOL><INDENT>if L is None:<EOL><INDENT>L = [None]*len(fieldnames)<EOL><DEDENT>super().__init__(L)<EOL>for k, v in kwargs.items():<EOL><INDENT>setattr(self, k, v)<EOL><DEDENT><DEDENT>@classmethod<EOL>def length(cls):<EOL><INDENT>return len(cls._fields)<EOL><DEDENT><DEDENT>for i, attrname in enumerate(fieldnames):<EOL><INDENT>setattr(NamedListTemplate, attrname, property(operator.itemgetter(i), itemsetter(i)))<EOL><DEDENT>return NamedListTemplate<EOL> | like namedtuple but editable | f1810:m1 |
def columnize(rows): | <EOL>allNonspaces = set()<EOL>allNonspaces.add(max(len(r) for r in rows)+<NUM_LIT:1>)<EOL>for r in rows:<EOL><INDENT>for i, ch in enumerate(r):<EOL><INDENT>if not ch.isspace():<EOL><INDENT>allNonspaces.add(i)<EOL><DEDENT><DEDENT><DEDENT>colstart = <NUM_LIT:0><EOL>prev = <NUM_LIT:0><EOL>for i in allNonspaces:<EOL><INDENT>if i > prev+<NUM_LIT:1>:<EOL><INDENT>yield colstart, prev+<NUM_LIT:1><EOL>colstart = i<EOL><DEDENT>prev = i<EOL><DEDENT> | Generate (i,j) indexes for fixed-width columns found in rows | f1814:m1 |
@asyncthread<EOL>def save_html(p, *vsheets): | with open(p.resolve(), '<STR_LIT:w>', encoding='<STR_LIT:ascii>', errors='<STR_LIT>') as fp:<EOL><INDENT>for sheet in vsheets:<EOL><INDENT>fp.write('<STR_LIT>'.format(sheetname=html.escape(sheet.name)))<EOL>fp.write('<STR_LIT>'.format(sheetname=html.escape(sheet.name)))<EOL>fp.write('<STR_LIT>')<EOL>for col in sheet.visibleCols:<EOL><INDENT>contents = html.escape(col.name)<EOL>fp.write('<STR_LIT>'.format(colname=contents))<EOL><DEDENT>fp.write('<STR_LIT>')<EOL>for r in Progress(sheet.rows, '<STR_LIT>'):<EOL><INDENT>fp.write('<STR_LIT>')<EOL>for col in sheet.visibleCols:<EOL><INDENT>fp.write('<STR_LIT>')<EOL>fp.write(html.escape(col.getDisplayValue(r)))<EOL>fp.write('<STR_LIT>')<EOL><DEDENT>fp.write('<STR_LIT>')<EOL><DEDENT>fp.write('<STR_LIT>')<EOL>status('<STR_LIT>' % p)<EOL><DEDENT><DEDENT> | Save vsheets as HTML tables in a single file | f1821:m2 |
def load_csv(vs): | with vs.source.open_text() as fp:<EOL><INDENT>for i in range(options.skip):<EOL><INDENT>wrappedNext(fp) <EOL><DEDENT>if options.safety_first:<EOL><INDENT>rdr = csv.reader(removeNulls(fp), **csvoptions())<EOL><DEDENT>else:<EOL><INDENT>rdr = csv.reader(fp, **csvoptions())<EOL><DEDENT>vs.rows = []<EOL>headers = [wrappedNext(rdr) for i in range(int(options.header))]<EOL>if headers:<EOL><INDENT>vs.columns = ArrayNamedColumns('<STR_LIT>'.join(x) for x in zip(*headers))<EOL><DEDENT>else:<EOL><INDENT>r = wrappedNext(rdr)<EOL>vs.addRow(r)<EOL>vs.columns = ArrayColumns(len(vs.rows[<NUM_LIT:0>]))<EOL><DEDENT>if not vs.columns:<EOL><INDENT>vs.columns = [ColumnItem(<NUM_LIT:0>)]<EOL><DEDENT>vs.recalc() <EOL>with Progress(total=vs.source.filesize) as prog:<EOL><INDENT>try:<EOL><INDENT>samplelen = <NUM_LIT:0><EOL>for i in range(options_num_first_rows): <EOL><INDENT>row = wrappedNext(rdr)<EOL>vs.addRow(row)<EOL>samplelen += sum(len(x) for x in row)<EOL><DEDENT>samplelen //= options_num_first_rows <EOL>while True:<EOL><INDENT>vs.addRow(wrappedNext(rdr))<EOL>prog.addProgress(samplelen)<EOL><DEDENT><DEDENT>except StopIteration:<EOL><INDENT>pass <EOL><DEDENT><DEDENT><DEDENT>vs.recalc()<EOL>return vs<EOL> | Convert from CSV, first handling header row specially. | f1827:m4 |
@asyncthread<EOL>def save_csv(p, sheet): | with p.open_text(mode='<STR_LIT:w>') as fp:<EOL><INDENT>cw = csv.writer(fp, **csvoptions())<EOL>colnames = [col.name for col in sheet.visibleCols]<EOL>if '<STR_LIT>'.join(colnames):<EOL><INDENT>cw.writerow(colnames)<EOL><DEDENT>for r in Progress(sheet.rows, '<STR_LIT>'):<EOL><INDENT>cw.writerow([col.getDisplayValue(r) for col in sheet.visibleCols])<EOL><DEDENT><DEDENT> | Save as single CSV file, handling column names as first line. | f1827:m5 |
def tsv_trdict(vs): | if options.safety_first:<EOL><INDENT>delim = options.get('<STR_LIT>', vs)<EOL>return {ord(delim): options.get('<STR_LIT>', vs), <EOL><NUM_LIT:10>: options.get('<STR_LIT>', vs), <EOL><NUM_LIT>: options.get('<STR_LIT>', vs), <EOL>}<EOL><DEDENT>return {}<EOL> | returns string.translate dictionary for replacing tabs and newlines | f1829:m2 |
def save_tsv_header(p, vs): | trdict = tsv_trdict(vs)<EOL>delim = options.delimiter<EOL>with p.open_text(mode='<STR_LIT:w>') as fp:<EOL><INDENT>colhdr = delim.join(col.name.translate(trdict) for col in vs.visibleCols) + '<STR_LIT:\n>'<EOL>if colhdr.strip(): <EOL><INDENT>fp.write(colhdr)<EOL><DEDENT><DEDENT> | Write tsv header for Sheet `vs` to Path `p`. | f1829:m3 |
@asyncthread<EOL>def save_tsv(p, vs): | delim = options.get('<STR_LIT>', vs)<EOL>trdict = tsv_trdict(vs)<EOL>save_tsv_header(p, vs)<EOL>with p.open_text(mode='<STR_LIT:a>') as fp:<EOL><INDENT>for dispvals in genAllValues(vs.rows, vs.visibleCols, trdict, format=True):<EOL><INDENT>fp.write(delim.join(dispvals))<EOL>fp.write('<STR_LIT:\n>')<EOL><DEDENT><DEDENT>status('<STR_LIT>' % p)<EOL> | Write sheet to file `fn` as TSV. | f1829:m5 |
def append_tsv_row(vs, row): | if not vs.source.exists():<EOL><INDENT>with contextlib.suppress(FileExistsError):<EOL><INDENT>parentdir = vs.source.parent.resolve()<EOL>if parentdir:<EOL><INDENT>os.makedirs(parentdir)<EOL><DEDENT><DEDENT>save_tsv_header(vs.source, vs)<EOL><DEDENT>with vs.source.open_text(mode='<STR_LIT:a>') as fp:<EOL><INDENT>fp.write('<STR_LIT:\t>'.join(col.getDisplayValue(row) for col in vs.visibleCols) + '<STR_LIT:\n>')<EOL><DEDENT> | Append `row` to vs.source, creating file with correct headers if necessary. For internal use only. | f1829:m6 |
def reload_sync(self): | header_lines = options.get('<STR_LIT>', self)<EOL>delim = options.get('<STR_LIT>', self)<EOL>with self.source.open_text() as fp:<EOL><INDENT>lines = list(getlines(fp, int(header_lines) or <NUM_LIT:1>))<EOL>headers = [L.split(delim) for L in lines]<EOL>if header_lines <= <NUM_LIT:0>:<EOL><INDENT>self.columns = [ColumnItem('<STR_LIT>', i) for i in range(len(headers[<NUM_LIT:0>]))]<EOL><DEDENT>else:<EOL><INDENT>self.columns = [<EOL>ColumnItem('<STR_LIT>'.join(x), i)<EOL>for i, x in enumerate(zip(*headers[:header_lines]))<EOL>]<EOL><DEDENT>lines = lines[header_lines:] <EOL>self._rowtype = namedlist('<STR_LIT>', [c.name for c in self.columns])<EOL>self.recalc()<EOL>self.rows = []<EOL>with Progress(total=self.source.filesize) as prog:<EOL><INDENT>for L in itertools.chain(lines, getlines(fp)):<EOL><INDENT>row = L.split(delim)<EOL>ncols = self._rowtype.length() <EOL>if len(row) > ncols:<EOL><INDENT>newcols = [ColumnItem('<STR_LIT>', len(row)+i, width=<NUM_LIT:8>) for i in range(len(row)-ncols)]<EOL>self._rowtype = namedlist(self._rowtype.__name__, list(self._rowtype._fields) + ['<STR_LIT:_>' for c in newcols])<EOL>for c in newcols:<EOL><INDENT>self.addColumn(c)<EOL><DEDENT><DEDENT>elif len(row) < ncols:<EOL><INDENT>row.extend([None]*(ncols-len(row)))<EOL><DEDENT>self.addRow(self._rowtype(row))<EOL>prog.addProgress(len(L))<EOL><DEDENT><DEDENT><DEDENT> | Perform synchronous loading of TSV file, discarding header lines. | f1829:c0:m1 |
@classmethod<EOL><INDENT>def get_by_ip(cls, ip):<DEDENT> | ret = cls.hosts_by_ip.get(ip)<EOL>if ret is None:<EOL><INDENT>ret = cls.hosts_by_ip[ip] = [Host(ip)]<EOL><DEDENT>return ret<EOL> | Returns Host instance for the given ip address. | f1830:c0:m1 |
def save_md(p, *vsheets): | with p.open_text(mode='<STR_LIT:w>') as fp:<EOL><INDENT>for vs in vsheets:<EOL><INDENT>if len(vsheets) > <NUM_LIT:1>:<EOL><INDENT>fp.write('<STR_LIT>' % vs.name)<EOL><DEDENT>fp.write('<STR_LIT:|>' + '<STR_LIT:|>'.join('<STR_LIT>' % (col.width or options.default_width, markdown_escape(col.name)) for col in vs.visibleCols) + '<STR_LIT>')<EOL>fp.write('<STR_LIT:|>' + '<STR_LIT:+>'.join(markdown_colhdr(col) for col in vs.visibleCols) + '<STR_LIT>')<EOL>for row in Progress(vs.rows, '<STR_LIT>'):<EOL><INDENT>fp.write('<STR_LIT:|>' + '<STR_LIT:|>'.join('<STR_LIT>' % (col.width or options.default_width, markdown_escape(col.getDisplayValue(row))) for col in vs.visibleCols) + '<STR_LIT>')<EOL><DEDENT>fp.write('<STR_LIT:\n>')<EOL><DEDENT><DEDENT>status('<STR_LIT>' % p)<EOL> | pipe tables compatible with org-mode | f1831:m2 |
def combineColumns(cols): | return Column("<STR_LIT:+>".join(c.name for c in cols),<EOL>getter=lambda col,row,cols=cols,ch='<STR_LIT:U+0020>': ch.join(c.getDisplayValue(row) for c in cols))<EOL> | Return Column object formed by joining fields in given columns. | f1836:m1 |
def clipline(x1, y1, x2, y2, xmin, ymin, xmax, ymax): | dx = x2-x1<EOL>dy = y2-y1<EOL>pq = [<EOL>(-dx, x1-xmin), <EOL>( dx, xmax-x1), <EOL>(-dy, y1-ymin), <EOL>( dy, ymax-y1), <EOL>]<EOL>u1, u2 = <NUM_LIT:0>, <NUM_LIT:1><EOL>for p, q in pq:<EOL><INDENT>if p < <NUM_LIT:0>: <EOL><INDENT>u1 = max(u1, q/p)<EOL><DEDENT>elif p > <NUM_LIT:0>: <EOL><INDENT>u2 = min(u2, q/p)<EOL><DEDENT>else: <EOL><INDENT>if q < <NUM_LIT:0>: <EOL><INDENT>return None<EOL><DEDENT><DEDENT><DEDENT>if u1 > u2: <EOL><INDENT>return None<EOL><DEDENT>xn1 = x1 + dx*u1<EOL>yn1 = y1 + dy*u1<EOL>xn2 = x1 + dx*u2<EOL>yn2 = y1 + dy*u2<EOL>return xn1, yn1, xn2, yn2<EOL> | Liang-Barsky algorithm, returns [xn1,yn1,xn2,yn2] of clipped line within given area, or None | f1838:m1 |
def iterline(x1, y1, x2, y2): | xdiff = abs(x2-x1)<EOL>ydiff = abs(y2-y1)<EOL>xdir = <NUM_LIT:1> if x1 <= x2 else -<NUM_LIT:1><EOL>ydir = <NUM_LIT:1> if y1 <= y2 else -<NUM_LIT:1><EOL>r = math.ceil(max(xdiff, ydiff))<EOL>if r == <NUM_LIT:0>: <EOL><INDENT>yield x1, y1<EOL><DEDENT>else:<EOL><INDENT>x, y = math.floor(x1), math.floor(y1)<EOL>i = <NUM_LIT:0><EOL>while i < r:<EOL><INDENT>x += xdir * xdiff / r<EOL>y += ydir * ydiff / r<EOL>yield x, y<EOL>i += <NUM_LIT:1><EOL><DEDENT><DEDENT> | Yields (x, y) coords of line from (x1, y1) to (x2, y2) | f1838:m2 |
def resetCanvasDimensions(self, windowHeight, windowWidth): | self.plotwidth = windowWidth*<NUM_LIT:2><EOL>self.plotheight = (windowHeight-<NUM_LIT:1>)*<NUM_LIT:4> <EOL>self.pixels = [[defaultdict(list) for x in range(self.plotwidth)] for y in range(self.plotheight)]<EOL> | sets total available canvas dimensions to (windowHeight, windowWidth) (in char cells) | f1838:c2:m2 |
@property<EOL><INDENT>def plotterCursorBox(self):<DEDENT> | return Box(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>)<EOL> | Returns pixel bounds of cursor as a Box. Override to provide a cursor. | f1838:c2:m7 |
def getPixelAttrRandom(self, x, y): | c = list(attr for attr, rows in self.pixels[y][x].items()<EOL>for r in rows if attr and attr not in self.hiddenAttrs)<EOL>return random.choice(c) if c else <NUM_LIT:0><EOL> | weighted-random choice of attr at this pixel. | f1838:c2:m10 |
def getPixelAttrMost(self, x, y): | r = self.pixels[y][x]<EOL>c = sorted((len(rows), attr, rows) for attr, rows in list(r.items()) if attr and attr not in self.hiddenAttrs)<EOL>if not c:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>_, attr, rows = c[-<NUM_LIT:1>]<EOL>if isinstance(self.source, BaseSheet) and anySelected(self.source, rows):<EOL><INDENT>attr = CursesAttr(attr, <NUM_LIT:8>).update_attr(colors.color_graph_selected, <NUM_LIT:10>).attr<EOL><DEDENT>return attr<EOL> | most common attr at this pixel. | f1838:c2:m11 |
def rowsWithin(self, bbox): | ret = {}<EOL>for y in range(bbox.ymin, bbox.ymax+<NUM_LIT:1>):<EOL><INDENT>for x in range(bbox.xmin, bbox.xmax+<NUM_LIT:1>):<EOL><INDENT>for attr, rows in self.pixels[y][x].items():<EOL><INDENT>if attr not in self.hiddenAttrs:<EOL><INDENT>for r in rows:<EOL><INDENT>ret[id(r)] = r<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>return list(ret.values())<EOL> | return list of deduped rows within bbox | f1838:c2:m13 |
def reset(self): | self.polylines.clear()<EOL>self.legends.clear()<EOL>self.plotAttrs.clear()<EOL>self.unusedAttrs = list(colors[colorname.translate(str.maketrans('<STR_LIT:_>', '<STR_LIT:U+0020>'))].attr for colorname in options.plot_colors.split())<EOL> | clear everything in preparation for a fresh reload() | f1838:c3:m2 |
def setCursorSize(self, p): | self.cursorBox = BoundingBox(self.cursorBox.xmin, self.cursorBox.ymin, p.x, p.y)<EOL>self.cursorBox.w = max(self.cursorBox.w, self.canvasCharWidth)<EOL>self.cursorBox.h = max(self.cursorBox.h, self.canvasCharHeight)<EOL> | sets width based on diagonal corner p | f1838:c3:m9 |
@property<EOL><INDENT>def canvasCharWidth(self):<DEDENT> | return self.visibleBox.w*<NUM_LIT:2>/self.plotviewBox.w<EOL> | Width in canvas units of a single char in the terminal | f1838:c3:m10 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.