6h0 SSKJr SSKrSSKrSSKJrJrJrJrJrJ r J r J r J r SSK Jr SSKJr \R"(aSSKJr SS KJrJr SS KJrJrJr \rS rS rS rSr Sr!Sr"Sr#Sr$Sr%Sr&\#\$-\%-\&-r'Sr(Sr)Sr*Sr+Sr,Sr-Sr.Sr/Sr0Sr1Sr2S r3S!r4S"r5\-1r6\-\,\/\3\.\1\0\2\4\51 r7\7Rq5r9\9Ru\15 \9Ru\35 "S#S$\ 5r;"S%S&\ 5r<"S'S(\ 5r="S)S*\ 5r>"S+S,\ 5r?"S-S.\ 5r@"S/S0\;\<\@5rA"S1S2\ 5rB"S3S4\ 5rC"S5S6\ 5rD"S7S8\ 5rE"S9S:\ 5rF"S;S<\ 5rG"S=S>\E\F\G\ 5rH"S?S@\ 5rI"SASB\ 5rJ"SCSD\ 5rK"SESF\K\ 5rL"SGSH\K\ 5rM"SISJ\ 5rN"SKSL\ 5rO"SMSN\ 5rP"SOSP\ 5rQ"SQSR\Q\P\ 5rR"SSST\ 5rSg)U) annotationsN) AnyCallable CollectionIterableIteratorMappingOptionalProtocolSet)_)error) ByteString)UiTVfsT)dirstatematchermiscsrevlogfilestorages sharedstoreslfss streamclones side-datasshallowfilestorageii@i isdefaultsprevioussfulltextsp1s branchmap-allsbranchmap-servedschangelog-cachesbranchmap-detect-pure-topos full-manifestsfile-node-tagssmanifestlog-cachesrev-branch-caches tags-defaults tags-servedc\rSrSr%SrS\S'S\S'\RS5r\RS5r \RS 5r \RS 5r S r g ) _ipeerconnectionaRepresents 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. UiuizOptional[misc.IPath]pathcg)aRReturns a URL string representing this peer. Currently, implementations expose the raw URL used to construct the instance. It may contain credentials as part of the URL. The expectations of the value aren't well-defined and this could lead to data leakage. TODO audit/clean consumers and more clearly define the contents of this value. Nselfs A/usr/lib/python3/dist-packages/mercurial/interfaces/repository.pyurl_ipeerconnection.urlcg)zReturns a local repository instance. If the peer represents a local repository, returns an object that can be used to interface with it. Otherwise returns ``None``. Nrrs r!local_ipeerconnection.localr$r%cg)z;Returns a boolean indicating if this peer can be pushed to.Nrrs r!canpush_ipeerconnection.canpushr$r%cg)zClose the connection to this peer. This is called when the peer will no longer be used. Resources associated with the peer should be cleaned up. Nrrs r!close_ipeerconnection.closer$r%rN) __name__ __module__ __qualname____firstlineno____doc____annotations__abcabstractmethodr"r'r*r-__static_attributes__rr%r!rrs F )        JJ   r%rc\rSrSrSr\R SSj5r\R S Sj5r\R S Sj5r Sr g) ipeercapabilitiesz+Peer sub-interface related to capabilities.cg)a Determine support for a named capability. Returns ``False`` if capability not supported. Returns ``True`` if boolean capability is supported. Returns a string if capability support is non-boolean. Capability strings may or may not map to wire protocol capabilities. Nr)r names r!capableipeercapabilities.capabler$r%cg)zHObtain capabilities of the peer. Returns a set of string capabilities. Nrrs r! capabilitiesipeercapabilities.capabilitiesr$r%cg)zcRequire a capability to be present. Raises a ``CapabilityError`` if the capability isn't present. Nrr r<purposes r! requirecapipeercapabilities.requirecapr$r%rNr<bytesreturnz bool | bytesrIz Set[bytes]r<rHrDrHrINone) r/r0r1r2r3r5r6r=r@rEr7rr%r!r9r9sQ5          r%r9c\rSrSrSr\R S5r\R S5r\R S5r \R SSj5r \R S5r \R S 5r \R S 5r \R S 5r\R S 5r\R S 5r\R S5r\R S5rSrg) ipeercommandszClient-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. cg)z{Obtain heads in named branches. Returns a dict mapping branch name to an iterable of nodes that are heads on that branch. Nrrs r! branchmapipeercommands.branchmapr$r%cg)z?Retrieve a clonebundle across the wire. Returns a chunkbuffer Nrr rs r!get_cached_bundle_inline&ipeercommands.get_cached_bundle_inliner$r%cg)zZObtains the clone bundles manifest for the repo. Returns the manifest as unparsed bytes. Nrrs r! clonebundlesipeercommands.clonebundlesr$r%Ncg)z?Used to facilitate debugging of arguments passed over the wire.Nrr onetwothreefourfives r! debugwireargsipeercommands.debugwireargsr$r%c g)zObtain remote repository data as a bundle. This command is how the bulk of repository data is transferred from the peer to the local repository Returns a generator of bundle data. Nr)r sourcekwargss r! getbundleipeercommands.getbundler$r%cg)zVDetermine all known head revisions in the peer. Returns an iterable of binary nodes. Nrrs r!headsipeercommands.headsr$r%cg)zDetermine whether multiple nodes are known. Accepts an iterable of nodes whose presence to check for. Returns an iterable of booleans indicating of the corresponding node at that index is known to the peer. Nrr nodess r!knownipeercommands.knownr$r%cg)zKObtain all keys in a pushkey namespace. Returns an iterable of key names. Nrr namespaces r!listkeysipeercommands.listkeysr$r%cg)zaResolve a value to a known revision. Returns a binary node of the resolved revision on success. Nrr keys r!lookupipeercommands.lookupr$r%cg)zSet a value using the ``pushkey`` protocol. Arguments correspond to the pushkey namespace and key to operate on and the old and new values for that key. Returns a string with the peer result. The value inside varies by the namespace. Nrr rrrwoldnews r!pushkeyipeercommands.pushkey r$r%cg)zVObtain streaming clone data. Successful result should be a generator of data chunks. Nrrs r! stream_outipeercommands.stream_out+r$r%cg)zTransfer repository data to the peer. This is how the bulk of data during a push is transferred. Returns the integer number of heads added to the peer. Nr)r bundlerir"s r!unbundleipeercommands.unbundle2r$r%rNNN)r/r0r1r2r3r5r6rQrUrXrarfrirnrsrxr~rrr7rr%r!rNrNsA           NN                        r%rNc\rSrSrSr\R S5r\R S5r\R S5r \R S5r Sr g) ipeerlegacycommandsi<zInterface 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. cg)zObtain nodes between pairs of nodes. ``pairs`` is an iterable of node pairs. Returns an iterable of iterables of nodes corresponding to each requested pair. Nrr pairss r!betweenipeerlegacycommands.betweenDr$r%cg)zObtain ancestor changesets of specific nodes back to a branch point. For each requested node, the peer finds the first ancestor node that is a DAG root or is a merge. Returns an iterable of iterables with the resolved values for each node. Nrrls r!branchesipeerlegacycommands.branchesNr$r%cg)zBObtain a changegroup with data for descendants of specified nodes.Nr)r rmrds r! changegroupipeerlegacycommands.changegroupXr$r%cgNr)r basesrirds r!changegroupsubset%ipeerlegacycommands.changegroupsubset\ r%rN) r/r0r1r2r3r5r6rrrrr7rr%r!rr<sq       QQ   r%rc\rSrSrSr\R S5r\R S5r\R S5r Sr g)ipeercommandexecutoriaa0Represents 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 outstanding requests are waited on. cg)aBRequest that a named command be executed. Receives the command name and a dictionary of command arguments. Returns a ``concurrent.futures.Future`` that will resolve to the result of that command request. That exact value is left up to the implementation and possibly varies by command. Not all commands can coexist with other commands in an executor instance: it depends on the underlying wire protocol transport being used and the command itself. Implementations MAY call ``sendcommands()`` automatically if the requested command can not coexist with other commands in this executor. Implementations MAY call ``sendcommands()`` automatically when the future's ``result()`` is called. So, consumers using multiple commands with an executor MUST ensure that ``result()`` is not called until all command requests have been issued. Nr)r r<argss r! callcommand ipeercommandexecutor.callcommandjr$r%cg)a:Trigger submission of queued command requests. Not all transports submit commands as soon as they are requested to run. When called, this method forces queued command requests to be issued. It will no-op if all commands have already been sent. When called, no more new commands may be issued with this executor. Nrrs r! sendcommands!ipeercommandexecutor.sendcommandsr$r%cg)a)Signal that this command request is finished. When called, no more new commands may be issued. All outstanding commands that have previously been issued are waited on before returning. This not only includes waiting for the futures to resolve, but also waiting for all response data to arrive. In other words, calling this waits for all on-wire state for issued command requests to finish. 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. Nrrs r!r-ipeercommandexecutor.closer$r%rN) r/r0r1r2r3r5r6rrr-r7rr%r!rrasU   ,      r%rcJ\rSrSr%SrS\S'\RS5rSr g) ipeerrequestsiz+Interface for executing commands on a peer.boollimitedargumentscg)aA context manager that resolves to an ipeercommandexecutor. The object this resolves to can be used to issue command requests to the peer. Callers should call its ``callcommand`` method to issue command requests. A new executor should be obtained for each distinct set of commands (possibly just a single command) that the consumer wants to execute as part of a single operation or round trip. This is because some peers are half-duplex and/or don't support persistent connections. e.g. in the case of HTTP peers, commands sent to an executor represent a single HTTP request. While some peers may support multiple command sends over the wire per executor, consumers need to code to the least capable peer. So it should be assumed that command executors buffer 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. Nrrs r!commandexecutoripeerrequests.commandexecutorr$r%rN) r/r0r1r2r3r4r5r6rr7rr%r!rrs&5L  r%rcp\rSrSr%SrSrS\S'S\S'S\S 'SSS jjrSS jrSS jr Sr g )peeriz]Unified interface for peer repositories. All peer instances must conform to this interface. Frrmisc.IPath | NonerrrNcXlX lgr)rr)r rr remotehiddens r!__init__ peer.__init__s  r%cUR5nX;agSU-nUH)nURU5(dMU[U5Ss $ g)NTs%s=F)r@ startswithlen)r r<capscaps r!r= peer.capablesP  " <}C~~d##3t9;''r%cvURU5(ag[R"[S5X!4-5e)NsAcannot %s; remote repository does not support the '%s' capability)r=rCapabilityErrorrrCs r!rEpeer.requirecaps@ <<   ## % o    r%)rrNF)rrrrrrrIrLrGrK) r/r0r1r2r3rr4rr=rEr7rr%r!rrs\ #d"  F #'"         r%rc<\rSrSr%SrS\S'S\S'S\S'Srg) iverifyproblemizRepresents 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. bytes | NonewarningrnoderNr/r0r1r2r3r4r7rr%r!rrs&1 - r%rc\rSrSr%SrS\S'S\S'S\S'S\S'S \S 'S\S 'S \S 'S\S'S\S'S\S'S \S'Srg)irevisiondeltaiadRepresents a delta between one revision and another. Instances convey enough information to allow a revision to be exchanged with another repository. Instances represent the fulltext revision data or a delta against another revision. Therefore the ``revision`` and ``delta`` attributes are mutually exclusive. Typically used for changegroup generation. rHrp1nodep2noderlinknodeintflagsbasenodez int | Nonebaserevisionsizerevisiondeltasidedataprotocol_flagsrNrrr%r!rrs{  K( M6 M6H J O ! 6  4r%rc\rSrSrSr\R S5r\R S5r\R S5r \R S5r Sr g) ifilerevisionssequenceiAaContains 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. The *null* revision (revision number -1) is always the last item in the index. cg)zThe total number of revisions.Nrrs r!__len__ifilerevisionssequence.__len__Lr$r%cg)a)Returns the object having a specific revision number. Returns an 8-tuple with the following fields: offset+flags Contains the offset and flags for the revision. 64-bit unsigned integer where first 6 bytes are the offset and the next 2 bytes are flags. The offset can be 0 if it is not used by the store. compressed size Size of the revision data in the store. It can be 0 if it isn't needed by the store. uncompressed size Fulltext size. It can be 0 if it isn't needed by the store. base revision Revision number of revision the delta for storage is encoded against. -1 indicates not encoded against a base revision. link revision Revision number of changelog revision this entry is related to. p1 revision Revision number of 1st parent. -1 if no 1st parent. p2 revision Revision number of 2nd parent. -1 if no 1st parent. node Binary node value for this revision number. Negative values should index off the end of the sequence. ``-1`` should return the null revision. ``-2`` should return the most recent revision. Nrr revs r! __getitem__"ifilerevisionssequence.__getitem__Pr$r%cg)z!Whether a revision number exists.Nrrs r! __contains__#ifilerevisionssequence.__contains__pr$r%cg)z.Add an item to the index at specific revision.Nr)r ientrys r!insertifilerevisionssequence.inserttr$r%rN) r/r0r1r2r3r5r6rrrrr7rr%r!rrAso --   > 00 ==r%rcR\rSrSr%SrS\S'\RSSj5r\RSSj5r \RS5r \RSS j5r \RS 5r \RS 5r \RS 5r\RS 5r\RS5r\RS5r\RS5r\RS5r\RS5r\RSSj5r\RS5rSrg) ifileindexiyaiStorage 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. The index logically consists of: * A mapping between revision numbers and nodes. * DAG data (storing and querying the relationship between nodes). * Metadata to facilitate storage. rHnullidcg)z4Obtain the number of revisions stored for this file.Nrrs r!rifileindex.__len__r$r%cg)z,Iterate over revision numbers for this file.Nrrs r!__iter__ifileindex.__iter__r$r%cg)zReturns a bool indicating if a node is known to this store. Implementations must only return True for full, binary node values: hex nodes, revision numbers, and partial node matches must be rejected. The null node is never present. Nrr rs r!hasnodeifileindex.hasnoder$r%Ncg)z:Iterate over revision numbers for this file, with control.Nrr startstops r!revsifileindex.revsr$r%cg)zeReturns a 2-tuple of parent nodes for a revision. Values will be ``nullid`` if the parent is empty. Nrrs r!parentsifileindex.parentsr$r%cgz0Like parents() but operates on revision numbers.Nrrs r! parentrevsifileindex.parentrevsr$r%cg)zaObtain the revision number given a node. Raises ``error.LookupError`` if the node is not known. Nrrs r!rifileindex.revr$r%cg)z`Obtain the node value given a revision number. Raises ``IndexError`` if the node is not known. Nrrs r!rifileindex.noder$r%cg)zAttempt to resolve a value to a node. Value can be a binary node, hex node, revision number, or a string that can be converted to an integer. Raises ``error.LookupError`` if a node could not be resolved. Nrrs r!rxifileindex.lookupr$r%cgz=Obtain the changeset revision number a revision is linked to.Nrrs r!linkrevifileindex.linkrevr$r%cg)z6Return whether a revision's content has been censored.Nrrs r! iscensoredifileindex.iscensoredr$r%cg)zlObtain an iterable of nodes containing heads of common ancestors. See ``ancestor.commonancestorsheads()``. Nr)r node1node2s r!commonancestorsheadsifileindex.commonancestorsheadsr$r%cg)zObtain descendant revision numbers for a set of revision numbers. If ``nullrev`` is in the set, this is equivalent to ``revs()``. Nr)r rs r! descendantsifileindex.descendantsr$r%cg)a7Obtain a list of nodes that are DAG heads, with control. The set of revisions examined can be limited by specifying ``start`` and ``stop``. ``start`` is a node. ``stop`` is an iterable of nodes. DAG traversal starts at earlier revision ``start`` and iterates forward until any node in ``stop`` is encountered. Nrrs r!riifileindex.headsr$r%cg)zDObtain nodes that are children of a node. Returns a list of nodes. Nrrs r!childrenifileindex.childrenr$r%rrIr)rIz Iterator[int])rNNN)r/r0r1r2r3r4r5r6rrrrrrrrrxrrr rrirr7rr%r!rrys  M;CC ;;    II    ??          LL EE            r%rc \rSrSrSr\R S5r\R S5r\R S5r \R S5r \R S5r \R S5r \R S S S \ 4S j5rS rg ) ifiledataizStorage interface for data storage of a specific file. This complements ``ifileindex`` and provides an interface for accessing data for a tracked file. cg)zYObtain the fulltext size of file data. Any metadata is excluded from size measurements. Nrrs r!sizeifiledata.sizer$r%cg)a:Obtain fulltext data for a node. By default, any storage transformations are applied before the data is returned. If ``raw`` is True, non-raw storage transformations are not applied. The fulltext data may contain a header containing metadata. Most consumers should use ``read()`` to obtain the actual file data. Nrrs r!rifiledata.revisionr$r%cgzObtain raw data for a node.Nrrs r!rawdataifiledata.rawdatar$r%cg)ztResolve file fulltext data. This is similar to ``revision()`` except any metadata in the data headers is stripped. Nrrs r!readifiledata.read r$r%cg)zObtain copy metadata for a node. Returns ``False`` if no copy metadata is stored or a 2-tuple of (path, node) from which this revision was copied. Nrrs r!renamedifiledata.renamedr$r%cg)zCompare fulltext to another revision. Returns True if the fulltext is different from what is stored. This takes copy metadata into account. TODO better document the copy metadata and censoring logic. Nrr rfulltexts r!cmp ifiledata.cmpr$r%NFcg)a Produce ``irevisiondelta`` for revisions. Given an iterable of nodes, emits objects conforming to the ``irevisiondelta`` interface that describe revisions in storage. This method is a generator. The input nodes may be unordered. Implementations must ensure that a node's parents are emitted before the node itself. Transitively, this means that a node may only be emitted once all its ancestors in ``nodes`` have also been emitted. By default, emits "index" data (the ``node``, ``p1node``, and ``p2node`` attributes). If ``revisiondata`` is set, revision data will also be present on the emitted objects. With default argument values, implementations can choose to emit either fulltext revision data or a delta. When emitting deltas, implementations must consider whether the delta's base revision fulltext is available to the receiver. The base revision fulltext is guaranteed to be available if any of the following are met: * Its fulltext revision was emitted by this method call. * A delta for that revision was emitted by this method call. * ``assumehaveparentrevisions`` is True and the base revision is a parent of the node. ``nodesorder`` can be used to control the order that revisions are emitted. By default, revisions can be reordered as long as they are in DAG topological order (see above). If the value is ``nodes``, the iteration order from ``nodes`` should be used. If the value is ``storage``, then the native order from the backing storage layer is used. (Not all storage layers will have strong ordering and behavior of this mode is storage-dependent.) ``nodes`` ordering can force revisions to be emitted before their ancestors, so consumers should use it with care. The ``linknode`` attribute on the returned ``irevisiondelta`` may not be set and it is the caller's responsibility to resolve it, if needed. If ``deltamode`` is CG_DELTAMODE_PREV and revision data is requested, 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. Nr)r rm nodesorder revisiondataassumehaveparentrevisions deltamodes r! emitrevisionsifiledata.emitrevisions%r$r%r)r/r0r1r2r3r5r6rrr!r$r'r,CG_DELTAMODE_STDr3r7rr%r!rrs          **          "'" 6 6 r%rc\rSrSrSr\R S5r\R S Sj5r\R S Sj5r \R S Sj5r \R S5r \R S 5r S r g) ifilemutationi_z8Storage interface for mutation events of a tracked file.cg)zAdd a new revision to the store. Takes file data, dictionary of metadata, a transaction, linkrev, and parent nodes. Returns the node that was added. May no-op if a revision matching the supplied data is already stored. Nr)r filedatameta transactionrp1p2s r!addifilemutation.addbr$r%Nc g)abAdd a new revision to the store and return its number. This is similar to ``add()`` except it operates at a lower level. The data passed in already contains a metadata header, if any. ``node`` and ``flags`` can be used to define the expected node and the flags to use with storage. ``flags`` is a bitwise value composed of the various ``REVISION_FLAG_*`` constants. ``add()`` is usually called when adding files from e.g. the working 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. Nr) r r0r;rr<r=rr cachedeltas r! addrevisionifilemutation.addrevisionnr$r%cg)aQProcess 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. The ``delta`` field contains ``mpatch`` data to apply to a base revision, identified by ``deltabase``. The base node can be ``nullid``, in which case the header from the delta can be ignored and the delta used as the fulltext. ``alwayscache`` instructs the lower layers to cache the content of the newly added revision, even if it needs to be explicitly computed. This used to be the default when ``addrevisioncb`` was provided up to Mercurial 5.8. ``addrevisioncb`` should be called for each new rev as it is committed. ``duplicaterevisioncb`` should be called for all revs with a pre-existing node. ``maybemissingparents`` is a bool indicating whether the incoming data may reference parents/ancestor revisions that aren't present. This flag is set when receiving data into a "shallow" store that doesn't hold all history. Returns a list of nodes that were processed. A node will be in the list even if it existed in the store previously. Nr)r deltas linkmapperr; addrevisioncbduplicaterevisioncbmaybemissingparentss r!addgroupifilemutation.addgroupr$r%cg)aLRemove the content of a single revision. The specified ``node`` will have its content purged from storage. Future attempts to access the revision data for this node will result in failure. A ``tombstone`` message can optionally be stored. This message may be displayed to users when they attempt to access the missing revision data. Storage backends may have stored deltas against the previous content in this revision. As part of censoring a revision, these storage backends are expected to rewrite any internally stored deltas such that they no longer reference the deleted content. Nr)r trr tombstones r!censorrevisionifilemutation.censorrevisionr$r%cg)aGFind the minimum revision that must be stripped to strip a linkrev. Returns a 2-tuple containing the minimum revision number and a set of all revisions numbers that would be broken by this strip. TODO this is highly revlog centric and should be abstracted into a higher-level deletion API. ``repair.strip()`` relies on this. Nrr minlinks r! getstrippointifilemutation.getstrippointr$r%cg)aRemove storage of items starting at a linkrev. This uses ``getstrippoint()`` to determine the first node to remove. Then it effectively truncates storage for all revisions after that. TODO this is highly revlog centric and should be abstracted into a higher-level deletion API. Nrr rSr;s r!stripifilemutation.stripr$r%r)NrNNNF)r%)r/r0r1r2r3r5r6r>rBrJrOrTrXr7rr%r!r7r7_sB       6   !$ $ L   "      r%r7c\rSrSrSr\R S5r\R SSj5r\R S Sj5r Sr g) ifilestorageiz5Complete storage interface for a single tracked file.cg)zObtain 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. Nrrs r!filesifilestorage.filesr$r%cg)afObtain 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. exclusivefiles Iterable of (vfs, path) describing files that are exclusively used to back storage for this tracked path. sharedfiles Iterable of (vfs, path) describing files that are used to back storage for this tracked path. Those files may also provide storage for other stored entities. revisionscount Number of revisions available for retrieval. trackedsize Total size in bytes of all tracked revisions. This is a sum of the length of the fulltext of all revisions. storedsize Total size in bytes used to store data for all tracked revisions. This is commonly less than ``trackedsize`` due to internal usage of deltas rather than fulltext revisions. Not all storage backends may support all queries are have a reasonable value to use. In that case, the value should be set to ``None`` and callers are expected to handle this special value. Nrr exclusivefiles sharedfilesrevisionscount trackedsize storedsizes r! storageinfoifilestorage.storageinfor$r%cg)aKVerifies the integrity of file storage. ``state`` is a dict holding state of the verifier process. It can be used to communicate data between invocations of multiple storage primitives. If individual revisions cannot have their revision content resolved, the method is expected to set the ``skipread`` key to a set of nodes that encountered problems. If set, the method can also add the node(s) to ``safe_renamed`` in order to indicate nodes that may perform the rename checks with currently accessible data. The method yields objects conforming to the ``iverifyproblem`` interface. Nrr states r!verifyintegrityifilestorage.verifyintegrityr$r%rNFFFFF)rIzIterable[iverifyproblem]) r/r0r1r2r3r5r6r^rgrlr7rr%r!r\r\sc?    & & P   r%r\c\rSrSrSr\R S5r\R S5r\R S5r \R S5r Sr g) idirsi!zInterface representing a collection of directories from paths. This interface is essentially a derived data structure representing directories from a collection of paths. cg)z\Add a path to the collection. All directories in the path will be added to the collection. NrrTs r!addpath idirs.addpath(r$r%cg)zRemove a path from the collection. If the removal was the last path in a particular directory, the directory is removed from the collection. NrrTs r!delpath idirs.delpath/r$r%cg)z9Iterate over the directories in this collection of paths.Nrrs r!ridirs.__iter__7r$r%cg)z3Whether a specific directory is in this collection.NrrTs r!ridirs.__contains__;r$r%rN) r/r0r1r2r3r5r6rrrurrr7rr%r!rprp!ss        HH BBr%rpc.\rSrSrSr\R SSj5r\R SSj5r\R S Sj5r \R S!Sj5r \ r \R S"Sj5r \R S#Sj5r \R S$S j5r\R S%S j5r\R S&S j5r\R S&S j5r\R S'S j5r\R S(S)Sjj5r\R S*Sj5r\R S+Sj5r\R S,Sj5r\R S-S.Sjj5r\R S/Sj5r\R S(S0Sjj5r\R S1Sj5r\R S2Sj5r\R S3Sj5r\R S3Sj5r\R S4Sj5r\R S5Sj5r\R S6Sj5r Sr!g)7 imanifestdicti@zInterface 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. cg)zReturns the binary node value for a path in the manifest. Raises ``KeyError`` if the path does not exist in the manifest. Equivalent to ``self.find(path)[0]``. Nrrvs r!rimanifestdict.__getitem__Gr$r%cg)zReturns the entry for a path in the manifest. Returns a 2-tuple of (node, flags). Raises ``KeyError`` if the path does not exist in the manifest. NrrTs r!findimanifestdict.findPr$r%cg)z-Return the number of entries in the manifest.Nrrs r!rimanifestdict.__len__Yr$r%cg)z:Returns True if the manifest has entries, False otherwise.Nrrs r! __nonzero__imanifestdict.__nonzero__]r$r%cg)zDefine the node value and flags for a path in the manifest. Equivalent to __setitem__ followed by setflag, but can be more efficient. Nr)r rrrs r!setimanifestdict.setcr$r%cg)zDefine the node value for a path in the manifest. If the path is already in the manifest, its flags will be copied to the new entry. Nr)r rrs r! __setitem__imanifestdict.__setitem__jr$r%cg)z&Whether a path exists in the manifest.NrrTs r!rimanifestdict.__contains__rr$r%cg)zZRemove a path from the manifest. Raises ``KeyError`` if the path is not in the manifest. NrrTs r! __delitem__imanifestdict.__delitem__vr$r%cgz#Iterate over paths in the manifest.Nrrs r!rimanifestdict.__iter__}r$r%cgrrrs r!iterkeysimanifestdict.iterkeysr$r%cg)z'Obtain a list of paths in the manifest.Nrrs r!keysimanifestdict.keysr$r%Ncg)zObtain the set of paths in this manifest but not in another. ``match`` is an optional matcher function to be applied to both manifests. Returns a set of paths. Nr)r othermatchs r! filesnotinimanifestdict.filesnotinr$r%cg)z7Returns an object implementing the ``idirs`` interface.Nrrs r!dirsimanifestdict.dirsr$r%cg)z=Returns a bool indicating if a directory is in this manifest.Nr)r dirs r!hasdirimanifestdict.hasdirr$r%cg)zGenerator of paths in manifest satisfying a matcher. If the matcher has explicit files listed and they don't exist in the manifest, ``match.bad()`` is called for each missing file. Nr)r rs r!walkimanifestdict.walkr$r%cg)a*Find differences between this manifest and another. This manifest is compared to ``other``. If ``match`` is provided, the two manifests are filtered against this matcher and only entries satisfying the matcher are compared. If ``clean`` is True, unchanged files are included in the returned object. Returns a dict with paths as keys and values of 2-tuples of 2-tuples of the form ``((node1, flag1), (node2, flag2))`` where ``(node1, flag1)`` represents the node and flags for this manifest and ``(node2, flag2)`` are the same for the other manifest. Nr)r rrcleans r!diffimanifestdict.diffr$r%cg)zfSet the flag value for a given path. Raises ``KeyError`` if the path is not already in the manifest. Nr)r rflags r!setflagimanifestdict.setflagr$r%cg)z?Obtain the node value for a path or a default value if missing.Nr)r rdefaults r!getimanifestdict.getr$r%cg)z>Return the flags value for a path (default: empty bytestring).NrrTs r!rimanifestdict.flagsr$r%cg)zReturn a copy of this manifest.Nrrs r!copyimanifestdict.copyr$r%cg)z?Returns an iterable of (path, node) for items in this manifest.Nrrs r!itemsimanifestdict.itemsr$r%cg)zIdentical to items().Nrrs r! iteritemsimanifestdict.iteritemsr$r%cg)zReturns an iterable of (path, node, flags) for this manifest. Similar to ``iteritems()`` except items are a 3-tuple and include flags. Nrrs r! iterentriesimanifestdict.iterentriesr$r%cg)zeObtain the raw data representation for this manifest. Result is used to create a manifest revision. Nrrs r!textimanifestdict.textr$r%cg)aObtain a delta between this manifest and another given changes. ``base`` in the raw data representation for another manifest. ``changes`` is an iterable of ``(path, to_delete)``. Returns a 2-tuple containing ``bytearray(self.text())`` and the delta between ``base`` and this manifest. If this manifest implementation can't support ``fastdelta()``, raise ``mercurial.manifest.FastdeltaUnavailable``. Nr)r basechangess r! fastdeltaimanifestdict.fastdeltar$r%r)rwrHrIrH)rrHrItuple[bytes, bytes]r)rIr)rrHrrHrrHrIrL)rrHrrHrIrL)rrHrIr)rrHrIrL)rIIterator[bytes])rI list[bytes]rrJ)rIz misc.IDirs)rrHrIr)rzmatcher.IMatcherrIrr)rrrzmatcher.IMatcher | NonerrrIzQdict[bytes, tuple[tuple[bytes | None, bytes], tuple[bytes | None, bytes]] | None])rrHrrHrIrL)rrHrIr)rrHrIrH)rIr|)rIzIterator[tuple[bytes, bytes]])rIz$Iterator[tuple[bytes, bytes, bytes]])rIr)rrrzIterable[tuple[bytes, bool]]rIztuple[ByteString, ByteString])"r/r0r1r2r3r5r6rrrr__bool__rrrrrrrrrrrrrrrrrrrrrr7rr%r!r|r|@s        << IIH      55    22 22 66    FF LL    *.   '       2    NN MM .. NN $$         )E &  r%r|c`\rSrSrSr\R S5r\R S5rSr g)imanifestrevisionbaseizBase 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. cg)zObtain a copy of this manifest instance. Returns an object conforming to the ``imanifestrevisionwritable`` interface. The instance will be associated with the same ``imanifestlog`` collection as this instance. Nrrs r!rimanifestrevisionbase.copyr$r%cg)zmObtain the parsed manifest data structure. The returned object conforms to the ``imanifestdict`` interface. Nrrs r!r$imanifestrevisionbase.read r$r%rN) r/r0r1r2r3r5r6rr$r7rr%r!rrs;       r%rcl\rSrSr%Sr\R SSj5rS\S'\R SSSjj5r \R SSS .SS jjj5r \R SS S .SS jj5r \R SS .SSjj5r \R SSSjj5r \R SSj5rSrg)imanifestrevisionstorediz@Interface representing a manifest revision committed to storage.cg)z"The binary node for this manifest.Nrrs r!rimanifestrevisionstored.noder$r%rrFcg)aMObtain the manifest data structure representing changes from parent. This manifest is compared to its 1st parent. A new manifest representing those differences is constructed. If `shallow` is True, this will read the delta for this directory, without recursively reading subdirectory manifests. Instead, any subdirectory entry will be reported as it appears in the manifest, i.e. the subdirectory will be reported among files and distinguished only by its 't' flag. This only apply if the underlying manifest support it. The returned object conforms to the ``imanifestdict`` interface. Nrr shallows r! readdelta!imanifestrevisionstored.readdeltar$r%N)rcg)aread some manifest information as fast if possible This might return a "delta", a manifest object containing only file changed compared to another revisions. The `valid_bases` argument control the set of revision that might be used as a base. If no delta can be retrieved quickly, a full read of the manifest will be performed instead. The function return a tuple with two elements. The first one is the delta base used (or None if we did a full read), the second one is the manifest information. If `shallow` is True, this will read the delta for this directory, without recursively reading subdirectory manifests. Instead, any subdirectory entry will be reported as it appears in the manifest, i.e. the subdirectory will be reported among files and distinguished only by its 't' flag. This only apply if the underlying manifest support it. The returned object conforms to the ``imanifestdict`` interface. Nr)r valid_basesrs r!read_any_fast_delta+imanifestrevisionstored.read_any_fast_delta+r$r%T)rexactcg)aZreturn a diff from this revision against both parents. If `exact` is False, this might return a superset of the diff, containing files that are actually present as is in one of the parents. If `shallow` is True, this will read the delta for this directory, without recursively reading subdirectory manifests. Instead, any subdirectory entry will be reported as it appears in the manifest, i.e. the subdirectory will be reported among files and distinguished only by its 't' flag. This only apply if the underlying manifest support it. The returned object conforms to the ``imanifestdict`` interface.Nr)r rrs r!read_delta_parents*imanifestrevisionstored.read_delta_parentsHr$r%cg)aReturn a manifest containing just the entries that might be new to the repository. This is often equivalent to a diff against both parents, but without garantee. For performance reason, It might contains more files in some cases. If `shallow` is True, this will read the delta for this directory, without recursively reading subdirectory manifests. Instead, any subdirectory entry will be reported as it appears in the manifest, i.e. the subdirectory will be reported among files and distinguished only by its 't' flag. This only apply if the underlying manifest support it. The returned object conforms to the ``imanifestdict`` interface.Nrrs r!read_delta_new_entries.imanifestrevisionstored.read_delta_new_entriesWr$r%cg)zVCalls either ``read()`` or ``readdelta()``. The faster of the two options is called. Nrrs r!readfast imanifestrevisionstored.readfastgr$r%cg)zaCalls ``self.read().find(key)``. Returns a 2-tuple of ``(node, flags)`` or raises ``KeyError``. Nrrvs r!rimanifestrevisionstored.findnr$r%r)rIrHF)rrr)rzCollection[int] | Nonerr)rrrr)rwrHrIr)r/r0r1r2r3r5r6rr4rrrrrrr7rr%r!rrsJ11K     /3   +    8 49 L L 8= L L      r%rcB\rSrSrSr\R SSj5rSrg)imanifestrevisionwritableivzAInterface representing a manifest revision that can be committed.Ncg)aAdd this revision to storage. Takes a transaction object, the changeset revision number it will be associated with, its parent nodes, and lists of added and removed paths. If match is provided, storage can choose not to inspect or write out items that do not match. Storage is still required to be able to provide the full manifest in the future for any directories written (these manifests should not be "narrowed on disk"). Returns the binary node of the created revision. Nr)r r;rrraddedremovedrs r!writeimanifestrevisionwritable.writeyr$r%rr) r/r0r1r2r3r5r6rr7rr%r!rrvs KJN  r%rc*\rSrSr%SrS\S'S\S'S\S'S \S 'S \S '\RS 5r\RS5r \RS5r \RS5r \RS5r \RS5r \RS5r\RS5r\RS5r\RS5r\RS5r\RS5r\RS)Sj5r\RS*Sj5r\RS5r\RS5r\RS5r\RS5r\RS 5r\RS!5r\RS"5r\RS+S#j5r\RS$5r\RS*S%j5r\RS,S&j5r \RS'5r!S(r"g)-imanifeststorageiz$Storage interface for manifest data. NodeConstants nodeconstantsrHtreerindexVfsopenerdict fulltextcachecg)z8Obtain the number of revisions stored for this manifest.Nrrs r!rimanifeststorage.__len__r$r%cg)z0Iterate over revision numbers for this manifest.Nrrs r!rimanifeststorage.__iter__r$r%cg)zhObtain the revision number given a binary node. Raises ``error.LookupError`` if the node is not known. Nrrs r!rimanifeststorage.revr$r%cg)zkObtain the node value given a revision number. Raises ``error.LookupError`` if the revision is not known. Nrrs r!rimanifeststorage.noder$r%cg)zAttempt to resolve a value to a node. Value can be a binary node, hex node, revision number, or a bytes that can be converted to an integer. Raises ``error.LookupError`` if a ndoe could not be resolved. Nr)r values r!rximanifeststorage.lookupr$r%cg)zaReturns a 2-tuple of parent nodes for a node. Values will be ``nullid`` if the parent is empty. Nrrs r!rimanifeststorage.parentsr$r%cgrrrs r!rimanifeststorage.parentrevsr$r%cgrrrs r!rimanifeststorage.linkrevr$r%cg)z Obtain fulltext data for a node.Nrrs r!rimanifeststorage.revisionr$r%cgr rrs r!r!imanifeststorage.rawdatar$r%cg)z}Obtain a delta between two revision numbers. The returned data is the result of ``bdiff.bdiff()`` on the raw revision data. Nr)r rev1rev2s r!revdiffimanifeststorage.revdiffr$r%cg)zfCompare fulltext to another revision. Returns True if the fulltext is different from what is stored. Nrr*s r!r,imanifeststorage.cmpr$r%Ncg)zdProduce ``irevisiondelta`` describing revisions. See the documentation for ``ifiledata`` for more. Nr)r rmr/r0r1s r!r3imanifeststorage.emitrevisionsr$r%cg)z^Process a series of deltas for storage. See the documentation in ``ifilemutation`` for more. Nr)r rErFr;rGrHs r!rJimanifeststorage.addgroupr$r%cg)zObtain the size of tracked data. Is equivalent to ``len(m.rawdata(node))``. TODO this method is only used by upgrade code and may be removed. Nrrs r!rawsizeimanifeststorage.rawsize r$r%cg)zvFind minimum revision that must be stripped to strip a linkrev. See the documentation in ``ifilemutation`` for more. NrrRs r!rTimanifeststorage.getstrippointr$r%cg)zeRemove storage of items starting at a linkrev. See the documentation in ``ifilemutation`` for more. NrrWs r!rXimanifeststorage.stripr$r%cg)zuObtain the expected sizes of backing files. TODO this is used by verify and it should not be part of the interface. Nrrs r! checksizeimanifeststorage.checksize r$r%cg)zObtain paths that are backing storage for this manifest. TODO this is used by verify and there should probably be a better API for this functionality. Nrrs r!r^imanifeststorage.files'r$r%cg)zObtain the revision that a revision is delta'd against. TODO delta encoding is an implementation detail of storage and should not be exposed to the storage interface. Nrrs r! deltaparentimanifeststorage.deltaparent/r$r%c g)zClone this instance to another.Nr)r rMdestres r!cloneimanifeststorage.clone7r$r%cg)z/Clear any caches associated with this instance.Nrr clear_persisted_datas r! clearcachesimanifeststorage.clearcaches;r$r%cg)z.Obtain a manifest storage instance for a tree.Nr)r ds r!dirlogimanifeststorage.dirlog?r$r%c g)aAdd a revision to storage. ``m`` is an object conforming to ``imanifestdict``. ``link`` is the linkrev revision number. ``p1`` and ``p2`` are the parent revision numbers. ``added`` and ``removed`` are iterables of added and removed paths, respectively. ``readtree`` is a function that can be used to read the child tree(s) when recursively writing the full tree structure when using treemanifets. ``match`` is a matcher that can be used to hint to storage that not all 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. Nr) r mr;linkr<r=rrreadtreers r!r>imanifeststorage.addCr$r%cg)zObtain 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. Nrras r!rgimanifeststorage.storageinfoer$r%cg)zreturn an actual revlog instance if any This exist because a lot of code leverage the fact the underlying storage is a revlog for optimization, so giving simple way to access the revlog instance helps such code. Nrrs r! get_revlogimanifeststorage.get_revlogtr$r%r)NFFrrrn)#r/r0r1r2r3r4r5r6rrrrrxrrrrr!rr,r3rJr"rTrXr)r^r.r2r7r;r>rgrEr7rr%r!rrs.  7 K "!1 K   GG ??             ?? LL // **       "'                             .. >> ==   B        r%rc\rSrSr%SrS\S'S\S'\RS5r\RSSj5r \RS 5r \RSSS jj5r \RS 5r \RS 5r S rg) imanifestlogi~zInterface 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 tree manifests. rrrnarrowedcg)zObtain a manifest instance for a given binary node. Equivalent to calling ``self.get('', node)``. The returned object conforms to the ``imanifestrevisionstored`` interface. Nrrs r!rimanifestlog.__getitem__r$r%cg)aRetrieve the manifest instance for a given directory and binary node. ``node`` always refers to the node of the root manifest (which will be the only manifest if flat manifests are being used). If ``tree`` is the empty string, the root manifest is returned. Otherwise the manifest for the specified directory will be returned (requires tree manifests). If ``verify`` is True, ``LookupError`` is raised if the node is not known. The returned object conforms to the ``imanifestrevisionstored`` interface. Nr)r rrverifys r!rimanifestlog.getr$r%cg)zRetrieve an interface to storage for a particular tree. If ``tree`` is the empty bytestring, storage for the root manifest will be returned. Otherwise storage for a tree manifest is returned. TODO formalize interface for returned object. Nr)r rs r! getstorageimanifestlog.getstorager$r%cg)z-Clear caches associated with this collection.Nrr5s r!r7imanifestlog.clearcachesr$r%cg)zfObtain the revision number for a binary node. Raises ``error.LookupError`` if the node is not known. Nrrs r!rimanifestlog.revr$r%cg)z8update whatever cache are relevant for the used storage.Nr)r r;s r! update_cachesimanifestlog.update_cachesr$r%rN)Tr)r6rrIrL)r/r0r1r2r3r4r5r6rrrPr7rrWr7rr%r!rHrH~s! 7N8     "    <<    GGr%rHc<\rSrSrSr\R S5rSrg)ilocalrepositoryfilestorageizLocal repository sub-interface providing access to tracked file storage. This interface defines how a repository accesses storage for a single tracked file path. cg)zdObtain a filelog for a tracked path. The returned type conforms to the ``ifilestorage`` interface. Nr)r fs r!file ilocalrepositoryfilestorage.filer$r%rN) r/r0r1r2r3r5r6r]r7rr%r!rZrZs!    r%rZc \rSrSr%SrS\S'S\S'S\S'S\S 'S\S 'S\S 'S \S 'S\S'S\S'S\S'S\S'S\S'S\S'S\S'S\S'S\S'S\S'S\S'S\S'S\S'S\S'S\S 'S\S!'S\S"'S\S#'S\S$'\RS%5r\RS|S'j5r \RS(5r \RS|S)j5r S\S*'S\S+'S,\S-'S.\S/'S\S0'\RS}S1j5r \RS25r \RS35r\RS45r\RS55r\r\RS65r\RS75r\RS85r\RS95r\RS~S:j5r\RS;5r\RSS<j5r\RS=5r\RS>5r\RS?5r\RS@5r\RSA5r\RSB5r\RSC5r\RSD5r \RSSEj5r!\RSF5r"\RSG5r#\RSH5r$\RSI5r%\RSJ5r&\RSK5r'\RSL5r(\RSM5r)\RSN5r*\RSSOj5r+\RSP5r,\RS|SQj5r-\RSR5r.\RSS5r/\RSSTj5r0\RSU5r1\RSV5r2\RS|SWj5r3\RSX5r4\RSY5r5\RSSZj5r6\RSS[j5r7\RS\5r8\RS]5r9\RS^5r:\RSS_j5r;\RS`5r<\RSSaj5r=\RSb5r>\RSScj5r?\RSd5r@\RSe5rA\RSSfj5rB\RS~Sgj5rC\RSh5rD\RSi5rE\RSSjj5rF\RSk5rG\RSl5rH\RSm5rI\RS|Snj5rJ\RSSoj5rK\RSp5rL\RSq5rM\RSr5rNSs\St'\RSu5rO\RSv5rP\RSSwj5rQ\RSx5rR\RSSyj5rS\RSz5rTS{rUg&)ilocalrepositorymainizrMain interface for local repositories. This currently captures the reality of things - not how things should be. rrrHrz set[bytes] supported requirementsfeatures filternamezMapping[bytes, Vfs]vfs_maprwvfsvfssvfsrootrorigrootrauditor nofsauditorrbaseuir sharedpathstorespathrsjoincachevfs wcachevfsfilteredrevcachenamesfilecopiesmodecg)z$Close the handle on this repository.Nrrs r!r-ilocalrepositorymain.closeJr$r%Ncg)z6Obtain an object conforming to the ``peer`` interface.NrrTs r!rilocalrepositorymain.peerNr$r%cg)z+Obtain an unfiltered/raw view of this repo.Nrrs r! unfilteredilocalrepositorymain.unfilteredRr$r%cg)z'Obtain a named view of this repository.Nr)r r<visibilityexceptionss r!filteredilocalrepositorymain.filteredVr$r%obsstore changelogrH manifestlogzintdirstate.idirstater narrowpatscg)z$Obtain a matcher for the narrowspec.Nr)r r includeexacts r! narrowmatch ilocalrepositorymain.narrowmatchlr$r%cg)z*Define the narrowspec for this repository.Nr)r newincludes newexcludess r! setnarrowpats"ilocalrepositorymain.setnarrowpatspr$r%cg)zTry to resolve a changectx.Nrr changeids r!r ilocalrepositorymain.__getitem__tr$r%cg)zWhether a changeset exists.Nrrs r!r!ilocalrepositorymain.__contains__xr$r%cg)zAlways returns True.Trrs r!r ilocalrepositorymain.__nonzero__|r%cg)z-Returns the number of changesets in the repo.Nrrs r!rilocalrepositorymain.__len__r$r%cg)z(Iterate over revisions in the changelog.Nrrs r!rilocalrepositorymain.__iter__r$r%cg)z%Evaluate a revset. Emits revisions. Nrr exprrs r!rilocalrepositorymain.revsr$r%cg)z/Evaluate a revset. Emits changectx instances. Nrrs r!rilocalrepositorymain.setr$r%cg)z1Find revisions matching one of the given revsets.Nr)r specsuser localaliass r!anyrevsilocalrepositorymain.anyrevsr$r%cg)z8Returns a string representing the location of this repo.Nrrs r!r"ilocalrepositorymain.urlr$r%c g)z Call a hook.Nr)r r<throwrs r!hookilocalrepositorymain.hookr$r%cg)z Return a mapping of tag to node.Nrrs r!tagsilocalrepositorymain.tagsr$r%cg)zReturn the type of a given tag.Nr)r tagnames r!tagtypeilocalrepositorymain.tagtyper$r%cg)z*Return a list of tags ordered by revision.Nrrs r!tagslistilocalrepositorymain.tagslistr$r%cg)z'Return the tags associated with a node.Nrrs r!nodetagsilocalrepositorymain.nodetagsr$r%cg)zrs#      M $8 ,*%$9!  !%""',*#@ &(.&$" $  OO%./*+/ x/ d  ) . ) XX,?X?D5=X5=pp p fp p fx Hx vD :y-D NBHB>v Hv r H 0b 3Xb J 5x ,o xo dBG8BGJ  (  x 8x v5 5c c r%