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

-:2f70ca07f0af
+:4cd7e5a8b3cf
 def __init__(self, plugin, parent=None, name=None):
 """
 Constructor
 @param plugin reference to the plugin object
-@param parent parent widget (QWidget)
+@type VcsMercurialPlugin
-@param name name of this object (string)
+@param parent parent widget
+@type QWidget
+@param name name of this object
+@type str
 """
 from .CloseheadExtension.closehead import Closehead
 from .GpgExtension.gpg import Gpg
 from .HgUtilities import getConfigPath
 from .HisteditExtension.histedit import Histedit
 def getPlugin(self):
 """
 Public method to get a reference to the plugin object.
-@return reference to the plugin object (VcsMercurialPlugin)
+@return reference to the plugin object
+@rtype VcsMercurialPlugin
 """
 return self.__plugin
 def getEncoding(self):
 """
 Public method to get the encoding to be used by Mercurial.
-@return encoding (string)
+@return encoding
+@rtype str
 """
 return self.__plugin.getPreferences("Encoding")
 def vcsShutdown(self):
 """
 def initCommand(self, command):
 """
 Public method to initialize a command arguments list.
-@param command command name (string)
+@param command command name
-@return list of command options (list of string)
+@type str
+@return list of command options
+@rtype list of str
 """
 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
+@return flag indicating the existence and an error message
-(string)
+@rtype tuple of (bool, str)
 """
 from .HgUtilities import hgVersion
 self.versionStr, self.version, errMsg = hgVersion(self.__plugin)
 hgExists = errMsg == ""
 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 vcsDir name of the VCS directory
-@param noDialog flag indicating quiet operations (boolean)
+@type str
-@return always TRUE
+@param noDialog flag indicating quiet operations
+@type bool
+@return always True
+@rtype bool
 """
 return True
 def vcsConvertProject(self, vcsDataDict, project, 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)
+@param projectDir project directory
 @type str
 @param noDialog flag indicating quiet operations
 @type bool
 @param addAll flag indicating to add all files to the repository
 @type bool
 """
 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)
+@type dict
+@param projectDir project directory to create
+@type str
 @param noDialog flag indicating quiet operations
-@return flag indicating an execution without errors (boolean)
+@type bool
+@return flag indicating an execution without errors
+@rtype bool
 """
 noDialog = False
 try:
 rev = vcsDataDict["revision"]
 except KeyError:
 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)
+@type dict
-@return flag indicating an execution without errors (boolean)
+@param projectDir project directory to create
+@type str
+@return flag indicating an execution without errors
+@rtype bool
 """
 status = self.vcsCheckout(vcsDataDict, projectDir)
 shutil.rmtree(os.path.join(projectDir, self.adminDir), ignore_errors=True)
 if os.path.exists(os.path.join(projectDir, Hg.IgnoreFileName)):
 os.remove(os.path.join(projectDir, Hg.IgnoreFileName))
 ):
 """
 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
+@param name file/directory name to be committed
-strings)
+@type str or list of str
-@param message message for this operation (string)
+@param message message for this operation
+@type str
 @param noDialog flag indicating quiet operations
-@param closeBranch flag indicating a close branch commit (boolean)
+@type bool
-@param mq flag indicating a queue commit (boolean)
+@param closeBranch flag indicating a close branch commit
-@param merge flag indicating a merge commit (boolean)
+@type bool
+@param mq flag indicating a queue commit
+@type bool
+@param merge flag indicating a merge commit
+@type bool
 """
 from .HgCommitDialog import HgCommitDialog
 msg = message
 """
 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)
+@type str
-@param revision revision to update to (string)
+@param noDialog flag indicating quiet operations
-@return flag indicating, that the update contained an add
+@type bool
-or delete (boolean)
+@param revision revision to update to
+@type str
+@return flag indicating, that the update contained an add or delete
+@rtype bool
 """
 args = self.initCommand("update")
 if "-v" not in args and "--verbose" not in args:
 args.append("-v")
 if revision:
 def vcsAdd(self, name, isDir=False, noDialog=False):  # noqa: U100
 """
 Public method used to add a file/directory to the Mercurial repository.
-@param name file/directory name to be added (string)
+@param name file/directory name to be added
-@param isDir flag indicating name is a directory (boolean)
+@type str
+@param isDir flag indicating name is a directory
+@type bool
 @param noDialog flag indicating quiet operations
+@type bool
 """
 args = self.initCommand("add")
 args.append("-v")
 if isinstance(name, list):
 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 name file/directory name to be added
-@param isDir flag indicating name is a directory (boolean)
+@type str
+@param isDir flag indicating name is a directory
+@type bool
 """
 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
+@param path root directory of the tree to be added
-strings))
+@type str or list of str
 """
 self.vcsAdd(path, isDir=False)
 def vcsRemove(self, name, project=False, noDialog=False):  # noqa: U100
 """
 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
+@param name file/directory name to be removed
-strings))
+@type str or list of str
-@param project flag indicating deletion of a project tree (boolean)
+@param project flag indicating deletion of a project tree
-(not needed)
+@type bool
 @param noDialog flag indicating quiet operations
-@return flag indicating successfull operation (boolean)
+@type bool
+@return flag indicating successfull operation
+@rtype bool
 """
 args = self.initCommand("remove")
 args.append("-v")
 if noDialog and "--force" not in args:
 args.append("--force")
 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 name file/directory name to be moved
+@type str
 @param project reference to the project object
-@param target new name of the file/directory (string)
+@type Project
+@param target new name of the file/directory
+@type str
 @param noDialog flag indicating quiet operations
-@return flag indicating successfull operation (boolean)
+@type bool
+@return flag indicating successfull operation
+@rtype bool
 """
 from .HgCopyDialog import HgCopyDialog
 isDir = os.path.isdir(name)
 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)
+@param name file/directory name to be diffed
+@type str
 """
 from .HgDiffDialog import HgDiffDialog
 names = name[:] if isinstance(name, list) else [name]
 for nam in names:
 """
 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)
+@type str or list of str
 """
 from .HgStatusDialog import HgStatusDialog
 if self.status is None:
 self.status = HgStatusDialog(self)
 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 mq flag indicating to show the queue status as well
+@type bool
 @param largefiles flag indicating to show the largefiles status as
-well (boolean)
+well
+@type bool
 """
 from .HgSummaryDialog import HgSummaryDialog
 if self.summary is None:
 self.summary = HgSummaryDialog(self)
 def vcsTag(self, name=None, revision=None, tagName=None):  # noqa: U100
 """
 Public method used to set/remove a tag in the Mercurial repository.
 @param name file/directory name to determine the repo root from
-(string)
+@type str
-@param revision revision to set tag for (string)
+@param revision revision to set tag for
-@param tagName name of the tag (string)
+@type str
-@return flag indicating a performed tag action (boolean)
+@param tagName name of the tag
+@type str
+@return flag indicating a performed tag action
+@rtype bool
 """
 from .HgTagDialog import HgTagDialog
 dlg = HgTagDialog(self.hgGetTagsList(withType=True), revision, tagName)
 if dlg.exec() == QDialog.DialogCode.Accepted:
 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)
+@param name file/directory name to be merged
+@type str
 """
 from eric7.UI.DeleteFilesConfirmationDialog import DeleteFilesConfirmationDialog
 args = self.initCommand("resolve")
 if self.getPlugin().getPreferences("InternalMerge"):
 def vcsSwitch(self, name):
 """
 Public method used to switch a working directory to a different
 revision.
-@param name directory name to be switched (string)
+@param name directory name to be switched
-@return flag indicating, that the switch contained an add
+@type str
-or delete (boolean)
+@return flag indicating, that the switch contained an add or delete
+@rtype bool
 """
 from .HgRevisionSelectionDialog import HgRevisionSelectionDialog
 dlg = HgRevisionSelectionDialog(
 self.hgGetTagsList(),
 """
 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
+@return registered state (one of canBeCommited and canBeAdded)
 @rtype int
 """
 if name.endswith(os.sep):
 name = name[:-1]
 name = os.path.normcase(name)
 <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)
+@type dict
-@param shortcut flag indicating a shortcut should be taken (boolean)
+@param dname directory to check in
+@type str
+@param shortcut flag indicating a shortcut should be taken
+@type bool
 @return the received dictionary completed with a combination of
 canBeCommited and canBeAdded or None in order to signal an error
+@rtype dict
 """
 if dname.endswith(os.sep):
 dname = dname[:-1]
 dname = os.path.normcase(dname)
 def vcsName(self):
 """
 Public method returning the name of the vcs.
-@return always 'Mercurial' (string)
+@return always 'Mercurial'
+@rtype str
 """
 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)
+@param project reference to the project
+@type Project
 """
 ppath = project.getProjectPath()
 if ppath:
 ignoreName = os.path.join(ppath, Hg.IgnoreFileName)
 if not os.path.exists(ignoreName):
 def vcsCleanup(self, name):
 """
 Public method used to cleanup the working directory.
-@param name directory name to be cleaned up (string)
+@param name directory name to be cleaned up
+@type str
 """
 patterns = self.getPlugin().getPreferences("CleanupPatterns").split()
 entries = []
 for pat in patterns:
 def vcsCommandLine(self, name):
 """
 Public method used to execute arbitrary mercurial commands.
-@param name directory name of the working directory (string)
+@param name directory name of the working directory
+@type str
 """
 from .HgCommandDialog import HgCommandDialog
 dlg = HgCommandDialog(self.commandHistory, name)
 if dlg.exec() == QDialog.DialogCode.Accepted:
 ):
 """
 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)
+@type Project
+@param archive name of the project in the repository
+@type str
 @param editable flag indicating that the project name is editable
-(boolean)
+@type bool
-@param parent parent widget (QWidget)
+@param parent parent widget
-@return reference to the instantiated options dialog (HgOptionsDialog)
+@type QWidget
+@return reference to the instantiated options dialog
+@rtype 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)
+@param parent parent widget
+@type QWidget
 @return reference to the instantiated options dialog
-(HgNewProjectOptionsDialog)
+@rtype HgNewProjectOptionsDialog
 """
 from .HgNewProjectOptionsDialog import HgNewProjectOptionsDialog
 return HgNewProjectOptionsDialog(self, parent)
 def vcsRepositoryInfos(self, ppath):  # noqa: U100
 """
 Public method to retrieve information about the repository.
-@param ppath local path to get the repository infos (string)
+@param ppath local path to get the repository infos
-@return string with ready formated info for display (string)
+@type str
+@return string with ready formated info for display
+@rtype str
 """
 args = self.initCommand("log")
 args.extend(
 [
 "--template",
 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)
+@rtype bool
 """
 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)
+@param url url string
-@return properly normalized url for mercurial (string)
+@type str
+@return properly normalized url for mercurial
+@rtype str
 """
 url = url.replace("\\", "/")
 if url.endswith("/"):
 url = url[:-1]
 urll = url.split("//")
 def hgCopy(self, name, project):
 """
 Public method used to copy a file/directory.
-@param name file/directory name to be copied (string)
+@param name file/directory name to be copied
+@type str
 @param project reference to the project object
-@return flag indicating successful operation (boolean)
+@type Project
+@return flag indicating successful operation
+@rtype bool
 """
 from .HgCopyDialog import HgCopyDialog
 dlg = HgCopyDialog(name)
 res = False
 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)
+@param withType flag indicating to get the tag type as well
-@return list of tags (list of string) or list of tuples of
+@type bool
-tag name and flag indicating a local tag (list of tuple of string
+@return list of tags or list of tuples of tag name and flag indicating
-and boolean), if withType is True
+a local tag, if withType is True
+@rtype list of str or list of [(str, bool)]
 """
 args = self.initCommand("tags")
 args.append("--verbose")
 output, error = self.__client.runcommand(args)
 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)
+@type bool
 """
 from .HgTagBranchListDialog import HgTagBranchListDialog
 self.tagbranchList = HgTagBranchListDialog(self)
 self.tagbranchList.show()
 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)
+@param name file/directory name to be diffed
+@type str
 """
 from .HgDiffDialog import HgDiffDialog
 from .HgRevisionsSelectionDialog import HgRevisionsSelectionDialog
 names = name[:] if isinstance(name, list) else [name]
 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 name file name to get from the repository
-@param rev revision to retrieve (string)
+@type str
-@return contents of the file (string) and an error message (string)
+@param rev revision to retrieve
+@type str
+@return contents of the file (string) and an error message
+@rtype str
 """
 args = self.initCommand("cat")
 if rev:
 args.append("--rev")
 args.append(rev)
 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 name file name to be diffed
-@param extended flag indicating the extended variant (boolean)
+@type str
-@param revisions tuple of two revisions (tuple of strings)
+@param extended flag indicating the extended variant
+@type bool
+@param revisions tuple of two revisions
+@type tuple of (str, str)
 @exception ValueError raised to indicate an invalid name parameter
 """
 from eric7.UI.CompareDialog import CompareDialog
 from .HgRevisionsSelectionDialog import HgRevisionsSelectionDialog
 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 name file/directory name to show the log of
+@type str
 @param isFile flag indicating log for a file is to be shown
-(boolean)
+@type bool
 """
 from .HgLogBrowserDialog import HgLogBrowserDialog
 if name == self.getClient().getRepository():
 name = None
 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 force flag indicating a forced push
-@param newBranch flag indicating to push a new branch (boolean)
+@type bool
-@param rev revision to be pushed (including all ancestors) (string)
+@param newBranch flag indicating to push a new branch
+@type bool
+@param rev revision to be pushed (including all ancestors)
+@type str
 """
 args = self.initCommand("push")
 args.append("-v")
 if force:
 args.append("-f")
 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,
+@param mode mode of the operation (one of 'heads', 'parents', 'tip')
-tip)
+@type str
 """
 if mode not in ("heads", "parents", "tip"):
 mode = "heads"
 info = []
 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 name file/directory name to be resolved
+@type str
 @param unresolve flag indicating to mark the file/directory as
-unresolved (boolean)
+unresolved
+@type bool
 """
 args = self.initCommand("resolve")
 if unresolve:
 args.append("--unmark")
 else:
 def hgAbortMerge(self):
 """
 Public method to abort an uncommitted merge.
-@return flag indicating, that the abortion contained an add
+@return flag indicating, that the abortion contained an add or delete
-or delete (boolean)
+@rtype bool
 """
 if self.version >= (4, 5, 0):
 args = self.initCommand("merge")
 args.append("--abort")
 else:
 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 name directory name to create the ignore file in
-@param autoAdd flag indicating to add it automatically (boolean)
+@type str
+@param autoAdd flag indicating to add it automatically
+@type bool
 @return flag indicating success
+@rtype bool
 """
 status = False
 ignorePatterns = [
 "glob:.eric6project",
 "glob:.eric7project",
 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)
+or a change to the project file
+@rtype bool
 """
 from .HgImportDialog import HgImportDialog
 dlg = HgImportDialog(self)
 if dlg.exec() == QDialog.DialogCode.Accepted:
 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)
+indicating a forced operation)
-@return flag indicating success (boolean)
+@type tuple of (list of str, str, bool)
+@return flag indicating success
+@rtype bool
 @exception ValueError raised to indicate an invalid phase
 """
 from .HgPhaseDialog import HgPhaseDialog
 if data is None:
 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
+@param revs list of revisions to show in the revisions pane
-strings)
+@type list of str
-@return flag indicating that the project should be reread (boolean)
+@return flag indicating that the project should be reread
+@rtype bool
 """
 from .HgGraftDialog import HgGraftDialog
 res = False
 dlg = HgGraftDialog(self, revs)
 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)
+@return full path of the .hgsub file
+@rtype str
 """
 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)
+@return flag indicating the existence of sub-repositories
+@rtype bool
 """
 hgsub = self.getHgSubPath()
 return os.path.isfile(hgsub) and os.stat(hgsub).st_size > 0
 def hgAddSubrepository(self):
 def canPull(self):
 """
 Public method to check, if pull is possible.
-@return flag indicating pull capability (boolean)
+@return flag indicating pull capability
+@rtype bool
 """
 return self.__defaultConfigured
 def canPush(self):
 """
 Public method to check, if push is possible.
-@return flag indicating push capability (boolean)
+@return flag indicating push capability
+@rtype bool
 """
 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)
+@param path name of the changed file
+@type str
 """
 if self.__client:
 ok, err = self.__client.restartServer()
 if not ok:
 EricMessageBox.warning(
 def isExtensionActive(self, extensionName):
 """
 Public method to check, if an extension is active.
-@param extensionName name of the extension to check for (string)
+@param extensionName name of the extension to check for
-@return flag indicating an active extension (boolean)
+@type str
+@return flag indicating an active extension
+@rtype bool
 """
 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)
+@param extensionName name of the extension
-@return reference to the extension object (boolean)
+@type str
+@return reference to the extension object
+@rtype bool
 """
 return self.__extensions[extensionName]
 ###########################################################################
 ## Methods to get the helper objects are below.
 """
 Public method to instantiate a helper object for the different
 project browsers.
 @param browser reference to the project browser object
+@type ProjectBaseBrowser
 @param project reference to the project object
+@type Project
 @param isTranslationsBrowser flag indicating, the helper is requested
 for the translations browser (this needs some special treatment)
+@type bool
 @return the project browser helper object
+@rtype HgProjectBrowserHelper
 """
 from .ProjectBrowserHelper import HgProjectBrowserHelper
 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
+@type Project
 @return the project helper object
+@rtype HgProjectHelper
 """
 # find the root of the repo
 repodir = project.getProjectPath()
 while repodir and not os.path.isdir(os.path.join(repodir, self.adminDir)):
 repodir = os.path.dirname(repodir)
 def getClient(self):
 """
 Public method to get a reference to the command server interface.
-@return reference to the client (HgClient)
+@return reference to the client
+@rtype HgClient
 """
 if self.__client is None:
 self.__createClient(self.__repoDir)
 return self.__client
 """
 Protected method to create an instance of the VCS status monitor
 thread.
 @param interval check interval for the monitor thread in seconds
-(integer)
+@type int
-@param project reference to the project object (Project)
+@param project reference to the project object
-@return reference to the monitor thread (QThread)
+@type Project
+@return reference to the monitor thread
+@rtype HgStatusMonitorThread
 """
 from .HgStatusMonitorThread import HgStatusMonitorThread
 return HgStatusMonitorThread(interval, project, self)
 def hgGetBookmarksList(self):
 """
 Public method to get the list of bookmarks.
-@return list of bookmarks (list of string)
+@return list of bookmarks
+@rtype list of str
 """
 args = self.initCommand("bookmarks")
 client = self.getClient()
 output = client.runcommand(args)[0]
 def hgBookmarkDefine(self, revision=None, bookmark=None):
 """
 Public method to define a bookmark.
-@param revision revision to set bookmark for (string)
+@param revision revision to set bookmark for
-@param bookmark name of the bookmark (string)
+@type str
+@param bookmark name of the bookmark
+@type str
 """
 from .HgBookmarkDialog import HgBookmarkDialog
 if bool(revision) and bool(bookmark):
 ok = True
 def hgBookmarkDelete(self, bookmark=None):
 """
 Public method to delete a bookmark.
-@param bookmark name of the bookmark (string)
+@param bookmark name of the bookmark
+@type str
 """
 if bookmark:
 ok = True
 else:
 bookmark, ok = QInputDialog.getItem(
 def hgBookmarkMove(self, revision=None, bookmark=None):
 """
 Public method to move a bookmark.
-@param revision revision to set bookmark for (string)
+@param revision revision to set bookmark for
-@param bookmark name of the bookmark (string)
+@type str
+@param bookmark name of the bookmark
+@type str
 """
 from .HgBookmarkDialog import HgBookmarkDialog
 if bool(revision) and bool(bookmark):
 ok = True
 def __getInOutBookmarks(self, incoming):
 """
 Private method to get the list of incoming or outgoing bookmarks.
-@param incoming flag indicating to get incoming bookmarks (boolean)
+@param incoming flag indicating to get incoming bookmarks
-@return list of bookmarks (list of string)
+@type bool
+@return list of bookmarks
+@rtype list of str
 """
 bookmarksList = []
 args = (
 self.initCommand("incoming") if incoming else self.initCommand("outgoing")

Mercurial Repositories > eric / file comparison

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

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