eric: comparison Project/Project.py

-:b0996e4a289e
+:1d8dd9706f46
 import shutil
 import glob
 import fnmatch
 import copy
 import zipfile
-import cStringIO
+import io
 from PyQt4.QtCore import *
 from PyQt4.QtGui import *
 from E4Gui.E4Application import e4App
 from Globals import recentNameProject
-from ProjectBrowserModel import ProjectBrowserModel
+from .ProjectBrowserModel import ProjectBrowserModel
-from AddLanguageDialog import AddLanguageDialog
+from .AddLanguageDialog import AddLanguageDialog
-from AddFileDialog import AddFileDialog
+from .AddFileDialog import AddFileDialog
-from AddDirectoryDialog import AddDirectoryDialog
+from .AddDirectoryDialog import AddDirectoryDialog
-from PropertiesDialog import PropertiesDialog
+from .PropertiesDialog import PropertiesDialog
-from AddFoundFilesDialog import AddFoundFilesDialog
+from .AddFoundFilesDialog import AddFoundFilesDialog
-from DebuggerPropertiesDialog import DebuggerPropertiesDialog
+from .DebuggerPropertiesDialog import DebuggerPropertiesDialog
-from FiletypeAssociationDialog import FiletypeAssociationDialog
+from .FiletypeAssociationDialog import FiletypeAssociationDialog
-from LexerAssociationDialog import LexerAssociationDialog
+from .LexerAssociationDialog import LexerAssociationDialog
-from UserPropertiesDialog import UserPropertiesDialog
+from .UserPropertiesDialog import UserPropertiesDialog
 from E4XML.XMLUtilities import make_parser
 from E4XML.XMLErrorHandler import XMLErrorHandler, XMLFatalParseError
 from E4XML.XMLEntityResolver import XMLEntityResolver
 if "*.qm" not in self.pdata["FILETYPES"]:
 self.pdata["FILETYPES"]["*.qm"] = "TRANSLATIONS"
 try:
 if self.__fileTypeCallbacks[self.pdata["PROJECTTYPE"][0]] is not None:
 ftypes = self.__fileTypeCallbacks[self.pdata["PROJECTTYPE"][0]]()
-for pattern, ftype in ftypes.items():
+for pattern, ftype in list(ftypes.items()):
 if pattern not in self.pdata["FILETYPES"]:
 self.pdata["FILETYPES"][pattern] = ftype
 self.setDirty(True)
 except KeyError:
 pass
 QMessageBox.critical(None,
 self.trUtf8("Read project file"),
 self.trUtf8("""Compressed project files not supported."""
 """ The compression library is missing."""))
 return False
-f = gzip.open(fn, "rb")
+f = gzip.open(fn, "r")
 else:
-f = open(fn, "rb")
+f = open(fn, "r")
 line = f.readline()
 dtdLine = f.readline()
 f.close()
 except EnvironmentError:
 QApplication.restoreOverrideCursor()
 QMessageBox.critical(None,
 self.trUtf8("Read project file"),
 self.trUtf8("""Compressed project files not supported."""
 """ The compression library is missing."""))
 return False
-f = gzip.open(fn, "rb")
+f = gzip.open(fn, "r")
 else:
-f = open(fn, "rb")
+f = open(fn, "r")
 try:
 try:
 parser.parse(f)
 except UnicodeEncodeError:
 f.seek(0)
-buf = cStringIO.StringIO(f.read())
+buf = io.StringIO(f.read())
 parser.parse(buf)
 finally:
 f.close()
 except IOError:
 QApplication.restoreOverrideCursor()
 QMessageBox.critical(None,
 self.trUtf8("Save project file"),
 self.trUtf8("""Compressed project files not supported."""
 """ The compression library is missing."""))
 return False
-f = gzip.open(fn, "wb")
+f = gzip.open(fn, "w")
 else:
-f = open(fn, "wb")
+f = open(fn, "w")
 ProjectWriter(f, os.path.splitext(os.path.basename(fn))[0]).writeXML()
 f.close()
 fn, ext = os.path.splitext(os.path.basename(self.pfile))
 fn = os.path.join(self.getProjectManagementDir(), '%s.e4q' % fn)
 if os.path.exists(fn):
 try:
-f = open(fn, "rb")
+f = open(fn, "r")
 parser = make_parser(True)
 handler = UserProjectHandler(self)
 er = XMLEntityResolver()
 eh = XMLErrorHandler()
 try:
 try:
 parser.parse(f)
 except UnicodeEncodeError:
 f.seek(0)
-buf = cStringIO.StringIO(f.read())
+buf = io.StringIO(f.read())
 parser.parse(buf)
 finally:
 f.close()
 except IOError:
 QMessageBox.critical(None,
 fn, ext = os.path.splitext(os.path.basename(self.pfile))
 fn = os.path.join(self.getProjectManagementDir(), '%s.e4q' % fn)
 try:
-f = open(fn, "wb")
+f = open(fn, "w")
 UserProjectWriter(f, os.path.splitext(os.path.basename(fn))[0]).writeXML()
 f.close()
 except IOError:
 QMessageBox.critical(None,
 self.trUtf8("Read project session"),
 self.trUtf8("""Compressed project session files not"""
 """ supported. The compression library is missing."""))
 return
-f = gzip.open(fn, "rb")
+f = gzip.open(fn, "r")
 else:
 if ext.lower() == ".e3p":
 fn = os.path.join(self.ppath, '%s.e3s' % fn)
 else:
 fn = os.path.join(self.getProjectManagementDir(),
 '%s%s.e4s' % (fn, indicator))
-f = open(fn, "rb")
+f = open(fn, "r")
 line = f.readline()
 dtdLine = f.readline()
 f.close()
 except EnvironmentError:
 if not quiet:
 QMessageBox.critical(None,
 self.trUtf8("Read project session"),
 self.trUtf8("<p>The project session <b>{0}</b> could not"
 " be read.</p>").format(fn))
 return
-f = gzip.open(fn, "rb")
+f = gzip.open(fn, "r")
 else:
-f = open(fn, "rb")
+f = open(fn, "r")
 try:
 try:
 parser.parse(f)
 except UnicodeEncodeError:
 f.seek(0)
-buf = cStringIO.StringIO(f.read())
+buf = io.StringIO(f.read())
 parser.parse(buf)
 finally:
 f.close()
 except IOError:
 if not quiet:
 QMessageBox.critical(None,
 self.trUtf8("Save project session"),
 self.trUtf8("""Compressed project session files not"""
 """ supported. The compression library is missing."""))
 return
-f = gzip.open(fn, "wb")
+f = gzip.open(fn, "w")
 else:
 fn = os.path.join(self.getProjectManagementDir(),
 '%s%s.e4s' % (fn, indicator))
-f = open(fn, "wb")
+f = open(fn, "w")
 SessionWriter(f, os.path.splitext(os.path.basename(fn))[0]).writeXML()
 f.close()
 QMessageBox.critical(None,
 self.trUtf8("Read tasks"),
 self.trUtf8("""Compressed tasks files not supported."""
 """ The compression library is missing."""))
 return
-f = gzip.open(fn, "rb")
+f = gzip.open(fn, "r")
 else:
 if ext.lower() == ".e3p":
 fn = os.path.join(self.ppath, '%s.e3t' % fn)
 else:
 fn = os.path.join(self.getProjectManagementDir(), '%s.e4t' % fn)
 if not os.path.exists(fn):
 return
-f = open(fn, "rb")
+f = open(fn, "r")
 line = f.readline()
 dtdLine = f.readline()
 f.close()
 except EnvironmentError:
 QMessageBox.critical(None,
 QMessageBox.critical(None,
 self.trUtf8("Read tasks"),
 self.trUtf8("""Compressed tasks files not supported."""
 """ The compression library is missing."""))
 return
-f = gzip.open(fn, "rb")
+f = gzip.open(fn, "r")
 else:
-f = open(fn, "rb")
+f = open(fn, "r")
 try:
 try:
 parser.parse(f)
 except UnicodeEncodeError:
 f.seek(0)
-buf = cStringIO.StringIO(f.read())
+buf = io.StringIO(f.read())
 parser.parse(buf)
 finally:
 f.close()
 except IOError:
 QMessageBox.critical(None,
 QMessageBox.critical(None,
 self.trUtf8("Save tasks"),
 self.trUtf8("""Compressed tasks files not supported."""
 """ The compression library is missing."""))
 return
-f = gzip.open(fn, "wb")
+f = gzip.open(fn, "w")
 else:
 fn = os.path.join(self.getProjectManagementDir(), '%s.e4t' % fn)
-f = open(fn, "wb")
+f = open(fn, "w")
 TasksWriter(f, True, os.path.splitext(os.path.basename(fn))[0]).writeXML()
 f.close()
 self.trUtf8("Read debugger properties"),
 self.trUtf8("""Compressed project session files not"""
 """ supported. The compression library is"""
 """ missing."""))
 return
-f = gzip.open(fn, "rb")
+f = gzip.open(fn, "r")
 else:
 if ext.lower() == ".e3p":
 fn = os.path.join(self.ppath, '%s.e3d' % fn)
 else:
 fn = os.path.join(self.getProjectManagementDir(), '%s.e4d' % fn)
-f = open(fn, "rb")
+f = open(fn, "r")
 line = f.readline()
 dtdLine = f.readline()
 f.close()
 except EnvironmentError:
 if not quiet:
 QMessageBox.critical(None,
 self.trUtf8("Read debugger properties"),
 self.trUtf8("<p>The project debugger properties file"
 " <b>{0}</b> could not be read.</p>").format(fn))
 return
-f = gzip.open(fn, "rb")
+f = gzip.open(fn, "r")
 else:
-f = open(fn, "rb")
+f = open(fn, "r")
 try:
 try:
 parser.parse(f)
 except UnicodeEncodeError:
 f.seek(0)
-buf = cStringIO.StringIO(f.read())
+buf = io.StringIO(f.read())
 parser.parse(buf)
 if self.debugProperties["INTERPRETER"]:
 self.debugPropertiesLoaded = True
 else:
 self.debugPropertiesLoaded = False
 self.trUtf8("Save debugger properties"),
 self.trUtf8("""Compressed project debugger properties files"""
 """ not supported. The compression library is"""
 """ missing."""))
 return
-f = gzip.open(fn, "wb")
+f = gzip.open(fn, "w")
 else:
 fn = os.path.join(self.getProjectManagementDir(), '%s.e4d' % fn)
-f = open(fn, "wb")
+f = open(fn, "w")
 DebuggerPropertiesWriter(f, os.path.splitext(os.path.basename(fn))[0])\
 .writeXML()
 f.close()
 QMessageBox.No)
 if res != QMessageBox.Yes:
 return  # don't overwrite
 shutil.copy(fn, target)
-except IOError, why:
+except IOError as why:
 QMessageBox.critical(None,
 self.trUtf8("Add file"),
 self.trUtf8("<p>The selected file <b>{0}</b> could not be"
 " added to <b>{1}</b>.</p>")
 .format(fn, target),
 @param quiet flag indicating quiet operations (boolean)
 """
 # get all relevant filename patterns
 patterns = []
 ignorePatterns = []
-for pattern, patterntype in self.pdata["FILETYPES"].items():
+for pattern, patterntype in list(self.pdata["FILETYPES"].items()):
 if patterntype == filetype:
 patterns.append(pattern)
 elif patterntype == "__IGNORE__":
 ignorePatterns.append(pattern)
 return
 if not Utilities.samepath(target, source) and not os.path.isdir(target):
 try:
 os.makedirs(target)
-except IOError, why:
+except IOError as why:
 QMessageBox.critical(None,
 self.trUtf8("Add directory"),
 self.trUtf8("<p>The target directory <b>{0}</b> could not be"
 " created.</p>")
 .format(target),
 if canceled != QMessageBox.Yes:
 return False
 try:
 os.rename(oldfn, newfn)
-except OSError, msg:
+except OSError as msg:
 QMessageBox.critical(None,
 self.trUtf8("Rename File"),
 self.trUtf8("""<p>The file <b>{0}</b> could not be renamed.<br />"""
-"""Reason: {1}</p>""").format(oldfn, unicode(msg)))
+"""Reason: {1}</p>""").format(oldfn, str(msg)))
 return False
 if fn in self.pdata["SOURCES"] or \
 fn in self.pdata["FORMS"] or \
 fn in self.pdata["TRANSLATIONS"] or \
 self.saveProject()
 # check, if the existing project directory is already under
 # VCS control
 pluginManager = e4App().getObject("PluginManager")
-for indicator, vcsData in pluginManager.getVcsSystemIndicators().items():
+for indicator, vcsData in list(pluginManager.getVcsSystemIndicators().items()):
 if os.path.exists(os.path.join(self.ppath, indicator)):
 if len(vcsData) > 1:
 vcsList = []
 for vcsSystemStr, vcsSystemDisplay in vcsData:
 vcsList.append(vcsSystemDisplay)
 self.trUtf8("New Project"),
 self.trUtf8("Select version control system for the project"),
 vcsSystemsDisplay,
 0, False)
 if ok and vcsSelected != self.trUtf8("None"):
-for vcsSystem, vcsSystemDisplay in vcsSystemsDict.items():
+for vcsSystem, vcsSystemDisplay in list(vcsSystemsDict.items()):
 if vcsSystemDisplay == vcsSelected:
 break
 else:
 vcsSystem = "None"
 self.pdata["VCS"] = [vcsSystem]
 """
 QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
 QApplication.processEvents()
 # search the project directory for files with known extensions
-filespecs = self.pdata["FILETYPES"].keys()
+filespecs = list(self.pdata["FILETYPES"].keys())
 for filespec in filespecs:
 files = Utilities.direntries(self.ppath, True, filespec)
 for file in files:
 self.appendFile(file)
 @param filename filename used to determine the associated lexer language (string)
 @return the requested lexer language (string)
 """
 # try user settings first
-for pattern, language in self.pdata["LEXERASSOCS"].items():
+for pattern, language in list(self.pdata["LEXERASSOCS"].items()):
 if fnmatch.fnmatch(filename, pattern):
 return language
 # try project type specific defaults next
 projectType = self.pdata["PROJECTTYPE"][0]
 self.vcs = self.initVCS()
 if self.vcs is None:
 # check, if project is version controlled
 pluginManager = e4App().getObject("PluginManager")
 for indicator, vcsData in \
-pluginManager.getVcsSystemIndicators().items():
+list(pluginManager.getVcsSystemIndicators().items()):
 if os.path.exists(os.path.join(self.ppath, indicator)):
 if len(vcsData) > 1:
 vcsList = []
 for vcsSystemStr, vcsSystemDisplay in vcsData:
 vcsList.append(vcsSystemDisplay)
 if "PKGLIST" in lst:
 lst.remove("PKGLIST")
 # write the file
 try:
-pkglistFile = open(pkglist, "wb")
+pkglistFile = open(pkglist, "w")
 pkglistFile.write("\n".join(lst))
 pkglistFile.close()
-except IOError, why:
+except IOError as why:
 QMessageBox.critical(None,
 self.trUtf8("Create Package List"),
 self.trUtf8("""<p>The file <b>PKGLIST</b> could not be created.</p>"""
-"""<p>Reason: {0}</p>""").format(unicode(why)),
+"""<p>Reason: {0}</p>""").format(str(why)),
 QMessageBox.StandardButtons(\
 QMessageBox.Ok))
 return
 if not "PKGLIST" in self.pdata["OTHERS"]:
 QMessageBox.StandardButtons(\
 QMessageBox.Ok))
 return
 try:
-pkglistFile = open(pkglist, "rb")
+pkglistFile = open(pkglist, "r")
 names = pkglistFile.read()
 pkglistFile.close()
-names = names.splitlines()
+names = sorted(names.splitlines())
-names.sort()
+except IOError as why:
-except IOError, why:
 QMessageBox.critical(None,
 self.trUtf8("Create Plugin Archive"),
 self.trUtf8("""<p>The file <b>PKGLIST</b> could not be read.</p>"""
-"""<p>Reason: {0}</p>""").format(unicode(why)),
+"""<p>Reason: {0}</p>""").format(str(why)),
 QMessageBox.StandardButtons(\
 QMessageBox.Ok))
 return
 archive = \
 try:
 try:
 archiveFile = zipfile.ZipFile(archive, "w", zipfile.ZIP_DEFLATED)
 except RuntimeError:
 archiveFile = zipfile.ZipFile(archive, "w")
-except IOError, why:
+except IOError as why:
 QMessageBox.critical(None,
 self.trUtf8("Create Plugin Archive"),
 self.trUtf8("""<p>The eric4 plugin archive file <b>{0}</b> could """
 """not be created.</p>"""
-"""<p>Reason: {1}</p>""").format(archive, unicode(why)),
+"""<p>Reason: {1}</p>""").format(archive, str(why)),
 QMessageBox.StandardButtons(\
 QMessageBox.Ok))
 return
 for name in names:
 else:
 archiveFile.write(os.path.join(self.ppath, name), name)
 if name == self.pdata["MAINSCRIPT"][0]:
 version = self.__pluginExtractVersion(\
 os.path.join(self.ppath, self.pdata["MAINSCRIPT"][0]))
-except OSError, why:
+except OSError as why:
 QMessageBox.critical(None,
 self.trUtf8("Create Plugin Archive"),
 self.trUtf8("""<p>The file <b>{0}</b> could not be stored """
 """in the archive. Ignoring it.</p>"""
 """<p>Reason: {1}</p>""")\
-.format(os.path.join(self.ppath, name), unicode(why)),
+.format(os.path.join(self.ppath, name), str(why)),
 QMessageBox.StandardButtons(\
 QMessageBox.Ok))
 archiveFile.writestr("VERSION", version)
 archiveFile.close()
 """
 try:
 f = open(filename, "r")
 sourcelines = f.readlines()
 f.close()
-except IOError, why:
+except IOError as why:
 QMessageBox.critical(None,
 self.trUtf8("Create Plugin Archive"),
 self.trUtf8("""<p>The plugin file <b>{0}</b> could """
 """not be read.</p>"""
-"""<p>Reason: {1}</p>""").format(archive, unicode(why)),
+"""<p>Reason: {1}</p>""").format(archive, str(why)),
 QMessageBox.StandardButtons(\
 QMessageBox.Ok))
 return ""
 lineno = 0
 version = "0.0.0"
 try:
 f = open(filename, "r")
 sourcelines = f.readlines()
 f.close()
-except IOError, why:
+except IOError as why:
 QMessageBox.critical(None,
 self.trUtf8("Create Plugin Archive"),
 self.trUtf8("""<p>The plugin file <b>{0}</b> could """
 """not be read.</p>"""
-"""<p>Reason: {1}</p>""").format(archive, unicode(why)),
+"""<p>Reason: {1}</p>""").format(archive, str(why)),
 QMessageBox.StandardButtons(\
 QMessageBox.Ok))
 return ""
 lineno = 0

Mercurial Repositories > eric / file comparison

comparison: Project/Project.py

Project/Project.py