This is an archive of the discontinued Mercurial Phabricator instance.

Differential D7305

cleanup: remove pointless r-prefixes on double-quoted strings
ClosedPublic

Authored by durin42 on Nov 7 2019, 2:36 PM.

Details

Reviewers
martinvonz
indygreg
Group Reviewers
hg-reviewers
Commits
rHG313e3a279828: cleanup: remove pointless r-prefixes on double-quoted strings
Summary

This is only double-quoted strings. I'll do single-quoted strings as a
second step. These had existed because our source transformer didn't
turn r"" into b"", so we had tagged some strings as r-strings to get
"native" strings on both Pythons. Now that the transformer is gone, we
can dispense with this nonsense.

Methodology:

I ran

hg locate 'set:added() or modified() or clean()' | egrep '.*\.py$'  | xargs egrep --color=never -n  -- \[\^a-z\]r\"\[\^\"\\\\\]\*\"\[\^\"\]

in an emacs grep-mode buffer, and then used a keyboard macro to
iterate over the results and remove the r prefix as needed.

  1. skip-blame removing unneeded r prefixes left over from Python 3 migration.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

durin42 created this revision.Nov 7 2019, 2:36 PM
indygreg accepted this revision.Nov 8 2019, 11:58 AM
indygreg added a subscriber: indygreg.

Thank you so much for doing this! The presence of raw literals since removing the source transformer has been bothering me too. In the ideal world, we ban the use of raw literals except in literals containing backslashes or newlines.

This revision is now accepted and ready to land.Nov 8 2019, 11:58 AM

Revision Contents
Changeset List

Diff 17793

contrib/check-code.py

], ],
] ]
# transform plain test rules to unified test's # transform plain test rules to unified test's
for i in [0, 1]: for i in [0, 1]:
for tp in testpats[i]: for tp in testpats[i]:
p = tp[0] p = tp[0]
m = tp[1] m = tp[1]
if p.startswith(r'^'): if p.startswith('^'):
p = r"^ [$>] (%s)" % p[1:] p = "^ [$>] (%s)" % p[1:]
else: else:
p = r"^ [$>] .*(%s)" % p p = "^ [$>] .*(%s)" % p
utestpats[i].append((p, m) + tp[2:]) utestpats[i].append((p, m) + tp[2:])
# don't transform the following rules: # don't transform the following rules:
# " > \t" and " \t" should be allowed in unified tests # " > \t" and " \t" should be allowed in unified tests
testpats[0].append((r'^( *)\t', "don't use tabs to indent")) testpats[0].append((r'^( *)\t', "don't use tabs to indent"))
utestpats[0].append((r'^( ?)\t', "don't use tabs to indent")) utestpats[0].append((r'^( ?)\t', "don't use tabs to indent"))
utestfilters = [ utestfilters = [

contrib/perf.py

def d(): def d():
if os.name != r'nt': if os.name != r'nt':
os.system( os.system(
b"HGRCPATH= %s version -q > /dev/null" % fsencode(sys.argv[0]) b"HGRCPATH= %s version -q > /dev/null" % fsencode(sys.argv[0])
) )
else: else:
os.environ[r'HGRCPATH'] = r' ' os.environ[r'HGRCPATH'] = r' '
os.system(r"%s version -q > NUL" % sys.argv[0]) os.system("%s version -q > NUL" % sys.argv[0])
timer(d) timer(d)
fm.end() fm.end()
@command(b'perfparents', formatteropts) @command(b'perfparents', formatteropts)
def perfparents(ui, repo, **opts): def perfparents(ui, repo, **opts):
"""benchmark the time necessary to fetch one changeset's parents. """benchmark the time necessary to fetch one changeset's parents.

doc/gendoc.py

msvcrt.setmode(sys.stderr.fileno(), os.O_BINARY) msvcrt.setmode(sys.stderr.fileno(), os.O_BINARY)
except ImportError: except ImportError:
pass pass
# This script is executed during installs and may not have C extensions # This script is executed during installs and may not have C extensions
# available. Relax C module requirements. # available. Relax C module requirements.
os.environ[r'HGMODULEPOLICY'] = r'allow' os.environ[r'HGMODULEPOLICY'] = r'allow'
# import from the live mercurial repo # import from the live mercurial repo
sys.path.insert(0, r"..") sys.path.insert(0, "..")
from mercurial import demandimport from mercurial import demandimport
demandimport.enable() demandimport.enable()
# Load util so that the locale path is set by i18n.setdatapath() before # Load util so that the locale path is set by i18n.setdatapath() before
# calling _(). # calling _().
from mercurial import util from mercurial import util
util.datapath util.datapath

hgdemandimport/demandimportpy2.py

def __init__(self, name, globals, locals, level): def __init__(self, name, globals, locals, level):
if '.' in name: if '.' in name:
head, rest = name.split('.', 1) head, rest = name.split('.', 1)
after = [rest] after = [rest]
else: else:
head = name head = name
after = [] after = []
object.__setattr__( object.__setattr__(
self, r"_data", (head, globals, locals, after, level, set()) self, "_data", (head, globals, locals, after, level, set())
) )
object.__setattr__(self, r"_module", None) object.__setattr__(self, "_module", None)
def _extend(self, name): def _extend(self, name):
"""add to the list of submodules to load""" """add to the list of submodules to load"""
self._data[3].append(name) self._data[3].append(name)
def _addref(self, name): def _addref(self, name):
"""Record that the named module ``name`` imports this module. """Record that the named module ``name`` imports this module.
elif locals.get(head + r'mod') is self: elif locals.get(head + r'mod') is self:
locals[head + r'mod'] = mod locals[head + r'mod'] = mod
for modname in modrefs: for modname in modrefs:
modref = sys.modules.get(modname, None) modref = sys.modules.get(modname, None)
if modref and getattr(modref, head, None) is self: if modref and getattr(modref, head, None) is self:
setattr(modref, head, mod) setattr(modref, head, mod)
object.__setattr__(self, r"_module", mod) object.__setattr__(self, "_module", mod)
def __repr__(self): def __repr__(self):
if self._module: if self._module:
return "<proxied module '%s'>" % self._data[0] return "<proxied module '%s'>" % self._data[0]
return "<unloaded module '%s'>" % self._data[0] return "<unloaded module '%s'>" % self._data[0]
def __call__(self, *args, **kwargs): def __call__(self, *args, **kwargs):
raise TypeError("%s object is not callable" % repr(self)) raise TypeError("%s object is not callable" % repr(self))

hgext/convert/common.py

self.checkexit(status, b''.join(output)) self.checkexit(status, b''.join(output))
return output return output
@propertycache @propertycache
def argmax(self): def argmax(self):
# POSIX requires at least 4096 bytes for ARG_MAX # POSIX requires at least 4096 bytes for ARG_MAX
argmax = 4096 argmax = 4096
try: try:
argmax = os.sysconf(r"SC_ARG_MAX") argmax = os.sysconf("SC_ARG_MAX")
except (AttributeError, ValueError): except (AttributeError, ValueError):
pass pass
# Windows shells impose their own limits on command line length, # Windows shells impose their own limits on command line length,
# down to 2047 bytes for cmd.exe under Windows NT/2k and 2500 bytes # down to 2047 bytes for cmd.exe under Windows NT/2k and 2500 bytes
# for older 4nt.exe. See http://support.microsoft.com/kb/830473 for # for older 4nt.exe. See http://support.microsoft.com/kb/830473 for
# details about cmd.exe limitations. # details about cmd.exe limitations.

hgext/convert/cvsps.py

.branchpoints - the branches that start at the current entry or empty .branchpoints - the branches that start at the current entry or empty
''' '''
def __init__(self, **entries): def __init__(self, **entries):
self.synthetic = False self.synthetic = False
self.__dict__.update(entries) self.__dict__.update(entries)
def __repr__(self): def __repr__(self):
items = ( items = ("%s=%r" % (k, self.__dict__[k]) for k in sorted(self.__dict__))
r"%s=%r" % (k, self.__dict__[k]) for k in sorted(self.__dict__) return "%s(%s)" % (type(self).__name__, ", ".join(items))
)
return r"%s(%s)" % (type(self).__name__, r", ".join(items))
class logerror(Exception): class logerror(Exception):
pass pass
def getrepopath(cvspath): def getrepopath(cvspath):
"""Return the repository path from a CVS path. """Return the repository path from a CVS path.

hgext/githelp.py

cmdoptions = list(cmdoptions) cmdoptions = list(cmdoptions)
opts = {} opts = {}
args = list(args) args = list(args)
while True: while True:
try: try:
args = fancyopts.fancyopts(list(args), cmdoptions, opts, True) args = fancyopts.fancyopts(list(args), cmdoptions, opts, True)
break break
except getopt.GetoptError as ex: except getopt.GetoptError as ex:
if r"requires argument" in ex.msg: if "requires argument" in ex.msg:
raise raise
if (r'--' + ex.opt) in ex.msg: if (r'--' + ex.opt) in ex.msg:
flag = b'--' + pycompat.bytestr(ex.opt) flag = b'--' + pycompat.bytestr(ex.opt)
elif (r'-' + ex.opt) in ex.msg: elif (r'-' + ex.opt) in ex.msg:
flag = b'-' + pycompat.bytestr(ex.opt) flag = b'-' + pycompat.bytestr(ex.opt)
else: else:
raise error.Abort( raise error.Abort(
_(b"unknown option %s") % pycompat.bytestr(ex.opt) _(b"unknown option %s") % pycompat.bytestr(ex.opt)

hgext/lfs/wireprotolfsserver.py

exists = False exists = False
# Items are always listed for downloads. They are dropped for uploads # Items are always listed for downloads. They are dropped for uploads
# IFF they already exist locally. # IFF they already exist locally.
if action == b'download': if action == b'download':
if not exists: if not exists:
rsp[r'error'] = { rsp[r'error'] = {
r'code': 404, r'code': 404,
r'message': r"The object does not exist", r'message': "The object does not exist",
} }
yield rsp yield rsp
continue continue
elif not verifies: elif not verifies:
rsp[r'error'] = { rsp[r'error'] = {
r'code': 422, # XXX: is this the right code? r'code': 422, # XXX: is this the right code?
r'message': r"The object is corrupt", r'message': "The object is corrupt",
} }
yield rsp yield rsp
continue continue
elif verifies: elif verifies:
yield rsp # Skip 'actions': already uploaded yield rsp # Skip 'actions': already uploaded
continue continue
rsp[r'actions'] = { rsp[r'actions'] = {
r'%s' r'%s'
% pycompat.strurl(action): { % pycompat.strurl(action): {
r'href': pycompat.strurl( r'href': pycompat.strurl(
b'%s%s/.hg/lfs/objects/%s' % (req.baseurl, req.apppath, oid) b'%s%s/.hg/lfs/objects/%s' % (req.baseurl, req.apppath, oid)
), ),
# datetime.isoformat() doesn't include the 'Z' suffix # datetime.isoformat() doesn't include the 'Z' suffix
r"expires_at": expiresat.strftime(r'%Y-%m-%dT%H:%M:%SZ'), "expires_at": expiresat.strftime(r'%Y-%m-%dT%H:%M:%SZ'),
r'header': _buildheader(), r'header': _buildheader(),
} }
} }
yield rsp yield rsp
def _processbasictransfer(repo, req, res, checkperm): def _processbasictransfer(repo, req, res, checkperm):

hgext/narrow/narrowwirepeer.py

def reposetup(repo): def reposetup(repo):
def wirereposetup(ui, peer): def wirereposetup(ui, peer):
def wrapped(orig, cmd, *args, **kwargs): def wrapped(orig, cmd, *args, **kwargs):
if cmd == b'unbundle': if cmd == b'unbundle':
# TODO: don't blindly add include/exclude wireproto # TODO: don't blindly add include/exclude wireproto
# arguments to unbundle. # arguments to unbundle.
include, exclude = repo.narrowpats include, exclude = repo.narrowpats
kwargs[r"includepats"] = b','.join(include) kwargs["includepats"] = b','.join(include)
kwargs[r"excludepats"] = b','.join(exclude) kwargs["excludepats"] = b','.join(exclude)
return orig(cmd, *args, **kwargs) return orig(cmd, *args, **kwargs)
extensions.wrapfunction(peer, b'_calltwowaystream', wrapped) extensions.wrapfunction(peer, b'_calltwowaystream', wrapped)
hg.wirepeersetupfuncs.append(wirereposetup) hg.wirepeersetupfuncs.append(wirereposetup)
@wireprotov1server.wireprotocommand( @wireprotov1server.wireprotocommand(

hgext/record.py

This command is not available when committing a merge.''' This command is not available when committing a merge.'''
if not ui.interactive(): if not ui.interactive():
raise error.Abort( raise error.Abort(
_(b'running non-interactively, use %s instead') % b'commit' _(b'running non-interactively, use %s instead') % b'commit'
) )
opts[r"interactive"] = True opts["interactive"] = True
overrides = {(b'experimental', b'crecord'): False} overrides = {(b'experimental', b'crecord'): False}
with ui.configoverride(overrides, b'record'): with ui.configoverride(overrides, b'record'):
return commands.commit(ui, repo, *pats, **opts) return commands.commit(ui, repo, *pats, **opts)
def qrefresh(origfn, ui, repo, *pats, **opts): def qrefresh(origfn, ui, repo, *pats, **opts):
if not opts[r'interactive']: if not opts[r'interactive']:
return origfn(ui, repo, *pats, **opts) return origfn(ui, repo, *pats, **opts)

hgext/remotefilelog/shallowutil.py

else: else:
raise RuntimeError( raise RuntimeError(
b'unsupported remotefilelog header: %s' % header b'unsupported remotefilelog header: %s' % header
) )
else: else:
# v0, str(int(size)) is the header # v0, str(int(size)) is the header
size = int(header) size = int(header)
except ValueError: except ValueError:
raise RuntimeError(r"unexpected remotefilelog header: illegal format") raise RuntimeError("unexpected remotefilelog header: illegal format")
if size is None: if size is None:
raise RuntimeError(r"unexpected remotefilelog header: no size found") raise RuntimeError("unexpected remotefilelog header: no size found")
return index + 1, size, flags return index + 1, size, flags
def buildfileblobheader(size, flags, version=None): def buildfileblobheader(size, flags, version=None):
"""return the header of a remotefilelog blob. """return the header of a remotefilelog blob.
see remotefilelogserver.createfileblob for the format. see remotefilelogserver.createfileblob for the format.
approximately the reverse of parsesizeflags. approximately the reverse of parsesizeflags.

hgext/zeroconf/__init__.py

if ip.startswith(r'127.'): if ip.startswith(r'127.'):
# if we have no internet connection, this can happen. # if we have no internet connection, this can happen.
return return
localip = socket.inet_aton(ip) localip = socket.inet_aton(ip)
server = Zeroconf.Zeroconf(ip) server = Zeroconf.Zeroconf(ip)
hostname = socket.gethostname().split(r'.')[0] hostname = socket.gethostname().split(r'.')[0]
host = hostname + r".local" host = hostname + r".local"
name = r"%s-%s" % (hostname, name) name = "%s-%s" % (hostname, name)
# advertise to browsers # advertise to browsers
svc = Zeroconf.ServiceInfo( svc = Zeroconf.ServiceInfo(
b'_http._tcp.local.', b'_http._tcp.local.',
pycompat.bytestr(name + r'._http._tcp.local.'), pycompat.bytestr(name + r'._http._tcp.local.'),
server=host, server=host,
port=port, port=port,
properties={b'description': desc, b'path': b"/" + path}, properties={b'description': desc, b'path': b"/" + path},
return return
server = Zeroconf.Zeroconf(ip) server = Zeroconf.Zeroconf(ip)
l = listener() l = listener()
Zeroconf.ServiceBrowser(server, b"_hg._tcp.local.", l) Zeroconf.ServiceBrowser(server, b"_hg._tcp.local.", l)
time.sleep(1) time.sleep(1)
server.close() server.close()
for value in l.found.values(): for value in l.found.values():
name = value.name[: value.name.index(b'.')] name = value.name[: value.name.index(b'.')]
url = r"http://%s:%s%s" % ( url = "http://%s:%s%s" % (
socket.inet_ntoa(value.address), socket.inet_ntoa(value.address),
value.port, value.port,
value.properties.get(r"path", r"/"), value.properties.get("path", "/"),
) )
yield b"zc-" + name, pycompat.bytestr(url) yield b"zc-" + name, pycompat.bytestr(url)
def config(orig, self, section, key, *args, **kwargs): def config(orig, self, section, key, *args, **kwargs):
if section == b"paths" and key.startswith(b"zc-"): if section == b"paths" and key.startswith(b"zc-"):
for name, path in getzcpaths(): for name, path in getzcpaths():
if name == key: if name == key:

mercurial/changegroup.py

if vfs: if vfs:
fh = vfs.open(filename, b"wb") fh = vfs.open(filename, b"wb")
else: else:
# Increase default buffer size because default is usually # Increase default buffer size because default is usually
# small (4k is common on Linux). # small (4k is common on Linux).
fh = open(filename, b"wb", 131072) fh = open(filename, b"wb", 131072)
else: else:
fd, filename = pycompat.mkstemp(prefix=b"hg-bundle-", suffix=b".hg") fd, filename = pycompat.mkstemp(prefix=b"hg-bundle-", suffix=b".hg")
fh = os.fdopen(fd, r"wb") fh = os.fdopen(fd, "wb")
cleanup = filename cleanup = filename
for c in chunks: for c in chunks:
fh.write(c) fh.write(c)
cleanup = None cleanup = None
return filename return filename
finally: finally:
if fh is not None: if fh is not None:
fh.close() fh.close()

mercurial/context.py

self._repo = repo self._repo = repo
def __bytes__(self): def __bytes__(self):
return short(self.node()) return short(self.node())
__str__ = encoding.strmethod(__bytes__) __str__ = encoding.strmethod(__bytes__)
def __repr__(self): def __repr__(self):
return r"<%s %s>" % (type(self).__name__, str(self)) return "<%s %s>" % (type(self).__name__, str(self))
def __eq__(self, other): def __eq__(self, other):
try: try:
return type(self) == type(other) and self._rev == other._rev return type(self) == type(other) and self._rev == other._rev
except AttributeError: except AttributeError:
return False return False
def __ne__(self, other): def __ne__(self, other):
try: try:
return b"%s@%s" % (self.path(), self._changectx) return b"%s@%s" % (self.path(), self._changectx)
except error.LookupError: except error.LookupError:
return b"%s@???" % self.path() return b"%s@???" % self.path()
__str__ = encoding.strmethod(__bytes__) __str__ = encoding.strmethod(__bytes__)
def __repr__(self): def __repr__(self):
return r"<%s %s>" % (type(self).__name__, str(self)) return "<%s %s>" % (type(self).__name__, str(self))
def __hash__(self): def __hash__(self):
try: try:
return hash((self._path, self._filenode)) return hash((self._path, self._filenode))
except AttributeError: except AttributeError:
return id(self) return id(self)
def __eq__(self, other): def __eq__(self, other):

mercurial/debugcommands.py

b'debugdate', b'debugdate',
[(b'e', b'extended', None, _(b'try extended date formats'))], [(b'e', b'extended', None, _(b'try extended date formats'))],
_(b'[-e] DATE [RANGE]'), _(b'[-e] DATE [RANGE]'),
norepo=True, norepo=True,
optionalrepo=True, optionalrepo=True,
) )
def debugdate(ui, date, range=None, **opts): def debugdate(ui, date, range=None, **opts):
"""parse and display a date""" """parse and display a date"""
if opts[r"extended"]: if opts["extended"]:
d = dateutil.parsedate(date, util.extendeddateformats) d = dateutil.parsedate(date, util.extendeddateformats)
else: else:
d = dateutil.parsedate(date) d = dateutil.parsedate(date)
ui.writenoi18n(b"internal: %d %d\n" % d) ui.writenoi18n(b"internal: %d %d\n" % d)
ui.writenoi18n(b"standard: %s\n" % dateutil.datestr(d)) ui.writenoi18n(b"standard: %s\n" % dateutil.datestr(d))
if range: if range:
m = dateutil.matchdate(range) m = dateutil.matchdate(range)
ui.writenoi18n(b"match: %s\n" % m(d[0])) ui.writenoi18n(b"match: %s\n" % m(d[0]))
keyfunc = None # sort by filename keyfunc = None # sort by filename
for file_, ent in sorted(pycompat.iteritems(repo.dirstate), key=keyfunc): for file_, ent in sorted(pycompat.iteritems(repo.dirstate), key=keyfunc):
if ent[3] == -1: if ent[3] == -1:
timestr = b'unset ' timestr = b'unset '
elif nodates: elif nodates:
timestr = b'set ' timestr = b'set '
else: else:
timestr = time.strftime( timestr = time.strftime(
r"%Y-%m-%d %H:%M:%S ", time.localtime(ent[3]) "%Y-%m-%d %H:%M:%S ", time.localtime(ent[3])
) )
timestr = encoding.strtolocal(timestr) timestr = encoding.strtolocal(timestr)
if ent[1] & 0o20000: if ent[1] & 0o20000:
mode = b'lnk' mode = b'lnk'
else: else:
mode = b'%3o' % (ent[1] & 0o777 & ~util.umask) mode = b'%3o' % (ent[1] & 0o777 & ~util.umask)
ui.write(b"%c %s %10d %s%s\n" % (ent[0], mode, ent[2], timestr, file_)) ui.write(b"%c %s %10d %s%s\n" % (ent[0], mode, ent[2], timestr, file_))
for f in repo.dirstate.copies(): for f in repo.dirstate.copies():

mercurial/dirstate.py

def invalidate(self): def invalidate(self):
'''Causes the next access to reread the dirstate. '''Causes the next access to reread the dirstate.
This is different from localrepo.invalidatedirstate() because it always This is different from localrepo.invalidatedirstate() because it always
rereads the dirstate. Use localrepo.invalidatedirstate() if you want to rereads the dirstate. Use localrepo.invalidatedirstate() if you want to
check whether the dirstate has changed before rereading it.''' check whether the dirstate has changed before rereading it.'''
for a in (r"_map", r"_branch", r"_ignore"): for a in ("_map", "_branch", "_ignore"):
if a in self.__dict__: if a in self.__dict__:
delattr(self, a) delattr(self, a)
self._lastnormaltime = 0 self._lastnormaltime = 0
self._dirty = False self._dirty = False
self._updatedfiles.clear() self._updatedfiles.clear()
self._parentwriters = 0 self._parentwriters = 0
self._origpl = None self._origpl = None
return self._map.keys() return self._map.keys()
def preload(self): def preload(self):
"""Loads the underlying data, if it's not already loaded""" """Loads the underlying data, if it's not already loaded"""
self._map self._map
def addfile(self, f, oldstate, state, mode, size, mtime): def addfile(self, f, oldstate, state, mode, size, mtime):
"""Add a tracked file to the dirstate.""" """Add a tracked file to the dirstate."""
if oldstate in b"?r" and r"_dirs" in self.__dict__: if oldstate in b"?r" and "_dirs" in self.__dict__:
self._dirs.addpath(f) self._dirs.addpath(f)
if oldstate == b"?" and r"_alldirs" in self.__dict__: if oldstate == b"?" and "_alldirs" in self.__dict__:
self._alldirs.addpath(f) self._alldirs.addpath(f)
self._map[f] = dirstatetuple(state, mode, size, mtime) self._map[f] = dirstatetuple(state, mode, size, mtime)
if state != b'n' or mtime == -1: if state != b'n' or mtime == -1:
self.nonnormalset.add(f) self.nonnormalset.add(f)
if size == -2: if size == -2:
self.otherparentset.add(f) self.otherparentset.add(f)
def removefile(self, f, oldstate, size): def removefile(self, f, oldstate, size):
""" """
Mark a file as removed in the dirstate. Mark a file as removed in the dirstate.
The `size` parameter is used to store sentinel values that indicate The `size` parameter is used to store sentinel values that indicate
the file's previous state. In the future, we should refactor this the file's previous state. In the future, we should refactor this
to be more explicit about what that state is. to be more explicit about what that state is.
""" """
if oldstate not in b"?r" and r"_dirs" in self.__dict__: if oldstate not in b"?r" and "_dirs" in self.__dict__:
self._dirs.delpath(f) self._dirs.delpath(f)
if oldstate == b"?" and r"_alldirs" in self.__dict__: if oldstate == b"?" and "_alldirs" in self.__dict__:
self._alldirs.addpath(f) self._alldirs.addpath(f)
if r"filefoldmap" in self.__dict__: if "filefoldmap" in self.__dict__:
normed = util.normcase(f) normed = util.normcase(f)
self.filefoldmap.pop(normed, None) self.filefoldmap.pop(normed, None)
self._map[f] = dirstatetuple(b'r', 0, size, 0) self._map[f] = dirstatetuple(b'r', 0, size, 0)
self.nonnormalset.add(f) self.nonnormalset.add(f)
def dropfile(self, f, oldstate): def dropfile(self, f, oldstate):
""" """
Remove a file from the dirstate. Returns True if the file was Remove a file from the dirstate. Returns True if the file was
previously recorded. previously recorded.
""" """
exists = self._map.pop(f, None) is not None exists = self._map.pop(f, None) is not None
if exists: if exists:
if oldstate != b"r" and r"_dirs" in self.__dict__: if oldstate != b"r" and "_dirs" in self.__dict__:
self._dirs.delpath(f) self._dirs.delpath(f)
if r"_alldirs" in self.__dict__: if "_alldirs" in self.__dict__:
self._alldirs.delpath(f) self._alldirs.delpath(f)
if r"filefoldmap" in self.__dict__: if "filefoldmap" in self.__dict__:
normed = util.normcase(f) normed = util.normcase(f)
self.filefoldmap.pop(normed, None) self.filefoldmap.pop(normed, None)
self.nonnormalset.discard(f) self.nonnormalset.discard(f)
return exists return exists
def clearambiguoustimes(self, files, now): def clearambiguoustimes(self, files, now):
for f in files: for f in files:
e = self.get(f) e = self.get(f)

mercurial/encoding.py

try: try:
try: try:
# make sure string is actually stored in UTF-8 # make sure string is actually stored in UTF-8
u = s.decode('UTF-8') u = s.decode('UTF-8')
if encoding == b'UTF-8': if encoding == b'UTF-8':
# fast path # fast path
return s return s
r = u.encode(_sysstr(encoding), r"replace") r = u.encode(_sysstr(encoding), "replace")
if u == r.decode(_sysstr(encoding)): if u == r.decode(_sysstr(encoding)):
# r is a safe, non-lossy encoding of s # r is a safe, non-lossy encoding of s
return safelocalstr(r) return safelocalstr(r)
return localstr(s, r) return localstr(s, r)
except UnicodeDecodeError: except UnicodeDecodeError:
# we should only get here if we're looking at an ancient changeset # we should only get here if we're looking at an ancient changeset
try: try:
u = s.decode(_sysstr(fallbackencoding)) u = s.decode(_sysstr(fallbackencoding))
r = u.encode(_sysstr(encoding), r"replace") r = u.encode(_sysstr(encoding), "replace")
if u == r.decode(_sysstr(encoding)): if u == r.decode(_sysstr(encoding)):
# r is a safe, non-lossy encoding of s # r is a safe, non-lossy encoding of s
return safelocalstr(r) return safelocalstr(r)
return localstr(u.encode('UTF-8'), r) return localstr(u.encode('UTF-8'), r)
except UnicodeDecodeError: except UnicodeDecodeError:
u = s.decode("utf-8", "replace") # last ditch u = s.decode("utf-8", "replace") # last ditch
# can't round-trip # can't round-trip
return u.encode(_sysstr(encoding), r"replace") return u.encode(_sysstr(encoding), "replace")
except LookupError as k: except LookupError as k:
raise error.Abort(k, hint=b"please check your locale settings") raise error.Abort(k, hint=b"please check your locale settings")
def fromlocal(s): def fromlocal(s):
# type: (bytes) -> Text # type: (bytes) -> Text
""" """
Convert a string from the local character encoding to UTF-8 Convert a string from the local character encoding to UTF-8

mercurial/extensions.py

def wrap(*args, **kwargs): def wrap(*args, **kwargs):
return wrapper(origfn, *args, **kwargs) return wrapper(origfn, *args, **kwargs)
currcls.__dict__[propname].func = wrap currcls.__dict__[propname].func = wrap
break break
if currcls is object: if currcls is object:
raise AttributeError( raise AttributeError("type '%s' has no property '%s'" % (cls, propname))
r"type '%s' has no property '%s'" % (cls, propname)
)
class wrappedfunction(object): class wrappedfunction(object):
'''context manager for temporarily wrapping a function''' '''context manager for temporarily wrapping a function'''
def __init__(self, container, funcname, wrapper): def __init__(self, container, funcname, wrapper):
assert callable(wrapper) assert callable(wrapper)
self._container = container self._container = container

mercurial/filemerge.py

def maketempfrompath(prefix, path): def maketempfrompath(prefix, path):
fullbase, ext = os.path.splitext(path) fullbase, ext = os.path.splitext(path)
pre = b"%s~%s" % (os.path.basename(fullbase), prefix) pre = b"%s~%s" % (os.path.basename(fullbase), prefix)
if tmproot: if tmproot:
name = os.path.join(tmproot, pre) name = os.path.join(tmproot, pre)
if ext: if ext:
name += ext name += ext
f = open(name, r"wb") f = open(name, "wb")
else: else:
fd, name = pycompat.mkstemp(prefix=pre + b'.', suffix=ext) fd, name = pycompat.mkstemp(prefix=pre + b'.', suffix=ext)
f = os.fdopen(fd, r"wb") f = os.fdopen(fd, "wb")
return f, name return f, name
def tempfromcontext(prefix, ctx): def tempfromcontext(prefix, ctx):
f, name = maketempfrompath(prefix, ctx.path()) f, name = maketempfrompath(prefix, ctx.path())
data = repo.wwritedata(ctx.path(), ctx.data()) data = repo.wwritedata(ctx.path(), ctx.data())
f.write(data) f.write(data)
f.close() f.close()
return name return name

mercurial/hgweb/server.py

def flush(self): def flush(self):
pass pass
def write(self, str): def write(self, str):
self.writelines(str.split(b'\n')) self.writelines(str.split(b'\n'))
def writelines(self, seq): def writelines(self, seq):
for msg in seq: for msg in seq:
self.handler.log_error(r"HG error: %s", encoding.strfromlocal(msg)) self.handler.log_error("HG error: %s", encoding.strfromlocal(msg))
class _httprequesthandler(httpservermod.basehttprequesthandler): class _httprequesthandler(httpservermod.basehttprequesthandler):
url_scheme = b'http' url_scheme = b'http'
@staticmethod @staticmethod
def preparehttpserver(httpserver, ui): def preparehttpserver(httpserver, ui):
self.do_write() self.do_write()
except Exception as e: except Exception as e:
# I/O below could raise another exception. So log the original # I/O below could raise another exception. So log the original
# exception first to ensure it is recorded. # exception first to ensure it is recorded.
if not ( if not (
isinstance(e, (OSError, socket.error)) isinstance(e, (OSError, socket.error))
and e.errno == errno.ECONNRESET and e.errno == errno.ECONNRESET
): ):
tb = r"".join(traceback.format_exception(*sys.exc_info())) tb = "".join(traceback.format_exception(*sys.exc_info()))
# We need a native-string newline to poke in the log # We need a native-string newline to poke in the log
# message, because we won't get a newline when using an # message, because we won't get a newline when using an
# r-string. This is the easy way out. # r-string. This is the easy way out.
newline = chr(10) newline = chr(10)
self.log_error( self.log_error(
r"Exception happened during processing " r"Exception happened during processing "
r"request '%s':%s%s", "request '%s':%s%s",
self.path, self.path,
newline, newline,
tb, tb,
) )
self._start_response(r"500 Internal Server Error", []) self._start_response("500 Internal Server Error", [])
self._write(b"Internal Server Error") self._write(b"Internal Server Error")
self._done() self._done()
def do_PUT(self): def do_PUT(self):
self.do_POST() self.do_POST()
def do_GET(self): def do_GET(self):
self.do_POST() self.do_POST()
ui, ui,
certfile=certfile, certfile=certfile,
cafile=cafile, cafile=cafile,
requireclientcert=reqcert, requireclientcert=reqcert,
) )
def setup(self): def setup(self):
self.connection = self.request self.connection = self.request
self.rfile = self.request.makefile(r"rb", self.rbufsize) self.rfile = self.request.makefile("rb", self.rbufsize)
self.wfile = self.request.makefile(r"wb", self.wbufsize) self.wfile = self.request.makefile("wb", self.wbufsize)
try: try:
import threading import threading
threading.activeCount() # silence pyflakes and bypass demandimport threading.activeCount() # silence pyflakes and bypass demandimport
_mixin = socketserver.ThreadingMixIn _mixin = socketserver.ThreadingMixIn
except ImportError: except ImportError:

mercurial/hgweb/wsgiheaders.py

These will be sorted in the order they were in the original header These will be sorted in the order they were in the original header
list, or were added to this instance, and may contain duplicates. list, or were added to this instance, and may contain duplicates.
Any fields deleted and re-inserted are always appended to the header Any fields deleted and re-inserted are always appended to the header
list. list.
""" """
return self._headers[:] return self._headers[:]
def __repr__(self): def __repr__(self):
return r"%s(%r)" % (self.__class__.__name__, self._headers) return "%s(%r)" % (self.__class__.__name__, self._headers)
def __str__(self): def __str__(self):
"""str() returns the formatted headers, complete with end line, """str() returns the formatted headers, complete with end line,
suitable for direct HTTP transmission.""" suitable for direct HTTP transmission."""
return b'\r\n'.join( return b'\r\n'.join(
[b"%s: %s" % kv for kv in self._headers] + [b'', b''] [b"%s: %s" % kv for kv in self._headers] + [b'', b'']
) )

mercurial/hook.py

hook failure. exception propagates if throw is "true". hook failure. exception propagates if throw is "true".
reason for "true" meaning "hook failed" is so that reason for "true" meaning "hook failed" is so that
unmodified commands (e.g. mercurial.commands.update) can unmodified commands (e.g. mercurial.commands.update) can
be run as hooks without wrappers to convert return values.''' be run as hooks without wrappers to convert return values.'''
if callable(funcname): if callable(funcname):
obj = funcname obj = funcname
funcname = pycompat.sysbytes(obj.__module__ + r"." + obj.__name__) funcname = pycompat.sysbytes(obj.__module__ + "." + obj.__name__)
else: else:
d = funcname.rfind(b'.') d = funcname.rfind(b'.')
if d == -1: if d == -1:
raise error.HookLoadError( raise error.HookLoadError(
_(b'%s hook is invalid: "%s" not in a module') _(b'%s hook is invalid: "%s" not in a module')
% (hname, funcname) % (hname, funcname)
) )
modname = funcname[:d] modname = funcname[:d]
oldpaths = sys.path oldpaths = sys.path
if procutil.mainfrozen(): if procutil.mainfrozen():
# binary installs require sys.path manipulation # binary installs require sys.path manipulation
modpath, modfile = os.path.split(modname) modpath, modfile = os.path.split(modname)
if modpath and modfile: if modpath and modfile:
sys.path = sys.path[:] + [modpath] sys.path = sys.path[:] + [modpath]
modname = modfile modname = modfile
with demandimport.deactivated(): with demandimport.deactivated():
try: try:
obj = __import__(pycompat.sysstr(modname)) obj = __import__(pycompat.sysstr(modname))
except (ImportError, SyntaxError): except (ImportError, SyntaxError):
e1 = sys.exc_info() e1 = sys.exc_info()
try: try:
# extensions are loaded with hgext_ prefix # extensions are loaded with hgext_ prefix
obj = __import__(r"hgext_%s" % pycompat.sysstr(modname)) obj = __import__("hgext_%s" % pycompat.sysstr(modname))
except (ImportError, SyntaxError): except (ImportError, SyntaxError):
e2 = sys.exc_info() e2 = sys.exc_info()
if ui.tracebackflag: if ui.tracebackflag:
ui.warn( ui.warn(
_( _(
b'exception from first failed import ' b'exception from first failed import '
b'attempt:\n' b'attempt:\n'
) )

mercurial/httppeer.py

fp.close() fp.close()
os.unlink(tempname) os.unlink(tempname)
def _calltwowaystream(self, cmd, fp, **args): def _calltwowaystream(self, cmd, fp, **args):
filename = None filename = None
try: try:
# dump bundle to disk # dump bundle to disk
fd, filename = pycompat.mkstemp(prefix=b"hg-bundle-", suffix=b".hg") fd, filename = pycompat.mkstemp(prefix=b"hg-bundle-", suffix=b".hg")
with os.fdopen(fd, r"wb") as fh: with os.fdopen(fd, "wb") as fh:
d = fp.read(4096) d = fp.read(4096)
while d: while d:
fh.write(d) fh.write(d)
d = fp.read(4096) d = fp.read(4096)
# start http push # start http push
with httpconnection.httpsendfile(self.ui, filename, b"rb") as fp_: with httpconnection.httpsendfile(self.ui, filename, b"rb") as fp_:
headers = {r'Content-Type': r'application/mercurial-0.1'} headers = {r'Content-Type': r'application/mercurial-0.1'}
return self._callstream(cmd, data=fp_, headers=headers, **args) return self._callstream(cmd, data=fp_, headers=headers, **args)

mercurial/lock.py

return self return self
def __exit__(self, exc_type, exc_value, exc_tb): def __exit__(self, exc_type, exc_value, exc_tb):
self.release() self.release()
def __del__(self): def __del__(self):
if self.held: if self.held:
warnings.warn( warnings.warn(
r"use lock.release instead of del lock", "use lock.release instead of del lock",
category=DeprecationWarning, category=DeprecationWarning,
stacklevel=2, stacklevel=2,
) )
# ensure the lock will be removed # ensure the lock will be removed
# even if recursive locking did occur # even if recursive locking did occur
self.held = 1 self.held = 1

mercurial/lsprof.py

class Stats(object): class Stats(object):
"""XXX docstring""" """XXX docstring"""
def __init__(self, data): def __init__(self, data):
self.data = data self.data = data
def sort(self, crit=r"inlinetime"): def sort(self, crit="inlinetime"):
"""XXX docstring""" """XXX docstring"""
# profiler_entries isn't defined when running under PyPy. # profiler_entries isn't defined when running under PyPy.
if profiler_entry: if profiler_entry:
if crit not in profiler_entry.__dict__: if crit not in profiler_entry.__dict__:
raise ValueError(b"Can't sort by %s" % crit) raise ValueError(b"Can't sort by %s" % crit)
elif self.data and not getattr(self.data[0], crit, None): elif self.data and not getattr(self.data[0], crit, None):
raise ValueError(b"Can't sort by %s" % crit) raise ValueError(b"Can't sort by %s" % crit)

mercurial/patch.py

if bfile == b'/dev/null': if bfile == b'/dev/null':
return self.op == b'DELETE' return self.op == b'DELETE'
return bfile == b'b/' + self.path return bfile == b'b/' + self.path
def ispatching(self, afile, bfile): def ispatching(self, afile, bfile):
return self._ispatchinga(afile) and self._ispatchingb(bfile) return self._ispatchinga(afile) and self._ispatchingb(bfile)
def __repr__(self): def __repr__(self):
return r"<patchmeta %s %r>" % (self.op, self.path) return "<patchmeta %s %r>" % (self.op, self.path)
def readgitpatch(lr): def readgitpatch(lr):
"""extract git-style metadata about patches from <patchname>""" """extract git-style metadata about patches from <patchname>"""
# Filter patch for git information # Filter patch for git information
gp = None gp = None
gitpatches = [] gitpatches = []

mercurial/policy.py

if member is None: if member is None:
return mod return mod
try: try:
return getattr(mod, member) return getattr(mod, member)
except AttributeError: except AttributeError:
if _isrustpermissive(): if _isrustpermissive():
return default return default
raise ImportError(r"Cannot import name %s" % member) raise ImportError("Cannot import name %s" % member)

mercurial/pure/osutil.py

if m0 == b'r': if m0 == b'r':
creation = _OPEN_EXISTING creation = _OPEN_EXISTING
elif m0 == b'w': elif m0 == b'w':
creation = _CREATE_ALWAYS creation = _CREATE_ALWAYS
elif m0 == b'a': elif m0 == b'a':
creation = _OPEN_ALWAYS creation = _OPEN_ALWAYS
flags |= _O_APPEND flags |= _O_APPEND
else: else:
raise ValueError(r"invalid mode: %s" % pycompat.sysstr(mode)) raise ValueError("invalid mode: %s" % pycompat.sysstr(mode))
fh = _kernel32.CreateFileA( fh = _kernel32.CreateFileA(
name, name,
access, access,
_FILE_SHARE_READ | _FILE_SHARE_WRITE | _FILE_SHARE_DELETE, _FILE_SHARE_READ | _FILE_SHARE_WRITE | _FILE_SHARE_DELETE,
None, None,
creation, creation,
_FILE_ATTRIBUTE_NORMAL, _FILE_ATTRIBUTE_NORMAL,

mercurial/pycompat.py

""" """
Partial backport from os.py in Python 3, which only accepts bytes. Partial backport from os.py in Python 3, which only accepts bytes.
In Python 2, our paths should only ever be bytes, a unicode path In Python 2, our paths should only ever be bytes, a unicode path
indicates a bug. indicates a bug.
""" """
if isinstance(filename, str): if isinstance(filename, str):
return filename return filename
else: else:
raise TypeError(r"expect str, not %s" % type(filename).__name__) raise TypeError("expect str, not %s" % type(filename).__name__)
# In Python 2, fsdecode() has a very chance to receive bytes. So it's # In Python 2, fsdecode() has a very chance to receive bytes. So it's
# better not to touch Python 2 part as it's already working fine. # better not to touch Python 2 part as it's already working fine.
fsdecode = identity fsdecode = identity
def getdoc(obj): def getdoc(obj):
return getattr(obj, '__doc__', None) return getattr(obj, '__doc__', None)

mercurial/statprof.py

) )
defaultdict = collections.defaultdict defaultdict = collections.defaultdict
contextmanager = contextlib.contextmanager contextmanager = contextlib.contextmanager
__all__ = [b'start', b'stop', b'reset', b'display', b'profile'] __all__ = [b'start', b'stop', b'reset', b'display', b'profile']
skips = { skips = {
r"util.py:check", "util.py:check",
r"extensions.py:closure", "extensions.py:closure",
r"color.py:colorcmd", "color.py:colorcmd",
r"dispatch.py:checkargs", "dispatch.py:checkargs",
r"dispatch.py:<lambda>", "dispatch.py:<lambda>",
r"dispatch.py:_runcatch", "dispatch.py:_runcatch",
r"dispatch.py:_dispatch", "dispatch.py:_dispatch",
r"dispatch.py:_runcommand", "dispatch.py:_runcommand",
r"pager.py:pagecmd", "pager.py:pagecmd",
r"dispatch.py:run", "dispatch.py:run",
r"dispatch.py:dispatch", "dispatch.py:dispatch",
r"dispatch.py:runcommand", "dispatch.py:runcommand",
r"hg.py:<module>", "hg.py:<module>",
r"evolve.py:warnobserrors", "evolve.py:warnobserrors",
} }
########################################################################### ###########################################################################
## Utils ## Utils
def clock(): def clock():
times = os.times() times = os.times()
except getopt.error as msg: except getopt.error as msg:
print(msg) print(msg)
printusage() printusage()
return 2 return 2
displayargs[b'limit'] = 0.05 displayargs[b'limit'] = 0.05
path = None path = None
for o, value in opts: for o, value in opts:
if o in (r"-l", r"--limit"): if o in ("-l", "--limit"):
displayargs[b'limit'] = float(value) displayargs[b'limit'] = float(value)
elif o in (r"-f", r"--file"): elif o in ("-f", "--file"):
path = value path = value
elif o in (r"-o", r"--output-file"): elif o in ("-o", "--output-file"):
displayargs[b'outputfile'] = value displayargs[b'outputfile'] = value
elif o in (r"-p", r"--script-path"): elif o in ("-p", "--script-path"):
displayargs[b'scriptpath'] = value displayargs[b'scriptpath'] = value
elif o in (r"-h", r"help"): elif o in ("-h", "help"):
printusage() printusage()
return 0 return 0
else: else:
assert False, b"unhandled option %s" % o assert False, b"unhandled option %s" % o
if not path: if not path:
print(r'must specify --file to load') print(r'must specify --file to load')
return 1 return 1
load_data(path=path) load_data(path=path)
display(**pycompat.strkwargs(displayargs)) display(**pycompat.strkwargs(displayargs))
return 0 return 0
if __name__ == r"__main__": if __name__ == "__main__":
sys.exit(main()) sys.exit(main())

mercurial/utils/procutil.py

"""return True if we are a frozen executable. """return True if we are a frozen executable.
The code supports py2exe (most common, Windows only) and tools/freeze The code supports py2exe (most common, Windows only) and tools/freeze
(portable, not much used). (portable, not much used).
""" """
return ( return (
pycompat.safehasattr(sys, "frozen") pycompat.safehasattr(sys, "frozen")
or pycompat.safehasattr(sys, "importers") # new py2exe or pycompat.safehasattr(sys, "importers") # new py2exe
or imp.is_frozen(r"__main__") # old py2exe or imp.is_frozen("__main__") # old py2exe
) # tools/freeze ) # tools/freeze
_hgexecutable = None _hgexecutable = None
def hgexecutable(): def hgexecutable():
"""return location of the 'hg' executable. """return location of the 'hg' executable.

mercurial/win32.py

# CertCreateCertificateContext encodings # CertCreateCertificateContext encodings
X509_ASN_ENCODING = 0x00000001 X509_ASN_ENCODING = 0x00000001
PKCS_7_ASN_ENCODING = 0x00010000 PKCS_7_ASN_ENCODING = 0x00010000
# These structs are only complete enough to achieve what we need. # These structs are only complete enough to achieve what we need.
class CERT_CHAIN_CONTEXT(ctypes.Structure): class CERT_CHAIN_CONTEXT(ctypes.Structure):
_fields_ = ( _fields_ = (
(r"cbSize", _DWORD), ("cbSize", _DWORD),
# CERT_TRUST_STATUS struct # CERT_TRUST_STATUS struct
(r"dwErrorStatus", _DWORD), ("dwErrorStatus", _DWORD),
(r"dwInfoStatus", _DWORD), ("dwInfoStatus", _DWORD),
(r"cChain", _DWORD), ("cChain", _DWORD),
(r"rgpChain", ctypes.c_void_p), ("rgpChain", ctypes.c_void_p),
(r"cLowerQualityChainContext", _DWORD), ("cLowerQualityChainContext", _DWORD),
(r"rgpLowerQualityChainContext", ctypes.c_void_p), ("rgpLowerQualityChainContext", ctypes.c_void_p),
(r"fHasRevocationFreshnessTime", _BOOL), ("fHasRevocationFreshnessTime", _BOOL),
(r"dwRevocationFreshnessTime", _DWORD), ("dwRevocationFreshnessTime", _DWORD),
) )
class CERT_USAGE_MATCH(ctypes.Structure): class CERT_USAGE_MATCH(ctypes.Structure):
_fields_ = ( _fields_ = (
(r"dwType", _DWORD), ("dwType", _DWORD),
# CERT_ENHKEY_USAGE struct # CERT_ENHKEY_USAGE struct
(r"cUsageIdentifier", _DWORD), ("cUsageIdentifier", _DWORD),
(r"rgpszUsageIdentifier", ctypes.c_void_p), # LPSTR * ("rgpszUsageIdentifier", ctypes.c_void_p), # LPSTR *
) )
class CERT_CHAIN_PARA(ctypes.Structure): class CERT_CHAIN_PARA(ctypes.Structure):
_fields_ = ( _fields_ = (
(r"cbSize", _DWORD), ("cbSize", _DWORD),
(r"RequestedUsage", CERT_USAGE_MATCH), ("RequestedUsage", CERT_USAGE_MATCH),
(r"RequestedIssuancePolicy", CERT_USAGE_MATCH), ("RequestedIssuancePolicy", CERT_USAGE_MATCH),
(r"dwUrlRetrievalTimeout", _DWORD), ("dwUrlRetrievalTimeout", _DWORD),
(r"fCheckRevocationFreshnessTime", _BOOL), ("fCheckRevocationFreshnessTime", _BOOL),
(r"dwRevocationFreshnessTime", _DWORD), ("dwRevocationFreshnessTime", _DWORD),
(r"pftCacheResync", ctypes.c_void_p), # LPFILETIME ("pftCacheResync", ctypes.c_void_p), # LPFILETIME
(r"pStrongSignPara", ctypes.c_void_p), # PCCERT_STRONG_SIGN_PARA ("pStrongSignPara", ctypes.c_void_p), # PCCERT_STRONG_SIGN_PARA
(r"dwStrongSignFlags", _DWORD), ("dwStrongSignFlags", _DWORD),
) )
# types of parameters of C functions used (required by pypy) # types of parameters of C functions used (required by pypy)
_crypt32.CertCreateCertificateContext.argtypes = [ _crypt32.CertCreateCertificateContext.argtypes = [
_DWORD, # cert encoding _DWORD, # cert encoding
ctypes.c_char_p, # cert ctypes.c_char_p, # cert
temp = b'%s-%08x' % (f, random.randint(0, 0xFFFFFFFF)) temp = b'%s-%08x' % (f, random.randint(0, 0xFFFFFFFF))
try: try:
os.rename(f, temp) # raises OSError EEXIST if temp exists os.rename(f, temp) # raises OSError EEXIST if temp exists
break break
except OSError as e: except OSError as e:
if e.errno != errno.EEXIST: if e.errno != errno.EEXIST:
raise raise
else: else:
raise IOError(errno.EEXIST, r"No usable temporary filename found") raise IOError(errno.EEXIST, "No usable temporary filename found")
try: try:
os.unlink(temp) os.unlink(temp)
except OSError: except OSError:
# The unlink might have failed because the READONLY attribute may heave # The unlink might have failed because the READONLY attribute may heave
# been set on the original file. Rename works fine with READONLY set, # been set on the original file. Rename works fine with READONLY set,
# but not os.unlink. Reset all attributes and try again. # but not os.unlink. Reset all attributes and try again.
_kernel32.SetFileAttributesA(temp, _FILE_ATTRIBUTE_NORMAL) _kernel32.SetFileAttributesA(temp, _FILE_ATTRIBUTE_NORMAL)