mercurial: comparison mercurial/localrepo.py

equal deleted inserted replaced

-:3a2b6158374a
+:8fa3f7c3a9ad
 import sys
 import time
 import weakref
 from concurrent import futures
+from typing import (
+Optional,
+)
 from .i18n import _
 from .node import (
 bin,
 hex,
 nullrev,
 # a missing file translates to no requirements.
 read = vfs.tryread if allowmissing else vfs.read
 return set(read(b'requires').splitlines())
-def makelocalrepository(baseui, path, intents=None):
+def makelocalrepository(baseui, path: bytes, intents=None):
 """Create a local repository object.
 Given arguments needed to construct a local repository, this function
 performs various early repository loading functionality (such as
 reading the ``.hg/requires`` and ``.hg/hgrc`` files), validates that
 features=features,
 intents=intents,
 )
-def loadhgrc(ui, wdirvfs, hgvfs, requirements, sharedvfs=None):
+def loadhgrc(
+ui,
+wdirvfs: vfsmod.vfs,
+hgvfs: vfsmod.vfs,
+requirements,
+sharedvfs: Optional[vfsmod.vfs] = None,
+):
 """Load hgrc files/content into a ui instance.
 This is called during repository opening to load any additional
 config files or settings relevant to the current repository.
 def __init__(
 self,
 baseui,
 ui,
-origroot,
+origroot: bytes,
-wdirvfs,
+wdirvfs: vfsmod.vfs,
-hgvfs,
+hgvfs: vfsmod.vfs,
 requirements,
 supportedrequirements,
-sharedpath,
+sharedpath: bytes,
 store,
-cachevfs,
+cachevfs: vfsmod.vfs,
-wcachevfs,
+wcachevfs: vfsmod.vfs,
 features,
 intents=None,
 ):
 """Create a new local repository instance.
 return len(unfi.changelog)
 def __iter__(self):
 return iter(self.changelog)
-def revs(self, expr, *args):
+def revs(self, expr: bytes, *args):
 """Find revisions matching a revset.
 The revset is specified as a string ``expr`` that may contain
 %-formatting to escape certain types. See ``revsetlang.formatspec``.
 that contains integer revisions.
 """
 tree = revsetlang.spectree(expr, *args)
 return revset.makematcher(tree)(self)
-def set(self, expr, *args):
+def set(self, expr: bytes, *args):
 """Find revisions matching a revset and emit changectx instances.
 This is a convenience wrapper around ``revs()`` that iterates the
 result and is a generator of changectx instances.
 user aliases, consider calling ``scmutil.revrange()``.
 """
 for r in self.revs(expr, *args):
 yield self[r]
-def anyrevs(self, specs, user=False, localalias=None):
+def anyrevs(self, specs: bytes, user=False, localalias=None):
 """Find revisions matching one of the given revsets.
 Revset aliases from the configuration are not expanded by default. To
 expand user aliases, specify ``user=True``. To provide some local
 definitions overriding user aliases, set ``localalias`` to
 )
 else:
 m = revset.matchany(None, specs, localalias=localalias)
 return m(self)
-def url(self):
+def url(self) -> bytes:
 return b'file:' + self.root
 def hook(self, name, throw=False, **args):
 """Call a hook, passing this repo instance.
 '''the type of shared repository (None if not shared)'''
 if self.sharedpath != self.path:
 return b'store'
 return None
-def wjoin(self, f, *insidef):
+def wjoin(self, f: bytes, *insidef: bytes) -> bytes:
 return self.vfs.reljoin(self.root, f, *insidef)
 def setparents(self, p1, p2=None):
 if p2 is None:
 p2 = self.nullid
 self[None].setparents(p1, p2)
 self._quick_access_changeid_invalidate()
-def filectx(self, path, changeid=None, fileid=None, changectx=None):
+def filectx(self, path: bytes, changeid=None, fileid=None, changectx=None):
 """changeid must be a changeset revision, if specified.
 fileid can be a file revision or node."""
 return context.filectx(
 self, path, changeid, fileid, changectx=changectx
 )
-def getcwd(self):
+def getcwd(self) -> bytes:
 return self.dirstate.getcwd()
-def pathto(self, f, cwd=None):
+def pathto(self, f: bytes, cwd: Optional[bytes] = None) -> bytes:
 return self.dirstate.pathto(f, cwd)
 def _loadfilter(self, filter):
 if filter not in self._filterpats:
 l = []
 return self._loadfilter(b'decode')
 def adddatafilter(self, name, filter):
 self._datafilters[name] = filter
-def wread(self, filename):
+def wread(self, filename: bytes) -> bytes:
 if self.wvfs.islink(filename):
 data = self.wvfs.readlink(filename)
 else:
 data = self.wvfs.read(filename)
 return self._filter(self._encodefilterpats, filename, data)
-def wwrite(self, filename, data, flags, backgroundclose=False, **kwargs):
+def wwrite(
+self,
+filename: bytes,
+data: bytes,
+flags: bytes,
+backgroundclose=False,
+**kwargs
+) -> int:
 """write ``data`` into ``filename`` in the working directory
 This returns length of written (maybe decoded) data.
 """
 data = self._filter(self._decodefilterpats, filename, data)
 self.wvfs.setflags(filename, False, True)
 else:
 self.wvfs.setflags(filename, False, False)
 return len(data)
-def wwritedata(self, filename, data):
+def wwritedata(self, filename: bytes, data: bytes) -> bytes:
 return self._filter(self._decodefilterpats, filename, data)
 def currenttransaction(self):
 """return the current transaction or None if non exists"""
 if self._transref:
 pass
 return a
-def undoname(fn):
+def undoname(fn: bytes) -> bytes:
 base, name = os.path.split(fn)
 assert name.startswith(b'journal')
 return os.path.join(base, name.replace(b'journal', b'undo', 1))
-def instance(ui, path, create, intents=None, createopts=None):
+def instance(ui, path: bytes, create, intents=None, createopts=None):
 # prevent cyclic import localrepo -> upgrade -> localrepo
 from . import upgrade
 localpath = urlutil.urllocalpath(path)
 repo = repo_maker()
 repo = upgrade.may_auto_upgrade(repo, repo_maker)
 return repo
-def islocal(path):
+def islocal(path: bytes) -> bool:
 return True
 def defaultcreateopts(ui, createopts=None):
 """Populate the default creation options for a repository.
 }
 return {k: v for k, v in createopts.items() if k not in known}
-def createrepository(ui, path, createopts=None, requirements=None):
+def createrepository(ui, path: bytes, createopts=None, requirements=None):
 """Create a new repository in a vfs.
 ``path`` path to the new repo's working directory.
 ``createopts`` options for the new repository.
 ``requirement`` predefined set of requirements.

changeset 49571	8fa3f7c3a9ad
parent 49493	4367c46a89ee
child 49585	18282cf18aa2