mercurial-scm/hg: mercurial/localrepo.py comparison

comparison mercurial/localrepo.py @ 49571:8fa3f7c3a9ad

typing: add basic type hints to localrepo.py There's a lot more that could be done, but this sticks to the obviously correct stuff that is either related to existing imports or primitives. Hopefully this helps smoke out more path related bytes vs str issues in TortoiseHg. I'm avoiding the interfaces for now, because they seem to confuse pytype and/or PyCharm. It might be worth typing the return of `makelocalrepository` to `localrepository`, but that leaks an implementation detail, so that can be revisited later.

author	Matt Harbison <matt_harbison@yahoo.com>
date	Wed, 02 Nov 2022 16:43:01 -0400
parents	4367c46a89ee
children	18282cf18aa2

comparison

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.

Mercurial > public > mercurial-scm > hg

comparison mercurial/localrepo.py @ 49571:8fa3f7c3a9ad