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

comparison mercurial/interfaces/repository.py @ 52445:26dd402c3497

interfaces: convert the repository zope interfaces to Protocol classes This is the same transformation as 382d9629cede did for dirstate. The same caveat applies- the code may not be valid, since the functions are missing the `self` arg, and the attrs should be plain attrs, not zope `Attribute`. These classes are pretty intertwined however, so making the same transformation to everything makes it easier to change and review. Additionally, there are some classes that subclass multiple protocol classes, and should themselves subclass `typing.Protocol` to be a protocol class. But defer that for now for clarity.

author	Matt Harbison <matt_harbison@yahoo.com>
date	Tue, 22 Oct 2024 16:04:27 -0400
parents	b2821a846470
children	c1674551c109

comparison

equal deleted inserted replaced

-:cdb45eb77efb
+:26dd402c3497
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 from __future__ import annotations
+from typing import (
+Protocol,
+)
 from ..i18n import _
 from .. import error
 from . import util as interfaceutil
 CACHES_POST_CLONE = CACHES_ALL.copy()
 CACHES_POST_CLONE.discard(CACHE_FILE_NODE_TAGS)
 CACHES_POST_CLONE.discard(CACHE_REV_BRANCH)
-class ipeerconnection(interfaceutil.Interface):
+class ipeerconnection(Protocol):
 """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 called when the peer will no longer be used. Resources
 associated with the peer should be cleaned up.
 """
-class ipeercapabilities(interfaceutil.Interface):
+class ipeercapabilities(Protocol):
 """Peer sub-interface related to capabilities."""
 def capable(name):
 """Determine support for a named capability.
 Raises a ``CapabilityError`` if the capability isn't present.
 """
-class ipeercommands(interfaceutil.Interface):
+class ipeercommands(Protocol):
 """Client-side interface for communicating over the wire protocol.
 This interface is used as a gateway to the Mercurial wire protocol.
 methods commonly call wire protocol commands of the same name.
 """
 Returns the integer number of heads added to the peer.
 """
-class ipeerlegacycommands(interfaceutil.Interface):
+class ipeerlegacycommands(Protocol):
 """Interface for implementing support for legacy wire protocol commands.
 Wire protocol commands transition to legacy status when they are no longer
 used by modern clients. To facilitate identifying which commands are
 legacy, the interfaces are split.
 def changegroupsubset(bases, heads, source):
 pass
-class ipeercommandexecutor(interfaceutil.Interface):
+class ipeercommandexecutor(Protocol):
 """Represents a mechanism to execute remote commands.
 This is the primary interface for requesting that wire protocol commands
 be executed. Instances of this interface are active in a context manager
 and have a well-defined lifetime. When the context manager exits, all
 This method may call ``sendcommands()`` if there are buffered commands.
 """
-class ipeerrequests(interfaceutil.Interface):
+class ipeerrequests(Protocol):
 """Interface for executing commands on a peer."""
 limitedarguments = interfaceutil.Attribute(
 """True if the peer cannot receive large argument value for commands."""
 )
 )
 % (purpose, name)
 )
-class iverifyproblem(interfaceutil.Interface):
+class iverifyproblem(Protocol):
 """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).
 ``None`` means the problem doesn't apply to a single revision.
 """
 )
-class irevisiondelta(interfaceutil.Interface):
+class irevisiondelta(Protocol):
 """Represents a delta between one revision and another.
 Instances convey enough information to allow a revision to be exchanged
 with another repository.
 This is a bitwise composition of the ``storageutil.CG_FLAG*`` constants.
 """
 )
-class ifilerevisionssequence(interfaceutil.Interface):
+class ifilerevisionssequence(Protocol):
 """Contains index data for all revisions of a file.
 Types implementing this behave like lists of tuples. The index
 in the list corresponds to the revision number. The values contain
 index metadata.
 def insert(self, i, entry):
 """Add an item to the index at specific revision."""
-class ifileindex(interfaceutil.Interface):
+class ifileindex(Protocol):
 """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.
 Returns a list of nodes.
 """
-class ifiledata(interfaceutil.Interface):
+class ifiledata(Protocol):
 """Storage interface for data storage of a specific file.
 This complements ``ifileindex`` and provides an interface for accessing
 data for a tracked file.
 """
 emitted just prior. The initial revision should be a delta against its
 1st parent.
 """
-class ifilemutation(interfaceutil.Interface):
+class ifilemutation(Protocol):
 """Storage interface for mutation events of a tracked file."""
 def add(filedata, meta, transaction, linkrev, p1, p2):
 """Add a new revision to the store.
 The method yields objects conforming to the ``iverifyproblem``
 interface.
 """
-class idirs(interfaceutil.Interface):
+class idirs(Protocol):
 """Interface representing a collection of directories from paths.
 This interface is essentially a derived data structure representing
 directories from a collection of paths.
 """
 def __contains__(path):
 """Whether a specific directory is in this collection."""
-class imanifestdict(interfaceutil.Interface):
+class imanifestdict(Protocol):
 """Interface representing a manifest data structure.
 A manifest is effectively a dict mapping paths to entries. Each entry
 consists of a binary node and extra flags affecting that entry.
 """
 If this manifest implementation can't support ``fastdelta()``,
 raise ``mercurial.manifest.FastdeltaUnavailable``.
 """
-class imanifestrevisionbase(interfaceutil.Interface):
+class imanifestrevisionbase(Protocol):
 """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.
 """
 Returns the binary node of the created revision.
 """
-class imanifeststorage(interfaceutil.Interface):
+class imanifeststorage(Protocol):
 """Storage interface for manifest data."""
 nodeconstants = interfaceutil.Attribute(
 """nodeconstants used by the current repository."""
 )
 storage is a revlog for optimization, so giving simple way to access
 the revlog instance helps such code.
 """
-class imanifestlog(interfaceutil.Interface):
+class imanifestlog(Protocol):
 """Interface representing a collection of manifest snapshots.
 Represents the root manifest in a repository.
 Also serves as a means to access nested tree manifests and to cache
 def update_caches(transaction):
 """update whatever cache are relevant for the used storage."""
-class ilocalrepositoryfilestorage(interfaceutil.Interface):
+class ilocalrepositoryfilestorage(Protocol):
 """Local repository sub-interface providing access to tracked file storage.
 This interface defines how a repository accesses storage for a single
 tracked file path.
 """
 The returned type conforms to the ``ifilestorage`` interface.
 """
-class ilocalrepositorymain(interfaceutil.Interface):
+class ilocalrepositorymain(Protocol):
 """Main interface for local repositories.
 This currently captures the reality of things - not how things should be.
 """
 ilocalrepositorymain, ilocalrepositoryfilestorage
 ):
 """Complete interface for a local repository."""
-class iwireprotocolcommandcacher(interfaceutil.Interface):
+class iwireprotocolcommandcacher(Protocol):
 """Represents a caching backend for wire protocol commands.
 Wire protocol version 2 supports transparent caching of many commands.
 To leverage this caching, servers can activate objects that cache
 command responses. Objects handle both cache writing and reading.

Mercurial > public > mercurial-scm > hg

comparison mercurial/interfaces/repository.py @ 52445:26dd402c3497