mercurial-scm/hg: comparison mercurial/interfaces/repository.py

equal deleted inserted replaced

-:57875cf423c9
+:2372284d9457
 # GNU General Public License version 2 or any later version.
 from __future__ import absolute_import
 from ..i18n import _
-from .. import (
+from .. import error
-error,
+from . import util as interfaceutil
-)
-from . import (
-util as interfaceutil,
-)
 # When narrowing is finalized and no longer subject to format changes,
 # we should move this to just "narrow" or similar.
 NARROW_REQUIREMENT = 'narrowhg-experimental'
 REVISION_FLAG_ELLIPSIS = 1 << 14
 REVISION_FLAG_EXTSTORED = 1 << 13
 REVISION_FLAG_SIDEDATA = 1 << 12
 REVISION_FLAGS_KNOWN = (
-REVISION_FLAG_CENSORED | REVISION_FLAG_ELLIPSIS | REVISION_FLAG_EXTSTORED
+REVISION_FLAG_CENSORED
+| REVISION_FLAG_ELLIPSIS
+| REVISION_FLAG_EXTSTORED
 | REVISION_FLAG_SIDEDATA
 )
 CG_DELTAMODE_STD = b'default'
 CG_DELTAMODE_PREV = b'previous'
 CG_DELTAMODE_FULL = b'fulltext'
 CG_DELTAMODE_P1 = b'p1'
 class ipeerconnection(interfaceutil.Interface):
 """Represents a "connection" to a repository.
 This is the base interface for representing a connection to a repository.
 It holds basic properties and methods applicable to all peer types.
 This is not a complete interface definition and should not be used
 outside of this module.
 """
 ui = interfaceutil.Attribute("""ui.ui instance""")
 def url():
 """Returns a URL string representing this peer.
 This is called when the peer will no longer be used. Resources
 associated with the peer should be cleaned up.
 """
 class ipeercapabilities(interfaceutil.Interface):
 """Peer sub-interface related to capabilities."""
 def capable(name):
 """Determine support for a named capability.
 def requirecap(name, purpose):
 """Require a capability to be present.
 Raises a ``CapabilityError`` if the capability isn't present.
 """
 class ipeercommands(interfaceutil.Interface):
 """Client-side interface for communicating over the wire protocol.
 This interface is used as a gateway to the Mercurial wire protocol.
 This is how the bulk of data during a push is transferred.
 Returns the integer number of heads added to the peer.
 """
 class ipeerlegacycommands(interfaceutil.Interface):
 """Interface for implementing support for legacy wire protocol commands.
 Wire protocol commands transition to legacy status when they are no longer
 def changegroup(nodes, source):
 """Obtain a changegroup with data for descendants of specified nodes."""
 def changegroupsubset(bases, heads, source):
 pass
 class ipeercommandexecutor(interfaceutil.Interface):
 """Represents a mechanism to execute remote commands.
 This is the primary interface for requesting that wire protocol commands
 When used as a context manager, this method is called when exiting the
 context manager.
 This method may call ``sendcommands()`` if there are buffered commands.
 """
 class ipeerrequests(interfaceutil.Interface):
 """Interface for executing commands on a peer."""
 limitedarguments = interfaceutil.Attribute(
 called commands until they are told to send them and that each
 command executor could result in a new connection or wire-level request
 being issued.
 """
 class ipeerbase(ipeerconnection, ipeercapabilities, ipeerrequests):
 """Unified interface for peer repositories.
 All peer instances must conform to this interface.
 """
 class ipeerv2(ipeerconnection, ipeercapabilities, ipeerrequests):
 """Unified peer interface for wire protocol version 2 peers."""
 apidescriptor = interfaceutil.Attribute(
-"""Data structure holding description of server API.""")
+"""Data structure holding description of server API."""
+)
 @interfaceutil.implementer(ipeerbase)
 class peer(object):
 """Base class for peer repositories."""
 return True
 name = '%s=' % name
 for cap in caps:
 if cap.startswith(name):
-return cap[len(name):]
+return cap[len(name) :]
 return False
 def requirecap(self, name, purpose):
 if self.capable(name):
 return
 raise error.CapabilityError(
-_('cannot %s; remote repository does not support the '
+_(
-'\'%s\' capability') % (purpose, name))
+'cannot %s; remote repository does not support the '
+'\'%s\' capability'
+)
+% (purpose, name)
+)
 class iverifyproblem(interfaceutil.Interface):
 """Represents a problem with the integrity of the repository.
 Instances of this interface are emitted to describe an integrity issue
 with a repository (e.g. corrupt storage, missing data, etc).
 Instances are essentially messages associated with severity.
 """
 warning = interfaceutil.Attribute(
-"""Message indicating a non-fatal problem.""")
+"""Message indicating a non-fatal problem."""
+)
-error = interfaceutil.Attribute(
-"""Message indicating a fatal problem.""")
+error = interfaceutil.Attribute("""Message indicating a fatal problem.""")
 node = interfaceutil.Attribute(
 """Revision encountering the problem.
 ``None`` means the problem doesn't apply to a single revision.
-""")
+"""
+)
 class irevisiondelta(interfaceutil.Interface):
 """Represents a delta between one revision and another.
 Instances convey enough information to allow a revision to be exchanged
 are mutually exclusive.
 Typically used for changegroup generation.
 """
-node = interfaceutil.Attribute(
+node = interfaceutil.Attribute("""20 byte node of this revision.""")
-"""20 byte node of this revision.""")
 p1node = interfaceutil.Attribute(
-"""20 byte node of 1st parent of this revision.""")
+"""20 byte node of 1st parent of this revision."""
+)
 p2node = interfaceutil.Attribute(
-"""20 byte node of 2nd parent of this revision.""")
+"""20 byte node of 2nd parent of this revision."""
+)
 linknode = interfaceutil.Attribute(
-"""20 byte node of the changelog revision this node is linked to.""")
+"""20 byte node of the changelog revision this node is linked to."""
+)
 flags = interfaceutil.Attribute(
 """2 bytes of integer flags that apply to this revision.
 This is a bitwise composition of the ``REVISION_FLAG_*`` constants.
-""")
+"""
+)
 basenode = interfaceutil.Attribute(
 """20 byte node of the revision this data is a delta against.
 ``nullid`` indicates that the revision is a full revision and not
 a delta.
-""")
+"""
+)
 baserevisionsize = interfaceutil.Attribute(
 """Size of base revision this delta is against.
 May be ``None`` if ``basenode`` is ``nullid``.
-""")
+"""
+)
 revision = interfaceutil.Attribute(
-"""Raw fulltext of revision data for this node.""")
+"""Raw fulltext of revision data for this node."""
+)
 delta = interfaceutil.Attribute(
 """Delta between ``basenode`` and ``node``.
 Stored in the bdiff delta format.
-""")
+"""
+)
 class ifilerevisionssequence(interfaceutil.Interface):
 """Contains index data for all revisions of a file.
 Types implementing this behave like lists of tuples. The index
 """Whether a revision number exists."""
 def insert(self, i, entry):
 """Add an item to the index at specific revision."""
 class ifileindex(interfaceutil.Interface):
 """Storage interface for index data of a single file.
 File storage data is divided into index metadata and data storage.
 This interface defines the index portion of the interface.
 * A mapping between revision numbers and nodes.
 * DAG data (storing and querying the relationship between nodes).
 * Metadata to facilitate storage.
 """
 def __len__():
 """Obtain the number of revisions stored for this file."""
 def __iter__():
 """Iterate over revision numbers for this file."""
 """Obtain nodes that are children of a node.
 Returns a list of nodes.
 """
 class ifiledata(interfaceutil.Interface):
 """Storage interface for data storage of a specific file.
 This complements ``ifileindex`` and provides an interface for accessing
 data for a tracked file.
 """
 def size(rev):
 """Obtain the fulltext size of file data.
 Any metadata is excluded from size measurements.
 """
 This takes copy metadata into account.
 TODO better document the copy metadata and censoring logic.
 """
-def emitrevisions(nodes,
+def emitrevisions(
-nodesorder=None,
+nodes,
-revisiondata=False,
+nodesorder=None,
-assumehaveparentrevisions=False,
+revisiondata=False,
-deltamode=CG_DELTAMODE_STD):
+assumehaveparentrevisions=False,
+deltamode=CG_DELTAMODE_STD,
+):
 """Produce ``irevisiondelta`` for revisions.
 Given an iterable of nodes, emits objects conforming to the
 ``irevisiondelta`` interface that describe revisions in storage.
 all revision data should be emitted as deltas against the revision
 emitted just prior. The initial revision should be a delta against its
 1st parent.
 """
 class ifilemutation(interfaceutil.Interface):
 """Storage interface for mutation events of a tracked file."""
 def add(filedata, meta, transaction, linkrev, p1, p2):
 """Add a new revision to the store.
 Returns the node that was added.
 May no-op if a revision matching the supplied data is already stored.
 """
-def addrevision(revisiondata, transaction, linkrev, p1, p2, node=None,
+def addrevision(
-flags=0, cachedelta=None):
+revisiondata,
+transaction,
+linkrev,
+p1,
+p2,
+node=None,
+flags=0,
+cachedelta=None,
+):
 """Add a new revision to the store.
 This is similar to ``add()`` except it operates at a lower level.
 The data passed in already contains a metadata header, if any.
 directory. ``addrevision()`` is often called by ``add()`` and for
 scenarios where revision data has already been computed, such as when
 applying raw data from a peer repo.
 """
-def addgroup(deltas, linkmapper, transaction, addrevisioncb=None,
+def addgroup(
-maybemissingparents=False):
+deltas,
+linkmapper,
+transaction,
+addrevisioncb=None,
+maybemissingparents=False,
+):
 """Process a series of deltas for storage.
 ``deltas`` is an iterable of 7-tuples of
 (node, p1, p2, linknode, deltabase, delta, flags) defining revisions
 to add.
 TODO this is highly revlog centric and should be abstracted into a
 higher-level deletion API.
 """
 class ifilestorage(ifileindex, ifiledata, ifilemutation):
 """Complete storage interface for a single tracked file."""
 def files():
 """Obtain paths that are backing storage for this file.
 TODO this is used heavily by verify code and there should probably
 be a better API for that.
 """
-def storageinfo(exclusivefiles=False, sharedfiles=False,
+def storageinfo(
-revisionscount=False, trackedsize=False,
+exclusivefiles=False,
-storedsize=False):
+sharedfiles=False,
+revisionscount=False,
+trackedsize=False,
+storedsize=False,
+):
 """Obtain information about storage for this file's data.
 Returns a dict describing storage for this tracked path. The keys
 in the dict map to arguments of the same. The arguments are bools
 indicating whether to calculate and obtain that data.
 The method yields objects conforming to the ``iverifyproblem``
 interface.
 """
 class idirs(interfaceutil.Interface):
 """Interface representing a collection of directories from paths.
 This interface is essentially a derived data structure representing
 directories from a collection of paths.
 def __iter__():
 """Iterate over the directories in this collection of paths."""
 def __contains__(path):
 """Whether a specific directory is in this collection."""
 class imanifestdict(interfaceutil.Interface):
 """Interface representing a manifest data structure.
 A manifest is effectively a dict mapping paths to entries. Each entry
 Returns a 2-tuple containing ``bytearray(self.text())`` and the
 delta between ``base`` and this manifest.
 """
 class imanifestrevisionbase(interfaceutil.Interface):
 """Base interface representing a single revision of a manifest.
 Should not be used as a primary interface: should always be inherited
 as part of a larger interface.
 """Obtain the parsed manifest data structure.
 The returned object conforms to the ``imanifestdict`` interface.
 """
 class imanifestrevisionstored(imanifestrevisionbase):
 """Interface representing a manifest revision committed to storage."""
 def node():
 """The binary node for this manifest."""
 def find(key):
 """Calls self.read().find(key)``.
 Returns a 2-tuple of ``(node, flags)`` or raises ``KeyError``.
 """
 class imanifestrevisionwritable(imanifestrevisionbase):
 """Interface representing a manifest revision that can be committed."""
 def write(transaction, linkrev, p1node, p2node, added, removed, match=None):
 manifests should not be "narrowed on disk").
 Returns the binary node of the created revision.
 """
 class imanifeststorage(interfaceutil.Interface):
 """Storage interface for manifest data."""
 tree = interfaceutil.Attribute(
 """The path to the directory this manifest tracks.
 The empty bytestring represents the root manifest.
-""")
+"""
+)
 index = interfaceutil.Attribute(
-"""An ``ifilerevisionssequence`` instance.""")
+"""An ``ifilerevisionssequence`` instance."""
+)
 indexfile = interfaceutil.Attribute(
 """Path of revlog index file.
 TODO this is revlog specific and should not be exposed.
-""")
+"""
+)
 opener = interfaceutil.Attribute(
 """VFS opener to use to access underlying files used for storage.
 TODO this is revlog specific and should not be exposed.
-""")
+"""
+)
 version = interfaceutil.Attribute(
 """Revlog version number.
 TODO this is revlog specific and should not be exposed.
-""")
+"""
+)
 _generaldelta = interfaceutil.Attribute(
 """Whether generaldelta storage is being used.
 TODO this is revlog specific and should not be exposed.
-""")
+"""
+)
 fulltextcache = interfaceutil.Attribute(
 """Dict with cache of fulltexts.
 TODO this doesn't feel appropriate for the storage interface.
-""")
+"""
+)
 def __len__():
 """Obtain the number of revisions stored for this manifest."""
 def __iter__():
 """Compare fulltext to another revision.
 Returns True if the fulltext is different from what is stored.
 """
-def emitrevisions(nodes,
+def emitrevisions(
-nodesorder=None,
+nodes,
-revisiondata=False,
+nodesorder=None,
-assumehaveparentrevisions=False):
+revisiondata=False,
+assumehaveparentrevisions=False,
+):
 """Produce ``irevisiondelta`` describing revisions.
 See the documentation for ``ifiledata`` for more.
 """
 """Clear any caches associated with this instance."""
 def dirlog(d):
 """Obtain a manifest storage instance for a tree."""
-def add(m, transaction, link, p1, p2, added, removed, readtree=None,
+def add(
-match=None):
+m, transaction, link, p1, p2, added, removed, readtree=None, match=None
+):
 """Add a revision to storage.
 ``m`` is an object conforming to ``imanifestdict``.
 ``link`` is the linkrev revision number.
 paths must be inspected; this is an optimization and can be safely
 ignored. Note that the storage must still be able to reproduce a full
 manifest including files that did not match.
 """
-def storageinfo(exclusivefiles=False, sharedfiles=False,
+def storageinfo(
-revisionscount=False, trackedsize=False,
+exclusivefiles=False,
-storedsize=False):
+sharedfiles=False,
+revisionscount=False,
+trackedsize=False,
+storedsize=False,
+):
 """Obtain information about storage for this manifest's data.
 See ``ifilestorage.storageinfo()`` for a description of this method.
 This one behaves the same way, except for manifest data.
 """
 class imanifestlog(interfaceutil.Interface):
 """Interface representing a collection of manifest snapshots.
 Represents the root manifest in a repository.
 """Obtain the revision number for a binary node.
 Raises ``error.LookupError`` if the node is not known.
 """
 class ilocalrepositoryfilestorage(interfaceutil.Interface):
 """Local repository sub-interface providing access to tracked file storage.
 This interface defines how a repository accesses storage for a single
 tracked file path.
 """Obtain a filelog for a tracked path.
 The returned type conforms to the ``ifilestorage`` interface.
 """
 class ilocalrepositorymain(interfaceutil.Interface):
 """Main interface for local repositories.
 This currently captures the reality of things - not how things should be.
 """
 supportedformats = interfaceutil.Attribute(
 """Set of requirements that apply to stream clone.
 This is actually a class attribute and is shared among all instances.
-""")
+"""
+)
 supported = interfaceutil.Attribute(
-"""Set of requirements that this repo is capable of opening.""")
+"""Set of requirements that this repo is capable of opening."""
+)
 requirements = interfaceutil.Attribute(
-"""Set of requirements this repo uses.""")
+"""Set of requirements this repo uses."""
+)
 features = interfaceutil.Attribute(
 """Set of "features" this repository supports.
 A "feature" is a loosely-defined term. It can refer to a feature
 Features are similar to ``requirements``. The main difference is that
 requirements are stored on-disk and represent requirements to open the
 repository. Features are more run-time capabilities of the repository
 and more granular capabilities (which may be derived from requirements).
-""")
+"""
+)
 filtername = interfaceutil.Attribute(
-"""Name of the repoview that is active on this repo.""")
+"""Name of the repoview that is active on this repo."""
+)
 wvfs = interfaceutil.Attribute(
-"""VFS used to access the working directory.""")
+"""VFS used to access the working directory."""
+)
 vfs = interfaceutil.Attribute(
 """VFS rooted at the .hg directory.
 Used to access repository data not in the store.
-""")
+"""
+)
 svfs = interfaceutil.Attribute(
 """VFS rooted at the store.
 Used to access repository data in the store. Typically .hg/store.
 But can point elsewhere if the store is shared.
-""")
+"""
+)
 root = interfaceutil.Attribute(
-"""Path to the root of the working directory.""")
+"""Path to the root of the working directory."""
+)
-path = interfaceutil.Attribute(
-"""Path to the .hg directory.""")
+path = interfaceutil.Attribute("""Path to the .hg directory.""")
 origroot = interfaceutil.Attribute(
-"""The filesystem path that was used to construct the repo.""")
+"""The filesystem path that was used to construct the repo."""
+)
 auditor = interfaceutil.Attribute(
 """A pathauditor for the working directory.
 This checks if a path refers to a nested repository.
 Operates on the filesystem.
-""")
+"""
+)
 nofsauditor = interfaceutil.Attribute(
 """A pathauditor for the working directory.
 This is like ``auditor`` except it doesn't do filesystem checks.
-""")
+"""
+)
 baseui = interfaceutil.Attribute(
-"""Original ui instance passed into constructor.""")
+"""Original ui instance passed into constructor."""
+)
-ui = interfaceutil.Attribute(
-"""Main ui instance for this instance.""")
+ui = interfaceutil.Attribute("""Main ui instance for this instance.""")
 sharedpath = interfaceutil.Attribute(
-"""Path to the .hg directory of the repo this repo was shared from.""")
+"""Path to the .hg directory of the repo this repo was shared from."""
+)
-store = interfaceutil.Attribute(
-"""A store instance.""")
+store = interfaceutil.Attribute("""A store instance.""")
-spath = interfaceutil.Attribute(
+spath = interfaceutil.Attribute("""Path to the store.""")
-"""Path to the store.""")
+sjoin = interfaceutil.Attribute("""Alias to self.store.join.""")
-sjoin = interfaceutil.Attribute(
-"""Alias to self.store.join.""")
 cachevfs = interfaceutil.Attribute(
 """A VFS used to access the cache directory.
 Typically .hg/cache.
-""")
+"""
+)
 wcachevfs = interfaceutil.Attribute(
 """A VFS used to access the cache directory dedicated to working copy
 Typically .hg/wcache.
-""")
+"""
+)
 filteredrevcache = interfaceutil.Attribute(
-"""Holds sets of revisions to be filtered.""")
+"""Holds sets of revisions to be filtered."""
+)
-names = interfaceutil.Attribute(
-"""A ``namespaces`` instance.""")
+names = interfaceutil.Attribute("""A ``namespaces`` instance.""")
 def close():
 """Close the handle on this repository."""
 def peer():
 """Obtain an unfiltered/raw view of this repo."""
 def filtered(name, visibilityexceptions=None):
 """Obtain a named view of this repository."""
-obsstore = interfaceutil.Attribute(
+obsstore = interfaceutil.Attribute("""A store of obsolescence data.""")
-"""A store of obsolescence data.""")
+changelog = interfaceutil.Attribute("""A handle on the changelog revlog.""")
-changelog = interfaceutil.Attribute(
-"""A handle on the changelog revlog.""")
 manifestlog = interfaceutil.Attribute(
 """An instance conforming to the ``imanifestlog`` interface.
 Provides access to manifests for the repository.
-""")
+"""
+)
-dirstate = interfaceutil.Attribute(
-"""Working directory state.""")
+dirstate = interfaceutil.Attribute("""Working directory state.""")
 narrowpats = interfaceutil.Attribute(
-"""Matcher patterns for this repository's narrowspec.""")
+"""Matcher patterns for this repository's narrowspec."""
+)
 def narrowmatch(match=None, includeexact=False):
 """Obtain a matcher for the narrowspec."""
 def setnarrowpats(newincludes, newexcludes):
 """Return the wlock if it's held or None."""
 def checkcommitpatterns(wctx, vdirs, match, status, fail):
 pass
-def commit(text='', user=None, date=None, match=None, force=False,
+def commit(
-editor=False, extra=None):
+text='',
+user=None,
+date=None,
+match=None,
+force=False,
+editor=False,
+extra=None,
+):
 """Add a new revision to the repository."""
 def commitctx(ctx, error=False, origctx=None):
 """Commit a commitctx instance to the repository."""
 """Inform the repository that nodes are about to be destroyed."""
 def destroyed():
 """Inform the repository that nodes have been destroyed."""
-def status(node1='.', node2=None, match=None, ignored=False,
+def status(
-clean=False, unknown=False, listsubrepos=False):
+node1='.',
+node2=None,
+match=None,
+ignored=False,
+clean=False,
+unknown=False,
+listsubrepos=False,
+):
 """Convenience method to call repo[x].status()."""
 def addpostdsstatus(ps):
 pass
 pass
 def checkpush(pushop):
 pass
-prepushoutgoinghooks = interfaceutil.Attribute(
+prepushoutgoinghooks = interfaceutil.Attribute("""util.hooks instance.""")
-"""util.hooks instance.""")
 def pushkey(namespace, key, old, new):
 pass
 def listkeys(namespace):
 pass
 def savecommitmessage(text):
 pass
-class completelocalrepository(ilocalrepositorymain,
-ilocalrepositoryfilestorage):
+class completelocalrepository(
+ilocalrepositorymain, ilocalrepositoryfilestorage
+):
 """Complete interface for a local repository."""
 class iwireprotocolcommandcacher(interfaceutil.Interface):
 """Represents a caching backend for wire protocol commands.
 Wire protocol version 2 supports transparent caching of many commands.
 the output layer, it will need to be encoded there as well. For large
 output, this redundant encoding could add overhead. Implementations
 could wrap the encoded object data in ``wireprototypes.encodedresponse``
 instances to avoid this overhead.
 """
 def __enter__():
 """Marks the instance as active.
 Should return self.
 """

changeset 43076	2372284d9457
parent 43032	a12a9af7536c
child 43077	687b865b95ad