eric: comparison eric6/UI/BrowserModel.py

-:c1af2e327675
+:bedbe458d792
 import os
 import fnmatch
 import json
-from PyQt5.QtCore import QDir, QModelIndex, QAbstractItemModel, \
+from PyQt5.QtCore import (
-QFileSystemWatcher, Qt, QProcess, QCoreApplication
+QDir, QModelIndex, QAbstractItemModel, QFileSystemWatcher, Qt, QProcess,
+QCoreApplication
+)
 from PyQt5.QtGui import QImageReader, QFont
 from PyQt5.QtWidgets import QApplication
 import UI.PixmapCache
 import Preferences
 if role == Qt.DisplayRole:
 item = index.internalPointer()
 if index.column() < item.columnCount():
 return item.data(index.column())
-elif index.column() == item.columnCount() and \
+elif (
-index.column() < self.columnCount(self.parent(index)):
+index.column() == item.columnCount() and
+index.column() < self.columnCount(self.parent(index))
+):
 # This is for the case where an item under a multi-column
 # parent doesn't have a value for all the columns
 return ""
 elif role == Qt.DecorationRole:
 if index.column() == 0:
 parent = QModelIndex()
 # The model/view framework considers negative values out-of-bounds,
 # however in python they work when indexing into lists. So make sure
 # we return an invalid index for out-of-bounds row/col
-if row < 0 or column < 0 or \
+if (
-row >= self.rowCount(parent) or column >= self.columnCount(parent):
+row < 0 or
+column < 0 or
+row >= self.rowCount(parent) or
+column >= self.columnCount(parent)
+):
 return QModelIndex()
 if not parent.isValid():
 parentItem = self.rootItem
 else:
 @param itm item to be watched (BrowserDirectoryItem)
 """
 if isinstance(itm, BrowserDirectoryItem):
 dirName = itm.dirName()
-if dirName != "" and \
+if (
-not dirName.startswith("//") and \
+dirName != "" and
-not dirName.startswith("\\\\"):
+not dirName.startswith("//") and
+not dirName.startswith("\\\\")
+):
 if dirName not in self.watcher.directories():
 self.watcher.addPath(dirName)
 if dirName in self.watchedItems:
 if itm not in self.watchedItems[dirName]:
 self.watchedItems[dirName].append(itm)
 node = BrowserDirectoryItem(
 parentItem,
 Utilities.toNativeSeparators(f.absoluteFilePath()),
 False)
 else:
-fileFilters = \
+fileFilters = Preferences.getUI(
-Preferences.getUI("BrowsersFileFilters").split(";")
+"BrowsersFileFilters").split(";")
 if fileFilters:
 fn = f.fileName()
 if any(fnmatch.fnmatch(fn, ff.strip())
 for ff in fileFilters):
 continue
 node = BrowserImportsItem(
 parentItem,
 QCoreApplication.translate("BrowserModel", "Imports"))
 self._addItem(node, parentItem)
 if "@@Import@@" in keys:
-for importedModule in \
+for importedModule in (
-dictionary["@@Import@@"].getImports().values():
+dictionary["@@Import@@"].getImports().values()
+):
 m_node = BrowserImportItem(
 node,
 importedModule.importedModuleName,
 importedModule.file,
 importedModule.linenos)
 self._addItem(m_node, node)
-for importedName, linenos in \
+for importedName, linenos in (
-importedModule.importedNames.items():
+importedModule.importedNames.items()
+):
 mn_node = BrowserImportItem(
 m_node,
 importedName,
 importedModule.file,
 linenos,
 dn = os.path.basename(self._dirName)
 BrowserItem.__init__(self, parent, dn)
 self.type_ = BrowserItemDirectory
-if not Utilities.isDrive(self._dirName) and \
+if (
-os.path.lexists(self._dirName) and os.path.islink(self._dirName):
+not Utilities.isDrive(self._dirName) and
+os.path.lexists(self._dirName) and
+os.path.islink(self._dirName)
+):
 self.symlink = True
 self.icon = UI.PixmapCache.getSymlinkIcon("dirClosed.png")
 else:
 self.icon = UI.PixmapCache.getIcon("dirClosed.png")
 self._populated = False
 @param finfo the string for the file (string)
 @param full flag indicating full pathname should be displayed (boolean)
 """
 self._filename = os.path.abspath(finfo)
 self.itemData[0] = os.path.basename(finfo)
-if self.isPython2File() or self.isPython3File() or \
+if (
-self.isRubyFile() or self.isIdlFile() or \
+self.isPython2File() or
-self.isProtobufFile():
+self.isPython3File() or
+self.isRubyFile() or
+self.isIdlFile() or
+self.isProtobufFile()
+):
 self._dirName = os.path.dirname(finfo)
 self._moduleName = os.path.basename(finfo)
 def fileName(self):
 """
 """
 Public method to check, if this file is a Python script.
 @return flag indicating a Python file (boolean)
 """
-return self.fileext in Preferences.getPython("PythonExtensions") or \
+return (
+self.fileext in Preferences.getPython("PythonExtensions") or
 (self.fileext == "" and
 self.sourceLanguage in ["Python", "Python2"])
+)
 def isPython3File(self):
 """
 Public method to check, if this file is a Python3 script.
 @return flag indicating a Python file (boolean)
 """
-return self.fileext in Preferences.getPython("Python3Extensions") or \
+return (
+self.fileext in Preferences.getPython("Python3Extensions") or
 (self.fileext == "" and self.sourceLanguage == "Python3")
+)
 def isRubyFile(self):
 """
 Public method to check, if this file is a Ruby script.
 @return flag indicating a Ruby file (boolean)
 """
-return self.fileext == '.rb' or \
+return (
+self.fileext == '.rb' or
 (self.fileext == "" and self.sourceLanguage == "Ruby")
+)
 def isDesignerFile(self):
 """
 Public method to check, if this file is a Qt-Designer file.
 """
 Public method to check, if this file is a D file.
 @return flag indicating a D file (boolean)
 """
-return self.fileext in ['.d', '.di'] or \
+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.
 if Preferences.getUI("BrowsersListFoldersFirst"):
 return order == Qt.DescendingOrder
 if issubclass(other.__class__, BrowserFileItem):
 sinit = os.path.basename(self._filename).startswith('__init__.py')
-oinit = \
+oinit = os.path.basename(other.fileName()).startswith(
-os.path.basename(other.fileName()).startswith('__init__.py')
+'__init__.py')
 if sinit and not oinit:
 return order == Qt.AscendingOrder
 if not sinit and oinit:
 return order == Qt.DescendingOrder
 self.icon = UI.PixmapCache.getIcon("class_private.png")
 elif cl.isProtected():
 self.icon = UI.PixmapCache.getIcon("class_protected.png")
 else:
 self.icon = UI.PixmapCache.getIcon("class.png")
-if self._classObject and \
+if (
-(self._classObject.methods or
+self._classObject and
-self._classObject.classes or
+(self._classObject.methods or
-self._classObject.attributes):
+self._classObject.classes or
+self._classObject.attributes)
+):
 self._populated = False
 self._lazyPopulation = True
 def name(self):
 """
 @param other reference to item to compare against (BrowserItem)
 @param column column number to use for the comparison (integer)
 @param order sort order (Qt.SortOrder) (for special sorting)
 @return true, if this item is less than other (boolean)
 """
-if issubclass(other.__class__, BrowserCodingItem) or \
+if issubclass(
-issubclass(other.__class__, BrowserClassAttributesItem):
+other.__class__,
+(BrowserCodingItem, BrowserClassAttributesItem)
+):
 return order == Qt.DescendingOrder
-if Preferences.getUI("BrowsersListContentsByOccurrence") and \
+if (
-column == 0:
+Preferences.getUI("BrowsersListContentsByOccurrence") and
+column == 0
+):
 if order == Qt.AscendingOrder:
 return self.lineno() < other.lineno()
 else:
 return self.lineno() > other.lineno()
 import Utilities.ClassBrowsers.ClbrBaseClasses
 self.type_ = BrowserItemMethod
 self._name = name
 self._functionObject = fn
 self._filename = filename
-if self._functionObject.modifier == \
+if (
-Utilities.ClassBrowsers.ClbrBaseClasses.Function.Static:
+self._functionObject.modifier ==
+Utilities.ClassBrowsers.ClbrBaseClasses.Function.Static
+):
 self.icon = UI.PixmapCache.getIcon("method_static.png")
-elif self._functionObject.modifier == \
+elif (
-Utilities.ClassBrowsers.ClbrBaseClasses.Function.Class:
+self._functionObject.modifier ==
+Utilities.ClassBrowsers.ClbrBaseClasses.Function.Class
+):
 self.icon = UI.PixmapCache.getIcon("method_class.png")
 elif self._functionObject.isPrivate():
 self.icon = UI.PixmapCache.getIcon("method_private.png")
 elif self._functionObject.isProtected():
 self.icon = UI.PixmapCache.getIcon("method_protected.png")
 self.itemData[0], self._functionObject.annotation)
 # if no defaults are wanted
 # ....format(name,
 #            ", ".join([e.split('=')[0].strip()
 #                       for e in self._functionObject.parameters]))
-if self._functionObject and \
+if (
-(self._functionObject.methods or self._functionObject.classes):
+self._functionObject and
+(self._functionObject.methods or self._functionObject.classes)
+):
 self._populated = False
 self._lazyPopulation = True
 def name(self):
 """
 if other._name.startswith('__init__'):
 return order == Qt.DescendingOrder
 elif issubclass(other.__class__, BrowserClassAttributesItem):
 return order == Qt.DescendingOrder
-if Preferences.getUI("BrowsersListContentsByOccurrence") and \
+if (
-column == 0:
+Preferences.getUI("BrowsersListContentsByOccurrence") and
+column == 0
+):
 if order == Qt.AscendingOrder:
 return self.lineno() < other.lineno()
 else:
 return self.lineno() > other.lineno()
 @param order sort order (Qt.SortOrder) (for special sorting)
 @return true, if this item is less than other (boolean)
 """
 if issubclass(other.__class__, BrowserCodingItem):
 return order == Qt.DescendingOrder
-elif issubclass(other.__class__, BrowserClassItem) or \
+elif issubclass(
-issubclass(other.__class__, BrowserMethodItem):
+other.__class__,
+(BrowserClassItem, BrowserMethodItem)
+):
 return order == Qt.AscendingOrder
 return BrowserItem.lessThan(self, other, column, order)
 @param other reference to item to compare against (BrowserItem)
 @param column column number to use for the comparison (integer)
 @param order sort order (Qt.SortOrder) (for special sorting)
 @return true, if this item is less than other (boolean)
 """
-if Preferences.getUI("BrowsersListContentsByOccurrence") and \
+if (
-column == 0:
+Preferences.getUI("BrowsersListContentsByOccurrence") and
+column == 0
+):
 if order == Qt.AscendingOrder:
 return self.lineno() < other.lineno()
 else:
 return self.lineno() > other.lineno()
 @param other reference to item to compare against (BrowserItem)
 @param column column number to use for the comparison (integer)
 @param order sort order (Qt.SortOrder) (for special sorting)
 @return true, if this item is less than other (boolean)
 """
-if issubclass(other.__class__, BrowserClassItem) or \
+if issubclass(
-issubclass(other.__class__, BrowserClassAttributesItem) or \
+other.__class__,
-issubclass(other.__class__, BrowserImportItem):
+(BrowserClassItem, BrowserClassAttributesItem, BrowserImportItem)
+):
 return order == Qt.AscendingOrder
 return BrowserItem.lessThan(self, other, column, order)
 @param other reference to item to compare against (BrowserItem)
 @param column column number to use for the comparison (integer)
 @param order sort order (Qt.SortOrder) (for special sorting)
 @return true, if this item is less than other (boolean)
 """
-if issubclass(other.__class__, BrowserClassItem) or \
+if issubclass(
-issubclass(other.__class__, BrowserClassAttributesItem):
+other.__class__,
+(BrowserClassItem, BrowserClassAttributesItem)
+):
 return order == Qt.AscendingOrder
 return BrowserItem.lessThan(self, other, column, order)
 @param other reference to item to compare against (BrowserItem)
 @param column column number to use for the comparison (integer)
 @param order sort order (Qt.SortOrder) (for special sorting)
 @return true, if this item is less than other (boolean)
 """
-if Preferences.getUI("BrowsersListContentsByOccurrence") and \
+if (
-column == 0:
+Preferences.getUI("BrowsersListContentsByOccurrence") and
+column == 0
+):
 if order == Qt.AscendingOrder:
 return self.lineno() < other.lineno()
 else:
 return self.lineno() > other.lineno()

Mercurial Repositories > eric / file comparison

comparison: eric6/UI/BrowserModel.py

eric6/UI/BrowserModel.py