code string | signature string | docstring string | loss_without_docstring float64 | loss_with_docstring float64 | factor float64 |
|---|---|---|---|---|---|
if role == Qt.DecorationRole:
if column == self.COL_DECORATION:
return item.decoration
elif role == Qt.FontRole:
return item.font
elif role == Qt.ForegroundRole:
return item.foregroundBrush
elif role == Qt.BackgroundRole:
... | def itemData(self, item, column, role=Qt.DisplayRole) | Returns the data stored under the given role for the item. O
The column parameter may be used to differentiate behavior per column.
The default implementation does nothing. Descendants should typically override this
function instead of data()
Note: If you do not have a ... | 2.511098 | 2.720106 | 0.923162 |
# logger.debug(" called index({}, {}, {}) {}"
# .format(parentIndex.row(), parentIndex.column(), parentIndex.isValid(),
# parentIndex.isValid() and parentIndex.column() != 0))
parentItem = self.getItem(parentIndex, altItem=self.invisibleRootItem)... | def index(self, row, column, parentIndex=QtCore.QModelIndex()) | Returns the index of the item in the model specified by the given row, column and parent
index.
Since each item contains information for an entire row of data, we create a model index
to uniquely identify it by calling createIndex() it with the row and column numbers and
... | 2.817537 | 2.860361 | 0.985029 |
if not index.isValid():
return QtCore.QModelIndex()
childItem = self.getItem(index, altItem=self.invisibleRootItem)
parentItem = childItem.parentItem
if parentItem == self.invisibleRootItem:
return QtCore.QModelIndex()
return self.createIndex(p... | def parent(self, index) | Returns the parent of the model item with the given index. If the item has no parent,
an invalid QModelIndex is returned.
A common convention used in models that expose tree data structures is that only items
in the first column have children. For that case, when reimplementing this... | 2.965716 | 3.359691 | 0.882735 |
parentItem = self.getItem(parentIndex, altItem=self.invisibleRootItem)
return parentItem.nChildren() | def rowCount(self, parentIndex=QtCore.QModelIndex()) | Returns the number of rows under the given parent. When the parent is valid it means
that rowCount is returning the number of children of parent.
Note: When implementing a table based model, rowCount() should return 0 when the parent
is valid. | 12.717434 | 14.89942 | 0.853552 |
parentItem = self.getItem(parentIndex, altItem=self.invisibleRootItem)
return parentItem.hasChildren() | def hasChildren(self, parentIndex=QtCore.QModelIndex()) | Returns true if parent has any children; otherwise returns false.
Use rowCount() on the parent to find out the number of children. | 7.954561 | 7.040884 | 1.129767 |
if role != Qt.CheckStateRole and role != Qt.EditRole:
return False
treeItem = self.getItem(index, altItem=self.invisibleRootItem)
try:
result = self.setItemData(treeItem, index.column(), value, role=role)
if result:
# Emit dataChanged... | def setData(self, index, value, role=Qt.EditRole) | Sets the role data for the item at index to value.
Returns true if successful; otherwise returns false.
The dataChanged and sigItemChanged signals will be emitted if the data was successfully
set.
Descendants should typically override setItemData function instead of set... | 7.784906 | 7.460179 | 1.043528 |
if index.isValid():
item = index.internalPointer()
if item:
return item
#return altItem if altItem is not None else self.invisibleRootItem # TODO: remove
return altItem | def getItem(self, index, altItem=None) | Returns the TreeItem for the given index. Returns the altItem if the index is invalid. | 5.161546 | 5.134117 | 1.005343 |
if parentIndex is None:
parentIndex=QtCore.QModelIndex()
parentItem = self.getItem(parentIndex, altItem=self.invisibleRootItem)
nChildren = parentItem.nChildren()
if position is None:
position = nChildren
assert 0 <= position <= nChildren, \
... | def insertItem(self, childItem, position=None, parentIndex=None) | Inserts a childItem before row 'position' under the parent index.
If position is None the child will be appended as the last child of the parent.
Returns the index of the new inserted child. | 2.805249 | 2.765741 | 1.014285 |
if not parentIndex.isValid():
logger.debug("No valid item selected for deletion (ignored).")
return
parentItem = self.getItem(parentIndex, None)
logger.debug("Removing children of {!r}".format(parentItem))
assert parentItem, "parentItem not found"
... | def removeAllChildrenAtIndex(self, parentIndex) | Removes all children of the item at the parentIndex.
The children's finalize method is called before removing them to give them a
chance to close their resources | 2.923654 | 2.990467 | 0.977658 |
if not itemIndex.isValid():
logger.debug("No valid item selected for deletion (ignored).")
return
item = self.getItem(itemIndex, "<no item>")
logger.debug("deleteItemAtIndex: removing {}".format(item))
parentIndex = itemIndex.parent()
parentItem... | def deleteItemAtIndex(self, itemIndex) | Removes the item at the itemIndex.
The item's finalize method is called before removing so it can close its resources. | 3.876057 | 3.962885 | 0.97809 |
oldItem = self.getItem(oldItemIndex)
childNumber = oldItem.childNumber()
parentIndex = oldItemIndex.parent()
self.deleteItemAtIndex(oldItemIndex)
insertedIndex = self.insertItem(newItem, position=childNumber, parentIndex=parentIndex)
return insertedIndex | def replaceItemAtIndex(self, newItem, oldItemIndex) | Removes the item at the itemIndex and insert a new item instead. | 3.44065 | 3.360048 | 1.023988 |
if self.isTopLevelIndex(childIndex):
return childIndex
else:
return self.findTopLevelItemIndex(childIndex.parent()) | def findTopLevelItemIndex(self, childIndex) | Traverses the tree upwards from childItem until its top level ancestor item is found.
Top level items are items that are direct children of the (invisible) root item.
This function therefore raises an exception when called with the root item. | 3.001402 | 2.917476 | 1.028767 |
def _getIndexAndItemByName(nodeName, parentItem, parentIndex):
if self.canFetchMore(parentIndex):
self.fetchMore(parentIndex)
for rowNr, childItem in enumerate(parentItem.childItems):
if childItem.nodeName == nodeName:
... | def findItemAndIndexPath(self, path, startIndex=None) | Searches all the model recursively (starting at startIndex) for an item where
item.nodePath == path.
Returns list of (item, itemIndex) tuples from the start index to that node.
Raises IndexError if the item cannot be found.
If startIndex is None, or path starts with a s... | 3.620155 | 3.493704 | 1.036194 |
rootItem = self.rootItem()
if rootItem is None:
logger.debug("No items in: {}".format(self))
else:
rootItem.logBranch(level=level) | def logItems(self, level=logging.DEBUG) | rootItem | 5.056633 | 4.090078 | 1.236317 |
checked = checked if checked is not None else {}
checkable = checkable if checkable is not None else {}
enabled = enabled if enabled is not None else {}
horizontal_header = self.horizontalHeader()
horizontal_header.setContextMenuPolicy(Qt.ActionsContextMenu)
se... | def addHeaderContextMenu(self, checked = None, checkable = None, enabled = None) | Adds the context menu from using header information
checked can be a header_name -> boolean dictionary. If given, headers
with the key name will get the checked value from the dictionary.
The corresponding column will be hidden if checked is False.
checkable can be a he... | 2.660144 | 2.697576 | 0.986124 |
show_column = lambda checked: self.setColumnHidden(column_idx, not checked)
return show_column | def __makeShowColumnFunction(self, column_idx) | Creates a function that shows or hides a column. | 5.423166 | 3.848691 | 1.409094 |
#logger.debug("Reading view settings for: {}".format(key))
if settings is None:
settings = QtCore.QSettings()
horizontal_header = self.horizontalHeader()
header_restored = horizontal_header.restoreState(settings.value(key))
# update actions
for col,... | def readViewSettings(self, key, settings=None) | Reads the persistent program settings
:param key: key where the setting will be read from
:param settings: optional QSettings object which can have a group already opened.
:returns: True if the header state was restored, otherwise returns False | 4.027204 | 3.652349 | 1.102634 |
#logger.debug("Writing view settings for: {}".format(key))
if settings is None:
settings = QtCore.QSettings()
settings.setValue(key, self.horizontalHeader().saveState()) | def saveProfile(self, key, settings=None) | Writes the view settings to the persistent store
:param key: key where the setting will be read from
:param settings: optional QSettings object which can have a group already opened. | 5.974761 | 5.45373 | 1.095537 |
if self.cls is None:
return None
elif hasattr(self.cls, 'descriptionHtml'):
return self.cls.descriptionHtml()
else:
return '' | def descriptionHtml(self) | HTML help describing the class. For use in the detail editor. | 3.518836 | 2.810668 | 1.251957 |
logger.info("Importing: {}".format(self.fullClassName))
self._triedImport = True
self._exception = None
self._cls = None
try:
for pyPath in self.pythonPath.split(':'):
if pyPath and pyPath not in sys.path:
logger.debug("App... | def tryImportClass(self) | Tries to import the registered class.
Will set the exception property if and error occurred. | 3.610557 | 3.554694 | 1.015715 |
if not self.triedImport and tryImport:
self.tryImportClass()
return self._cls | def getClass(self, tryImport=True) | Gets the underlying class. Tries to import if tryImport is True (the default).
Returns None if the import has failed (the exception property will contain the reason) | 7.702322 | 7.269413 | 1.059552 |
check_class(regItem, ClassRegItem)
if regItem.identifier in self._index:
oldRegItem = self._index[regItem.identifier]
logger.warn("Class key {!r} already registered as {}. Removing old regItem."
.format(regItem.identifier, oldRegItem.fullClassName... | def registerItem(self, regItem) | Adds a ClassRegItem object to the registry. | 3.349125 | 2.997733 | 1.11722 |
check_class(regItem, ClassRegItem)
logger.info("Removing {!r} containing {}".format(regItem.identifier, regItem.fullClassName))
del self._index[regItem.identifier]
idx = self._items.index(regItem)
del self._items[idx] | def removeItem(self, regItem) | Removes a ClassRegItem object to the registry.
Will raise a KeyError if the regItem is not registered. | 6.42804 | 5.202466 | 1.235576 |
groupName = groupName if groupName else self.settingsGroupName
settings = QtCore.QSettings()
#for key in sorted(settings.allKeys()):
# print(key)
if containsSettingsGroup(groupName, settings):
self.loadSettings(groupName)
else:
logger... | def loadOrInitSettings(self, groupName=None) | Reads the registry items from the persistent settings store, falls back on the
default plugins if there are no settings in the store for this registry. | 4.163124 | 4.019248 | 1.035797 |
groupName = groupName if groupName else self.settingsGroupName
settings = QtCore.QSettings()
logger.info("Reading {!r} from: {}".format(groupName, settings.fileName()))
settings.beginGroup(groupName)
self.clear()
try:
for key in settings.childKeys():... | def loadSettings(self, groupName=None) | Reads the registry items from the persistent settings store. | 3.613612 | 3.432771 | 1.052681 |
groupName = groupName if groupName else self.settingsGroupName
settings = QtCore.QSettings()
logger.info("Saving {} to: {}".format(groupName, settings.fileName()))
settings.remove(groupName) # start with a clean slate
settings.beginGroup(groupName)
try:
... | def saveSettings(self, groupName=None) | Writes the registry items into the persistent settings store. | 3.543471 | 3.448186 | 1.027633 |
groupName = groupName if groupName else self.settingsGroupName
settings = QtCore.QSettings()
logger.info("Deleting {} from: {}".format(groupName, settings.fileName()))
removeSettingsGroup(groupName) | def deleteSettings(self, groupName=None) | Deletes registry items from the persistent store. | 5.980699 | 6.03043 | 0.991753 |
logger.debug("dockVisibilityChanged of {!r}: visible={}".format(self, visible))
if visible:
self._repoTreeView.sigRepoItemChanged.connect(self.repoItemChanged)
self._isConnected = True
currentRepoItem, _currentIndex = self._repoTreeView.getCurrentItem()
... | def dockVisibilityChanged(self, visible) | Slot to be called when the dock widget that this pane contains become (in)visible.
Is used to (dis)connect the pane from its repo tree view and so prevent unnecessary
and potentially costly updates when the pane is hidden. | 7.471495 | 6.669228 | 1.120294 |
check_class(rti, (BaseRti, int), allow_none=True)
assert type(rti) != int, "rti: {}".format(rti)
try:
self._drawContents(rti)
self.setCurrentIndex(self.CONTENTS_PAGE_IDX)
except Exception as ex:
if DEBUGGING:
raise
... | def repoItemChanged(self, rti) | Updates the content when the current repo tree item changes.
The rti parameter can be None when no RTI is selected in the repository tree. | 5.721618 | 5.7327 | 0.998067 |
inspectorMenu.addAction(execInspectorDialogAction)
inspectorMenu.addSeparator()
for action in inspectorActionGroup.actions():
inspectorMenu.addAction(action)
return inspectorMenu | def addInspectorActionsToMenu(inspectorMenu, execInspectorDialogAction, inspectorActionGroup) | Adds menu items to the inpsectorMenu for the given set-inspector actions.
:param inspectorMenu: inspector menu that will be modified
:param execInspectorDialogAction: the "Browse Inspectors..." actions
:param inspectorActionGroup: action group with actions for selecting a new inspector
... | 2.046117 | 3.022561 | 0.676948 |
library, name = inspectorRegItem.splitName()
label = "{} ({})".format(name, library) if library else name
#self.label.setText(label)
self.menuButton.setText(label) | def updateFromInspectorRegItem(self, inspectorRegItem) | Updates the label from the full name of the InspectorRegItem | 6.271308 | 5.303674 | 1.182446 |
return StringCtiEditor(self, delegate, parent=parent) | def createEditor(self, delegate, parent, option) | Creates a StringCtiEditor.
For the parameters see the AbstractCti constructor documentation. | 37.705864 | 5.298931 | 7.11575 |
self.vb.enableAutoRange(self.vb.YAxis, False)
self.vb.setYRange(mn, mx, padding) | def setHistogramRange(self, mn, mx, padding=0.1) | Set the Y range on the histogram plot. This disables auto-scaling. | 3.786216 | 3.514025 | 1.077459 |
self.imageItem = weakref.ref(img)
img.sigImageChanged.connect(self.imageChanged)
img.setLookupTable(self.getLookupTable) ## send function pointer, not the result
#self.gradientChanged()
self.regionChanged()
self.imageChanged(autoLevel=True) | def setImageItem(self, img) | Set an ImageItem to have its levels and LUT automatically controlled
by this HistogramLUTItem. | 7.004917 | 6.360859 | 1.101253 |
if n is None:
if img.dtype == np.uint8:
n = 256
else:
n = 512
if self.lut is None:
self.lut = self.gradient.getLookupTable(n, alpha=alpha)
return self.lut | def getLookupTable(self, img=None, n=None, alpha=None) | Return a lookup table from the color gradient defined by this
HistogramLUTItem. | 2.773376 | 2.542894 | 1.090637 |
setXYAxesAutoRangeOn(self, self.xAxisRangeCti, self.yAxisRangeCti, axisNumber) | def setAutoRangeOn(self, axisNumber) | Sets the auto-range of the axis on.
:param axisNumber: 0 (X-axis), 1 (Y-axis), 2, (Both X and Y axes). | 14.707132 | 21.944294 | 0.670203 |
logger.debug("Finalizing: {}".format(self))
self.plotItem.scene().sigMouseMoved.disconnect(self.mouseMoved)
self.plotItem.close()
self.graphicsLayoutWidget.close() | def finalize(self) | Is called before destruction. Can be used to clean-up resources | 5.122831 | 5.095607 | 1.005343 |
self.titleLabel.setText('')
self.plotItem.clear()
self.plotItem.setLabel('left', '')
self.plotItem.setLabel('bottom', '') | def _clearContents(self) | Clears the the inspector widget when no valid input is available. | 3.564312 | 3.266274 | 1.091247 |
self.slicedArray = self.collector.getSlicedArray()
if not self._hasValidData():
self._clearContents()
raise InvalidDataError("No data available or it does not contain real numbers")
# -- Valid plot data from here on --
# PyQtGraph doesn't handle masked... | def _drawContents(self, reason=None, initiator=None) | Draws the plot contents from the sliced array of the collected repo tree item.
The reason parameter is used to determine if the axes will be reset (the initiator
parameter is ignored). See AbstractInspector.updateContents for their description. | 7.157082 | 6.798152 | 1.052798 |
try:
check_class(viewPos, QtCore.QPointF)
self.crossLineVerShadow.setVisible(False)
self.crossLineVertical.setVisible(False)
self.probeLabel.setText("")
self.probeDataItem.clear()
if (self._hasValidData() and self.config.probeCti.... | def mouseMoved(self, viewPos) | Updates the probe text with the values under the cursor.
Draws a vertical line and a symbol at the position of the probe. | 5.588543 | 5.389173 | 1.036995 |
# Try to see if env_var can be converted to an int
try:
env_var = int(env_var)
except ValueError:
pass
if isinstance(env_var, numbers.Number):
return bool(env_var)
elif is_a_string(env_var):
env_var = env_var.lower().strip()
if env_var in "false":
... | def environment_var_to_bool(env_var) | Converts an environment variable to a boolean
Returns False if the environment variable is False, 0 or a case-insenstive string "false"
or "0". | 2.579432 | 2.662944 | 0.968639 |
if masked_array is not None and masked_array.dtype.kind == 'f':
check_class(masked_array, ma.masked_array)
logger.debug("Replacing fill_values by NaNs")
masked_array[:] = ma.filled(masked_array, np.nan)
masked_array.set_fill_value(np.nan)
else:
return masked_array | def fill_values_to_nan(masked_array) | Replaces the fill_values of the masked array by NaNs
If the array is None or it does not contain floating point values, it cannot contain NaNs.
In that case the original array is returned. | 3.408305 | 3.121326 | 1.091941 |
if isinstance(s, six.string_types):
s = s.lower()
if s == 'true':
return True
elif s == 'false':
return False
else:
return ValueError('Invalid boolean representation: {!r}'.format(s))
else:
return s | def setting_str_to_bool(s) | Converts 'true' to True and 'false' to False if s is a string | 2.204857 | 2.089981 | 1.054965 |
#logger.debug("to_string: {!r} ({})".format(var, type(var)))
# Decode and select correct format specifier.
if is_binary(var):
fmt = strFormat
try:
decodedVar = var.decode(decode_bytes, 'replace')
except LookupError as ex:
# Add URL to exception message.
... | def to_string(var, masked=None, decode_bytes='utf-8', maskFormat='', strFormat='{}',
intFormat='{}', numFormat=DEFAULT_NUM_FORMAT, noneFormat='{!r}', otherFormat='{}') | Converts var to a python string or unicode string so Qt widgets can display them.
If var consists of bytes, the decode_bytes is used to decode the bytes.
If var consists of a numpy.str_, the result will be converted to a regular Python string.
This is necessary to display the string in Qt widg... | 3.071623 | 3.167717 | 0.969665 |
return isinstance(var, six.string_types) or (var is None and allow_none) | def is_a_string(var, allow_none=False) | Returns True if var is a string (ascii or unicode)
Result py-2 py-3
----------------- ----- -----
b'bytes literal' True False
'string literal' True True
u'unicode literal' True True
Also returns True if the var is a numpy string (numpy.string_, nump... | 2.947053 | 5.632115 | 0.523259 |
if not is_a_string(var, allow_none=allow_none):
raise TypeError("var must be a string, however type(var) is {}"
.format(type(var))) | def check_is_a_string(var, allow_none=False) | Calls is_a_string and raises a type error if the check fails. | 3.078089 | 2.820019 | 1.091513 |
return isinstance(var, six.text_type) or (var is None and allow_none) | def is_text(var, allow_none=False) | Returns True if var is a unicode text
Result py-2 py-3
----------------- ----- -----
b'bytes literal' False False
'string literal' False True
u'unicode literal' True True
Also works with the corresponding numpy types. | 3.256083 | 5.835526 | 0.557976 |
return isinstance(var, six.binary_type) or (var is None and allow_none) | def is_binary(var, allow_none=False) | Returns True if var is a binary (bytes) objects
Result py-2 py-3
----------------- ----- -----
b'bytes literal' True True
'string literal' True False
u'unicode literal' False False
Also works with the corresponding numpy types. | 3.252952 | 5.708185 | 0.569875 |
return isinstance(var, (list, tuple)) or (var is None and allow_none) | def is_a_sequence(var, allow_none=False) | Returns True if var is a list or a tuple (but not a string!) | 3.286296 | 2.876901 | 1.142304 |
if not is_a_sequence(var, allow_none=allow_none):
raise TypeError("var must be a list or tuple, however type(var) is {}"
.format(type(var))) | def check_is_a_sequence(var, allow_none=False) | Calls is_a_sequence and raises a type error if the check fails. | 3.335137 | 3.027427 | 1.101641 |
if not is_a_mapping(var, allow_none=allow_none):
raise TypeError("var must be a dict, however type(var) is {}"
.format(type(var))) | def check_is_a_mapping(var, allow_none=False) | Calls is_a_mapping and raises a type error if the check fails. | 3.387676 | 3.044033 | 1.112891 |
return isinstance(var, np.ndarray) or (var is None and allow_none) | def is_an_array(var, allow_none=False) | Returns True if var is a numpy array. | 3.261157 | 2.820828 | 1.156099 |
if not is_an_array(var, allow_none=allow_none):
raise TypeError("var must be a NumPy array, however type(var) is {}"
.format(type(var))) | def check_is_an_array(var, allow_none=False) | Calls is_an_array and raises a type error if the check fails. | 3.37706 | 3.067599 | 1.100881 |
kind = array.dtype.kind
assert kind in 'biufcmMOSUV', "Unexpected array kind: {}".format(kind)
return kind in 'iuf' | def array_has_real_numbers(array) | Uses the dtype kind of the numpy array to determine if it represents real numbers.
That is, the array kind should be one of: i u f
Possible dtype.kind values.
b boolean
i signed integer
u unsigned integer
f floating-point
c complex float... | 6.654174 | 6.114135 | 1.088326 |
if not isinstance(obj, target_class):
if not (allow_none and obj is None):
raise TypeError("obj must be a of type {}, got: {}"
.format(target_class, type(obj))) | def check_class(obj, target_class, allow_none = False) | Checks that the obj is a (sub)type of target_class.
Raises a TypeError if this is not the case.
:param obj: object whos type is to be checked
:type obj: any type
:param target_class: target type/class
:type target_class: any class or type
:param allow_none: if true obj ... | 2.786773 | 3.403183 | 0.818873 |
parts = full_symbol_name.rsplit('.', 1)
if len(parts) == 2:
module_name, symbol_name = parts
module_name = str(module_name) # convert from possible unicode
symbol_name = str(symbol_name)
#logger.debug("From module {} importing {!r}".format(module_name, symbol_name))
... | def import_symbol(full_symbol_name) | Imports a symbol (e.g. class, variable, etc) from a dot separated name.
Can be used to create a class whose type is only known at run-time.
The full_symbol_name must contain packages and module,
e.g.: 'argos.plugins.rti.ncdf.NcdfFileRti'
If the module doesn't exist an ImportError is ra... | 4.321577 | 4.393521 | 0.983625 |
displayValues=PEN_STYLE_DISPLAY_VALUES
configValues=PEN_STYLE_CONFIG_VALUES
if includeNone:
displayValues = [''] + list(displayValues)
configValues = [None] + list(configValues)
return ChoiceCti(nodeName, defaultData,
displayValues=displayValues, configValues=co... | def createPenStyleCti(nodeName, defaultData=0, includeNone=False) | Creates a ChoiceCti with Qt PenStyles.
If includeEmtpy is True, the first option will be None. | 3.751249 | 3.548013 | 1.057282 |
# A pen line width of zero indicates a cosmetic pen. This means that the pen width is
# always drawn one pixel wide, independent of the transformation set on the painter.
# Note that line widths other than 1 may be slow when anti aliasing is on.
return FloatCti(nodeName, defaultData=defaultData, sp... | def createPenWidthCti(nodeName, defaultData=1.0, zeroValueText=None) | Creates a FloatCti with defaults for configuring a QPen width.
If specialValueZero is set, this string will be displayed when 0.0 is selected.
If specialValueZero is None, the minValue will be 0.1 | 7.88968 | 7.635982 | 1.033224 |
try:
return families.index(qFont.family())
except ValueError:
if False and DEBUGGING:
raise
else:
logger.warn("{} not found in font families, using default.".format(qFont.family()))
return families.index(qFont.defaultFamily()) | def fontFamilyIndex(qFont, families) | Searches the index of qFont.family in the families list.
If qFont.family() is not in the list, the index of qFont.defaultFamily() is returned.
If that is also not present an error is raised. | 3.903739 | 3.824787 | 1.020642 |
try:
return weights.index(qFont.weight())
except ValueError:
if False and DEBUGGING:
raise
else:
logger.warn("{} not found in font weights, using normal.".format(qFont.weight()))
return weights.index(QtGui.QFont.Normal) | def fontWeightIndex(qFont, weights) | Searches the index of qFont.family in the weight list.
If qFont.weight() is not in the list, the index of QFont.Normal is returned.
If that is also not present an error is raised. | 4.245953 | 4.480841 | 0.947579 |
qColor = QtGui.QColor(data) # TODO: store a RGB string?
if not qColor.isValid():
raise ValueError("Invalid color specification: {!r}".format(data))
return qColor | def _enforceDataType(self, data) | Converts to str so that this CTI always stores that type. | 8.068489 | 7.914668 | 1.019435 |
dct = {}
if self.data != self.defaultData:
dct['data'] = self.data.name()
return dct | def _nodeGetNonDefaultsDict(self) | Retrieves this nodes` values as a dictionary to be used for persistence.
Non-recursive auxiliary function for getNonDefaultsDict | 6.144742 | 6.245707 | 0.983834 |
return ColorCtiEditor(self, delegate, parent=parent) | def createEditor(self, delegate, parent, option) | Creates a ColorCtiEditor.
For the parameters see the AbstractCti constructor documentation. | 36.284454 | 5.30126 | 6.844496 |
self.pickButton.clicked.disconnect(self.openColorDialog)
super(ColorCtiEditor, self).finalize() | def finalize(self) | Is called when the editor is closed. Disconnect signals. | 21.342043 | 11.395965 | 1.872772 |
try:
currentColor = self.getData()
except InvalidInputError:
currentColor = self.cti.data
qColor = QtWidgets.QColorDialog.getColor(currentColor, self)
if qColor.isValid():
self.setData(qColor)
self.commitAndClose() | def openColorDialog(self) | Opens a QColorDialog for the user | 5.947894 | 5.718358 | 1.04014 |
text = self.lineEditor.text()
if not text.startswith('#'):
text = '#' + text
validator = self.lineEditor.validator()
if validator is not None:
state, text, _ = validator.validate(text, 0)
if state != QtGui.QValidator.Acceptable:
... | def getData(self) | Gets data from the editor widget. | 4.348245 | 4.042727 | 1.075572 |
self._data = self._enforceDataType(data) # Enforce self._data to be a QFont
self.familyCti.data = fontFamilyIndex(self.data, list(self.familyCti.iterConfigValues))
self.pointSizeCti.data = self.data.pointSize()
self.weightCti.data = fontWeightIndex(self.data, list(self.weightCti... | def data(self, data) | Sets the font data of this item.
Does type conversion to ensure data is always of the correct type.
Also updates the children (which is the reason for this property to be overloaded. | 5.726327 | 4.950804 | 1.156646 |
self._defaultData = self._enforceDataType(defaultData) # Enforce to be a QFont
self.familyCti.defaultData = fontFamilyIndex(self.defaultData,
list(self.familyCti.iterConfigValues))
self.pointSizeCti.defaultData = self.defaultData.poin... | def defaultData(self, defaultData) | Sets the data of this item.
Does type conversion to ensure default data is always of the correct type. | 5.961202 | 6.070306 | 0.982027 |
font = self.data
if self.familyCti.configValue:
font.setFamily(self.familyCti.configValue)
else:
font.setFamily(QtGui.QFont().family()) # default family
font.setPointSize(self.pointSizeCti.configValue)
font.setWeight(self.weightCti.configValue)
... | def _updateTargetFromNode(self) | Applies the font config settings to the target widget's font.
That is the targetWidget.setFont() is called with a font create from the config values. | 3.317698 | 2.903242 | 1.142756 |
dct = {}
if self.data != self.defaultData:
dct['data'] = self.data.toString() # calls QFont.toString()
return dct | def _nodeGetNonDefaultsDict(self) | Retrieves this nodes` values as a dictionary to be used for persistence.
Non-recursive auxiliary function for getNonDefaultsDict | 9.658505 | 10.091542 | 0.957089 |
if 'data' in dct:
qFont = QtGui.QFont()
success = qFont.fromString(dct['data'])
if not success:
msg = "Unable to create QFont from string {!r}".format(dct['data'])
logger.warn(msg)
if DEBUGGING:
rais... | def _nodeSetValuesFromDict(self, dct) | Sets values from a dictionary in the current node.
Non-recursive auxiliary function for setValuesFromDict | 4.201223 | 4.41452 | 0.951683 |
return FontCtiEditor(self, delegate, parent=parent) | def createEditor(self, delegate, parent, option) | Creates a FontCtiEditor.
For the parameters see the AbstractCti documentation. | 35.270145 | 5.617267 | 6.27888 |
self.pickButton.clicked.disconnect(self.execFontDialog)
super(FontCtiEditor, self).finalize() | def finalize(self) | Is called when the editor is closed. Disconnect signals. | 27.507439 | 16.642723 | 1.652821 |
currentFont = self.getData()
newFont, ok = QtGui.QFontDialog.getFont(currentFont, self)
if ok:
self.setData(newFont)
else:
self.setData(currentFont)
self.commitAndClose() | def execFontDialog(self) | Opens a QColorDialog for the user | 3.476422 | 3.798289 | 0.91526 |
return FontChoiceCtiEditor(self, delegate, parent=parent) | def createEditor(self, delegate, parent, option) | Creates a ChoiceCtiEditor.
For the parameters see the AbstractCti constructor documentation. | 53.275536 | 9.560465 | 5.572484 |
self.comboBox.activated.disconnect(self.comboBoxActivated)
super(FontChoiceCtiEditor, self).finalize() | def finalize(self) | Is called when the editor is closed. Disconnect signals. | 20.519896 | 11.804565 | 1.738302 |
if not self.data:
return None
else:
pen = QtGui.QPen()
pen.setCosmetic(True)
pen.setColor(self.colorCti.configValue)
style = self.styleCti.configValue
if style is not None:
pen.setStyle(style)
pe... | def configValue(self) | Creates a QPen made of the children's config values. | 3.803986 | 2.896864 | 1.31314 |
pen = self.configValue
if pen is not None:
style = self.findByNodePath('style').configValue
if style is None and altStyle is not None:
pen.setStyle(altStyle)
width = self.findByNodePath('width').configValue
if width == 0.0 and al... | def createPen(self, altStyle=None, altWidth=None) | Creates a pen from the config values with the style overridden by altStyle if the
None-option is selected in the combo box. | 4.716495 | 4.386421 | 1.075249 |
if mask is False:
result = data
elif mask is True:
result = np.copy(data) if copyOnReplace else data
result[:] = replacementValue
else:
#logger.debug("############ count_nonzero: {}".format(np.count_nonzero(mask)))
if copyOnReplace and np.any(mask):
#... | def replaceMaskedValue(data, mask, replacementValue, copyOnReplace=True) | Replaces values where the mask is True with the replacement value.
:copyOnReplace makeCopy: If True (the default) it makes a copy if data is replaced. | 3.14631 | 3.43187 | 0.916792 |
kind = data.dtype.kind
if kind == 'i' or kind == 'u': # signed/unsigned int
data = data.astype(np.float, casting='safe')
if data.dtype.kind != 'f':
return # only replace for floats
else:
return replaceMaskedValue(data, mask, replacementValue, copyOnReplace=copyOnReplace) | def replaceMaskedValueWithFloat(data, mask, replacementValue, copyOnReplace=True) | Replaces values where the mask is True with the replacement value.
Will change the data type to float if the data is an integer.
If the data is not a float (or int) the function does nothing. Otherwise it will call
replaceMaskedValue with the same parameters.
:copyOnReplace makeCopy: I... | 3.661333 | 3.998104 | 0.915767 |
#https://docs.scipy.org/doc/numpy/reference/maskedarray.generic.html#accessing-the-data
awm = ArrayWithMask.createFromMaskedArray(maskedArray)
maskIdx = awm.maskIndex()
validData = awm.data[~maskIdx]
if len(validData) >= 1:
result = np.nanpercentile(validData, percentiles, *args, **k... | def maskedNanPercentile(maskedArray, percentiles, *args, **kwargs) | Calculates np.nanpercentile on the non-masked values | 4.374926 | 4.349178 | 1.00592 |
if array_is_structured(array):
# Enforce the array to be masked
if not isinstance(array, ma.MaskedArray):
array = ma.MaskedArray(array)
# Set the mask separately per field
for nr, field in enumerate(array.dtype.names):
if hasattr(missingValue, '__len__')... | def maskedEqual(array, missingValue) | Mask an array where equal to a given (missing)value.
Unfortunately ma.masked_equal does not work with structured arrays. See:
https://mail.scipy.org/pipermail/numpy-discussion/2011-July/057669.html
If the data is a structured array the mask is applied for every field (i.e. forming a
lo... | 3.454457 | 3.268187 | 1.056995 |
check_class(mask, (np.ndarray, bool, np.bool_))
if isinstance(mask, (bool, np.bool_)):
self._mask = bool(mask)
else:
self._mask = mask | def mask(self, mask) | The mask values. Must be an array or a boolean scalar. | 3.576523 | 2.975596 | 1.201952 |
if is_an_array(self.mask) and self.mask.shape != self.data.shape:
raise ConsistencyError("Shape mismatch mask={}, data={}"
.format(self.mask.shape != self.data.shape)) | def checkIsConsistent(self) | Raises a ConsistencyError if the mask has an incorrect shape. | 6.300773 | 4.19382 | 1.502395 |
if isinstance(masked_arr, ArrayWithMask):
return masked_arr
check_class(masked_arr, (np.ndarray, ma.MaskedArray))
# A MaskedConstant (i.e. masked) is a special case of MaskedArray. It does not seem to have
# a fill_value so we use None to use the default.
#... | def createFromMaskedArray(cls, masked_arr) | Creates an ArrayWithMak
:param masked_arr: a numpy MaskedArray or numpy array
:return: ArrayWithMask | 3.727051 | 3.595301 | 1.036645 |
return ma.masked_array(data=self.data, mask=self.mask, fill_value=self.fill_value) | def asMaskedArray(self) | Creates converts to a masked array | 2.946459 | 3.127187 | 0.942208 |
if isinstance(self.mask, bool):
return self.mask
else:
return self.mask[index] | def maskAt(self, index) | Returns the mask at the index.
It the mask is a boolean it is returned since this boolean representes the mask for
all array elements. | 3.834957 | 3.978611 | 0.963894 |
if isinstance(self.mask, bool):
return np.full(self.data.shape, self.mask, dtype=np.bool)
else:
return self.mask | def maskIndex(self) | Returns a boolean index with True if the value is masked.
Always has the same shape as the maksedArray.data, event if the mask is a single boolan. | 3.234486 | 2.98564 | 1.083348 |
tdata = np.transpose(self.data, *args, **kwargs)
tmask = np.transpose(self.mask, *args, **kwargs) if is_an_array(self.mask) else self.mask
return ArrayWithMask(tdata, tmask, self.fill_value) | def transpose(self, *args, **kwargs) | Transposes the array and mask separately
:param awm: ArrayWithMask
:return: copy/view with transposed | 3.233379 | 3.219656 | 1.004262 |
if self.mask is False:
pass
elif self.mask is True:
self.data[:] = replacementValue
else:
self.data[self.mask] = replacementValue | def replaceMaskedValue(self, replacementValue) | Replaces values where the mask is True with the replacement value. | 3.191117 | 2.678072 | 1.191572 |
kind = self.data.dtype.kind
if kind == 'i' or kind == 'u': # signed/unsigned int
self.data = self.data.astype(np.float, casting='safe')
if self.data.dtype.kind != 'f':
return # only replace for floats
if self.mask is False:
pass
elif... | def replaceMaskedValueWithNan(self) | Replaces values where the mask is True with the replacement value.
Will change the data type to float if the data is an integer.
If the data is not a float (or int) the function does nothing. | 3.223175 | 3.294281 | 0.978415 |
self.statusLabel.setText("Importing {}...".format(regItem.fullName))
QtWidgets.qApp.processEvents()
regItem.tryImportClass()
self.tableView.model().emitDataChanged(regItem)
self.statusLabel.setText("")
QtWidgets.qApp.processEvents() | def importRegItem(self, regItem) | Imports the regItem
Writes this in the statusLabel while the import is in progress. | 4.413406 | 3.743109 | 1.179075 |
for regItem in self.registeredItems:
if not regItem.triedImport:
self.importRegItem(regItem)
logger.debug("Importing finished.") | def tryImportAllPlugins(self) | Tries to import all underlying plugin classes | 8.29627 | 8.050774 | 1.030494 |
check_class(regItem, ClassRegItem, allow_none=True)
self.tableView.setCurrentRegItem(regItem) | def setCurrentRegItem(self, regItem) | Sets the current item to the regItem | 9.20616 | 10.398013 | 0.885377 |
self.editor.clear()
self.editor.setTextColor(QCOLOR_REGULAR)
regItem = self.getCurrentRegItem()
if regItem is None:
return
if self._importOnSelect and regItem.successfullyImported is None:
self.importRegItem(regItem)
if regItem.success... | def currentItemChanged(self, _currentIndex=None, _previousIndex=None) | Updates the description text widget when the user clicks on a selector in the table.
The _currentIndex and _previousIndex parameters are ignored. | 3.654158 | 3.678726 | 0.993321 |
logger.debug("Importing plugins: {}".format(self))
for tabNr in range(self.tabWidget.count()):
tab = self.tabWidget.widget(tabNr)
tab.tryImportAllPlugins() | def tryImportAllPlugins(self) | Refreshes the tables of all tables by importing the underlying classes | 4.345952 | 5.086007 | 0.854492 |
dimNames = [] # TODO: cache?
for dimNr, dimScales in enumerate(h5Dataset.dims):
if len(dimScales) == 0:
dimNames.append('Dim{}'.format(dimNr))
elif len(dimScales) == 1:
dimScaleLabel, dimScaleDataset = dimScales.items()[0]
path = dimScaleDataset.name
... | def dimNamesFromDataset(h5Dataset) | Constructs the dimension names given a h5py dataset.
First looks in the dataset's dimension scales to see if it refers to another
dataset. In that case the referred dataset's name is used. If not, the label of the
dimension scale is used. Finally, if this is empty, the dimension is numbered. | 3.875279 | 3.484589 | 1.11212 |
dtype = h5Dataset.dtype
if dtype.names:
return '<structured>'
else:
if dtype.metadata and 'vlen' in dtype.metadata:
vlen_type = dtype.metadata['vlen']
try:
return "<vlen {}>".format(vlen_type.__name__) # when vlen_type is a type
exc... | def dataSetElementType(h5Dataset) | Returns a string describing the element type of the dataset | 4.125027 | 4.103672 | 1.005204 |
attributes = h5Dataset.attrs
if not attributes:
return '' # a premature optimization :-)
for key in ('unit', 'units', 'Unit', 'Units', 'UNIT', 'UNITS'):
if key in attributes:
# In Python3 the attributes are byte strings so we must decode them
# This a bug in h5p... | def dataSetUnit(h5Dataset) | Returns the unit of the h5Dataset by looking in the attributes.
It searches in the attributes for one of the following keys:
'unit', 'units', 'Unit', 'Units', 'UNIT', 'UNITS'. If these are not found, the empty
string is returned.
Always returns a string | 5.451123 | 4.4644 | 1.22102 |
attributes = h5Dataset.attrs
if not attributes:
return None # a premature optimization :-)
for key in ('missing_value', 'MissingValue', 'missingValue', 'FillValue', '_FillValue'):
if key in attributes:
missingDataValue = attributes[key]
if is_an_array(missingDat... | def dataSetMissingValue(h5Dataset) | Returns the missingData given a HDF-5 dataset
Looks for one of the following attributes: _FillValue, missing_value, MissingValue,
missingValue. Returns None if these attributes are not found.
HDF-EOS and NetCDF files seem to put the attributes in 1-element arrays. So if the
attribute c... | 4.889225 | 3.635069 | 1.345015 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.