eric: comparison src/eric7/Plugins/VcsPlugins/vcsMercurial/hg.py

-:e9e7eca7efee
+:bf71ee032bb4
 class Hg(VersionControl):
 """
 Class implementing the version control systems interface to Mercurial.
 @signal committed() emitted after the commit action has completed
 @signal activeExtensionsChanged() emitted when the list of active
 extensions has changed
 @signal iniFileChanged() emitted when a Mercurial/repo configuration file
 has changed
 """
 committed = pyqtSignal()
 activeExtensionsChanged = pyqtSignal()
 iniFileChanged = pyqtSignal()
 IgnoreFileName = ".hgignore"
 def __init__(self, plugin, parent=None, name=None):
 """
 Constructor
 @param plugin reference to the plugin object
 @param parent parent widget (QWidget)
 @param name name of this object (string)
 """
 VersionControl.__init__(self, parent, name)
 self.defaultOptions = {
-'global': [''],
+"global": [""],
-'commit': [''],
+"commit": [""],
-'checkout': [''],
+"checkout": [""],
-'update': [''],
+"update": [""],
-'add': [''],
+"add": [""],
-'remove': [''],
+"remove": [""],
-'diff': [''],
+"diff": [""],
-'log': [''],
+"log": [""],
-'history': [''],
+"history": [""],
-'status': [''],
+"status": [""],
-'tag': [''],
+"tag": [""],
-'export': ['']
+"export": [""],
 }
 self.__plugin = plugin
 self.__ui = parent
 self.options = self.defaultOptions
 self.tagsList = []
 self.branchesList = []
 self.allTagsBranchesList = []
 self.bookmarksList = []
 self.showedTags = False
 self.showedBranches = False
 self.tagTypeList = [
-'tags',
+"tags",
-'branches',
+"branches",
 ]
 self.commandHistory = []
 if "HG_ASP_DOT_NET_HACK" in os.environ:
-self.adminDir = '_hg'
+self.adminDir = "_hg"
 else:
-self.adminDir = '.hg'
+self.adminDir = ".hg"
 self.logBrowser = None
 self.logBrowserIncoming = None
 self.logBrowserOutgoing = None
 self.diff = None
 self.sbsDiff = None
 self.repoEditor = None
 self.serveDlg = None
 self.bookmarksListDlg = None
 self.bookmarksInOutDlg = None
 self.conflictsDlg = None
 self.bundleFile = None
 self.__lastChangeGroupPath = None
 self.statusCache = {}
 self.__commitData = {}
 self.__commitDialog = None
 self.__forgotNames = []
 self.__activeExtensions = []
 from .HgUtilities import getConfigPath
 self.__iniWatcher = QFileSystemWatcher(self)
 self.__iniWatcher.fileChanged.connect(self.__iniFileChanged)
 cfgFile = getConfigPath()
 if os.path.exists(cfgFile):
 self.__iniWatcher.addPath(cfgFile)
 self.__client = None
 self.__createClient()
 self.__projectHelper = None
 self.__repoDir = ""
 self.__repoIniFile = ""
 self.__defaultConfigured = False
 self.__defaultPushConfigured = False
 # instantiate the extensions
 from .QueuesExtension.queues import Queues
 from .PurgeExtension.purge import Purge
 from .GpgExtension.gpg import Gpg
 from .RebaseExtension.rebase import Rebase
 from .ShelveExtension.shelve import Shelve
 from .LargefilesExtension.largefiles import Largefiles
 from .StripExtension.strip import Strip
 from .HisteditExtension.histedit import Histedit
 from .CloseheadExtension.closehead import Closehead
 self.__extensions = {
 "mq": Queues(self),
 "purge": Purge(self),
 "gpg": Gpg(self),
 "rebase": Rebase(self),
 "largefiles": Largefiles(self),
 "strip": Strip(self),
 "histedit": Histedit(self),
 "closehead": Closehead(self),
 }
 def getPlugin(self):
 """
 Public method to get a reference to the plugin object.
 @return reference to the plugin object (VcsMercurialPlugin)
 """
 return self.__plugin
 def getEncoding(self):
 """
 Public method to get the encoding to be used by Mercurial.
 @return encoding (string)
 """
 return self.__plugin.getPreferences("Encoding")
 def vcsShutdown(self):
 """
 Public method used to shutdown the Mercurial interface.
 """
 if self.logBrowser is not None:
 self.tagbranchList.close()
 if self.annotate is not None:
 self.annotate.close()
 if self.serveDlg is not None:
 self.serveDlg.close()
 if self.bookmarksListDlg is not None:
 self.bookmarksListDlg.close()
 if self.bookmarksInOutDlg is not None:
 self.bookmarksInOutDlg.close()
 if self.conflictsDlg is not None:
 self.conflictsDlg.close()
 if self.bundleFile and os.path.exists(self.bundleFile):
 os.remove(self.bundleFile)
 # shut down the project helpers
 if self.__projectHelper is not None:
 self.__projectHelper.shutdown()
 # shut down the extensions
 for extension in self.__extensions.values():
 extension.shutdown()
 # shut down the client
 self.__client and self.__client.stopServer()
 def initCommand(self, command):
 """
 Public method to initialize a command arguments list.
 @param command command name (string)
 @return list of command options (list of string)
 """
 args = [command]
 self.addArguments(args, self.__plugin.getGlobalOptions())
 return args
 def vcsExists(self):
 """
 Public method used to test for the presence of the hg executable.
 @return flag indicating the existence (boolean) and an error message
 (string)
 """
 from .HgUtilities import hgVersion
 self.versionStr, self.version, errMsg = hgVersion(self.__plugin)
 hgExists = errMsg == ""
 if hgExists:
 self.__getExtensionsInfo()
 return hgExists, errMsg
 def vcsInit(self, vcsDir, noDialog=False):
 """
 Public method used to initialize the mercurial repository.
 The initialization is done, when a project is converted into a
 Mercurial controlled project. Therefore we always return TRUE without
 doing anything.
 @param vcsDir name of the VCS directory (string)
 @param noDialog flag indicating quiet operations (boolean)
 @return always TRUE
 """
 return True
 def vcsConvertProject(self, vcsDataDict, project, addAll=True):
 """
 Public method to convert an uncontrolled project to a version
 controlled project.
 @param vcsDataDict dictionary of data required for the conversion
 @type dict
 @param project reference to the project object
 @type Project
 @param addAll flag indicating to add all files to the repository
 success = self.vcsImport(vcsDataDict, project.ppath, addAll=addAll)[0]
 if not success:
 EricMessageBox.critical(
 self.__ui,
 self.tr("Create project repository"),
-self.tr(
+self.tr("""The project repository could not be created."""),
-"""The project repository could not be created."""))
+)
 else:
 pfn = project.pfile
 if not os.path.isfile(pfn):
 pfn += "z"
 project.closeProject()
 project.openProject(pfn)
 def vcsImport(self, vcsDataDict, projectDir, noDialog=False, addAll=True):
 """
 Public method used to import the project into the Mercurial repository.
 @param vcsDataDict dictionary of data required for the import
 @type dict
 @param projectDir project directory (string)
 @type str
 @param noDialog flag indicating quiet operations
 and a flag indicating the version controll status
 @rtype tuple of (bool, bool)
 """
 msg = vcsDataDict["message"]
 if not msg:
-msg = '***'
+msg = "***"
 args = self.initCommand("init")
 args.append(projectDir)
-dia = HgDialog(self.tr('Creating Mercurial repository'), self)
+dia = HgDialog(self.tr("Creating Mercurial repository"), self)
 res = dia.startProcess(args)
 if res:
 dia.exec()
 status = dia.normalExit()
 if status:
 self.stopClient()
 self.__repoDir = projectDir
 ignoreName = os.path.join(projectDir, Hg.IgnoreFileName)
 if not os.path.exists(ignoreName):
 status = self.hgCreateIgnoreFile(projectDir)
 if status and addAll:
 args = self.initCommand("commit")
-args.append('--addremove')
+args.append("--addremove")
-args.append('--message')
+args.append("--message")
 args.append(msg)
-dia = HgDialog(
+dia = HgDialog(self.tr("Initial commit to Mercurial repository"), self)
-self.tr('Initial commit to Mercurial repository'),
-self)
 res = dia.startProcess(args)
 if res:
 dia.exec()
 status = dia.normalExit()
 return status, False
 def vcsCheckout(self, vcsDataDict, projectDir, noDialog=False):
 """
 Public method used to check the project out of a Mercurial repository
 (clone).
 @param vcsDataDict dictionary of data required for the checkout
 @param projectDir project directory to create (string)
 @param noDialog flag indicating quiet operations
 @return flag indicating an execution without errors (boolean)
 """
 try:
 rev = vcsDataDict["revision"]
 except KeyError:
 rev = None
 vcsUrl = self.hgNormalizeURL(vcsDataDict["url"])
 args = self.initCommand("clone")
 if rev:
 args.append("--rev")
 args.append(rev)
 if vcsDataDict["largefiles"]:
 args.append("--all-largefiles")
 args.append(vcsUrl)
 args.append(projectDir)
 if noDialog:
 out, err = self.__client.runcommand(args)
 return err == ""
 else:
-dia = HgDialog(
+dia = HgDialog(self.tr("Cloning project from a Mercurial repository"), self)
-self.tr('Cloning project from a Mercurial repository'),
-self)
 res = dia.startProcess(args)
 if res:
 dia.exec()
 return dia.normalExit()
 def vcsExport(self, vcsDataDict, projectDir):
 """
 Public method used to export a directory from the Mercurial repository.
 @param vcsDataDict dictionary of data required for the checkout
 @param projectDir project directory to create (string)
 @return flag indicating an execution without errors (boolean)
 """
 status = self.vcsCheckout(vcsDataDict, projectDir)
 shutil.rmtree(os.path.join(projectDir, self.adminDir), True)
 if os.path.exists(os.path.join(projectDir, Hg.IgnoreFileName)):
 os.remove(os.path.join(projectDir, Hg.IgnoreFileName))
 return status
-def vcsCommit(self, name, message, noDialog=False, closeBranch=False,
+def vcsCommit(
-mq=False, merge=False):
+self, name, message, noDialog=False, closeBranch=False, mq=False, merge=False
+):
 """
 Public method used to make the change of a file/directory permanent
 in the Mercurial repository.
 @param name file/directory name to be committed (string or list of
 strings)
 @param message message for this operation (string)
 @param noDialog flag indicating quiet operations
 @param closeBranch flag indicating a close branch commit (boolean)
 @param mq flag indicating a queue commit (boolean)
 @param merge flag indicating a merge commit (boolean)
 """
 msg = message
 if mq or merge:
 # ensure dialog is shown for a queue commit
 noDialog = False
 if not noDialog:
 # call CommitDialog and get message from there
 if self.__commitDialog is None:
 from .HgCommitDialog import HgCommitDialog
-self.__commitDialog = HgCommitDialog(self, msg, mq, merge,
-self.__ui)
+self.__commitDialog = HgCommitDialog(self, msg, mq, merge, self.__ui)
 self.__commitDialog.accepted.connect(self.__vcsCommit_Step2)
 self.__commitDialog.show()
 self.__commitDialog.raise_()
 self.__commitDialog.activateWindow()
 self.__commitData["name"] = name
 self.__commitData["msg"] = msg
 self.__commitData["noDialog"] = noDialog
 self.__commitData["closeBranch"] = closeBranch
 self.__commitData["mq"] = mq
 self.__commitData["merge"] = merge
 if noDialog:
 self.__vcsCommit_Step2()
 def __vcsCommit_Step2(self):
 """
 Private slot performing the second step of the commit action.
 """
 name = self.__commitData["name"]
 msg = self.__commitData["msg"]
 noDialog = self.__commitData["noDialog"]
 closeBranch = self.__commitData["closeBranch"]
 mq = self.__commitData["mq"]
 merge = self.__commitData["merge"]
 if not noDialog:
 # check, if there are unsaved changes, that should be committed
 if isinstance(name, list):
 nameList = name
 else:
 # check for commit of the project
 if os.path.isdir(nam):
 project = ericApp().getObject("Project")
 if nam == project.getProjectPath():
 ok &= (
-project.checkAllScriptsDirty(
+project.checkAllScriptsDirty(reportSyntaxErrors=True)
-reportSyntaxErrors=True) and
+and project.checkDirty()
-project.checkDirty()
 )
 continue
 elif os.path.isfile(nam):
-editor = (
+editor = ericApp().getObject("ViewManager").getOpenEditor(nam)
-ericApp().getObject("ViewManager").getOpenEditor(nam)
-)
 if editor:
 ok &= editor.checkDirty()
 if not ok:
 break
 if not ok:
 res = EricMessageBox.yesNo(
 self.__ui,
 self.tr("Commit Changes"),
 self.tr(
 """The commit affects files, that have unsaved"""
-""" changes. Shall the commit be continued?"""),
+""" changes. Shall the commit be continued?"""
-icon=EricMessageBox.Warning)
+),
+icon=EricMessageBox.Warning,
+)
 if not res:
 return
 if self.__commitDialog is not None:
-(msg, amend, commitSubrepositories, author,
+(
-dateTime) = self.__commitDialog.getCommitData()
+msg,
+amend,
+commitSubrepositories,
+author,
+dateTime,
+) = self.__commitDialog.getCommitData()
 self.__commitDialog.deleteLater()
 self.__commitDialog = None
 if amend and not msg:
 msg = self.__getMostRecentCommitMessage()
 else:
 amend = False
 commitSubrepositories = False
 author = ""
 dateTime = ""
 if not msg and not amend:
-msg = '***'
+msg = "***"
 args = self.initCommand("commit")
 args.append("-v")
 if mq:
 args.append("--mq")
 elif merge:
 args.append(msg)
 if isinstance(name, list):
 self.addArguments(args, name)
 else:
 args.append(name)
-dia = HgDialog(
+dia = HgDialog(self.tr("Committing changes to Mercurial repository"), self)
-self.tr('Committing changes to Mercurial repository'),
-self)
 res = dia.startProcess(args)
 if res:
 dia.exec()
 self.committed.emit()
 if self.__forgotNames:
 model = ericApp().getObject("Project").getModel()
 for name in self.__forgotNames:
 model.updateVCSStatus(name)
 self.__forgotNames = []
 self.checkVCSStatus()
 def vcsCommitMessages(self):
 """
 Public method to get the list of saved commit messages.
 @return list of saved commit messages
 @rtype list of str
 """
 # try per project commit history first
 messages = self._vcsProjectCommitMessages()
 if not messages:
 # empty list returned, try the vcs specific one
-messages = self.getPlugin().getPreferences('Commits')
+messages = self.getPlugin().getPreferences("Commits")
 return messages
 def vcsAddCommitMessage(self, message):
 """
 Public method to add a commit message to the list of saved messages.
 @param message message to be added
 @type str
 """
 if not self._vcsAddProjectCommitMessage(message):
 commitMessages = self.vcsCommitMessages()
 if message in commitMessages:
 commitMessages.remove(message)
 commitMessages.insert(0, message)
 no = Preferences.getVCS("CommitMessages")
 del commitMessages[no:]
-self.getPlugin().setPreferences('Commits', commitMessages)
+self.getPlugin().setPreferences("Commits", commitMessages)
 def vcsClearCommitMessages(self):
 """
 Public method to clear the list of saved messages.
 """
 if not self._vcsClearProjectCommitMessages():
-self.getPlugin().setPreferences('Commits', [])
+self.getPlugin().setPreferences("Commits", [])
 def __getMostRecentCommitMessage(self):
 """
 Private method to get the most recent commit message.
 Note: This message is extracted from the parent commit of the
 working directory.
 @return most recent commit message
 @rtype str
 """
 args = self.initCommand("log")
 args.append("--rev")
 args.append(".")
-args.append('--template')
+args.append("--template")
-args.append('{desc}')
+args.append("{desc}")
 output, error = self.__client.runcommand(args)
 return output
 def vcsUpdate(self, name=None, noDialog=False, revision=None):
 """
 Public method used to update a file/directory with the Mercurial
 repository.
 @param name file/directory name to be updated (not used)
 @param noDialog flag indicating quiet operations (boolean)
 @param revision revision to update to (string)
 @return flag indicating, that the update contained an add
 or delete (boolean)
 if "-v" not in args and "--verbose" not in args:
 args.append("-v")
 if revision:
 args.append("-r")
 args.append(revision)
 if noDialog:
 out, err = self.__client.runcommand(args)
 res = False
 else:
-dia = HgDialog(self.tr(
+dia = HgDialog(self.tr("Synchronizing with the Mercurial repository"), self)
-'Synchronizing with the Mercurial repository'),
-self)
 res = dia.startProcess(args)
 if res:
 dia.exec()
 res = dia.hasAddOrDelete()
 self.checkVCSStatus()
 return res
 def vcsAdd(self, name, isDir=False, noDialog=False):
 """
 Public method used to add a file/directory to the Mercurial repository.
 @param name file/directory name to be added (string)
 @param isDir flag indicating name is a directory (boolean)
 @param noDialog flag indicating quiet operations
 """
 args = self.initCommand("add")
 args.append("-v")
 if isinstance(name, list):
 self.addArguments(args, name)
 else:
 args.append(name)
 if noDialog:
 out, err = self.__client.runcommand(args)
 else:
 dia = HgDialog(
-self.tr(
+self.tr("Adding files/directories to the Mercurial repository"), self
-'Adding files/directories to the Mercurial repository'),
+)
-self)
 res = dia.startProcess(args)
 if res:
 dia.exec()
 def vcsAddBinary(self, name, isDir=False):
 """
 Public method used to add a file/directory in binary mode to the
 Mercurial repository.
 @param name file/directory name to be added (string)
 @param isDir flag indicating name is a directory (boolean)
 """
 self.vcsAdd(name, isDir)
 def vcsAddTree(self, path):
 """
 Public method to add a directory tree rooted at path to the Mercurial
 repository.
 @param path root directory of the tree to be added (string or list of
 strings))
 """
 self.vcsAdd(path, isDir=False)
 def vcsRemove(self, name, project=False, noDialog=False):
 """
 Public method used to remove a file/directory from the Mercurial
 repository.
 The default operation is to remove the local copy as well.
 @param name file/directory name to be removed (string or list of
 strings))
 @param project flag indicating deletion of a project tree (boolean)
 (not needed)
 @param noDialog flag indicating quiet operations
 @return flag indicating successfull operation (boolean)
 """
 args = self.initCommand("remove")
 args.append("-v")
-if noDialog and '--force' not in args:
+if noDialog and "--force" not in args:
-args.append('--force')
+args.append("--force")
 if isinstance(name, list):
 self.addArguments(args, name)
 else:
 args.append(name)
 if noDialog:
 out, err = self.__client.runcommand(args)
 res = err == ""
 else:
 dia = HgDialog(
-self.tr(
+self.tr("Removing files/directories from the Mercurial" " repository"),
-'Removing files/directories from the Mercurial'
+self,
-' repository'),
+)
-self)
 res = dia.startProcess(args)
 if res:
 dia.exec()
 res = dia.normalExitWithoutErrors()
 return res
 def vcsMove(self, name, project, target=None, noDialog=False):
 """
 Public method used to move a file/directory.
 @param name file/directory name to be moved (string)
 @param project reference to the project object
 @param target new name of the file/directory (string)
 @param noDialog flag indicating quiet operations
 @return flag indicating successfull operation (boolean)
 """
 isDir = os.path.isdir(name)
 res = False
 if noDialog:
 if target is None:
 return False
 force = True
 accepted = True
 else:
 from .HgCopyDialog import HgCopyDialog
 dlg = HgCopyDialog(name, None, True)
 accepted = dlg.exec() == QDialog.DialogCode.Accepted
 if accepted:
 target, force = dlg.getData()
 if accepted:
 args = self.initCommand("rename")
 args.append("-v")
 if force:
-args.append('--force')
+args.append("--force")
 args.append(name)
 args.append(target)
 if noDialog:
 out, err = self.__client.runcommand(args)
 res = err == ""
 else:
-dia = HgDialog(self.tr('Renaming {0}').format(name), self)
+dia = HgDialog(self.tr("Renaming {0}").format(name), self)
 res = dia.startProcess(args)
 if res:
 dia.exec()
 res = dia.normalExit()
 if res:
 if isDir:
 project.removeDirectory(name)
 else:
 project.removeFile(name)
 return res
 def vcsDiff(self, name):
 """
 Public method used to view the difference of a file/directory to the
 Mercurial repository.
 If name is a directory and is the project directory, all project files
 are saved first. If name is a file (or list of files), which is/are
 being edited and has unsaved modification, they can be saved or the
 operation may be aborted.
 @param name file/directory name to be diffed (string)
 """
 names = name[:] if isinstance(name, list) else [name]
 for nam in names:
 if os.path.isfile(nam):
 project = ericApp().getObject("Project")
 if nam == project.ppath and not project.saveAllScripts():
 return
 if self.diff is None:
 from .HgDiffDialog import HgDiffDialog
 self.diff = HgDiffDialog(self)
 self.diff.show()
 self.diff.raise_()
 QApplication.processEvents()
 self.diff.start(name, refreshable=True)
 def vcsStatus(self, name):
 """
 Public method used to view the status of files/directories in the
 Mercurial repository.
 @param name file/directory name(s) to show the status of
 (string or list of strings)
 """
 if self.status is None:
 from .HgStatusDialog import HgStatusDialog
 self.status = HgStatusDialog(self)
 self.status.show()
 self.status.raise_()
 self.status.start(name)
 def hgSummary(self, mq=False, largefiles=False):
 """
 Public method used to show some summary information of the
 working directory state.
 @param mq flag indicating to show the queue status as well (boolean)
 @param largefiles flag indicating to show the largefiles status as
 well (boolean)
 """
 if self.summary is None:
 from .HgSummaryDialog import HgSummaryDialog
 self.summary = HgSummaryDialog(self)
 self.summary.show()
 self.summary.raise_()
 self.summary.start(mq=mq, largefiles=largefiles)
 def vcsTag(self, name=None, revision=None, tagName=None):
 """
 Public method used to set/remove a tag in the Mercurial repository.
 @param name file/directory name to determine the repo root from
 (string)
 @param revision revision to set tag for (string)
 @param tagName name of the tag (string)
 @return flag indicating a performed tag action (boolean)
 """
 from .HgTagDialog import HgTagDialog
-dlg = HgTagDialog(self.hgGetTagsList(withType=True),
-revision, tagName)
+dlg = HgTagDialog(self.hgGetTagsList(withType=True), revision, tagName)
 if dlg.exec() == QDialog.DialogCode.Accepted:
 tag, revision, tagOp, force = dlg.getParameters()
 else:
 return False
 args = self.initCommand("tag")
 msgPart = ""
 if tagOp in [HgTagDialog.CreateLocalTag, HgTagDialog.DeleteLocalTag]:
-args.append('--local')
+args.append("--local")
 msgPart = "local "
 else:
 msgPart = "global "
 if tagOp in [HgTagDialog.DeleteGlobalTag, HgTagDialog.DeleteLocalTag]:
-args.append('--remove')
+args.append("--remove")
 if (
-tagOp in [
+tagOp in [HgTagDialog.CreateGlobalTag, HgTagDialog.CreateLocalTag]
-HgTagDialog.CreateGlobalTag, HgTagDialog.CreateLocalTag] and
+and revision
-revision
 ):
 args.append("--rev")
 args.append(revision)
 if force:
 args.append("--force")
-args.append('--message')
+args.append("--message")
 if tagOp in [HgTagDialog.CreateGlobalTag, HgTagDialog.CreateLocalTag]:
 tag = tag.strip().replace(" ", "_")
 args.append("Created {1}tag <{0}>.".format(tag, msgPart))
 else:
 args.append("Removed {1}tag <{0}>.".format(tag, msgPart))
 args.append(tag)
-dia = HgDialog(self.tr('Tagging in the Mercurial repository'),
+dia = HgDialog(self.tr("Tagging in the Mercurial repository"), self)
-self)
 res = dia.startProcess(args)
 if res:
 dia.exec()
 return True
 def vcsRevert(self, name):
 """
 Public method used to revert changes made to a file/directory.
 @param name file/directory name to be reverted
 @type str
 @return flag indicating, that the update contained an add
 or delete
 @rtype bool
 self.addArguments(args, name)
 names = name[:]
 else:
 args.append(name)
 names = [name]
 project = ericApp().getObject("Project")
 names = [project.getRelativePath(nam) for nam in names]
 if names[0]:
-from UI.DeleteFilesConfirmationDialog import (
+from UI.DeleteFilesConfirmationDialog import DeleteFilesConfirmationDialog
-DeleteFilesConfirmationDialog
-)
 dlg = DeleteFilesConfirmationDialog(
 self.parent(),
 self.tr("Revert changes"),
 self.tr(
 "Do you really want to revert all changes to these files"
-" or directories?"),
+" or directories?"
-names)
+),
+names,
+)
 yes = dlg.exec() == QDialog.DialogCode.Accepted
 else:
 yes = EricMessageBox.yesNo(
 None,
 self.tr("Revert changes"),
-self.tr("""Do you really want to revert all changes of"""
+self.tr(
-""" the project?"""))
+"""Do you really want to revert all changes of"""
+""" the project?"""
+),
+)
 if yes:
-dia = HgDialog(self.tr('Reverting changes'), self)
+dia = HgDialog(self.tr("Reverting changes"), self)
 res = dia.startProcess(args)
 if res:
 dia.exec()
 res = dia.hasAddOrDelete()
 self.checkVCSStatus()
 else:
 res = False
 return res
 def vcsMerge(self, name, rev=""):
 """
 Public method used to merge a URL/revision into the local project.
 @param name file/directory name to be merged
 @type str
 @param rev revision to merge with
 @type str
 """
 if not rev:
 from .HgMergeDialog import HgMergeDialog
-dlg = HgMergeDialog(self.hgGetTagsList(),
-self.hgGetBranchesList(),
+dlg = HgMergeDialog(
-self.hgGetBookmarksList())
+self.hgGetTagsList(),
+self.hgGetBranchesList(),
+self.hgGetBookmarksList(),
+)
 if dlg.exec() == QDialog.DialogCode.Accepted:
 rev, force = dlg.getParameters()
 else:
 return
 else:
 force = False
 args = self.initCommand("merge")
 if force:
 args.append("--force")
 if self.getPlugin().getPreferences("InternalMerge"):
 args.append("--tool")
 args.append("internal:merge")
 if rev:
 args.append("--rev")
 args.append(rev)
-dia = HgDialog(self.tr('Merging'), self)
+dia = HgDialog(self.tr("Merging"), self)
 res = dia.startProcess(args)
 if res:
 dia.exec()
 self.checkVCSStatus()
 def hgReMerge(self, name):
 """
 Public method used to merge a URL/revision into the local project.
 @param name file/directory name to be merged (string)
 """
 args = self.initCommand("resolve")
 if self.getPlugin().getPreferences("InternalMerge"):
 args.append("--tool")
 self.addArguments(args, name)
 names = name[:]
 else:
 args.append(name)
 names = [name]
 project = ericApp().getObject("Project")
 names = [project.getRelativePath(nam) for nam in names]
 if names[0]:
-from UI.DeleteFilesConfirmationDialog import (
+from UI.DeleteFilesConfirmationDialog import DeleteFilesConfirmationDialog
-DeleteFilesConfirmationDialog
-)
 dlg = DeleteFilesConfirmationDialog(
 self.parent(),
 self.tr("Re-Merge"),
 self.tr(
-"Do you really want to re-merge these files"
+"Do you really want to re-merge these files" " or directories?"
-" or directories?"),
+),
-names)
+names,
+)
 yes = dlg.exec() == QDialog.DialogCode.Accepted
 else:
 yes = EricMessageBox.yesNo(
 None,
 self.tr("Re-Merge"),
-self.tr("""Do you really want to re-merge the project?"""))
+self.tr("""Do you really want to re-merge the project?"""),
+)
 if yes:
-dia = HgDialog(self.tr('Re-Merging').format(name), self)
+dia = HgDialog(self.tr("Re-Merging").format(name), self)
 res = dia.startProcess(args)
 if res:
 dia.exec()
 self.checkVCSStatus()
 def vcsSwitch(self, name):
 """
 Public method used to switch a working directory to a different
 revision.
 @param name directory name to be switched (string)
 @return flag indicating, that the switch contained an add
 or delete (boolean)
 """
 from .HgRevisionSelectionDialog import HgRevisionSelectionDialog
 dlg = HgRevisionSelectionDialog(
 self.hgGetTagsList(),
 self.hgGetBranchesList(),
 bookmarksList=self.hgGetBookmarksList(),
-noneLabel=self.tr("Current branch tip")
+noneLabel=self.tr("Current branch tip"),
 )
 if dlg.exec() == QDialog.DialogCode.Accepted:
 rev = dlg.getRevision()
 return self.vcsUpdate(name, revision=rev)
 return False
 def vcsRegisteredState(self, name):
 """
 Public method used to get the registered state of a file in the vcs.
 @param name file or directory name to check
 @type str
 @return a combination of canBeCommited and canBeAdded
 @rtype int
 """
 if name.endswith(os.sep):
 name = name[:-1]
 name = os.path.normcase(name)
-if (
+if os.path.isdir(name) and os.path.isdir(os.path.join(name, self.adminDir)):
-os.path.isdir(name) and
-os.path.isdir(os.path.join(name, self.adminDir))
-):
 return self.canBeCommitted
 if name in self.statusCache:
 return self.statusCache[name]
 args = self.initCommand("status")
-args.append('--all')
+args.append("--all")
-args.append('--noninteractive')
+args.append("--noninteractive")
 output, error = self.__client.runcommand(args)
 if output:
 repodir = self.getClient().getRepository()
 for line in output.splitlines():
 if len(line) > 2 and line[0] in "MARC!?I" and line[1] == " ":
 flag, path = line.split(" ", 1)
-absname = Utilities.normcasepath(
+absname = Utilities.normcasepath(os.path.join(repodir, path))
-os.path.join(repodir, path))
 if flag not in "?I" and absname == name:
 return self.canBeCommitted
 return self.canBeAdded
 def vcsAllRegisteredStates(self, names, dname, shortcut=True):
 """
 Public method used to get the registered states of a number of files
 in the vcs.
 <b>Note:</b> If a shortcut is to be taken, the code will only check,
 if the named directory has been scanned already. If so, it is assumed,
 that the states for all files have been populated by the previous run.
 @param names dictionary with all filenames to be checked as keys
 @param dname directory to check in (string)
 @param shortcut flag indicating a shortcut should be taken (boolean)
 @return the received dictionary completed with a combination of
 canBeCommited and canBeAdded or None in order to signal an error
 """
 if dname.endswith(os.sep):
 dname = dname[:-1]
 dname = os.path.normcase(dname)
 found = False
 for name in list(self.statusCache.keys()):
 if name in names:
 found = True
 names[name] = self.statusCache[name]
 if not found:
 args = self.initCommand("status")
-args.append('--all')
+args.append("--all")
-args.append('--noninteractive')
+args.append("--noninteractive")
 output, error = self.__client.runcommand(args)
 if output:
 repoPath = self.getClient().getRepository()
 dirs = [x for x in names.keys() if os.path.isdir(x)]
 for line in output.splitlines():
 if line and line[0] in "MARC!?I":
 self.statusCache[dirName] = self.canBeCommitted
 else:
 self.statusCache[name] = self.canBeAdded
 if dirName not in self.statusCache:
 self.statusCache[dirName] = self.canBeAdded
 return names
 def clearStatusCache(self):
 """
 Public method to clear the status cache.
 """
 self.statusCache = {}
 def vcsName(self):
 """
 Public method returning the name of the vcs.
 @return always 'Mercurial' (string)
 """
 return "Mercurial"
 def vcsInitConfig(self, project):
 """
 Public method to initialize the VCS configuration.
 This method ensures, that an ignore file exists.
 @param project reference to the project (Project)
 """
 ppath = project.getProjectPath()
 if ppath:
 ignoreName = os.path.join(ppath, Hg.IgnoreFileName)
 if not os.path.exists(ignoreName):
 self.hgCreateIgnoreFile(project.getProjectPath(), autoAdd=True)
 def vcsCleanup(self, name):
 """
 Public method used to cleanup the working directory.
 @param name directory name to be cleaned up (string)
 """
 patterns = self.getPlugin().getPreferences("CleanupPatterns").split()
 entries = []
 for pat in patterns:
 entries.extend(Utilities.direntries(name, True, pat))
 for entry in entries:
 with contextlib.suppress(OSError):
 os.remove(entry)
 def vcsCommandLine(self, name):
 """
 Public method used to execute arbitrary mercurial commands.
 @param name directory name of the working directory (string)
 """
 from .HgCommandDialog import HgCommandDialog
 dlg = HgCommandDialog(self.commandHistory, name)
 if dlg.exec() == QDialog.DialogCode.Accepted:
 command = dlg.getData()
 commandList = Utilities.parseOptionString(command)
 # This moves any previous occurrence of these arguments to the head
 # of the list.
 if command in self.commandHistory:
 self.commandHistory.remove(command)
 self.commandHistory.insert(0, command)
 args = []
 self.addArguments(args, commandList)
-dia = HgDialog(self.tr('Mercurial command'), self)
+dia = HgDialog(self.tr("Mercurial command"), self)
 res = dia.startProcess(args)
 if res:
 dia.exec()
 def vcsOptionsDialog(self, project, archive, editable=False, parent=None):
 """
 Public method to get a dialog to enter repository info.
 @param project reference to the project object
 @param archive name of the project in the repository (string)
 @param editable flag indicating that the project name is editable
 (boolean)
 @param parent parent widget (QWidget)
 @return reference to the instantiated options dialog (HgOptionsDialog)
 """
 from .HgOptionsDialog import HgOptionsDialog
 return HgOptionsDialog(self, project, parent)
 def vcsNewProjectOptionsDialog(self, parent=None):
 """
 Public method to get a dialog to enter repository info for getting a
 new project.
 @param parent parent widget (QWidget)
 @return reference to the instantiated options dialog
 (HgNewProjectOptionsDialog)
 """
 from .HgNewProjectOptionsDialog import HgNewProjectOptionsDialog
 return HgNewProjectOptionsDialog(self, parent)
 def vcsRepositoryInfos(self, ppath):
 """
 Public method to retrieve information about the repository.
 @param ppath local path to get the repository infos (string)
 @return string with ready formated info for display (string)
 """
 args = self.initCommand("parents")
-args.append('--template')
+args.append("--template")
-args.append('{rev}:{node|short}@@@{tags}@@@{author|xmlescape}@@@'
+args.append(
-'{date|isodate}@@@{branches}@@@{bookmarks}\n')
+"{rev}:{node|short}@@@{tags}@@@{author|xmlescape}@@@"
+"{date|isodate}@@@{branches}@@@{bookmarks}\n"
+)
 output, error = self.__client.runcommand(args)
 infoBlock = []
 if output:
 for index, line in enumerate(output.splitlines(), start=1):
-(changeset, tags, author, date, branches,
+(changeset, tags, author, date, branches, bookmarks) = line.split("@@@")
-bookmarks) = line.split("@@@")
 cdate, ctime = date.split()[:2]
 info = []
-info.append(QCoreApplication.translate(
+info.append(
-"mercurial",
+QCoreApplication.translate(
-"""<tr><td><b>Parent #{0}</b></td><td></td></tr>\n"""
+"mercurial",
-"""<tr><td><b>Changeset</b></td><td>{1}</td></tr>""")
+"""<tr><td><b>Parent #{0}</b></td><td></td></tr>\n"""
-.format(index, changeset))
+"""<tr><td><b>Changeset</b></td><td>{1}</td></tr>""",
+).format(index, changeset)
+)
 if tags:
-info.append(QCoreApplication.translate(
+info.append(
+QCoreApplication.translate(
+"mercurial", """<tr><td><b>Tags</b></td><td>{0}</td></tr>"""
+).format("<br/>".join(tags.split()))
+)
+if bookmarks:
+info.append(
+QCoreApplication.translate(
+"mercurial",
+"""<tr><td><b>Bookmarks</b></td><td>{0}</td></tr>""",
+).format("<br/>".join(bookmarks.split()))
+)
+if branches:
+info.append(
+QCoreApplication.translate(
+"mercurial",
+"""<tr><td><b>Branches</b></td><td>{0}</td></tr>""",
+).format("<br/>".join(branches.split()))
+)
+info.append(
+QCoreApplication.translate(
 "mercurial",
-"""<tr><td><b>Tags</b></td><td>{0}</td></tr>""")
+"""<tr><td><b>Last author</b></td><td>{0}</td></tr>\n"""
-.format('<br/>'.join(tags.split())))
+"""<tr><td><b>Committed date</b></td><td>{1}</td></tr>\n"""
-if bookmarks:
+"""<tr><td><b>Committed time</b></td><td>{2}</td></tr>""",
-info.append(QCoreApplication.translate(
+).format(author, cdate, ctime)
-"mercurial",
+)
-"""<tr><td><b>Bookmarks</b></td><td>{0}</td></tr>""")
-.format('<br/>'.join(bookmarks.split())))
-if branches:
-info.append(QCoreApplication.translate(
-"mercurial",
-"""<tr><td><b>Branches</b></td><td>{0}</td></tr>""")
-.format('<br/>'.join(branches.split())))
-info.append(QCoreApplication.translate(
-"mercurial",
-"""<tr><td><b>Last author</b></td><td>{0}</td></tr>\n"""
-"""<tr><td><b>Committed date</b></td><td>{1}</td></tr>\n"""
-"""<tr><td><b>Committed time</b></td><td>{2}</td></tr>""")
-.format(author, cdate, ctime))
 infoBlock.append("\n".join(info))
 infoStr = (
-"""<tr></tr>{0}""".format("<tr></tr>".join(infoBlock))
+"""<tr></tr>{0}""".format("<tr></tr>".join(infoBlock)) if infoBlock else ""
-if infoBlock else
-""
 )
 url = ""
 args = self.initCommand("showconfig")
-args.append('paths.default')
+args.append("paths.default")
 output, error = self.__client.runcommand(args)
 url = output.splitlines()[0].strip() if output else ""
 return QCoreApplication.translate(
-'mercurial',
+"mercurial",
 """<h3>Repository information</h3>\n"""
 """<p><table>\n"""
 """<tr><td><b>Mercurial V.</b></td><td>{0}</td></tr>\n"""
 """<tr></tr>\n"""
 """<tr><td><b>URL</b></td><td>{1}</td></tr>\n"""
 """{2}"""
-"""</table></p>\n"""
+"""</table></p>\n""",
 ).format(self.versionStr, url, infoStr)
 def vcsSupportCommandOptions(self):
 """
 Public method to signal the support of user settable command options.
 @return flag indicating the support  of user settable command options
 (boolean)
 """
 return False
 ###########################################################################
 ## Private Mercurial specific methods are below.
 ###########################################################################
 def hgNormalizeURL(self, url):
 """
 Public method to normalize a url for Mercurial.
 @param url url string (string)
 @return properly normalized url for mercurial (string)
 """
-url = url.replace('\\', '/')
+url = url.replace("\\", "/")
-if url.endswith('/'):
+if url.endswith("/"):
 url = url[:-1]
-urll = url.split('//')
+urll = url.split("//")
-return "{0}//{1}".format(urll[0], '/'.join(urll[1:]))
+return "{0}//{1}".format(urll[0], "/".join(urll[1:]))
 def hgCopy(self, name, project):
 """
 Public method used to copy a file/directory.
 @param name file/directory name to be copied (string)
 @param project reference to the project object
 @return flag indicating successful operation (boolean)
 """
 from .HgCopyDialog import HgCopyDialog
 dlg = HgCopyDialog(name)
 res = False
 if dlg.exec() == QDialog.DialogCode.Accepted:
 target, force = dlg.getData()
 args = self.initCommand("copy")
 args.append("-v")
 args.append(name)
 args.append(target)
-dia = HgDialog(
+dia = HgDialog(self.tr("Copying {0}").format(name), self)
-self.tr('Copying {0}').format(name), self)
 res = dia.startProcess(args)
 if res:
 dia.exec()
 res = dia.normalExit()
-if (
+if res and target.startswith(project.getProjectPath()):
-res and
-target.startswith(project.getProjectPath())
-):
 if os.path.isdir(name):
 project.copyDirectory(name, target)
 else:
 project.appendFile(target)
 return res
 def hgGetTagsList(self, withType=False):
 """
 Public method to get the list of tags.
 @param withType flag indicating to get the tag type as well (boolean)
 @return list of tags (list of string) or list of tuples of
 tag name and flag indicating a local tag (list of tuple of string
 and boolean), if withType is True
 """
 args = self.initCommand("tags")
-args.append('--verbose')
+args.append("--verbose")
 output, error = self.__client.runcommand(args)
 tagsList = []
 if output:
 for line in output.splitlines():
 li = line.strip().split()
 if li[-1][0] in "1234567890":
 if name not in ["tip", "default"]:
 if withType:
 tagsList.append((name, isLocal))
 else:
 tagsList.append(name)
 if withType:
 return tagsList
 else:
 if tagsList:
 self.tagsList = tagsList
 return self.tagsList[:]
 def hgGetBranchesList(self):
 """
 Public method to get the list of branches.
 @return list of branches (list of string)
 """
 args = self.initCommand("branches")
-args.append('--closed')
+args.append("--closed")
 output, error = self.__client.runcommand(args)
 if output:
 self.branchesList = []
 for line in output.splitlines():
 li = line.strip().split()
 if li[-1][0] in "1234567890":
 else:
 del li[-2:]
 name = " ".join(li)
 if name not in ["tip", "default"]:
 self.branchesList.append(name)
 return self.branchesList[:]
 def hgListTagBranch(self, tags=True):
 """
 Public method used to list the available tags or branches.
 @param tags flag indicating listing of branches or tags
 (False = branches, True = tags)
 """
 from .HgTagBranchListDialog import HgTagBranchListDialog
 self.tagbranchList = HgTagBranchListDialog(self)
 self.tagbranchList.show()
 if tags:
 if not self.showedTags:
 self.showedTags = True
 allTagsBranchesList = self.allTagsBranchesList
 else:
 self.tagsList = []
 allTagsBranchesList = None
-self.tagbranchList.start(
+self.tagbranchList.start(tags, self.tagsList, allTagsBranchesList)
-tags, self.tagsList, allTagsBranchesList)
 else:
 if not self.showedBranches:
 self.showedBranches = True
 allTagsBranchesList = self.allTagsBranchesList
 else:
 self.branchesList = []
 allTagsBranchesList = None
-self.tagbranchList.start(
+self.tagbranchList.start(tags, self.branchesList, self.allTagsBranchesList)
-tags, self.branchesList, self.allTagsBranchesList)
 def hgAnnotate(self, name):
 """
 Public method to show the output of the hg annotate command.
 @param name file name to show the annotations for (string)
 """
 if self.annotate is None:
 from .HgAnnotateDialog import HgAnnotateDialog
 self.annotate = HgAnnotateDialog(self)
 self.annotate.show()
 self.annotate.raise_()
 self.annotate.start(name)
 def hgExtendedDiff(self, name):
 """
 Public method used to view the difference of a file/directory to the
 Mercurial repository.
 If name is a directory and is the project directory, all project files
 are saved first. If name is a file (or list of files), which is/are
 being edited and has unsaved modification, they can be saved or the
 operation may be aborted.
 This method gives the chance to enter the revisions to be compared.
 @param name file/directory name to be diffed (string)
 """
 names = name[:] if isinstance(name, list) else [name]
 for nam in names:
 if os.path.isfile(nam):
 return
 else:
 project = ericApp().getObject("Project")
 if nam == project.ppath and not project.saveAllScripts():
 return
 from .HgRevisionsSelectionDialog import HgRevisionsSelectionDialog
 dlg = HgRevisionsSelectionDialog(
 self.hgGetTagsList(),
 self.hgGetBranchesList(),
-bookmarksList=self.hgGetBookmarksList()
+bookmarksList=self.hgGetBookmarksList(),
 )
 if dlg.exec() == QDialog.DialogCode.Accepted:
 revisions = dlg.getRevisions()
 if self.diff is None:
 from .HgDiffDialog import HgDiffDialog
 self.diff = HgDiffDialog(self)
 self.diff.show()
 self.diff.raise_()
 self.diff.start(name, revisions)
 def __hgGetFileForRevision(self, name, rev=""):
 """
 Private method to get a file for a specific revision from the
 repository.
 @param name file name to get from the repository (string)
 @param rev revision to retrieve (string)
 @return contents of the file (string) and an error message (string)
 """
 args = self.initCommand("cat")
 if rev:
 args.append("--rev")
 args.append(rev)
 args.append(name)
 output, error = self.__client.runcommand(args)
 # return file contents with 'universal newlines'
-return output.replace('\r\n', '\n').replace('\r', '\n'), error
+return output.replace("\r\n", "\n").replace("\r", "\n"), error
 def vcsSbsDiff(self, name, extended=False, revisions=None):
 """
 Public method used to view the difference of a file to the Mercurial
 repository side-by-side.
 @param name file name to be diffed (string)
 @param extended flag indicating the extended variant (boolean)
 @param revisions tuple of two revisions (tuple of strings)
 @exception ValueError raised to indicate an invalid name parameter
 """
 if isinstance(name, list):
 raise ValueError("Wrong parameter type")
 if extended:
 from .HgRevisionsSelectionDialog import HgRevisionsSelectionDialog
 dlg = HgRevisionsSelectionDialog(
 self.hgGetTagsList(),
 self.hgGetBranchesList(),
-bookmarksList=self.hgGetBookmarksList()
+bookmarksList=self.hgGetBookmarksList(),
 )
 if dlg.exec() == QDialog.DialogCode.Accepted:
 rev1, rev2 = dlg.getRevisions()
 else:
 return
 elif revisions:
 rev1, rev2 = revisions[0], revisions[1]
 else:
 rev1, rev2 = "", ""
 output1, error = self.__hgGetFileForRevision(name, rev=rev1)
 if error:
 EricMessageBox.critical(
-self.__ui,
+self.__ui, self.tr("Mercurial Side-by-Side Difference"), error
-self.tr("Mercurial Side-by-Side Difference"),
+)
-error)
 return
 name1 = "{0} (rev. {1})".format(name, rev1 and rev1 or ".")
 if rev2:
 output2, error = self.__hgGetFileForRevision(name, rev=rev2)
 if error:
 EricMessageBox.critical(
-self.__ui,
+self.__ui, self.tr("Mercurial Side-by-Side Difference"), error
-self.tr("Mercurial Side-by-Side Difference"),
+)
-error)
 return
 name2 = "{0} (rev. {1})".format(name, rev2)
 else:
 try:
 with open(name, "r", encoding="utf-8") as f1:
 name2 = "{0} (Work)".format(name)
 except OSError:
 EricMessageBox.critical(
 self.__ui,
 self.tr("Mercurial Side-by-Side Difference"),
-self.tr(
+self.tr("""<p>The file <b>{0}</b> could not be read.</p>""").format(
-"""<p>The file <b>{0}</b> could not be read.</p>""")
+name
-.format(name))
+),
+)
 return
 if self.sbsDiff is None:
 from UI.CompareDialog import CompareDialog
 self.sbsDiff = CompareDialog()
 self.sbsDiff.show()
 self.sbsDiff.raise_()
 self.sbsDiff.compare(output1, output2, name1, name2)
 def vcsLogBrowser(self, name=None, isFile=False):
 """
 Public method used to browse the log of a file/directory from the
 Mercurial repository.
 @param name file/directory name to show the log of (string)
 @param isFile flag indicating log for a file is to be shown
 (boolean)
 """
 if name == self.getClient().getRepository():
 name = None
 if self.logBrowser is None:
 from .HgLogBrowserDialog import HgLogBrowserDialog
 self.logBrowser = HgLogBrowserDialog(self)
 self.logBrowser.show()
 self.logBrowser.raise_()
 self.logBrowser.start(name=name, isFile=isFile)
 def hgIncoming(self):
 """
 Public method used to view the log of incoming changes from the
 Mercurial repository.
 """
 if self.logBrowserIncoming is None:
 from .HgLogBrowserDialog import HgLogBrowserDialog
-self.logBrowserIncoming = HgLogBrowserDialog(
-self, mode="incoming")
+self.logBrowserIncoming = HgLogBrowserDialog(self, mode="incoming")
 self.logBrowserIncoming.show()
 self.logBrowserIncoming.raise_()
 self.logBrowserIncoming.start()
 def hgOutgoing(self):
 """
 Public method used to view the log of outgoing changes from the
 Mercurial repository.
 """
 if self.logBrowserOutgoing is None:
 from .HgLogBrowserDialog import HgLogBrowserDialog
-self.logBrowserOutgoing = HgLogBrowserDialog(
-self, mode="outgoing")
+self.logBrowserOutgoing = HgLogBrowserDialog(self, mode="outgoing")
 self.logBrowserOutgoing.show()
 self.logBrowserOutgoing.raise_()
 self.logBrowserOutgoing.start()
 def hgPull(self, revisions=None):
 """
 Public method used to pull changes from a remote Mercurial repository.
 @param revisions list of revisions to be pulled
 @type list of str
 @return flag indicating, that the update contained an add
 or delete
 @rtype bool
 """
 if (
-self.getPlugin().getPreferences("PreferUnbundle") and
+self.getPlugin().getPreferences("PreferUnbundle")
-self.bundleFile and
+and self.bundleFile
-os.path.exists(self.bundleFile) and
+and os.path.exists(self.bundleFile)
-revisions is None
+and revisions is None
 ):
 command = "unbundle"
-title = self.tr('Apply changegroups')
+title = self.tr("Apply changegroups")
 else:
 command = "pull"
-title = self.tr('Pulling from a remote Mercurial repository')
+title = self.tr("Pulling from a remote Mercurial repository")
 args = self.initCommand(command)
-args.append('-v')
+args.append("-v")
 if self.getPlugin().getPreferences("PullUpdate"):
-args.append('--update')
+args.append("--update")
 if command == "unbundle":
 args.append(self.bundleFile)
 if revisions:
 for rev in revisions:
 args.append("--rev")
 args.append(rev)
 dia = HgDialog(title, self)
 res = dia.startProcess(args)
 if res:
 dia.exec()
 res = dia.hasAddOrDelete()
-if (
+if self.bundleFile and os.path.exists(self.bundleFile):
-self.bundleFile and
-os.path.exists(self.bundleFile)
-):
 os.remove(self.bundleFile)
 self.bundleFile = None
 self.checkVCSStatus()
 return res
 def hgPush(self, force=False, newBranch=False, rev=None):
 """
 Public method used to push changes to a remote Mercurial repository.
 @param force flag indicating a forced push (boolean)
 @param newBranch flag indicating to push a new branch (boolean)
 @param rev revision to be pushed (including all ancestors) (string)
 """
 args = self.initCommand("push")
-args.append('-v')
+args.append("-v")
 if force:
-args.append('-f')
+args.append("-f")
 if newBranch:
-args.append('--new-branch')
+args.append("--new-branch")
 if rev:
-args.append('--rev')
+args.append("--rev")
 args.append(rev)
-dia = HgDialog(
+dia = HgDialog(self.tr("Pushing to a remote Mercurial repository"), self)
-self.tr('Pushing to a remote Mercurial repository'), self)
 res = dia.startProcess(args)
 if res:
 dia.exec()
 self.checkVCSStatus()
 def hgInfo(self, mode="heads"):
 """
 Public method to show information about the heads of the repository.
 @param mode mode of the operation (string, one of heads, parents,
 tip)
 """
 if mode not in ("heads", "parents", "tip"):
 mode = "heads"
 info = []
 args = self.initCommand(mode)
-args.append('--template')
+args.append("--template")
-args.append('{rev}:{node|short}@@@{tags}@@@{author|xmlescape}@@@'
+args.append(
-'{date|isodate}@@@{branches}@@@{parents}@@@{bookmarks}\n')
+"{rev}:{node|short}@@@{tags}@@@{author|xmlescape}@@@"
+"{date|isodate}@@@{branches}@@@{parents}@@@{bookmarks}\n"
+)
 output, error = self.__client.runcommand(args)
 if output:
 for index, line in enumerate(output.splitlines(), start=1):
-(changeset, tags, author, date, branches, parents,
+(
-bookmarks) = line.split("@@@")
+changeset,
+tags,
+author,
+date,
+branches,
+parents,
+bookmarks,
+) = line.split("@@@")
 cdate, ctime = date.split()[:2]
 info.append("""<p><table>""")
 if mode == "heads":
-info.append(QCoreApplication.translate(
+info.append(
+QCoreApplication.translate(
+"mercurial",
+"""<tr><td><b>Head #{0}</b></td><td></td></tr>\n""",
+).format(index)
+)
+elif mode == "parents":
+info.append(
+QCoreApplication.translate(
+"mercurial",
+"""<tr><td><b>Parent #{0}</b></td><td></td></tr>\n""",
+).format(index)
+)
+elif mode == "tip":
+info.append(
+QCoreApplication.translate(
+"mercurial", """<tr><td><b>Tip</b></td><td></td></tr>\n"""
+)
+)
+info.append(
+QCoreApplication.translate(
 "mercurial",
-"""<tr><td><b>Head #{0}</b></td><td></td></tr>\n""")
+"""<tr><td><b>Changeset</b></td><td>{0}</td></tr>""",
-.format(index))
+).format(changeset)
-elif mode == "parents":
+)
-info.append(QCoreApplication.translate(
+if tags:
+info.append(
+QCoreApplication.translate(
+"mercurial", """<tr><td><b>Tags</b></td><td>{0}</td></tr>"""
+).format("<br/>".join(tags.split()))
+)
+if bookmarks:
+info.append(
+QCoreApplication.translate(
+"mercurial",
+"""<tr><td><b>Bookmarks</b></td><td>{0}</td></tr>""",
+).format("<br/>".join(bookmarks.split()))
+)
+if branches:
+info.append(
+QCoreApplication.translate(
+"mercurial",
+"""<tr><td><b>Branches</b></td><td>{0}</td></tr>""",
+).format("<br/>".join(branches.split()))
+)
+if parents:
+info.append(
+QCoreApplication.translate(
+"mercurial",
+"""<tr><td><b>Parents</b></td><td>{0}</td></tr>""",
+).format("<br/>".join(parents.split()))
+)
+info.append(
+QCoreApplication.translate(
 "mercurial",
-"""<tr><td><b>Parent #{0}</b></td><td></td></tr>\n""")
+"""<tr><td><b>Last author</b></td><td>{0}</td></tr>\n"""
-.format(index))
+"""<tr><td><b>Committed date</b></td><td>{1}</td></tr>\n"""
-elif mode == "tip":
+"""<tr><td><b>Committed time</b></td><td>{2}</td></tr>\n"""
-info.append(QCoreApplication.translate(
+"""</table></p>""",
-"mercurial",
+).format(author, cdate, ctime)
-"""<tr><td><b>Tip</b></td><td></td></tr>\n"""))
+)
-info.append(QCoreApplication.translate(
-"mercurial",
-"""<tr><td><b>Changeset</b></td><td>{0}</td></tr>""")
-.format(changeset))
-if tags:
-info.append(QCoreApplication.translate(
-"mercurial",
-"""<tr><td><b>Tags</b></td><td>{0}</td></tr>""")
-.format('<br/>'.join(tags.split())))
-if bookmarks:
-info.append(QCoreApplication.translate(
-"mercurial",
-"""<tr><td><b>Bookmarks</b></td><td>{0}</td></tr>""")
-.format('<br/>'.join(bookmarks.split())))
-if branches:
-info.append(QCoreApplication.translate(
-"mercurial",
-"""<tr><td><b>Branches</b></td><td>{0}</td></tr>""")
-.format('<br/>'.join(branches.split())))
-if parents:
-info.append(QCoreApplication.translate(
-"mercurial",
-"""<tr><td><b>Parents</b></td><td>{0}</td></tr>""")
-.format('<br/>'.join(parents.split())))
-info.append(QCoreApplication.translate(
-"mercurial",
-"""<tr><td><b>Last author</b></td><td>{0}</td></tr>\n"""
-"""<tr><td><b>Committed date</b></td><td>{1}</td></tr>\n"""
-"""<tr><td><b>Committed time</b></td><td>{2}</td></tr>\n"""
-"""</table></p>""")
-.format(author, cdate, ctime))
 dlg = VcsRepositoryInfoDialog(None, "\n".join(info))
 dlg.exec()
 def hgConflicts(self):
 """
 Public method used to show a list of files containing conflicts.
 """
 if self.conflictsDlg is None:
 from .HgConflictsListDialog import HgConflictsListDialog
 self.conflictsDlg = HgConflictsListDialog(self)
 self.conflictsDlg.show()
 self.conflictsDlg.raise_()
 self.conflictsDlg.start()
 def vcsResolved(self, name, unresolve=False):
 """
 Public method used to resolve conflicts of a file/directory.
 @param name file/directory name to be resolved (string)
 @param unresolve flag indicating to mark the file/directory as
 unresolved (boolean)
 """
 args = self.initCommand("resolve")
 if unresolve:
 args.append("--unmark")
 else:
 args.append("--mark")
 if isinstance(name, list):
 self.addArguments(args, name)
 else:
 args.append(name)
 title = (
 self.tr("Marking as 'unresolved'")
-if unresolve else
+if unresolve
-self.tr("Marking as 'resolved'")
+else self.tr("Marking as 'resolved'")
 )
 dia = HgDialog(title, self)
 res = dia.startProcess(args)
 if res:
 dia.exec()
 self.checkVCSStatus()
 def hgAbortMerge(self):
 """
 Public method to abort an uncommitted merge.
 @return flag indicating, that the abortion contained an add
 or delete (boolean)
 """
 if self.version >= (4, 5, 0):
 args = self.initCommand("merge")
 args.append("--abort")
 else:
 args = self.initCommand("update")
 args.append("--clean")
-dia = HgDialog(
+dia = HgDialog(self.tr("Aborting uncommitted merge"), self)
-self.tr('Aborting uncommitted merge'),
-self)
 res = dia.startProcess(args, showArgs=False)
 if res:
 dia.exec()
 res = dia.hasAddOrDelete()
 self.checkVCSStatus()
 return res
 def hgBranch(self):
 """
 Public method used to create a branch in the Mercurial repository.
 """
 from .HgBranchInputDialog import HgBranchInputDialog
 dlg = HgBranchInputDialog(self.hgGetBranchesList())
 if dlg.exec() == QDialog.DialogCode.Accepted:
 name, commit, force = dlg.getData()
 name = name.strip().replace(" ", "_")
 args = self.initCommand("branch")
 if force:
 args.append("--force")
 args.append(name)
-dia = HgDialog(
+dia = HgDialog(self.tr("Creating branch in the Mercurial repository"), self)
-self.tr('Creating branch in the Mercurial repository'),
-self)
 res = dia.startProcess(args)
 if res:
 dia.exec()
 if commit:
 project = ericApp().getObject("Project")
 self.vcsCommit(
 project.getProjectPath(),
-self.tr("Created new branch <{0}>.").format(
+self.tr("Created new branch <{0}>.").format(name),
-name))
+)
 def hgShowBranch(self):
 """
 Public method used to show the current branch of the working directory.
 """
 args = self.initCommand("branch")
-dia = HgDialog(self.tr('Showing current branch'), self)
+dia = HgDialog(self.tr("Showing current branch"), self)
 res = dia.startProcess(args, showArgs=False)
 if res:
 dia.exec()
 def hgGetCurrentBranch(self):
 """
 Public method to get the current branch of the working directory.
 @return name of the current branch
 @rtype str
 """
 args = self.initCommand("branch")
 output, error = self.__client.runcommand(args)
 return output.strip()
 def hgEditUserConfig(self):
 """
 Public method used to edit the user configuration file.
 """
 from .HgUserConfigDialog import HgUserConfigDialog
 dlg = HgUserConfigDialog(version=self.version)
 dlg.exec()
-def hgEditConfig(self, repoName=None,
+def hgEditConfig(self, repoName=None, withLargefiles=True, largefilesData=None):
-withLargefiles=True, largefilesData=None):
 """
 Public method used to edit the repository configuration file.
 @param repoName directory name containing the repository
 @type str
 @param withLargefiles flag indicating to configure the largefiles
 section
 @type bool
 section of the data dialog
 @type dict
 """
 if repoName is None:
 repoName = self.getClient().getRepository()
 cfgFile = os.path.join(repoName, self.adminDir, "hgrc")
 if not os.path.exists(cfgFile):
 # open dialog to enter the initial data
-withLargefiles = (self.isExtensionActive("largefiles") and
+withLargefiles = self.isExtensionActive("largefiles") and withLargefiles
-withLargefiles)
 from .HgRepoConfigDataDialog import HgRepoConfigDataDialog
-dlg = HgRepoConfigDataDialog(withLargefiles=withLargefiles,
-largefilesData=largefilesData)
+dlg = HgRepoConfigDataDialog(
+withLargefiles=withLargefiles, largefilesData=largefilesData
+)
 if dlg.exec() == QDialog.DialogCode.Accepted:
 createContents = True
 defaultUrl, defaultPushUrl = dlg.getData()
 if withLargefiles:
 lfMinSize, lfPattern = dlg.getLargefilesData()
 # write the data entered
 cfg.write("[paths]\n")
 if defaultUrl:
 cfg.write("default = {0}\n".format(defaultUrl))
 if defaultPushUrl:
-cfg.write("default-push = {0}\n".format(
+cfg.write("default-push = {0}\n".format(defaultPushUrl))
-defaultPushUrl))
+if withLargefiles and (lfMinSize, lfPattern) != (None, None):
-if (
-withLargefiles and
-(lfMinSize, lfPattern) != (None, None)
-):
 cfg.write("\n[largefiles]\n")
 if lfMinSize is not None:
 cfg.write("minsize = {0}\n".format(lfMinSize))
 if lfPattern is not None:
 cfg.write("patterns =\n")
-cfg.write("  {0}\n".format(
+cfg.write("  {0}\n".format("\n  ".join(lfPattern)))
-"\n  ".join(lfPattern)))
 self.__monitorRepoIniFile(repoName)
 self.__iniFileChanged(cfgFile)
 self.repoEditor = MiniEditor(cfgFile, "Properties")
 self.repoEditor.show()
 def hgVerify(self):
 """
 Public method to verify the integrity of the repository.
 """
 args = self.initCommand("verify")
 dia = HgDialog(
-self.tr('Verifying the integrity of the Mercurial repository'),
+self.tr("Verifying the integrity of the Mercurial repository"), self
-self)
+)
 res = dia.startProcess(args)
 if res:
 dia.exec()
 def hgShowConfig(self):
 """
 Public method to show the combined configuration.
 """
 args = self.initCommand("showconfig")
 args.append("--untrusted")
-dia = HgDialog(
+dia = HgDialog(self.tr("Showing the combined configuration settings"), self)
-self.tr('Showing the combined configuration settings'),
-self)
 res = dia.startProcess(args, showArgs=False)
 if res:
 dia.exec()
 def hgShowPaths(self):
 """
 Public method to show the path aliases for remote repositories.
 """
 args = self.initCommand("paths")
-dia = HgDialog(
+dia = HgDialog(self.tr("Showing aliases for remote repositories"), self)
-self.tr('Showing aliases for remote repositories'),
-self)
 res = dia.startProcess(args, showArgs=False)
 if res:
 dia.exec()
 def hgRecover(self):
 """
 Public method to recover an interrupted transaction.
 """
 args = self.initCommand("recover")
-dia = HgDialog(
+dia = HgDialog(self.tr("Recovering from interrupted transaction"), self)
-self.tr('Recovering from interrupted transaction'),
-self)
 res = dia.startProcess(args, showArgs=False)
 if res:
 dia.exec()
 def hgIdentify(self):
 """
 Public method to identify the current working directory.
 """
 args = self.initCommand("identify")
-dia = HgDialog(self.tr('Identifying project directory'), self)
+dia = HgDialog(self.tr("Identifying project directory"), self)
 res = dia.startProcess(args, showArgs=False)
 if res:
 dia.exec()
 def hgCreateIgnoreFile(self, name, autoAdd=False):
 """
 Public method to create the ignore file.
 @param name directory name to create the ignore file in (string)
 @param autoAdd flag indicating to add it automatically (boolean)
 @return flag indicating success
 """
 status = False
 "glob:cur",
 "glob:tmp",
 "glob:__pycache__",
 "glob:**.DS_Store",
 ]
 ignoreName = os.path.join(name, Hg.IgnoreFileName)
 res = (
 EricMessageBox.yesNo(
 self.__ui,
 self.tr("Create .hgignore file"),
-self.tr("""<p>The file <b>{0}</b> exists already."""
+self.tr(
-""" Overwrite it?</p>""").format(ignoreName),
+"""<p>The file <b>{0}</b> exists already."""
-icon=EricMessageBox.Warning)
+""" Overwrite it?</p>"""
-if os.path.exists(ignoreName) else
+).format(ignoreName),
-True
+icon=EricMessageBox.Warning,
+)
+if os.path.exists(ignoreName)
+else True
 )
 if res:
 try:
 # create a .hgignore file
 with open(ignoreName, "w") as ignore:
 ignore.write("\n".join(ignorePatterns))
 ignore.write("\n")
 status = True
 except OSError:
 status = False
 if status and autoAdd:
 self.vcsAdd(ignoreName, noDialog=True)
 project = ericApp().getObject("Project")
 project.appendFile(ignoreName)
 return status
 def hgBundle(self, bundleData=None):
 """
 Public method to create a changegroup file.
 @param bundleData dictionary containing the bundle creation information
 @type dict
 """
 if bundleData is None:
 from .HgBundleDialog import HgBundleDialog
-dlg = HgBundleDialog(self.hgGetTagsList(),
-self.hgGetBranchesList(),
+dlg = HgBundleDialog(
-self.hgGetBookmarksList(),
+self.hgGetTagsList(),
-version=self.version)
+self.hgGetBranchesList(),
+self.hgGetBookmarksList(),
+version=self.version,
+)
 if dlg.exec() != QDialog.DialogCode.Accepted:
 return
 revs, baseRevs, compression, bundleAll = dlg.getParameters()
 else:
 revs = bundleData["revs"]
 if bundleData["base"]:
 baseRevs = [bundleData["base"]]
 else:
 baseRevs = []
 compression = ""
 bundleAll = bundleData["all"]
 fname, selectedFilter = EricFileDialog.getSaveFileNameAndFilter(
 None,
 self.tr("Create changegroup"),
 self.__lastChangeGroupPath,
 self.tr("Mercurial Changegroup Files (*.hg)"),
 None,
-EricFileDialog.DontConfirmOverwrite)
+EricFileDialog.DontConfirmOverwrite,
+)
 if not fname:
 return  # user aborted
 fpath = pathlib.Path(fname)
 if not fpath.suffix:
 ex = selectedFilter.split("(*")[1].split(")")[0]
 if ex:
 fpath = fpath.with_suffix(ex)
 if fpath.exists():
 res = EricMessageBox.yesNo(
 self.__ui,
 self.tr("Create changegroup"),
-self.tr("<p>The Mercurial changegroup file <b>{0}</b> "
+self.tr(
-"already exists. Overwrite it?</p>")
+"<p>The Mercurial changegroup file <b>{0}</b> "
-.format(fpath),
+"already exists. Overwrite it?</p>"
-icon=EricMessageBox.Warning)
+).format(fpath),
+icon=EricMessageBox.Warning,
+)
 if not res:
 return
 self.__lastChangeGroupPath = str(fpath.parent)
 args = self.initCommand("bundle")
 if bundleAll:
 args.append("--all")
 for rev in revs:
 args.append("--rev")
 args.append(baseRev)
 if compression:
 args.append("--type")
 args.append(compression)
 args.append(str(fpath))
-dia = HgDialog(self.tr('Create changegroup'), self)
+dia = HgDialog(self.tr("Create changegroup"), self)
 res = dia.startProcess(args)
 if res:
 dia.exec()
 def hgPreviewBundle(self):
 """
 Public method used to view the log of incoming changes from a
 changegroup file.
 """
 file = EricFileDialog.getOpenFileName(
 None,
 self.tr("Preview changegroup"),
 self.__lastChangeGroupPath,
-self.tr("Mercurial Changegroup Files (*.hg);;All Files (*)"))
+self.tr("Mercurial Changegroup Files (*.hg);;All Files (*)"),
+)
 if file:
 self.__lastChangeGroupPath = os.path.dirname(file)
 if self.logBrowserIncoming is None:
 from .HgLogBrowserDialog import HgLogBrowserDialog
-self.logBrowserIncoming = HgLogBrowserDialog(
-self, mode="incoming")
+self.logBrowserIncoming = HgLogBrowserDialog(self, mode="incoming")
 self.logBrowserIncoming.show()
 self.logBrowserIncoming.raise_()
 self.logBrowserIncoming.start(bundle=file)
 def hgUnbundle(self, files=None):
 """
 Public method to apply changegroup files.
 @param files list of bundle files to be applied
 @type list of str
 @return flag indicating, that the update contained an add
 or delete
 @rtype bool
 if not files:
 files = EricFileDialog.getOpenFileNames(
 None,
 self.tr("Apply changegroups"),
 self.__lastChangeGroupPath,
-self.tr("Mercurial Changegroup Files (*.hg);;All Files (*)"))
+self.tr("Mercurial Changegroup Files (*.hg);;All Files (*)"),
+)
 if files:
 self.__lastChangeGroupPath = os.path.dirname(files[0])
 update = EricMessageBox.yesNo(
 self.__ui,
 self.tr("Apply changegroups"),
 self.tr("""Shall the working directory be updated?"""),
-yesDefault=True)
+yesDefault=True,
+)
 args = self.initCommand("unbundle")
 if update:
 args.append("--update")
 args.append("--verbose")
 args.extend(files)
-dia = HgDialog(self.tr('Apply changegroups'), self)
+dia = HgDialog(self.tr("Apply changegroups"), self)
 res = dia.startProcess(args)
 if res:
 dia.exec()
 res = dia.hasAddOrDelete()
 self.checkVCSStatus()
 return res
 def hgBisect(self, subcommand):
 """
 Public method to perform bisect commands.
 @param subcommand name of the subcommand (one of 'good', 'bad',
 'skip' or 'reset')
 @type str
 @exception ValueError raised to indicate an invalid bisect subcommand
 """
 if subcommand not in ("good", "bad", "skip", "reset"):
 raise ValueError(
-self.tr("Bisect subcommand ({0}) invalid.")
+self.tr("Bisect subcommand ({0}) invalid.").format(subcommand)
-.format(subcommand))
+)
 rev = ""
 if subcommand in ("good", "bad", "skip"):
 from .HgRevisionSelectionDialog import HgRevisionSelectionDialog
 dlg = HgRevisionSelectionDialog(
 self.hgGetTagsList(),
 self.hgGetBranchesList(),
-bookmarksList=self.hgGetBookmarksList()
+bookmarksList=self.hgGetBookmarksList(),
 )
 if dlg.exec() == QDialog.DialogCode.Accepted:
 rev = dlg.getRevision()
 else:
 return
 args = self.initCommand("bisect")
 args.append("--{0}".format(subcommand))
 if rev:
 args.append(rev)
-dia = HgDialog(
+dia = HgDialog(self.tr("Mercurial Bisect ({0})").format(subcommand), self)
-self.tr('Mercurial Bisect ({0})').format(subcommand), self)
 res = dia.startProcess(args)
 if res:
 dia.exec()
 def vcsForget(self, name):
 """
 Public method used to remove a file from the Mercurial repository.
 This will not remove the file from the project directory.
 @param name file/directory name to be removed
 @type str or list of str
 """
 args = self.initCommand("forget")
-args.append('-v')
+args.append("-v")
 if isinstance(name, list):
 self.addArguments(args, name)
 else:
 args.append(name)
 dia = HgDialog(
-self.tr('Removing files from the Mercurial repository only'),
+self.tr("Removing files from the Mercurial repository only"), self
-self)
+)
 res = dia.startProcess(args)
 if res:
 dia.exec()
 if isinstance(name, list):
 self.__forgotNames.extend(name)
 else:
 self.__forgotNames.append(name)
 def hgBackout(self):
 """
 Public method used to backout an earlier changeset from the Mercurial
 repository.
 """
 from .HgBackoutDialog import HgBackoutDialog
-dlg = HgBackoutDialog(self.hgGetTagsList(),
-self.hgGetBranchesList(),
+dlg = HgBackoutDialog(
-self.hgGetBookmarksList())
+self.hgGetTagsList(), self.hgGetBranchesList(), self.hgGetBookmarksList()
+)
 if dlg.exec() == QDialog.DialogCode.Accepted:
 rev, merge, date, user, message = dlg.getParameters()
 if not rev:
 EricMessageBox.warning(
 self.__ui,
 self.tr("Backing out changeset"),
-self.tr("""No revision given. Aborting..."""))
+self.tr("""No revision given. Aborting..."""),
+)
 return
 args = self.initCommand("backout")
-args.append('-v')
+args.append("-v")
 if merge:
-args.append('--merge')
+args.append("--merge")
 if date:
-args.append('--date')
+args.append("--date")
 args.append(date)
 if user:
-args.append('--user')
+args.append("--user")
 args.append(user)
-args.append('--message')
+args.append("--message")
 args.append(message)
 args.append(rev)
-dia = HgDialog(self.tr('Backing out changeset'), self)
+dia = HgDialog(self.tr("Backing out changeset"), self)
 res = dia.startProcess(args)
 if res:
 dia.exec()
 def hgRollback(self):
 """
 Public method used to rollback the last transaction.
 """
 res = EricMessageBox.yesNo(
 None,
 self.tr("Rollback last transaction"),
-self.tr("""Are you sure you want to rollback the last"""
+self.tr(
-""" transaction?"""),
+"""Are you sure you want to rollback the last""" """ transaction?"""
-icon=EricMessageBox.Warning)
+),
+icon=EricMessageBox.Warning,
+)
 if res:
-dia = HgDialog(self.tr('Rollback last transaction'), self)
+dia = HgDialog(self.tr("Rollback last transaction"), self)
 res = dia.startProcess(["rollback"])
 if res:
 dia.exec()
 def hgServe(self, repoPath):
 """
 Public method used to serve the project.
 @param repoPath directory containing the repository
 @type str
 """
 from .HgServeDialog import HgServeDialog
 self.serveDlg = HgServeDialog(self, repoPath)
 self.serveDlg.show()
 def hgImport(self):
 """
 Public method to import a patch file.
 @return flag indicating, that the import contained an add, a delete
 or a change to the project file (boolean)
 """
 from .HgImportDialog import HgImportDialog
 dlg = HgImportDialog(self)
 if dlg.exec() == QDialog.DialogCode.Accepted:
-(patchFile, noCommit, message, date, user, withSecret, stripCount,
+(
-force) = dlg.getParameters()
+patchFile,
+noCommit,
+message,
+date,
+user,
+withSecret,
+stripCount,
+force,
+) = dlg.getParameters()
 args = self.initCommand("import")
 args.append("--verbose")
 if noCommit:
 args.append("--no-commit")
 else:
 if message:
-args.append('--message')
+args.append("--message")
 args.append(message)
 if date:
-args.append('--date')
+args.append("--date")
 args.append(date)
 if user:
-args.append('--user')
+args.append("--user")
 args.append(user)
 if stripCount != 1:
 args.append("--strip")
 args.append(str(stripCount))
 if force:
 args.append("--force")
 if withSecret:
 args.append("--secret")
 args.append(patchFile)
 dia = HgDialog(self.tr("Import Patch"), self)
 res = dia.startProcess(args)
 if res:
 dia.exec()
 res = dia.hasAddOrDelete()
 self.checkVCSStatus()
 else:
 res = False
 return res
 def hgExport(self):
 """
 Public method to export patches to files.
 """
 from .HgExportDialog import HgExportDialog
-dlg = HgExportDialog(self.hgGetBookmarksList(),
-self.version >= (4, 7, 0))
+dlg = HgExportDialog(self.hgGetBookmarksList(), self.version >= (4, 7, 0))
 if dlg.exec() == QDialog.DialogCode.Accepted:
-(filePattern, revisions, bookmark, switchParent, allText,
+(
-noDates, git) = dlg.getParameters()
+filePattern,
+revisions,
+bookmark,
+switchParent,
+allText,
+noDates,
+git,
+) = dlg.getParameters()
 args = self.initCommand("export")
 args.append("--output")
 args.append(filePattern)
 args.append("--verbose")
 if switchParent:
 args.append("--bookmark")
 args.append(bookmark)
 else:
 for rev in revisions:
 args.append(rev)
 dia = HgDialog(self.tr("Export Patches"), self)
 res = dia.startProcess(args)
 if res:
 dia.exec()
 def hgPhase(self, data=None):
 """
 Public method to change the phase of revisions.
 @param data tuple giving phase data (list of revisions, phase, flag
 indicating a forced operation) (list of strings, string, boolean)
 @return flag indicating success (boolean)
 @exception ValueError raised to indicate an invalid phase
 """
 if data is None:
 from .HgPhaseDialog import HgPhaseDialog
 dlg = HgPhaseDialog()
 if dlg.exec() == QDialog.DialogCode.Accepted:
 data = dlg.getData()
 if data:
 revs, phase, force = data
 if phase not in ("p", "d", "s"):
 raise ValueError("Invalid phase given.")
 args = self.initCommand("phase")
 if phase == "p":
 args.append("--public")
 elif phase == "d":
 args.append("--draft")
 else:
 args.append("--secret")
 if force:
 args.append("--force")
 for rev in revs:
 args.append(rev)
 dia = HgDialog(self.tr("Change Phase"), self)
 res = dia.startProcess(args)
 if res:
 dia.exec()
 res = dia.normalExitWithoutErrors()
 else:
 res = False
 return res
 def hgGraft(self, revs=None):
 """
 Public method to copy changesets from another branch.
 @param revs list of revisions to show in the revisions pane (list of
 strings)
 @return flag indicating that the project should be reread (boolean)
 """
 from .HgGraftDialog import HgGraftDialog
 res = False
 dlg = HgGraftDialog(self, revs)
 if dlg.exec() == QDialog.DialogCode.Accepted:
-(revs,
+(
-(userData, currentUser, userName),
+revs,
-(dateData, currentDate, dateStr),
+(userData, currentUser, userName),
-log, dryrun, noCommit) = dlg.getData()
+(dateData, currentDate, dateStr),
+log,
+dryrun,
+noCommit,
+) = dlg.getData()
 args = self.initCommand("graft")
 args.append("--verbose")
 if userData:
 if currentUser:
 args.append("--currentuser")
 if dryrun:
 args.append("--dry-run")
 if noCommit:
 args.append("--no-commit")
 args.extend(revs)
-dia = HgDialog(self.tr('Copy Changesets'), self)
+dia = HgDialog(self.tr("Copy Changesets"), self)
 res = dia.startProcess(args)
 if res:
 dia.exec()
 res = dia.hasAddOrDelete()
 self.checkVCSStatus()
 return res
 def __hgGraftSubCommand(self, subcommand, title):
 """
 Private method to perform a Mercurial graft subcommand.
 @param subcommand subcommand flag
 @type str
 @param title tirle of the dialog
 @type str
 @return flag indicating that the project should be reread
 @rtype bool
 """
 args = self.initCommand("graft")
 args.append(subcommand)
 args.append("--verbose")
 dia = HgDialog(title, self)
 res = dia.startProcess(args)
 if res:
 dia.exec()
 res = dia.hasAddOrDelete()
 self.checkVCSStatus()
 return res
 def hgGraftContinue(self, path):
 """
 Public method to continue copying changesets from another branch.
 @param path directory name of the project
 @type str
 @return flag indicating that the project should be reread
 @rtype bool
 """
 return self.__hgGraftSubCommand(
-"--continue", self.tr('Copy Changesets (Continue)'))
+"--continue", self.tr("Copy Changesets (Continue)")
+)
 def hgGraftStop(self, path):
 """
 Public method to stop an interrupted copying session.
 @param path directory name of the project
 @type str
 @return flag indicating that the project should be reread
 @rtype bool
 """
-return self.__hgGraftSubCommand(
+return self.__hgGraftSubCommand("--stop", self.tr("Copy Changesets (Stop)"))
-"--stop", self.tr('Copy Changesets (Stop)'))
 def hgGraftAbort(self, path):
 """
 Public method to abort an interrupted copying session and perform
 a rollback.
 @param path directory name of the project
 @type str
 @return flag indicating that the project should be reread
 @rtype bool
 """
-return self.__hgGraftSubCommand(
+return self.__hgGraftSubCommand("--abort", self.tr("Copy Changesets (Abort)"))
-"--abort", self.tr('Copy Changesets (Abort)'))
 def hgArchive(self):
 """
 Public method to create an unversioned archive from the repository.
 """
 from .HgArchiveDialog import HgArchiveDialog
 dlg = HgArchiveDialog(self)
 if dlg.exec() == QDialog.DialogCode.Accepted:
 archive, type_, prefix, subrepos = dlg.getData()
 args = self.initCommand("archive")
 if type_:
 args.append("--type")
 args.append(type_)
 if prefix:
 args.append("--prefix")
 args.append(prefix)
 if subrepos:
 args.append("--subrepos")
 args.append(archive)
 dia = HgDialog(self.tr("Create Unversioned Archive"), self)
 res = dia.startProcess(args)
 if res:
 dia.exec()
 def hgDeleteBackups(self):
 """
 Public method to delete all backup bundles in the backup area.
 """
-backupdir = os.path.join(self.getClient().getRepository(),
+backupdir = os.path.join(
-self.adminDir, "strip-backup")
+self.getClient().getRepository(), self.adminDir, "strip-backup"
+)
 yes = EricMessageBox.yesNo(
 self.__ui,
 self.tr("Delete All Backups"),
 self.tr(
 """<p>Do you really want to delete all backup bundles"""
 """ stored in the backup area?<br/><b>{0}</b></p>"""
-).format(backupdir)
+).format(backupdir),
 )
 if yes:
 shutil.rmtree(backupdir, True)
 ###########################################################################
 ## Methods to deal with sub-repositories are below.
 ###########################################################################
 def getHgSubPath(self):
 """
 Public method to get the path to the .hgsub file containing the
 definitions of sub-repositories.
 @return full path of the .hgsub file (string)
 """
 ppath = self.__projectHelper.getProject().getProjectPath()
 return os.path.join(ppath, ".hgsub")
 def hasSubrepositories(self):
 """
 Public method to check, if the project might have sub-repositories.
 @return flag indicating the existence of sub-repositories (boolean)
 """
 hgsub = self.getHgSubPath()
 return os.path.isfile(hgsub) and os.stat(hgsub).st_size > 0
 def hgAddSubrepository(self):
 """
 Public method to add a sub-repository.
 """
 from .HgAddSubrepositoryDialog import HgAddSubrepositoryDialog
 ppath = self.__projectHelper.getProject().getProjectPath()
 hgsub = self.getHgSubPath()
 dlg = HgAddSubrepositoryDialog(ppath)
 if dlg.exec() == QDialog.DialogCode.Accepted:
 relPath, subrepoType, subrepoUrl = dlg.getData()
 if subrepoType == "hg":
 url = subrepoUrl
 else:
 url = "[{0}]{1}".format(subrepoType, subrepoUrl)
 entry = "{0} = {1}\n".format(relPath, url)
 contents = []
 if os.path.isfile(hgsub):
 # file exists; check, if such an entry exists already
 needsAdd = False
 try:
 EricMessageBox.critical(
 self.__ui,
 self.tr("Add Sub-repository"),
 self.tr(
 """<p>The sub-repositories file .hgsub could not"""
-""" be read.</p><p>Reason: {0}</p>""")
+""" be read.</p><p>Reason: {0}</p>"""
-.format(str(err)))
+).format(str(err)),
+)
 return
 if entry in contents:
 EricMessageBox.critical(
 self.__ui,
 self.tr("Add Sub-repository"),
 self.tr(
 """<p>The sub-repositories file .hgsub already"""
 """ contains an entry <b>{0}</b>."""
-""" Aborting...</p>""").format(entry))
+""" Aborting...</p>"""
+).format(entry),
+)
 return
 else:
 needsAdd = True
 if contents and not contents[-1].endswith("\n"):
 contents[-1] = contents[-1] + "\n"
 contents.append(entry)
 try:
 with open(hgsub, "w") as f:
 EricMessageBox.critical(
 self.__ui,
 self.tr("Add Sub-repository"),
 self.tr(
 """<p>The sub-repositories file .hgsub could not"""
-""" be written to.</p><p>Reason: {0}</p>""")
+""" be written to.</p><p>Reason: {0}</p>"""
-.format(str(err)))
+).format(str(err)),
+)
 return
 if needsAdd:
 self.vcsAdd(hgsub)
 self.__projectHelper.getProject().appendFile(hgsub)
 def hgRemoveSubrepositories(self):
 """
 Public method to remove sub-repositories.
 """
 hgsub = self.getHgSubPath()
 subrepositories = []
 if not os.path.isfile(hgsub):
 EricMessageBox.critical(
 self.__ui,
 self.tr("Remove Sub-repositories"),
-self.tr("""<p>The sub-repositories file .hgsub does not"""
+self.tr(
-""" exist. Aborting...</p>"""))
+"""<p>The sub-repositories file .hgsub does not"""
+""" exist. Aborting...</p>"""
+),
+)
 return
 try:
 with open(hgsub, "r") as f:
 subrepositories = [line.strip() for line in f.readlines()]
 except OSError as err:
 EricMessageBox.critical(
 self.__ui,
 self.tr("Remove Sub-repositories"),
-self.tr("""<p>The sub-repositories file .hgsub could not"""
+self.tr(
-""" be read.</p><p>Reason: {0}</p>""")
+"""<p>The sub-repositories file .hgsub could not"""
-.format(str(err)))
+""" be read.</p><p>Reason: {0}</p>"""
+).format(str(err)),
+)
 return
-from .HgRemoveSubrepositoriesDialog import (
+from .HgRemoveSubrepositoriesDialog import HgRemoveSubrepositoriesDialog
-HgRemoveSubrepositoriesDialog
-)
 dlg = HgRemoveSubrepositoriesDialog(subrepositories)
 if dlg.exec() == QDialog.DialogCode.Accepted:
 subrepositories, removedSubrepos, deleteSubrepos = dlg.getData()
 contents = "\n".join(subrepositories) + "\n"
 try:
 EricMessageBox.critical(
 self.__ui,
 self.tr("Remove Sub-repositories"),
 self.tr(
 """<p>The sub-repositories file .hgsub could not"""
-""" be written to.</p><p>Reason: {0}</p>""")
+""" be written to.</p><p>Reason: {0}</p>"""
-.format(str(err)))
+).format(str(err)),
+)
 return
 if deleteSubrepos:
 ppath = self.__projectHelper.getProject().getProjectPath()
 for removedSubrepo in removedSubrepos:
 subrepoPath = removedSubrepo.split("=", 1)[0].strip()
 subrepoAbsPath = os.path.join(ppath, subrepoPath)
 shutil.rmtree(subrepoAbsPath, True)
 ###########################################################################
 ## Methods to handle configuration dependent stuff are below.
 ###########################################################################
 def __checkDefaults(self):
 """
 Private method to check, if the default and default-push URLs
 have been configured.
 """
 args = self.initCommand("showconfig")
-args.append('paths')
+args.append("paths")
 output, error = self.__client.runcommand(args)
 self.__defaultConfigured = False
 self.__defaultPushConfigured = False
 if output:
 for line in output.splitlines():
 line = line.strip()
-if (
+if line.startswith("paths.default=") and not line.endswith("="):
-line.startswith("paths.default=") and
-not line.endswith("=")
-):
 self.__defaultConfigured = True
-if (
+if line.startswith("paths.default-push=") and not line.endswith("="):
-line.startswith("paths.default-push=") and
-not line.endswith("=")
-):
 self.__defaultPushConfigured = True
 def canCommitMerge(self):
 """
 Public method to check, if the working directory is an uncommitted
 merge.
 @return flag indicating commit merge capability
 @rtype bool
 """
 args = self.initCommand("identify")
 output, error = self.__client.runcommand(args)
-return output.count('+') == 2
+return output.count("+") == 2
 def canPull(self):
 """
 Public method to check, if pull is possible.
 @return flag indicating pull capability (boolean)
 """
 return self.__defaultConfigured
 def canPush(self):
 """
 Public method to check, if push is possible.
 @return flag indicating push capability (boolean)
 """
 return self.__defaultPushConfigured or self.__defaultConfigured
 def __iniFileChanged(self, path):
 """
 Private slot to handle a change of the Mercurial configuration file.
 @param path name of the changed file (string)
 """
 if self.__client:
 ok, err = self.__client.restartServer()
 if not ok:
 EricMessageBox.warning(
 None,
 self.tr("Mercurial Command Server"),
 self.tr(
 """<p>The Mercurial Command Server could not be"""
-""" restarted.</p><p>Reason: {0}</p>""").format(err))
+""" restarted.</p><p>Reason: {0}</p>"""
+).format(err),
+)
 self.__getExtensionsInfo()
 if self.__repoIniFile and path == self.__repoIniFile:
 self.__checkDefaults()
 self.iniFileChanged.emit()
 def __monitorRepoIniFile(self, repodir):
 """
 Private slot to add a repository configuration file to the list of
 monitored files.
 @param repodir directory name of the repository
 @type str
 """
 cfgFile = os.path.join(repodir, self.adminDir, "hgrc")
 if os.path.exists(cfgFile):
 self.__iniWatcher.addPath(cfgFile)
 self.__repoIniFile = cfgFile
 self.__checkDefaults()
 ###########################################################################
 ## Methods to handle extensions are below.
 ###########################################################################
 def __getExtensionsInfo(self):
 """
 Private method to get the active extensions from Mercurial.
 """
 activeExtensions = sorted(self.__activeExtensions)
 self.__activeExtensions = []
 args = self.initCommand("showconfig")
-args.append('extensions')
+args.append("extensions")
 output, error = self.__client.runcommand(args)
 if output:
 for line in output.splitlines():
-extensionName = (
+extensionName = line.split("=", 1)[0].strip().split(".")[-1].strip()
-line.split("=", 1)[0].strip().split(".")[-1].strip()
-)
 self.__activeExtensions.append(extensionName)
 if self.version < (4, 8, 0) and "closehead" in self.__activeExtensions:
 self.__activeExtensions.remove["closehead"]
 if activeExtensions != sorted(self.__activeExtensions):
 self.activeExtensionsChanged.emit()
 def isExtensionActive(self, extensionName):
 """
 Public method to check, if an extension is active.
 @param extensionName name of the extension to check for (string)
 @return flag indicating an active extension (boolean)
 """
 extensionName = extensionName.strip()
 isActive = extensionName in self.__activeExtensions
 return isActive
 def getExtensionObject(self, extensionName):
 """
 Public method to get a reference to an extension object.
 @param extensionName name of the extension (string)
 @return reference to the extension object (boolean)
 """
 return self.__extensions[extensionName]
 ###########################################################################
 ## Methods to get the helper objects are below.
 ###########################################################################
-def vcsGetProjectBrowserHelper(self, browser, project,
+def vcsGetProjectBrowserHelper(self, browser, project, isTranslationsBrowser=False):
-isTranslationsBrowser=False):
 """
 Public method to instantiate a helper object for the different
 project browsers.
 @param browser reference to the project browser object
 @param project reference to the project object
 @param isTranslationsBrowser flag indicating, the helper is requested
 for the translations browser (this needs some special treatment)
 @return the project browser helper object
 """
 from .ProjectBrowserHelper import HgProjectBrowserHelper
-return HgProjectBrowserHelper(self, browser, project,
-isTranslationsBrowser)
+return HgProjectBrowserHelper(self, browser, project, isTranslationsBrowser)
 def vcsGetProjectHelper(self, project):
 """
 Public method to instantiate a helper object for the project.
 @param project reference to the project object
 @return the project helper object
 """
 # find the root of the repo
 repodir = project.getProjectPath()
 while not os.path.isdir(os.path.join(repodir, self.adminDir)):
 repodir = os.path.dirname(repodir)
 if not repodir or os.path.splitdrive(repodir)[1] == os.sep:
 repodir = ""
 break
 self.__projectHelper = self.__plugin.getProjectHelper()
 self.__projectHelper.setObjects(self, project)
 if repodir:
 self.__repoDir = repodir
 self.__createClient(repodir)
 self.__monitorRepoIniFile(repodir)
 return self.__projectHelper
 ###########################################################################
 ## Methods to handle the Mercurial command server are below.
 ###########################################################################
 def __createClient(self, repodir=""):
 """
 Private method to create a Mercurial command server client.
 @param repodir path of the local repository
 @type str
 """
 self.stopClient()
 self.__client = HgClient(repodir, "utf-8", self)
 ok, err = self.__client.startServer()
 if not ok:
 EricMessageBox.warning(
 None,
 self.tr("Mercurial Command Server"),
 self.tr(
 """<p>The Mercurial Command Server could not be"""
-""" started.</p><p>Reason: {0}</p>""").format(err))
+""" started.</p><p>Reason: {0}</p>"""
+).format(err),
+)
 def getClient(self):
 """
 Public method to get a reference to the command server interface.
 @return reference to the client (HgClient)
 """
 if self.__client is None:
 self.__createClient(self.__repoDir)
 return self.__client
 def stopClient(self):
 """
 Public method to stop the command server client.
 """
 if self.__client is not None:
 self.__client.stopServer()
 self.__client = None
 ###########################################################################
 ## Status Monitor Thread methods
 ###########################################################################
 def _createStatusMonitorThread(self, interval, project):
 """
 Protected method to create an instance of the VCS status monitor
 thread.
 @param interval check interval for the monitor thread in seconds
 (integer)
 @param project reference to the project object (Project)
 @return reference to the monitor thread (QThread)
 """
 from .HgStatusMonitorThread import HgStatusMonitorThread
 return HgStatusMonitorThread(interval, project, self)
 ###########################################################################
 ## Bookmarks methods
 ###########################################################################
 def hgListBookmarks(self):
 """
 Public method used to list the available bookmarks.
 """
 self.bookmarksList = []
 if self.bookmarksListDlg is None:
 from .HgBookmarksListDialog import HgBookmarksListDialog
 self.bookmarksListDlg = HgBookmarksListDialog(self)
 self.bookmarksListDlg.show()
 self.bookmarksListDlg.raise_()
 self.bookmarksListDlg.start(self.bookmarksList)
 def hgGetBookmarksList(self):
 """
 Public method to get the list of bookmarks.
 @return list of bookmarks (list of string)
 """
 args = self.initCommand("bookmarks")
 client = self.getClient()
 output = client.runcommand(args)[0]
 self.bookmarksList = []
 for line in output.splitlines():
 li = line.strip().split()
 if li[-1][0] in "1234567890":
 # last element is a rev:changeset
 del li[-1]
 if li[0] == "*":
 del li[0]
 name = " ".join(li)
 self.bookmarksList.append(name)
 return self.bookmarksList[:]
 def hgBookmarkDefine(self, revision=None, bookmark=None):
 """
 Public method to define a bookmark.
 @param revision revision to set bookmark for (string)
 @param bookmark name of the bookmark (string)
 """
 if bool(revision) and bool(bookmark):
 ok = True
 else:
 from .HgBookmarkDialog import HgBookmarkDialog
-dlg = HgBookmarkDialog(HgBookmarkDialog.DEFINE_MODE,
-self.hgGetTagsList(),
+dlg = HgBookmarkDialog(
-self.hgGetBranchesList(),
+HgBookmarkDialog.DEFINE_MODE,
-self.hgGetBookmarksList())
+self.hgGetTagsList(),
+self.hgGetBranchesList(),
+self.hgGetBookmarksList(),
+)
 if dlg.exec() == QDialog.DialogCode.Accepted:
 revision, bookmark = dlg.getData()
 ok = True
 else:
 ok = False
 if ok:
 args = self.initCommand("bookmarks")
 if revision:
 args.append("--rev")
 args.append(revision)
 args.append(bookmark)
-dia = HgDialog(self.tr('Mercurial Bookmark'), self)
+dia = HgDialog(self.tr("Mercurial Bookmark"), self)
 res = dia.startProcess(args)
 if res:
 dia.exec()
 def hgBookmarkDelete(self, bookmark=None):
 """
 Public method to delete a bookmark.
 @param bookmark name of the bookmark (string)
 """
 if bookmark:
 ok = True
 else:
 bookmark, ok = QInputDialog.getItem(
 None,
 self.tr("Delete Bookmark"),
 self.tr("Select the bookmark to be deleted:"),
 [""] + sorted(self.hgGetBookmarksList()),
-0, True)
+0,
+True,
+)
 if ok and bookmark:
 args = self.initCommand("bookmarks")
 args.append("--delete")
 args.append(bookmark)
-dia = HgDialog(self.tr('Delete Mercurial Bookmark'), self)
+dia = HgDialog(self.tr("Delete Mercurial Bookmark"), self)
 res = dia.startProcess(args)
 if res:
 dia.exec()
 def hgBookmarkRename(self, renameInfo=None):
 """
 Public method to rename a bookmark.
 @param renameInfo old and new names of the bookmark
 @type tuple of str and str
 """
 if not renameInfo:
 from .HgBookmarkRenameDialog import HgBookmarkRenameDialog
 dlg = HgBookmarkRenameDialog(self.hgGetBookmarksList())
 if dlg.exec() == QDialog.DialogCode.Accepted:
 renameInfo = dlg.getData()
 if renameInfo:
 args = self.initCommand("bookmarks")
 args.append("--rename")
 args.append(renameInfo[0])
 args.append(renameInfo[1])
-dia = HgDialog(self.tr('Rename Mercurial Bookmark'), self)
+dia = HgDialog(self.tr("Rename Mercurial Bookmark"), self)
 res = dia.startProcess(args)
 if res:
 dia.exec()
 def hgBookmarkMove(self, revision=None, bookmark=None):
 """
 Public method to move a bookmark.
 @param revision revision to set bookmark for (string)
 @param bookmark name of the bookmark (string)
 """
 if bool(revision) and bool(bookmark):
 ok = True
 else:
 from .HgBookmarkDialog import HgBookmarkDialog
-dlg = HgBookmarkDialog(HgBookmarkDialog.MOVE_MODE,
-self.hgGetTagsList(),
+dlg = HgBookmarkDialog(
-self.hgGetBranchesList(),
+HgBookmarkDialog.MOVE_MODE,
-self.hgGetBookmarksList())
+self.hgGetTagsList(),
+self.hgGetBranchesList(),
+self.hgGetBookmarksList(),
+)
 if dlg.exec() == QDialog.DialogCode.Accepted:
 revision, bookmark = dlg.getData()
 ok = True
 else:
 ok = False
 if ok:
 args = self.initCommand("bookmarks")
 args.append("--force")
 if revision:
 args.append("--rev")
 args.append(revision)
 args.append(bookmark)
-dia = HgDialog(self.tr('Move Mercurial Bookmark'), self)
+dia = HgDialog(self.tr("Move Mercurial Bookmark"), self)
 res = dia.startProcess(args)
 if res:
 dia.exec()
 def hgBookmarkIncoming(self):
 """
 Public method to show a list of incoming bookmarks.
 """
 from .HgBookmarksInOutDialog import HgBookmarksInOutDialog
 self.bookmarksInOutDlg = HgBookmarksInOutDialog(
-self, HgBookmarksInOutDialog.INCOMING)
+self, HgBookmarksInOutDialog.INCOMING
+)
 self.bookmarksInOutDlg.show()
 self.bookmarksInOutDlg.start()
 def hgBookmarkOutgoing(self):
 """
 Public method to show a list of outgoing bookmarks.
 """
 from .HgBookmarksInOutDialog import HgBookmarksInOutDialog
 self.bookmarksInOutDlg = HgBookmarksInOutDialog(
-self, HgBookmarksInOutDialog.OUTGOING)
+self, HgBookmarksInOutDialog.OUTGOING
+)
 self.bookmarksInOutDlg.show()
 self.bookmarksInOutDlg.start()
 def __getInOutBookmarks(self, incoming):
 """
 Private method to get the list of incoming or outgoing bookmarks.
 @param incoming flag indicating to get incoming bookmarks (boolean)
 @return list of bookmarks (list of string)
 """
 bookmarksList = []
 args = (
-self.initCommand("incoming")
+self.initCommand("incoming") if incoming else self.initCommand("outgoing")
-if incoming else
-self.initCommand("outgoing")
 )
-args.append('--bookmarks')
+args.append("--bookmarks")
 client = self.getClient()
 output = client.runcommand(args)[0]
 for line in output.splitlines():
 if line.startswith(" "):
 li = line.strip().split()
 del li[-1]
 name = " ".join(li)
 bookmarksList.append(name)
 return bookmarksList
 def hgBookmarkPull(self, current=False, bookmark=None):
 """
 Public method to pull a bookmark from a remote repository.
 @param current flag indicating to pull the current bookmark
 @type bool
 @param bookmark name of the bookmark
 @type str
 """
 bookmark, ok = QInputDialog.getItem(
 None,
 self.tr("Pull Bookmark"),
 self.tr("Select the bookmark to be pulled:"),
 [""] + sorted(bookmarks),
-0, True)
+0,
+True,
+)
 if ok and bookmark:
 args = self.initCommand("pull")
-args.append('--bookmark')
+args.append("--bookmark")
 args.append(bookmark)
-dia = HgDialog(self.tr(
+dia = HgDialog(
-'Pulling bookmark from a remote Mercurial repository'),
+self.tr("Pulling bookmark from a remote Mercurial repository"), self
-self)
+)
 res = dia.startProcess(args)
 if res:
 dia.exec()
 def hgBookmarkPush(self, current=False, bookmark=None, allBookmarks=False):
 """
 Public method to push a bookmark to a remote repository.
 @param current flag indicating to push the current bookmark
 @type bool
 @param bookmark name of the bookmark
 @type str
 @param allBookmarks flag indicating to push all bookmarks
 bookmark, ok = QInputDialog.getItem(
 None,
 self.tr("Push Bookmark"),
 self.tr("Select the bookmark to be push:"),
 [""] + sorted(bookmarks),
-0, True)
+0,
+True,
+)
 if ok and (bool(bookmark) or all):
 args = self.initCommand("push")
 if allBookmarks:
-args.append('--all-bookmarks')
+args.append("--all-bookmarks")
 else:
-args.append('--bookmark')
+args.append("--bookmark")
 args.append(bookmark)
-dia = HgDialog(self.tr(
+dia = HgDialog(
-'Pushing bookmark to a remote Mercurial repository'),
+self.tr("Pushing bookmark to a remote Mercurial repository"), self
-self)
+)
 res = dia.startProcess(args)
 if res:
 dia.exec()

Mercurial Repositories > eric / file comparison

comparison: src/eric7/Plugins/VcsPlugins/vcsMercurial/hg.py

src/eric7/Plugins/VcsPlugins/vcsMercurial/hg.py