mercurial-scm/hg: comparison mercurial/hgweb/webutil.py

equal deleted inserted replaced

-:2372284d9457
+:687b865b95ad
 from ..utils import stringutil
 archivespecs = util.sortdict(
 (
-('zip', ('application/zip', 'zip', '.zip', None)),
+(b'zip', (b'application/zip', b'zip', b'.zip', None)),
-('gz', ('application/x-gzip', 'tgz', '.tar.gz', None)),
+(b'gz', (b'application/x-gzip', b'tgz', b'.tar.gz', None)),
-('bz2', ('application/x-bzip2', 'tbz2', '.tar.bz2', None)),
+(b'bz2', (b'application/x-bzip2', b'tbz2', b'.tar.bz2', None)),
 )
 )
 def archivelist(ui, nodeid, url=None):
-allowed = ui.configlist('web', 'allow-archive', untrusted=True)
+allowed = ui.configlist(b'web', b'allow-archive', untrusted=True)
 archives = []
 for typ, spec in archivespecs.iteritems():
 if typ in allowed or ui.configbool(
-'web', 'allow' + typ, untrusted=True
+b'web', b'allow' + typ, untrusted=True
 ):
 archives.append(
-{'type': typ, 'extension': spec[2], 'node': nodeid, 'url': url,}
+{
+b'type': typ,
+b'extension': spec[2],
+b'node': nodeid,
+b'url': url,
+}
 )
 return templateutil.mappinglist(archives)
 def up(p):
-if p[0:1] != "/":
+if p[0:1] != b"/":
-p = "/" + p
+p = b"/" + p
-if p[-1:] == "/":
+if p[-1:] == b"/":
 p = p[:-1]
 up = os.path.dirname(p)
-if up == "/":
+if up == b"/":
-return "/"
+return b"/"
-return up + "/"
+return up + b"/"
 def _navseq(step, firststep=None):
 if firststep:
 yield firststep
 if not self:
 # empty repo
 return templateutil.mappinglist(
 [
 {
-'before': templateutil.mappinglist([]),
+b'before': templateutil.mappinglist([]),
-'after': templateutil.mappinglist([]),
+b'after': templateutil.mappinglist([]),
 },
 ]
 )
 targets = []
 targets.append(pos + f)
 targets.append(pos - f)
 targets.sort()
 first = self._first()
-navbefore = [{'label': '(%i)' % first, 'node': self.hex(first)}]
+navbefore = [{b'label': b'(%i)' % first, b'node': self.hex(first)}]
 navafter = []
 for rev in targets:
 if rev not in self._revlog:
 continue
 if pos < rev < limit:
 navafter.append(
-{'label': '+%d' % abs(rev - pos), 'node': self.hex(rev)}
+{b'label': b'+%d' % abs(rev - pos), b'node': self.hex(rev)}
 )
 if 0 < rev < pos:
 navbefore.append(
-{'label': '-%d' % abs(rev - pos), 'node': self.hex(rev)}
+{b'label': b'-%d' % abs(rev - pos), b'node': self.hex(rev)}
 )
-navafter.append({'label': 'tip', 'node': 'tip'})
+navafter.append({b'label': b'tip', b'node': b'tip'})
 # TODO: maybe this can be a scalar object supporting tomap()
 return templateutil.mappinglist(
 [
 {
-'before': templateutil.mappinglist(navbefore),
+b'before': templateutil.mappinglist(navbefore),
-'after': templateutil.mappinglist(navafter),
+b'after': templateutil.mappinglist(navafter),
 },
 ]
 )
 # TODO: maybe this can be a wrapper class for changectx/filectx list, which
 # yields {'ctx': ctx}
 def _ctxsgen(context, ctxs):
 for s in ctxs:
 d = {
-'node': s.hex(),
+b'node': s.hex(),
-'rev': s.rev(),
+b'rev': s.rev(),
-'user': s.user(),
+b'user': s.user(),
-'date': s.date(),
+b'date': s.date(),
-'description': s.description(),
+b'description': s.description(),
-'branch': s.branch(),
+b'branch': s.branch(),
 }
-if util.safehasattr(s, 'path'):
+if util.safehasattr(s, b'path'):
-d['file'] = s.path()
+d[b'file'] = s.path()
 yield d
 def _siblings(siblings=None, hiderev=None):
 if siblings is None:
 def difffeatureopts(req, ui, section):
 diffopts = diffutil.difffeatureopts(
 ui, untrusted=True, section=section, whitespace=True
 )
-for k in ('ignorews', 'ignorewsamount', 'ignorewseol', 'ignoreblanklines'):
+for k in (
+b'ignorews',
+b'ignorewsamount',
+b'ignorewseol',
+b'ignoreblanklines',
+):
 v = req.qsparams.get(k)
 if v is not None:
 v = stringutil.parsebool(v)
 setattr(diffopts, k, v if v is not None else True)
 return diffopts
 def annotate(req, fctx, ui):
-diffopts = difffeatureopts(req, ui, 'annotate')
+diffopts = difffeatureopts(req, ui, b'annotate')
 return fctx.annotate(follow=True, diffopts=diffopts)
 def parents(ctx, hide=None):
 if isinstance(ctx, context.basefilectx):
 def renamelink(fctx):
 r = fctx.renamed()
 if r:
-return templateutil.mappinglist([{'file': r[0], 'node': hex(r[1])}])
+return templateutil.mappinglist([{b'file': r[0], b'node': hex(r[1])}])
 return templateutil.mappinglist([])
 def nodetagsdict(repo, node):
-return templateutil.hybridlist(repo.nodetags(node), name='name')
+return templateutil.hybridlist(repo.nodetags(node), name=b'name')
 def nodebookmarksdict(repo, node):
-return templateutil.hybridlist(repo.nodebookmarks(node), name='name')
+return templateutil.hybridlist(repo.nodebookmarks(node), name=b'name')
 def nodebranchdict(repo, ctx):
 branches = []
 branch = ctx.branch()
 branchnode = repo.branchtip(branch)
 except error.RepoLookupError:
 branchnode = None
 if branchnode == ctx.node():
 branches.append(branch)
-return templateutil.hybridlist(branches, name='name')
+return templateutil.hybridlist(branches, name=b'name')
 def nodeinbranch(repo, ctx):
 branches = []
 branch = ctx.branch()
 try:
 branchnode = repo.branchtip(branch)
 except error.RepoLookupError:
 branchnode = None
-if branch != 'default' and branchnode != ctx.node():
+if branch != b'default' and branchnode != ctx.node():
 branches.append(branch)
-return templateutil.hybridlist(branches, name='name')
+return templateutil.hybridlist(branches, name=b'name')
 def nodebranchnodefault(ctx):
 branches = []
 branch = ctx.branch()
-if branch != 'default':
+if branch != b'default':
 branches.append(branch)
-return templateutil.hybridlist(branches, name='name')
+return templateutil.hybridlist(branches, name=b'name')
 def _nodenamesgen(context, f, node, name):
 for t in f(node):
 yield {name: t}
 def showtag(repo, t1, node=nullid):
-args = (repo.nodetags, node, 'tag')
+args = (repo.nodetags, node, b'tag')
 return templateutil.mappinggenerator(_nodenamesgen, args=args, name=t1)
 def showbookmark(repo, t1, node=nullid):
-args = (repo.nodebookmarks, node, 'bookmark')
+args = (repo.nodebookmarks, node, b'bookmark')
 return templateutil.mappinggenerator(_nodenamesgen, args=args, name=t1)
 def branchentries(repo, stripecount, limit=0):
 tips = []
 for ctx, closed in sorted(tips, key=sortkey, reverse=True):
 if limit > 0 and count >= limit:
 return
 count += 1
 if closed:
-status = 'closed'
+status = b'closed'
 elif ctx.node() not in heads:
-status = 'inactive'
+status = b'inactive'
 else:
-status = 'open'
+status = b'open'
 yield {
-'parity': next(parity),
+b'parity': next(parity),
-'branch': ctx.branch(),
+b'branch': ctx.branch(),
-'status': status,
+b'status': status,
-'node': ctx.hex(),
+b'node': ctx.hex(),
-'date': ctx.date(),
+b'date': ctx.date(),
 }
 return templateutil.mappinggenerator(entries)
 def cleanpath(repo, path):
-path = path.lstrip('/')
+path = path.lstrip(b'/')
 auditor = pathutil.pathauditor(repo.root, realfs=False)
-return pathutil.canonpath(repo.root, '', path, auditor=auditor)
+return pathutil.canonpath(repo.root, b'', path, auditor=auditor)
 def changectx(repo, req):
-changeid = "tip"
+changeid = b"tip"
-if 'node' in req.qsparams:
+if b'node' in req.qsparams:
-changeid = req.qsparams['node']
+changeid = req.qsparams[b'node']
-ipos = changeid.find(':')
+ipos = changeid.find(b':')
 if ipos != -1:
 changeid = changeid[(ipos + 1) :]
 return scmutil.revsymbol(repo, changeid)
 def basechangectx(repo, req):
-if 'node' in req.qsparams:
+if b'node' in req.qsparams:
-changeid = req.qsparams['node']
+changeid = req.qsparams[b'node']
-ipos = changeid.find(':')
+ipos = changeid.find(b':')
 if ipos != -1:
 changeid = changeid[:ipos]
 return scmutil.revsymbol(repo, changeid)
 return None
 def filectx(repo, req):
-if 'file' not in req.qsparams:
+if b'file' not in req.qsparams:
-raise ErrorResponse(HTTP_NOT_FOUND, 'file not given')
+raise ErrorResponse(HTTP_NOT_FOUND, b'file not given')
-path = cleanpath(repo, req.qsparams['file'])
+path = cleanpath(repo, req.qsparams[b'file'])
-if 'node' in req.qsparams:
+if b'node' in req.qsparams:
-changeid = req.qsparams['node']
+changeid = req.qsparams[b'node']
-elif 'filenode' in req.qsparams:
+elif b'filenode' in req.qsparams:
-changeid = req.qsparams['filenode']
+changeid = req.qsparams[b'filenode']
 else:
-raise ErrorResponse(HTTP_NOT_FOUND, 'node or filenode not given')
+raise ErrorResponse(HTTP_NOT_FOUND, b'node or filenode not given')
 try:
 fctx = scmutil.revsymbol(repo, changeid)[path]
 except error.RepoError:
 fctx = repo.filectx(path, fileid=changeid)
 return fctx
 def linerange(req):
-linerange = req.qsparams.getall('linerange')
+linerange = req.qsparams.getall(b'linerange')
 if not linerange:
 return None
 if len(linerange) > 1:
-raise ErrorResponse(HTTP_BAD_REQUEST, 'redundant linerange parameter')
+raise ErrorResponse(HTTP_BAD_REQUEST, b'redundant linerange parameter')
 try:
-fromline, toline = map(int, linerange[0].split(':', 1))
+fromline, toline = map(int, linerange[0].split(b':', 1))
 except ValueError:
-raise ErrorResponse(HTTP_BAD_REQUEST, 'invalid linerange parameter')
+raise ErrorResponse(HTTP_BAD_REQUEST, b'invalid linerange parameter')
 try:
 return util.processlinerange(fromline, toline)
 except error.ParseError as exc:
 raise ErrorResponse(HTTP_BAD_REQUEST, pycompat.bytestr(exc))
 def formatlinerange(fromline, toline):
-return '%d:%d' % (fromline + 1, toline)
+return b'%d:%d' % (fromline + 1, toline)
 def _succsandmarkersgen(context, mapping):
-repo = context.resource(mapping, 'repo')
+repo = context.resource(mapping, b'repo')
 itemmappings = templatekw.showsuccsandmarkers(context, mapping)
 for item in itemmappings.tovalue(context, mapping):
-item['successors'] = _siblings(
+item[b'successors'] = _siblings(
-repo[successor] for successor in item['successors']
+repo[successor] for successor in item[b'successors']
 )
 yield item
 def succsandmarkers(context, mapping):
 return templateutil.mappinggenerator(_succsandmarkersgen, args=(mapping,))
 # teach templater succsandmarkers is switched to (context, mapping) API
-succsandmarkers._requires = {'repo', 'ctx'}
+succsandmarkers._requires = {b'repo', b'ctx'}
 def _whyunstablegen(context, mapping):
-repo = context.resource(mapping, 'repo')
+repo = context.resource(mapping, b'repo')
-ctx = context.resource(mapping, 'ctx')
+ctx = context.resource(mapping, b'ctx')
 entries = obsutil.whyunstable(repo, ctx)
 for entry in entries:
-if entry.get('divergentnodes'):
+if entry.get(b'divergentnodes'):
-entry['divergentnodes'] = _siblings(entry['divergentnodes'])
+entry[b'divergentnodes'] = _siblings(entry[b'divergentnodes'])
 yield entry
 def whyunstable(context, mapping):
 return templateutil.mappinggenerator(_whyunstablegen, args=(mapping,))
-whyunstable._requires = {'repo', 'ctx'}
+whyunstable._requires = {b'repo', b'ctx'}
 def commonentry(repo, ctx):
 node = scmutil.binnode(ctx)
 return {
 # TODO: perhaps ctx.changectx() should be assigned if ctx is a
 # filectx, but I'm not pretty sure if that would always work because
 # fctx.parents() != fctx.changectx.parents() for example.
-'ctx': ctx,
+b'ctx': ctx,
-'rev': ctx.rev(),
+b'rev': ctx.rev(),
-'node': hex(node),
+b'node': hex(node),
-'author': ctx.user(),
+b'author': ctx.user(),
-'desc': ctx.description(),
+b'desc': ctx.description(),
-'date': ctx.date(),
+b'date': ctx.date(),
-'extra': ctx.extra(),
+b'extra': ctx.extra(),
-'phase': ctx.phasestr(),
+b'phase': ctx.phasestr(),
-'obsolete': ctx.obsolete(),
+b'obsolete': ctx.obsolete(),
-'succsandmarkers': succsandmarkers,
+b'succsandmarkers': succsandmarkers,
-'instabilities': templateutil.hybridlist(
+b'instabilities': templateutil.hybridlist(
-ctx.instabilities(), name='instability'
+ctx.instabilities(), name=b'instability'
 ),
-'whyunstable': whyunstable,
+b'whyunstable': whyunstable,
-'branch': nodebranchnodefault(ctx),
+b'branch': nodebranchnodefault(ctx),
-'inbranch': nodeinbranch(repo, ctx),
+b'inbranch': nodeinbranch(repo, ctx),
-'branches': nodebranchdict(repo, ctx),
+b'branches': nodebranchdict(repo, ctx),
-'tags': nodetagsdict(repo, node),
+b'tags': nodetagsdict(repo, node),
-'bookmarks': nodebookmarksdict(repo, node),
+b'bookmarks': nodebookmarksdict(repo, node),
-'parent': lambda context, mapping: parents(ctx),
+b'parent': lambda context, mapping: parents(ctx),
-'child': lambda context, mapping: children(ctx),
+b'child': lambda context, mapping: children(ctx),
 }
 def changelistentry(web, ctx):
 '''Obtain a dictionary to be used for entries in a changelist.
 to the "shortlog" and "changelog" templates.
 '''
 repo = web.repo
 rev = ctx.rev()
 n = scmutil.binnode(ctx)
-showtags = showtag(repo, 'changelogtag', n)
+showtags = showtag(repo, b'changelogtag', n)
 files = listfilediffs(ctx.files(), n, web.maxfiles)
 entry = commonentry(repo, ctx)
 entry.update(
 {
-'allparents': lambda context, mapping: parents(ctx),
+b'allparents': lambda context, mapping: parents(ctx),
-'parent': lambda context, mapping: parents(ctx, rev - 1),
+b'parent': lambda context, mapping: parents(ctx, rev - 1),
-'child': lambda context, mapping: children(ctx, rev + 1),
+b'child': lambda context, mapping: children(ctx, rev + 1),
-'changelogtag': showtags,
+b'changelogtag': showtags,
-'files': files,
+b'files': files,
 }
 )
 return entry
 break
 count += 1
 entry = changelistentry(web, repo[rev])
-entry['parity'] = next(parityfn)
+entry[b'parity'] = next(parityfn)
 yield entry
 def symrevorshortnode(req, ctx):
-if 'node' in req.qsparams:
+if b'node' in req.qsparams:
-return templatefilters.revescape(req.qsparams['node'])
+return templatefilters.revescape(req.qsparams[b'node'])
 else:
 return short(scmutil.binnode(ctx))
 def _listfilesgen(context, ctx, stripecount):
 parity = paritygen(stripecount)
 for blockno, f in enumerate(ctx.files()):
-template = 'filenodelink' if f in ctx else 'filenolink'
+template = b'filenodelink' if f in ctx else b'filenolink'
 yield context.process(
 template,
 {
-'node': ctx.hex(),
+b'node': ctx.hex(),
-'file': f,
+b'file': f,
-'blockno': blockno + 1,
+b'blockno': blockno + 1,
-'parity': next(parity),
+b'parity': next(parity),
 },
 )
 def changesetentry(web, ctx):
 '''Obtain a dictionary to be used to render the "changeset" template.'''
-showtags = showtag(web.repo, 'changesettag', scmutil.binnode(ctx))
+showtags = showtag(web.repo, b'changesettag', scmutil.binnode(ctx))
 showbookmarks = showbookmark(
-web.repo, 'changesetbookmark', scmutil.binnode(ctx)
+web.repo, b'changesetbookmark', scmutil.binnode(ctx)
 )
 showbranch = nodebranchnodefault(ctx)
 basectx = basechangectx(web.repo, web.req)
 if basectx is None:
 basectx = ctx.p1()
-style = web.config('web', 'style')
+style = web.config(b'web', b'style')
-if 'style' in web.req.qsparams:
+if b'style' in web.req.qsparams:
-style = web.req.qsparams['style']
+style = web.req.qsparams[b'style']
 diff = diffs(web, ctx, basectx, None, style)
 parity = paritygen(web.stripecount)
 diffstatsgen = diffstatgen(web.repo.ui, ctx, basectx)
 )
 def _listfilediffsgen(context, files, node, max):
 for f in files[:max]:
-yield context.process('filedifflink', {'node': hex(node), 'file': f})
+yield context.process(b'filedifflink', {b'node': hex(node), b'file': f})
 if len(files) > max:
-yield context.process('fileellipses', {})
+yield context.process(b'fileellipses', {})
 def listfilediffs(files, node, max):
 return templateutil.mappedgenerator(
 _listfilediffsgen, args=(files, node, max)
 )
 def _prettyprintdifflines(context, lines, blockno, lineidprefix):
 for lineno, l in enumerate(lines, 1):
-difflineno = "%d.%d" % (blockno, lineno)
+difflineno = b"%d.%d" % (blockno, lineno)
-if l.startswith('+'):
+if l.startswith(b'+'):
-ltype = "difflineplus"
+ltype = b"difflineplus"
-elif l.startswith('-'):
+elif l.startswith(b'-'):
-ltype = "difflineminus"
+ltype = b"difflineminus"
-elif l.startswith('@'):
+elif l.startswith(b'@'):
-ltype = "difflineat"
+ltype = b"difflineat"
 else:
-ltype = "diffline"
+ltype = b"diffline"
 yield context.process(
 ltype,
 {
-'line': l,
+b'line': l,
-'lineno': lineno,
+b'lineno': lineno,
-'lineid': lineidprefix + "l%s" % difflineno,
+b'lineid': lineidprefix + b"l%s" % difflineno,
-'linenumber': "% 8s" % difflineno,
+b'linenumber': b"% 8s" % difflineno,
 },
 )
 def _diffsgen(
 diffopts = patch.diffopts(repo.ui, untrusted=True)
 parity = paritygen(stripecount)
 diffhunks = patch.diffhunks(repo, basectx, ctx, m, opts=diffopts)
 for blockno, (fctx1, fctx2, header, hunks) in enumerate(diffhunks, 1):
-if style != 'raw':
+if style != b'raw':
 header = header[1:]
-lines = [h + '\n' for h in header]
+lines = [h + b'\n' for h in header]
 for hunkrange, hunklines in hunks:
 if linerange is not None and hunkrange is not None:
 s1, l1, s2, l2 = hunkrange
 if not mdiff.hunkinrange((s2, l2), linerange):
 continue
 if lines:
 l = templateutil.mappedgenerator(
 _prettyprintdifflines, args=(lines, blockno, lineidprefix)
 )
 yield {
-'parity': next(parity),
+b'parity': next(parity),
-'blockno': blockno,
+b'blockno': blockno,
-'lines': l,
+b'lines': l,
 }
-def diffs(web, ctx, basectx, files, style, linerange=None, lineidprefix=''):
+def diffs(web, ctx, basectx, files, style, linerange=None, lineidprefix=b''):
 args = (
 web.repo,
 ctx,
 basectx,
 files,
 style,
 web.stripecount,
 linerange,
 lineidprefix,
 )
-return templateutil.mappinggenerator(_diffsgen, args=args, name='diffblock')
+return templateutil.mappinggenerator(
+_diffsgen, args=args, name=b'diffblock'
+)
 def _compline(type, leftlineno, leftline, rightlineno, rightline):
-lineid = leftlineno and ("l%d" % leftlineno) or ''
+lineid = leftlineno and (b"l%d" % leftlineno) or b''
-lineid += rightlineno and ("r%d" % rightlineno) or ''
+lineid += rightlineno and (b"r%d" % rightlineno) or b''
-llno = '%d' % leftlineno if leftlineno else ''
+llno = b'%d' % leftlineno if leftlineno else b''
-rlno = '%d' % rightlineno if rightlineno else ''
+rlno = b'%d' % rightlineno if rightlineno else b''
 return {
-'type': type,
+b'type': type,
-'lineid': lineid,
+b'lineid': lineid,
-'leftlineno': leftlineno,
+b'leftlineno': leftlineno,
-'leftlinenumber': "% 6s" % llno,
+b'leftlinenumber': b"% 6s" % llno,
-'leftline': leftline or '',
+b'leftline': leftline or b'',
-'rightlineno': rightlineno,
+b'rightlineno': rightlineno,
-'rightlinenumber': "% 6s" % rlno,
+b'rightlinenumber': b"% 6s" % rlno,
-'rightline': rightline or '',
+b'rightline': rightline or b'',
 }
 def _getcompblockgen(context, leftlines, rightlines, opcodes):
 for type, llo, lhi, rlo, rhi in opcodes:
 def _getcompblock(leftlines, rightlines, opcodes):
 args = (leftlines, rightlines, opcodes)
 return templateutil.mappinggenerator(
-_getcompblockgen, args=args, name='comparisonline'
+_getcompblockgen, args=args, name=b'comparisonline'
 )
 def _comparegen(context, contextnum, leftlines, rightlines):
 '''Generator function that provides side-by-side comparison data.'''
 s = difflib.SequenceMatcher(None, leftlines, rightlines)
 if contextnum < 0:
 l = _getcompblock(leftlines, rightlines, s.get_opcodes())
-yield {'lines': l}
+yield {b'lines': l}
 else:
 for oc in s.get_grouped_opcodes(n=contextnum):
 l = _getcompblock(leftlines, rightlines, oc)
-yield {'lines': l}
+yield {b'lines': l}
 def compare(contextnum, leftlines, rightlines):
 args = (contextnum, leftlines, rightlines)
 return templateutil.mappinggenerator(
-_comparegen, args=args, name='comparisonblock'
+_comparegen, args=args, name=b'comparisonblock'
 )
 def diffstatgen(ui, ctx, basectx):
 '''Generator function that provides the diffstat data.'''
-diffopts = patch.diffopts(ui, {'noprefix': False})
+diffopts = patch.diffopts(ui, {b'noprefix': False})
 stats = patch.diffstatdata(util.iterlines(ctx.diff(basectx, opts=diffopts)))
 maxname, maxtotal, addtotal, removetotal, binary = patch.diffstatsum(stats)
 while True:
 yield stats, maxname, maxtotal, addtotal, removetotal, binary
 def diffsummary(statgen):
 '''Return a short summary of the diff.'''
 stats, maxname, maxtotal, addtotal, removetotal, binary = next(statgen)
-return _(' %d files changed, %d insertions(+), %d deletions(-)\n') % (
+return _(b' %d files changed, %d insertions(+), %d deletions(-)\n') % (
 len(stats),
 addtotal,
 removetotal,
 )
 return 0
 return (float(i) / maxtotal) * 100
 fileno = 0
 for filename, adds, removes, isbinary in stats:
-template = 'diffstatlink' if filename in files else 'diffstatnolink'
+template = b'diffstatlink' if filename in files else b'diffstatnolink'
 total = adds + removes
 fileno += 1
 yield context.process(
 template,
 {
-'node': ctx.hex(),
+b'node': ctx.hex(),
-'file': filename,
+b'file': filename,
-'fileno': fileno,
+b'fileno': fileno,
-'total': total,
+b'total': total,
-'addpct': pct(adds),
+b'addpct': pct(adds),
-'removepct': pct(removes),
+b'removepct': pct(removes),
-'parity': next(parity),
+b'parity': next(parity),
 },
 )
 def diffstat(ctx, statgen, parity):
 args = (ctx, statgen, parity)
 return templateutil.mappedgenerator(_diffstattmplgen, args=args)
 class sessionvars(templateutil.wrapped):
-def __init__(self, vars, start='?'):
+def __init__(self, vars, start=b'?'):
 self._start = start
 self._vars = vars
 def __getitem__(self, key):
 return self._vars[key]
 def getmember(self, context, mapping, key):
 key = templateutil.unwrapvalue(context, mapping, key)
 return self._vars.get(key)
 def getmin(self, context, mapping):
-raise error.ParseError(_('not comparable'))
+raise error.ParseError(_(b'not comparable'))
 def getmax(self, context, mapping):
-raise error.ParseError(_('not comparable'))
+raise error.ParseError(_(b'not comparable'))
 def filter(self, context, mapping, select):
 # implement if necessary
-raise error.ParseError(_('not filterable'))
+raise error.ParseError(_(b'not filterable'))
 def itermaps(self, context):
 separator = self._start
 for key, value in sorted(self._vars.iteritems()):
 yield {
-'name': key,
+b'name': key,
-'value': pycompat.bytestr(value),
+b'value': pycompat.bytestr(value),
-'separator': separator,
+b'separator': separator,
 }
-separator = '&'
+separator = b'&'
 def join(self, context, mapping, sep):
 # could be '{separator}{name}={value|urlescape}'
-raise error.ParseError(_('not displayable without template'))
+raise error.ParseError(_(b'not displayable without template'))
 def show(self, context, mapping):
-return self.join(context, '')
+return self.join(context, b'')
 def tobool(self, context, mapping):
 return bool(self._vars)
 def tovalue(self, context, mapping):
 return 80
 def getwebsubs(repo):
 websubtable = []
-websubdefs = repo.ui.configitems('websub')
+websubdefs = repo.ui.configitems(b'websub')
 # we must maintain interhg backwards compatibility
-websubdefs += repo.ui.configitems('interhg')
+websubdefs += repo.ui.configitems(b'interhg')
 for key, pattern in websubdefs:
 # grab the delimiter from the character after the "s"
 unesc = pattern[1:2]
 delim = stringutil.reescape(unesc)
 % (delim, delim, delim),
 pattern,
 )
 if not match:
 repo.ui.warn(
-_("websub: invalid pattern for %s: %s\n") % (key, pattern)
+_(b"websub: invalid pattern for %s: %s\n") % (key, pattern)
 )
 continue
 # we need to unescape the delimiter for regexp and format
 delim_re = re.compile(br'(?<!\\)\\%s' % delim)
 try:
 regexp = re.compile(regexp, flags)
 websubtable.append((regexp, format))
 except re.error:
 repo.ui.warn(
-_("websub: invalid regexp for %s: %s\n") % (key, regexp)
+_(b"websub: invalid regexp for %s: %s\n") % (key, regexp)
 )
 return websubtable
 def getgraphnode(repo, ctx):

changeset 43077	687b865b95ad
parent 43076	2372284d9457
child 43087	66f2cc210a29