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

comparison mercurial/graphmod.py @ 43076:2372284d9457

formatting: blacken the codebase This is using my patch to black (https://github.com/psf/black/pull/826) so we don't un-wrap collection literals. Done with: hg files 'set:**.py - mercurial/thirdparty/** - "contrib/python-zstandard/**"' | xargs black -S # skip-blame mass-reformatting only # no-check-commit reformats foo_bar functions Differential Revision: https://phab.mercurial-scm.org/D6971

author	Augie Fackler <augie@google.com>
date	Sun, 06 Oct 2019 09:45:02 -0400
parents	264a2cbb25d0
children	687b865b95ad

comparison

equal deleted inserted replaced

-:57875cf423c9
+:2372284d9457
 # point. A number prefix means only the last N characters of the current block
 # will use that style, the rest will use the PARENT style. Add a - sign
 # (so making N negative) and all but the first N characters use that style.
 EDGES = {PARENT: '|', GRANDPARENT: ':', MISSINGPARENT: None}
 def dagwalker(repo, revs):
 """cset DAG generator yielding (id, CHANGESET, ctx, [parentinfo]) tuples
 This generator function walks through revisions (which should be ordered
 from bigger to lower). It returns a tuple for each node.
 ctx = repo[rev]
 # partition into parents in the rev set and missing parents, then
 # augment the lists with markers, to inform graph drawing code about
 # what kind of edge to draw between nodes.
 pset = set(p.rev() for p in ctx.parents() if p.rev() in revs)
-mpars = [p.rev() for p in ctx.parents()
+mpars = [
-if p.rev() != nullrev and p.rev() not in pset]
+p.rev()
+for p in ctx.parents()
+if p.rev() != nullrev and p.rev() not in pset
+]
 parents = [(PARENT, p) for p in sorted(pset)]
 for mpar in mpars:
 gp = gpcache.get(mpar)
 if gp is None:
 # precompute slow query as we know reachableroots() goes
 # through all revs (issue4782)
 if not isinstance(revs, smartset.baseset):
 revs = smartset.baseset(revs)
-gp = gpcache[mpar] = sorted(set(dagop.reachableroots(
+gp = gpcache[mpar] = sorted(
-repo, revs, [mpar])))
+set(dagop.reachableroots(repo, revs, [mpar]))
+)
 if not gp:
 parents.append((MISSINGPARENT, mpar))
 pset.add(mpar)
 else:
 parents.extend((GRANDPARENT, g) for g in gp if g not in pset)
 pset.update(gp)
 yield (ctx.rev(), CHANGESET, ctx, parents)
 def nodes(repo, nodes):
 """cset DAG generator yielding (id, CHANGESET, ctx, [parentids]) tuples
 This generator function walks the given nodes. It only returns parents
 that are in nodes, too.
 """
 include = set(nodes)
 for node in nodes:
 ctx = repo[node]
-parents = set((PARENT, p.rev()) for p in ctx.parents()
+parents = set(
-if p.node() in include)
+(PARENT, p.rev()) for p in ctx.parents() if p.node() in include
+)
 yield (ctx.rev(), CHANGESET, ctx, sorted(parents))
 def colored(dag, repo):
 """annotates a DAG with colored edge information
 For each DAG node this function emits tuples::
 elif setting == "color" and val.isalnum():
 config.setdefault(branch, {})[setting] = val
 if config:
 getconf = util.lrucachefunc(
-lambda rev: config.get(repo[rev].branch(), {}))
+lambda rev: config.get(repo[rev].branch(), {})
+)
 else:
 getconf = lambda rev: {}
 for (cur, type, data, parents) in dag:
 # Compute seen and next
 if cur not in seen:
-seen.append(cur) # new head
+seen.append(cur)  # new head
 colors[cur] = newcolor
 newcolor += 1
 col = seen.index(cur)
 color = colors.pop(cur)
 next = seen[:]
 # Add parents to next
 addparents = [p for pt, p in parents if p not in next]
-next[col:col + 1] = addparents
+next[col : col + 1] = addparents
 # Set colors for the parents
 for i, p in enumerate(addparents):
 if not i:
 colors[p] = color
 # Add edges to the graph
 edges = []
 for ecol, eid in enumerate(seen):
 if eid in next:
 bconf = getconf(eid)
-edges.append((
+edges.append(
-ecol, next.index(eid), colors[eid],
+(
-bconf.get('width', -1),
+ecol,
-bconf.get('color', '')))
+next.index(eid),
+colors[eid],
+bconf.get('width', -1),
+bconf.get('color', ''),
+)
+)
 elif eid == cur:
 for ptype, p in parents:
 bconf = getconf(p)
-edges.append((
+edges.append(
-ecol, next.index(p), color,
+(
-bconf.get('width', -1),
+ecol,
-bconf.get('color', '')))
+next.index(p),
+color,
+bconf.get('width', -1),
+bconf.get('color', ''),
+)
+)
 # Yield and move on
 yield (cur, type, data, (col, color), edges)
 seen = next
 def asciiedges(type, char, state, rev, parents):
 """adds edge info to changelog DAG walk suitable for ascii()"""
 seen = state['seen']
 if rev not in seen:
 state['edges'][parent] = state['styles'].get(ptype, '|')
 ncols = len(seen)
 width = 1 + ncols * 2
 nextseen = seen[:]
-nextseen[nodeidx:nodeidx + 1] = newparents
+nextseen[nodeidx : nodeidx + 1] = newparents
 edges = [(nodeidx, nextseen.index(p)) for p in knownparents]
 seen[:] = nextseen
 while len(newparents) > 2:
 # ascii() only knows how to add or remove a single column between two
 width += 2
 # remove current node from edge characters, no longer needed
 state['edges'].pop(rev, None)
 yield (type, char, width, (nodeidx, edges, ncols, nmorecols))
 def _fixlongrightedges(edges):
 for (i, (start, end)) in enumerate(edges):
 if end > start:
 edges[i] = (start, end + 1)
-def _getnodelineedgestail(
-echars, idx, pidx, ncols, coldiff, pdiff, fix_tail):
+def _getnodelineedgestail(echars, idx, pidx, ncols, coldiff, pdiff, fix_tail):
 if fix_tail and coldiff == pdiff and coldiff != 0:
 # Still going in the same non-vertical direction.
 if coldiff == -1:
 start = max(idx + 1, pidx)
-tail = echars[idx * 2:(start - 1) * 2]
+tail = echars[idx * 2 : (start - 1) * 2]
 tail.extend(["/", " "] * (ncols - start))
 return tail
 else:
 return ["\\", " "] * (ncols - idx - 1)
 else:
-remainder = (ncols - idx - 1)
+remainder = ncols - idx - 1
-return echars[-(remainder * 2):] if remainder > 0 else []
+return echars[-(remainder * 2) :] if remainder > 0 else []
 def _drawedges(echars, edges, nodeline, interline):
 for (start, end) in edges:
 if start == end + 1:
 interline[2 * end + 1] = "/"
 (start, end) = (end, start)
 for i in range(2 * start + 1, 2 * end):
 if nodeline[i] != "+":
 nodeline[i] = "-"
 def _getpaddingline(echars, idx, ncols, edges):
 # all edges up to the current node
-line = echars[:idx * 2]
+line = echars[: idx * 2]
 # an edge for the current node, if there is one
 if (idx, idx - 1) in edges or (idx, idx) in edges:
 # (idx, idx - 1)      (idx, idx)
 # | | | |           | | | |
 # +---o |           | o---+
 # | | X |           | X | |
 # | |/ /            | |/ /
 # | | |             | | |
-line.extend(echars[idx * 2:(idx + 1) * 2])
+line.extend(echars[idx * 2 : (idx + 1) * 2])
 else:
 line.extend([' ', ' '])
 # all edges to the right of the current node
 remainder = ncols - idx - 1
 if remainder > 0:
-line.extend(echars[-(remainder * 2):])
+line.extend(echars[-(remainder * 2) :])
 return line
 def _drawendinglines(lines, extra, edgemap, seen, state):
 """Draw ending lines for missing parent edges
 None indicates an edge that ends at between this node and the next
 remove = [p for p, c in edgemap.items() if c is None]
 for parent in remove:
 del edgemap[parent]
 seen.remove(parent)
 def asciistate():
 """returns the initial value for the "state" argument to ascii()"""
 return {
 'seen': [],
 'edges': {},
 'lastindex': 0,
 'styles': EDGES.copy(),
 'graphshorten': False,
 }
 def outputgraph(ui, graph):
 """outputs an ASCII graph of a DAG
 this is a helper function for 'ascii' below.
 this function can be monkey-patched by extensions to alter graph display
 without needing to mimic all of the edge-fixup logic in ascii()
 """
 for (ln, logstr) in graph:
 ui.write((ln + logstr).rstrip() + "\n")
 def ascii(ui, state, type, char, text, coldata):
 """prints an ASCII graph of the DAG
 takes the following arguments (one call per node in the graph):
 #     | | | |        | | | |
 #     | o---+  into  | o---+
 #     |  / /         |   | |  # <--- padding line
 #     o | |          |  / /
 #                    o | |
-add_padding_line = (len(text) > 2 and coldiff == -1 and
+add_padding_line = (
-[x for (x, y) in edges if x + 1 < y])
+len(text) > 2 and coldiff == -1 and [x for (x, y) in edges if x + 1 < y]
+)
 # fix_nodeline_tail says whether to rewrite
 #
 #     | | o | |        | | o | |
 #     | | |/ /         | | |/ /
 #     | |/ /           | |/ /
 #     o | |            o | |
 fix_nodeline_tail = len(text) <= 2 and not add_padding_line
 # nodeline is the line containing the node character (typically o)
-nodeline = echars[:idx * 2]
+nodeline = echars[: idx * 2]
 nodeline.extend([char, " "])
 nodeline.extend(
 _getnodelineedgestail(
-echars, idx, state['lastindex'], ncols, coldiff,
+echars,
-state['lastcoldiff'], fix_nodeline_tail))
+idx,
+state['lastindex'],
+ncols,
+coldiff,
+state['lastcoldiff'],
+fix_nodeline_tail,
+)
+)
 # shift_interline is the line containing the non-vertical
 # edges between this entry and the next
-shift_interline = echars[:idx * 2]
+shift_interline = echars[: idx * 2]
 for i in pycompat.xrange(2 + coldiff):
 shift_interline.append(' ')
 count = ncols - idx - 1
 if coldiff == -1:
 for i in pycompat.xrange(count):
 shift_interline.extend(['/', ' '])
 elif coldiff == 0:
-shift_interline.extend(echars[(idx + 1) * 2:ncols * 2])
+shift_interline.extend(echars[(idx + 1) * 2 : ncols * 2])
 else:
 for i in pycompat.xrange(count):
 shift_interline.extend(['\\', ' '])
 # draw edges from the current node to its parents
 else:
 lines.append(shift_interline)
 # make sure that there are as many graph lines as there are
 # log strings
-extra_interline = echars[:(ncols + coldiff) * 2]
+extra_interline = echars[: (ncols + coldiff) * 2]
 if len(lines) < len(text):
 while len(lines) < len(text):
 lines.append(extra_interline[:])
 _drawendinglines(lines, extra_interline, edgemap, seen, state)

Mercurial > public > mercurial-scm > hg

comparison mercurial/graphmod.py @ 43076:2372284d9457