eric: comparison src/eric7/UI/BrowserModel.py

-:2fe91fe443dd
+:328f3ec4b77a
 from eric7.EricGui import EricPixmapCache
 from eric7.SystemUtilities import FileSystemUtilities
 from eric7.Utilities import ClassBrowsers
 from eric7.Utilities.ClassBrowsers import ClbrBaseClasses
+# TODO: change this to enum.Enum
 BrowserItemRoot = 0
 BrowserItemSimpleDirectory = 1
 BrowserItemDirectory = 2
 BrowserItemSysPath = 3
 BrowserItemFile = 4
 def __init__(self, parent=None, nopopulate=False):
 """
 Constructor
-@param parent reference to parent object (QObject)
+@param parent reference to parent object
+@type QObject
 @param nopopulate flag indicating to not populate the model
-(boolean)
+@type bool
 """
 super().__init__(parent)
 self.progDir = None
 def columnCount(self, parent=None):
 """
 Public method to get the number of columns.
-@param parent index of parent item (QModelIndex)
+@param parent index of parent item
-@return number of columns (integer)
+@type QModelIndex
+@return number of columns
+@rtype int
 """
 if parent is None:
 parent = QModelIndex()
 item = parent.internalPointer() if parent.isValid() else self.rootItem
 def data(self, index, role):
 """
 Public method to get data of an item.
-@param index index of the data to retrieve (QModelIndex)
+@param index index of the data to retrieve
-@param role role of data (Qt.ItemDataRole)
+@type QModelIndex
+@param role role of data
+@type Qt.ItemDataRole
 @return requested data
+@rtype Any
 """
 if not index.isValid():
 return None
 if role == Qt.ItemDataRole.DisplayRole:
 def flags(self, index):
 """
 Public method to get the item flags.
-@param index index of the data to retrieve (QModelIndex)
+@param index index of the data to retrieve
-@return requested flags (Qt.ItemFlags)
+@type QModelIndex
+@return requested flags
+@rtype Qt.ItemFlags
 """
 if not index.isValid():
 return Qt.ItemFlag.ItemIsEnabled
 return Qt.ItemFlag.ItemIsEnabled | Qt.ItemFlag.ItemIsSelectable
 def headerData(self, section, orientation, role=Qt.ItemDataRole.DisplayRole):
 """
 Public method to get the header data.
-@param section number of section to get data for (integer)
+@param section number of section to get data for
-@param orientation header orientation (Qt.Orientation)
+@type int
-@param role role of data (Qt.ItemDataRole)
+@param orientation header orientation
+@type Qt.Orientation
+@param role role of data
+@type Qt.ItemDataRole
 @return requested header data
+@rtype Any
 """
 if (
 orientation == Qt.Orientation.Horizontal
 and role == Qt.ItemDataRole.DisplayRole
 ):
 def index(self, row, column, parent=None):
 """
 Public method to create an index.
-@param row row number of the new index (integer)
+@param row row number of the new index
-@param column column number of the new index (integer)
+@type int
-@param parent index of parent item (QModelIndex)
+@param column column number of the new index
-@return index object (QModelIndex)
+@type int
+@param parent index of parent item
+@type QModelIndex
+@return index object
+@rtype QModelIndex
 """
 if parent is None:
 parent = QModelIndex()
 # The model/view framework considers negative values out-of-bounds,
 def parent(self, index):
 """
 Public method to get the index of the parent object.
-@param index index of the item (QModelIndex)
+@param index index of the item
-@return index of parent item (QModelIndex)
+@type QModelIndex
+@return index of parent item
+@rtype QModelIndex
 """
 if not index.isValid():
 return QModelIndex()
 childItem = index.internalPointer()
 def rowCount(self, parent=None):
 """
 Public method to get the number of rows.
-@param parent index of parent item (QModelIndex)
+@param parent index of parent item
-@return number of rows (integer)
+@type QModelIndex
+@return number of rows
+@rtype int
 """
 if parent is None:
 parent = QModelIndex()
 # Only the first column should have children
 Public method to check for the presence of child items.
 We always return True for normal items in order to do lazy
 population of the tree.
-@param parent index of parent item (QModelIndex)
+@param parent index of parent item
-@return flag indicating the presence of child items (boolean)
+@type QModelIndex
+@return flag indicating the presence of child items
+@rtype bool
 """
 if parent is None:
 parent = QModelIndex()
 # Only the first column should have children
 def item(self, index):
 """
 Public method to get a reference to an item.
-@param index index of the data to retrieve (QModelIndex)
+@param index index of the data to retrieve
-@return requested item reference (BrowserItem)
+@type QModelIndex
+@return requested item reference
+@rtype BrowserItem
 """
 if not index.isValid():
 return None
 return index.internalPointer()
 def _addWatchedItem(self, itm):
 """
 Protected method to watch an item.
-@param itm item to be watched (BrowserDirectoryItem)
+@param itm item to be watched
+@type BrowserDirectoryItem
 """
 if isinstance(itm, BrowserDirectoryItem):
 dirName = itm.dirName()
 if (
 dirName != ""
 def _removeWatchedItem(self, itm):
 """
 Protected method to remove a watched item.
-@param itm item to be removed (BrowserDirectoryItem)
+@param itm item to be removed
+@type BrowserDirectoryItem
 """
 if isinstance(itm, BrowserDirectoryItem):
 dirName = itm.dirName()
 if dirName in self.watchedItems:
 if itm in self.watchedItems[dirName]:
 def directoryChanged(self, path):
 """
 Public slot to handle the directoryChanged signal of the watcher.
-@param path path of the directory (string)
+@param path path of the directory
+@type str
 """
 if path not in self.watchedItems:
 # just ignore the situation we don't have a reference to the item
 return
 def interpreterChanged(self, interpreter):
 """
 Public method to handle a change of the debug client's interpreter.
-@param interpreter interpreter of the debug client (string)
+@param interpreter interpreter of the debug client
+@type str
 """
 if interpreter and "python" in interpreter.lower():
 if interpreter.endswith("w.exe"):
 interpreter = interpreter.replace("w.exe", ".exe")
 if self.__sysPathInterpreter != interpreter:
 def programChange(self, dirname):
 """
 Public method to change the entry for the directory of file being
 debugged.
-@param dirname name of the directory containing the file (string)
+@param dirname name of the directory containing the file
+@type str
 """
 if self.progDir:
 if dirname == self.progDir.dirName():
 return
 def addTopLevelDir(self, dirname):
 """
 Public method to add a new toplevel directory.
-@param dirname name of the new toplevel directory (string)
+@param dirname name of the new toplevel directory
+@type str
 """
 if dirname not in self.toplevelDirs:
 itm = BrowserDirectoryItem(self.rootItem, dirname)
 self.addItem(itm)
 self.toplevelDirs.append(itm.dirName())
 def removeToplevelDir(self, index):
 """
 Public method to remove a toplevel directory.
 @param index index of the toplevel directory to be removed
-(QModelIndex)
+@type QModelIndex
 """
 if not index.isValid():
 return
 item = index.internalPointer()
 def _addItem(self, itm, parentItem):
 """
 Protected slot to add an item.
-@param itm reference to item to add (BrowserItem)
+@param itm reference to item to add
-@param parentItem reference to item to add to (BrowserItem)
+@type BrowserItem
+@param parentItem reference to item to add to
+@type BrowserItem
 """
 parentItem.appendChild(itm)
 def addItem(self, itm, parent=None):
 """
 Public slot to add an item.
-@param itm item to add (BrowserItem)
+@param itm item to add
-@param parent index of parent item (QModelIndex)
+@type BrowserItem
+@param parent index of parent item
+@type QModelIndex
 """
 if parent is None:
 parent = QModelIndex()
 parentItem = parent.internalPointer() if parent.isValid() else self.rootItem
 def populateItem(self, parentItem, repopulate=False):
 """
 Public method to populate an item's subtree.
 @param parentItem reference to the item to be populated
-@param repopulate flag indicating a repopulation (boolean)
+@type BrowserItem
+@param repopulate flag indicating a repopulation
+@type bool
 """
 if parentItem.type() == BrowserItemDirectory:
 self.populateDirectoryItem(parentItem, repopulate)
 elif parentItem.type() == BrowserItemSysPath:
 self.populateSysPathItem(parentItem, repopulate)
 def populateDirectoryItem(self, parentItem, repopulate=False):
 """
 Public method to populate a directory item's subtree.
 @param parentItem reference to the directory item to be populated
-@param repopulate flag indicating a repopulation (boolean)
+@type BrowserDirectoryItem
+@param repopulate flag indicating a repopulation
+@type bool
 """
 self._addWatchedItem(parentItem)
 qdir = QDir(parentItem.dirName())
 def populateSysPathItem(self, parentItem, repopulate=False):
 """
 Public method to populate a sys.path item's subtree.
 @param parentItem reference to the sys.path item to be populated
-@param repopulate flag indicating a repopulation (boolean)
+@type BrowserSysPathItem
+@param repopulate flag indicating a repopulation
+@type bool
 """
 if self.__sysPathInterpreter:
 script = "import sys, json; print(json.dumps(sys.path))"
 proc = QProcess()
 proc.start(self.__sysPathInterpreter, ["-c", script])
 def populateFileItem(self, parentItem, repopulate=False):
 """
 Public method to populate a file item's subtree.
 @param parentItem reference to the file item to be populated
-@param repopulate flag indicating a repopulation (boolean)
+@type BrowserFileItem
+@param repopulate flag indicating a repopulation
+@type bool
 """
 from eric7.Utilities import ClassBrowsers
 moduleName = parentItem.moduleName()
 fileName = parentItem.fileName()
 def populateClassItem(self, parentItem, repopulate=False):
 """
 Public method to populate a class item's subtree.
 @param parentItem reference to the class item to be populated
-@param repopulate flag indicating a repopulation (boolean)
+@type BrowserClassItem
+@param repopulate flag indicating a repopulation
+@type bool
 """
 cl = parentItem.classObject()
 file_ = parentItem.fileName()
 if cl is None:
 def populateMethodItem(self, parentItem, repopulate=False):
 """
 Public method to populate a method item's subtree.
 @param parentItem reference to the method item to be populated
-@param repopulate flag indicating a repopulation (boolean)
+@type BrowserItem
+@param repopulate flag indicating a repopulation
+@type bool
 """
 fn = parentItem.functionObject()
 file_ = parentItem.fileName()
 if fn is None:
 """
 Public method to populate a class attributes item's subtree.
 @param parentItem reference to the class attributes item to be
 populated
-@param repopulate flag indicating a repopulation (boolean)
+@type BrowserClassAttributesItem
+@param repopulate flag indicating a repopulation
+@type bool
 """
 classAttributes = parentItem.isClassAttributes()
 attributes = parentItem.attributes()
 if not attributes:
 return
 def __init__(self, parent, data):
 """
 Constructor
 @param parent reference to the parent item
+@type BrowserItem
 @param data single data of the item
+@type Any
 """
 self.childItems = []
 self.parentItem = parent
 self.itemData = [data]
 def appendChild(self, child):
 """
 Public method to add a child to this item.
-@param child reference to the child item to add (BrowserItem)
+@param child reference to the child item to add
+@type BrowserItem
 """
 self.childItems.append(child)
 self._populated = True
 def removeChild(self, child):
 """
 Public method to remove a child.
-@param child reference to the child to remove (BrowserItem)
+@param child reference to the child to remove
+@type BrowserItem
 """
 self.childItems.remove(child)
 def removeChildren(self):
 """
 def child(self, row):
 """
 Public method to get a child id.
-@param row number of child to get the id of (integer)
+@param row number of child to get the id of
-@return reference to the child item (BrowserItem)
+@type int
+@return reference to the child item
+@rtype BrowserItem
 """
 return self.childItems[row]
 def children(self):
 """
 Public method to get the ids of all child items.
-@return references to all child items (list of BrowserItem)
+@return references to all child items
+@rtype list of BrowserItem
 """
 return self.childItems[:]
 def childCount(self):
 """
 Public method to get the number of available child items.
-@return number of child items (integer)
+@return number of child items
+@rtype int
 """
 return len(self.childItems)
 def columnCount(self):
 """
 Public method to get the number of available data items.
-@return number of data items (integer)
+@return number of data items
+@rtype int
 """
 return len(self.itemData)
 def data(self, column):
 """
 Public method to get a specific data item.
-@param column number of the requested data item (integer)
+@param column number of the requested data item
+@type int
 @return stored data item
+@rtype Any
 """
 try:
 return self.itemData[column]
 except IndexError:
 return ""
 def parent(self):
 """
 Public method to get the reference to the parent item.
 @return reference to the parent item
+@rtype BrowserItem
 """
 return self.parentItem
 def row(self):
 """
 Public method to get the row number of this item.
-@return row number (integer)
+@return row number
+@rtype int
 """
 try:
 return self.parentItem.childItems.index(self)
 except ValueError:
 return 0
 def type(self):
 """
 Public method to get the item type.
 @return type of the item
-"""
+@rtype int
+"""
+# TODO: change this to reference the new Enum
 return self.type_
 def isPublic(self):
 """
 Public method returning the public visibility status.
-@return flag indicating public visibility (boolean)
+@return flag indicating public visibility
+@rtype bool
 """
 return True
 def getIcon(self):
 """
 Public method to get the items icon.
-@return the icon (QIcon)
+@return the icon
+@rtype QIcon
 """
 return self.icon
 def isPopulated(self):
 """
 Public method to chek, if this item is populated.
-@return population status (boolean)
+@return population status
+@rtype bool
 """
 return self._populated
 def isLazyPopulated(self):
 """
 Public method to check, if this item should be populated lazyly.
-@return lazy population flag (boolean)
+@return lazy population flag
+@rtype bool
 """
 return self._lazyPopulation
 def lessThan(self, other, column, order):  # noqa: U100
 """
 Public method to check, if the item is less than the other one.
-@param other reference to item to compare against (BrowserItem)
+@param other reference to item to compare against
-@param column column number to use for the comparison (integer)
+@type BrowserItem
-@param order sort order (Qt.SortOrder) (for special sorting)
+@param column column number to use for the comparison
-@return true, if this item is less than other (boolean)
+@type int
+@param order sort order (for special sorting)
+@type Qt.SortOrder
+@return true, if this item is less than other
+@rtype bool
 """
 try:
 return self.itemData[column] < other.itemData[column]
 except IndexError:
 return False
 def isSymlink(self):
 """
 Public method to check, if the items is a symbolic link.
-@return flag indicating a symbolic link (boolean)
+@return flag indicating a symbolic link
+@rtype bool
 """
 return self.symlink
 class BrowserSimpleDirectoryItem(BrowserItem):
 def __init__(self, parent, text, path=""):
 """
 Constructor
 @param parent parent item
-@param text text to be displayed (string)
+@type BrowserItem
-@param path path of the directory (string)
+@param text text to be displayed
+@type str
+@param path path of the directory
+@type str
 """
 BrowserItem.__init__(self, parent, text)
 self.type_ = BrowserItemSimpleDirectory
 def setName(self, dinfo, full=True):  # noqa: U100
 """
 Public method to set the directory name.
-@param dinfo dinfo is the string for the directory (string)
+@param dinfo dinfo is the string for the directory
-@param full flag indicating full path name should be displayed (boolean)
+@type str
+@param full flag indicating full path name should be displayed
+@type bool
 """
 self._dirName = os.path.abspath(dinfo)
 self.itemData[0] = os.path.basename(self._dirName)
 def dirName(self):
 """
 Public method returning the directory name.
-@return directory name (string)
+@return directory name
+@rtype str
 """
 return self._dirName
 def name(self):
 """
 Public method to return the name of the item.
-@return name of the item (string)
+@return name of the item
+@rtype str
 """
 return self._dirName
 def lessThan(self, other, column, order):
 """
 Public method to check, if the item is less than the other one.
-@param other reference to item to compare against (BrowserItem)
+@param other reference to item to compare against
-@param column column number to use for the comparison (integer)
+@type BrowserItem
-@param order sort order (Qt.SortOrder) (for special sorting)
+@param column column number to use for the comparison
-@return true, if this item is less than other (boolean)
+@type int
+@param order sort order (for special sorting)
+@type Qt.SortOrder
+@return true, if this item is less than other
+@rtype bool
 """
 if issubclass(other.__class__, BrowserFileItem) and Preferences.getUI(
 "BrowsersListFoldersFirst"
 ):
 return order == Qt.SortOrder.AscendingOrder
 def __init__(self, parent, dinfo, full=True):
 """
 Constructor
 @param parent parent item
-@param dinfo dinfo is the string for the directory (string)
+@type BrowserItem
-@param full flag indicating full pathname should be displayed (boolean)
+@param dinfo dinfo is the string for the directory
+@type str
+@param full flag indicating full pathname should be displayed
+@type bool
 """
 self._dirName = os.path.abspath(dinfo)
 dn = self._dirName if full else os.path.basename(self._dirName)
 BrowserItem.__init__(self, parent, dn)
 def setName(self, dinfo, full=True):
 """
 Public method to set the directory name.
-@param dinfo dinfo is the string for the directory (string)
+@param dinfo dinfo is the string for the directory
-@param full flag indicating full pathname should be displayed (boolean)
+@type str
+@param full flag indicating full pathname should be displayed
+@type bool
 """
 self._dirName = os.path.abspath(dinfo)
 dn = self._dirName if full else os.path.basename(self._dirName)
 self.itemData[0] = dn
 def dirName(self):
 """
 Public method returning the directory name.
-@return directory name (string)
+@return directory name
+@rtype str
 """
 return self._dirName
 def name(self):
 """
 Public method to return the name of the item.
-@return name of the item (string)
+@return name of the item
+@rtype str
 """
 return self._dirName
 def lessThan(self, other, column, order):
 """
 Public method to check, if the item is less than the other one.
-@param other reference to item to compare against (BrowserItem)
+@param other reference to item to compare against
-@param column column number to use for the comparison (integer)
+@type BrowserItem
-@param order sort order (Qt.SortOrder) (for special sorting)
+@param column column number to use for the comparison
-@return true, if this item is less than other (boolean)
+@type int
+@param order sort order (for special sorting)
+@type Qt.SortOrder
+@return true, if this item is less than other
+@rtype bool
 """
 if issubclass(other.__class__, BrowserFileItem) and Preferences.getUI(
 "BrowsersListFoldersFirst"
 ):
 return order == Qt.SortOrder.AscendingOrder
 def __init__(self, parent):
 """
 Constructor
 @param parent parent item
+@type BrowserItem
 """
 BrowserItem.__init__(self, parent, "sys.path")
 self.type_ = BrowserItemSysPath
 self.icon = EricPixmapCache.getIcon("filePython")
 def name(self):
 """
 Public method to return the name of the item.
-@return name of the item (string)
+@return name of the item
+@rtype str
 """
 return "sys.path"
 class BrowserFileItem(BrowserItem):
 def __init__(self, parent, finfo, full=True, sourceLanguage=""):
 """
 Constructor
 @param parent parent item
-@param finfo the string for the file (string)
+@type BrowserItem
-@param full flag indicating full pathname should be displayed (boolean)
+@param finfo the string for the file
-@param sourceLanguage source code language of the project (string)
+@type str
+@param full flag indicating full pathname should be displayed
+@type bool
+@param sourceLanguage source code language of the project
+@type str
 """
 BrowserItem.__init__(self, parent, os.path.basename(finfo))
 self.type_ = BrowserItemFile
 self.fileext = os.path.splitext(finfo)[1].lower()
 def setName(self, finfo, full=True):  # noqa: U100
 """
 Public method to set the directory name.
-@param finfo the string for the file (string)
+@param finfo the string for the file
-@param full flag indicating full pathname should be displayed (boolean)
+@type str
+@param full flag indicating full pathname should be displayed
+@type bool
 """
 self._filename = os.path.abspath(finfo)
 self.itemData[0] = os.path.basename(finfo)
 self.fileext = os.path.splitext(finfo)[1].lower()
 if self.isPython3File() or self.isRubyFile() or self.isParsableFile():
 def fileName(self):
 """
 Public method returning the filename.
-@return filename (string)
+@return filename
+@rtype str
 """
 return self._filename
 def name(self):
 """
 Public method to return the name of the item.
-@return name of the item (string)
+@return name of the item
+@rtype str
 """
 return self._filename
 def fileExt(self):
 """
 Public method returning the file extension.
-@return file extension (string)
+@return file extension
+@rtype str
 """
 return self.fileext
 def dirName(self):
 """
 Public method returning the directory name.
-@return directory name (string)
+@return directory name
+@rtype str
 """
 return self._dirName
 def moduleName(self):
 """
 Public method returning the module name.
-@return module name (string)
+@return module name
+@rtype str
 """
 return self._moduleName
 def isPython3File(self):
 """
 def isDFile(self):
 """
 Public method to check, if this file is a D file.
-@return flag indicating a D file (boolean)
+@return flag indicating a D file
+@rtype bool
 """
 return self.fileext in [".d", ".di"] or (
 self.fileext == "" and self.sourceLanguage == "D"
 )
 def lessThan(self, other, column, order):
 """
 Public method to check, if the item is less than the other one.
-@param other reference to item to compare against (BrowserItem)
+@param other reference to item to compare against
-@param column column number to use for the comparison (integer)
+@type BrowserItem
-@param order sort order (Qt.SortOrder) (for special sorting)
+@param column column number to use for the comparison
-@return true, if this item is less than other (boolean)
+@type int
+@param order sort order (for special sorting)
+@type Qt.SortOrder
+@return true, if this item is less than other
+@rtype bool
 """
 if not issubclass(other.__class__, BrowserFileItem) and Preferences.getUI(
 "BrowsersListFoldersFirst"
 ):
 return order == Qt.SortOrder.DescendingOrder
 def __init__(self, parent, cl, filename):
 """
 Constructor
 @param parent parent item
+@type BrowserItem
 @param cl Class object to be shown
-@param filename filename of the file defining this class
+@type Class
+@param filename file name of the file defining this class
+@type str
 """
 name = cl.name
 if hasattr(cl, "super") and cl.super:
 supers = []
 for sup in cl.super:
 def name(self):
 """
 Public method to return the name of the item.
-@return name of the item (string)
+@return name of the item
+@rtype str
 """
 return "{0}@@{1}".format(self._filename, self.lineno())
 def fileName(self):
 """
 Public method returning the filename.
-@return filename (string)
+@return filename
+@rtype str
 """
 return self._filename
 def classObject(self):
 """
 Public method returning the class object.
 @return reference to the class object
+@rtype Class
 """
 return self._classObject
 def lineno(self):
 """
 Public method returning the line number defining this object.
-@return line number defining the object (integer)
+@return line number defining the object
+@rtype int
 """
 return self._classObject.lineno
 def boundaries(self):
 """
 Public method returning the boundaries of the method definition.
-@return tuple with start end end line number (integer, integer)
+@return tuple with start end end line number
+@rtype tuple of (int, int)
 """
 return (self._classObject.lineno, self._classObject.endlineno)
 def lessThan(self, other, column, order):
 """
 Public method to check, if the item is less than the other one.
-@param other reference to item to compare against (BrowserItem)
+@param other reference to item to compare against
-@param column column number to use for the comparison (integer)
+@type BrowserItem
-@param order sort order (Qt.SortOrder) (for special sorting)
+@param column column number to use for the comparison
-@return true, if this item is less than other (boolean)
+@type int
+@param order sort order (for special sorting)
+@type Qt.SortOrder
+@return true, if this item is less than other
+@rtype bool
 """
 if issubclass(other.__class__, (BrowserCodingItem, BrowserClassAttributesItem)):
 return order == Qt.SortOrder.DescendingOrder
 if Preferences.getUI("BrowsersListContentsByOccurrence") and column == 0:
 def isPublic(self):
 """
 Public method returning the public visibility status.
-@return flag indicating public visibility (boolean)
+@return flag indicating public visibility
+@rtype bool
 """
 return self._classObject.isPublic()
 class BrowserMethodItem(BrowserItem):
 def __init__(self, parent, fn, filename):
 """
 Constructor
 @param parent parent item
+@type BrowserItem
 @param fn Function object to be shown
-@param filename filename of the file defining this class (string)
+@type Function
+@param filename filename of the file defining this class
+@type str
 """
 name = fn.name
 BrowserItem.__init__(self, parent, name)
 self.type_ = BrowserItemMethod
 def name(self):
 """
 Public method to return the name of the item.
-@return name of the item (string)
+@return name of the item
+@rtype str
 """
 return "{0}@@{1}".format(self._filename, self.lineno())
 def fileName(self):
 """
 Public method returning the filename.
-@return filename (string)
+@return filename
+@rtype str
 """
 return self._filename
 def functionObject(self):
 """
 Public method returning the function object.
 @return reference to the function object
+@rtype Function
 """
 return self._functionObject
 def lineno(self):
 """
 Public method returning the line number defining this object.
-@return line number defining the object (integer)
+@return line number defining the object
+@rtype int
 """
 return self._functionObject.lineno
 def boundaries(self):
 """
 Public method returning the boundaries of the method definition.
-@return tuple with start end end line number (integer, integer)
+@return tuple with start end end line number
+@rtype tuple of (int, int)
 """
 return (self._functionObject.lineno, self._functionObject.endlineno)
 def lessThan(self, other, column, order):
 """
 Public method to check, if the item is less than the other one.
-@param other reference to item to compare against (BrowserItem)
+@param other reference to item to compare against
-@param column column number to use for the comparison (integer)
+@type BrowserItem
-@param order sort order (Qt.SortOrder) (for special sorting)
+@param column column number to use for the comparison
-@return true, if this item is less than other (boolean)
+@type int
+@param order sort order (for special sorting)
+@type Qt.SortOrder
+@return true, if this item is less than other
+@rtype bool
 """
 if issubclass(other.__class__, BrowserMethodItem):
 if self._name.startswith("__init__"):
 return order == Qt.SortOrder.AscendingOrder
 if other._name.startswith("__init__"):
 def isPublic(self):
 """
 Public method returning the public visibility status.
-@return flag indicating public visibility (boolean)
+@return flag indicating public visibility
+@rtype bool
 """
 return self._functionObject.isPublic()
 class BrowserClassAttributesItem(BrowserItem):
 def __init__(self, parent, attributes, text, isClass=False):
 """
 Constructor
 @param parent parent item
+@type BrowserItem
 @param attributes list of attributes
-@param text text to be shown by this item (string)
+@type list of Attribute
-@param isClass flag indicating class attributes (boolean)
+@param text text to be shown by this item
+@type str
+@param isClass flag indicating class attributes
+@type bool
 """
 BrowserItem.__init__(self, parent, text)
 self.type_ = BrowserItemAttributes
 self._attributes = attributes.copy()
 def name(self):
 """
 Public method to return the name of the item.
-@return name of the item (string)
+@return name of the item
+@rtype str
 """
 return "{0}@@{1}".format(self.parentItem.name(), self.data(0))
 def attributes(self):
 """
 Public method returning the attribute list.
 @return reference to the list of attributes
+@rtype list of Attribute
 """
 return self._attributes
 def isClassAttributes(self):
 """
 Public method returning the attributes type.
-@return flag indicating class attributes (boolean)
+@return flag indicating class attributes
+@rtype bool
 """
 return self.__isClass
 def lessThan(self, other, column, order):
 """
 Public method to check, if the item is less than the other one.
-@param other reference to item to compare against (BrowserItem)
+@param other reference to item to compare against
-@param column column number to use for the comparison (integer)
+@type BrowserItem
-@param order sort order (Qt.SortOrder) (for special sorting)
+@param column column number to use for the comparison
-@return true, if this item is less than other (boolean)
+@type int
+@param order sort order (for special sorting)
+@type Qt.SortOrder
+@return true, if this item is less than other
+@rtype bool
 """
 if issubclass(other.__class__, BrowserCodingItem):
 return order == Qt.SortOrder.DescendingOrder
 elif issubclass(other.__class__, (BrowserClassItem, BrowserMethodItem)):
 return order == Qt.SortOrder.AscendingOrder
 def __init__(self, parent, attribute, isClass=False):
 """
 Constructor
 @param parent parent item
+@type BrowserItem
 @param attribute reference to the attribute object
-@param isClass flag indicating a class attribute (boolean)
+@type Attribute
+@param isClass flag indicating a class attribute
+@type bool
 """
 BrowserItem.__init__(self, parent, attribute.name)
 self.type_ = BrowserItemAttribute
 self._attributeObject = attribute
 def isPublic(self):
 """
 Public method returning the public visibility status.
-@return flag indicating public visibility (boolean)
+@return flag indicating public visibility
+@rtype bool
 """
 return self.__public
 def attributeObject(self):
 """
 Public method returning the class object.
 @return reference to the class object
+@rtype Class
 """
 return self._attributeObject
 def fileName(self):
 """
 Public method returning the filename.
-@return filename (string)
+@return filename
+@rtype str
 """
 return self._attributeObject.file
 def lineno(self):
 """
 Public method returning the line number defining this object.
-@return line number defining the object (integer)
+@return line number defining the object
+@rtype int
 """
 return self._attributeObject.lineno
 def linenos(self):
 """
 Public method returning the line numbers this object is assigned to.
-@return line number the object is assigned to (list of integers)
+@return line number the object is assigned to
+@rtype list of int
 """
 return self._attributeObject.linenos[:]
 def lessThan(self, other, column, order):
 """
 Public method to check, if the item is less than the other one.
-@param other reference to item to compare against (BrowserItem)
+@param other reference to item to compare against
-@param column column number to use for the comparison (integer)
+@type BrowserItem
-@param order sort order (Qt.SortOrder) (for special sorting)
+@param column column number to use for the comparison
-@return true, if this item is less than other (boolean)
+@type int
+@param order sort order (for special sorting)
+@type Qt.SortOrder
+@return true, if this item is less than other
+@rtype bool
 """
 if Preferences.getUI("BrowsersListContentsByOccurrence") and column == 0:
 if order == Qt.SortOrder.AscendingOrder:
 return self.lineno() < other.lineno()
 else:
 def __init__(self, parent, attributes, text):
 """
 Constructor
 @param parent parent item
+@type BrowserItem
 @param attributes list of attributes
-@param text text to be shown by this item (string)
+@type list of Attribute
+@param text text to be shown by this item
+@type str
 """
 BrowserClassAttributesItem.__init__(self, parent, attributes, text)
 class BrowserCodingItem(BrowserItem):
 def lessThan(self, other, column, order):
 """
 Public method to check, if the item is less than the other one.
-@param other reference to item to compare against (BrowserItem)
+@param other reference to item to compare against
-@param column column number to use for the comparison (integer)
+@type BrowserItem
-@param order sort order (Qt.SortOrder) (for special sorting)
+@param column column number to use for the comparison
-@return true, if this item is less than other (boolean)
+@type int
+@param order sort order (for special sorting)
+@type Qt.SortOrder
+@return true, if this item is less than other
+@rtype bool
 """
 if issubclass(
 other.__class__,
 (BrowserClassItem, BrowserClassAttributesItem, BrowserImportItem),
 ):
 def __init__(self, parent, text):
 """
 Constructor
 @param parent parent item
-@param text text to be shown by this item (string)
+@type BrowserItem
+@param text text to be shown by this item
+@type str
 """
 BrowserItem.__init__(self, parent, text)
 self.type_ = BrowserItemImports
 self.icon = EricPixmapCache.getIcon("imports")
 def lessThan(self, other, column, order):
 """
 Public method to check, if the item is less than the other one.
-@param other reference to item to compare against (BrowserItem)
+@param other reference to item to compare against
-@param column column number to use for the comparison (integer)
+@type BrowserItem
-@param order sort order (Qt.SortOrder) (for special sorting)
+@param column column number to use for the comparison
-@return true, if this item is less than other (boolean)
+@type int
+@param order sort order (for special sorting)
+@type Qt.SortOrder
+@return true, if this item is less than other
+@rtype bool
 """
 if issubclass(other.__class__, (BrowserClassItem, BrowserClassAttributesItem)):
 return order == Qt.SortOrder.AscendingOrder
 return BrowserItem.lessThan(self, other, column, order)
 def __init__(self, parent, text, filename, lineNumbers, isModule=True):
 """
 Constructor
 @param parent parent item
-@param text text to be shown by this item (string)
+@type BrowserItem
-@param filename name of the file (string)
+@param text text to be shown by this item
+@type str
+@param filename name of the file
+@type str
 @param lineNumbers list of line numbers of the import statement
-(list of integer)
+@type list of int
-@param isModule flag indicating a module item entry (boolean)
+@param isModule flag indicating a module item entry
+@type bool
 """
 BrowserItem.__init__(self, parent, text)
 self.__filename = filename
 self.__linenos = lineNumbers[:]
 def fileName(self):
 """
 Public method returning the filename.
-@return filename (string)
+@return filename
+@rtype str
 """
 return self.__filename
 def lineno(self):
 """
 Public method returning the line number of the first import.
-@return line number of the first import (integer)
+@return line number of the first import
+@rtype int
 """
 return self.__linenos[0]
 def linenos(self):
 """
 Public method returning the line numbers of all imports.
-@return line numbers of all imports (list of integers)
+@return line numbers of all imports
+@rtype list of int
 """
 return self.__linenos[:]
 def lessThan(self, other, column, order):
 """
 Public method to check, if the item is less than the other one.
-@param other reference to item to compare against (BrowserItem)
+@param other reference to item to compare against
-@param column column number to use for the comparison (integer)
+@type BrowserItem
-@param order sort order (Qt.SortOrder) (for special sorting)
+@param column column number to use for the comparison
-@return true, if this item is less than other (boolean)
+@type int
+@param order sort order (for special sorting)
+@type Qt.SortOrder
+@return true, if this item is less than other
+@rtype bool
 """
 if Preferences.getUI("BrowsersListContentsByOccurrence") and column == 0:
 if order == Qt.SortOrder.AscendingOrder:
 return self.lineno() < other.lineno()
 else:

Mercurial Repositories > eric / file comparison

comparison: src/eric7/UI/BrowserModel.py

src/eric7/UI/BrowserModel.py