This is an archive of the discontinued Mercurial Phabricator instance.

Differential D7013

py3: define and use pycompat.itervalues()
ClosedPublic

Authored by indygreg on Oct 7 2019, 4:04 PM.

Details

Reviewers
martinvonz
Group Reviewers
hg-reviewers
Commits
rHG74802979dd9d: py3: define and use pycompat.itervalues()
Summary

.itervalues() only exists on Python 2. Python 3's equivalent is
.values(). But we don't want to blindly use .values() everywhere
because on Python 2, it will create a list, which will have performance
implications.

This commit introduces pycompat.itervalues() which will call the appropriate
method on the passed object. We update all callers of obj.itervalues()
to pycompat.itervalues(obj) instead.

With this commit, the only source tranforming remaining is for
iteritems(). Victory is near...

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

indygreg created this revision.Oct 7 2019, 4:04 PM
indygreg added a commit: rHG74802979dd9d: py3: define and use pycompat.itervalues().Oct 8 2019, 2:17 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG74802979dd9d: py3: define and use pycompat.itervalues() (authored by indygreg). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 16964

contrib/synthrepo.py

diffopts = diffutil.diffallopts(ui, {'git': True}) diffopts = diffutil.diffallopts(ui, {'git': True})
diff = sum( diff = sum(
(d.splitlines() for d in ctx.diff(pctx, opts=diffopts)), [] (d.splitlines() for d in ctx.diff(pctx, opts=diffopts)), []
) )
fileadds, diradds, fileremoves, filechanges = 0, 0, 0, 0 fileadds, diradds, fileremoves, filechanges = 0, 0, 0, 0
for filename, mar, lineadd, lineremove, isbin in parsegitdiff(diff): for filename, mar, lineadd, lineremove, isbin in parsegitdiff(diff):
if isbin: if isbin:
continue continue
added = sum(lineadd.itervalues(), 0) added = sum(pycompat.itervalues(lineadd), 0)
if mar == 'm': if mar == 'm':
if added and lineremove: if added and lineremove:
lineschanged[ lineschanged[
roundto(added, 5), roundto(lineremove, 5) roundto(added, 5), roundto(lineremove, 5)
] += 1 ] += 1
filechanges += 1 filechanges += 1
elif mar == 'a': elif mar == 'a':
fileadds += 1 fileadds += 1

hgext/journal.py

for key, it in enumerate(iterables): for key, it in enumerate(iterables):
try: try:
iterable_map[key] = [next(it), key, it] iterable_map[key] = [next(it), key, it]
except StopIteration: except StopIteration:
# empty entry, can be ignored # empty entry, can be ignored
pass pass
while iterable_map: while iterable_map:
value, key, it = order(iterable_map.itervalues()) value, key, it = order(pycompat.itervalues(iterable_map))
yield value yield value
try: try:
iterable_map[key][0] = next(it) iterable_map[key][0] = next(it)
except StopIteration: except StopIteration:
# this iterable is empty, remove it from consideration # this iterable is empty, remove it from consideration
del iterable_map[key] del iterable_map[key]

hgext/rebase.py

rbsrt = rebaseruntime(repo, ui, {}) rbsrt = rebaseruntime(repo, ui, {})
rbsrt.restorestatus() rbsrt.restorestatus()
state = rbsrt.state state = rbsrt.state
except error.RepoLookupError: except error.RepoLookupError:
# i18n: column positioning for "hg summary" # i18n: column positioning for "hg summary"
msg = _(b'rebase: (use "hg rebase --abort" to clear broken state)\n') msg = _(b'rebase: (use "hg rebase --abort" to clear broken state)\n')
ui.write(msg) ui.write(msg)
return return
numrebased = len([i for i in state.itervalues() if i >= 0]) numrebased = len([i for i in pycompat.itervalues(state) if i >= 0])
# i18n: column positioning for "hg summary" # i18n: column positioning for "hg summary"
ui.write( ui.write(
_(b'rebase: %s, %s (rebase --continue)\n') _(b'rebase: %s, %s (rebase --continue)\n')
% ( % (
ui.label(_(b'%d rebased'), b'rebase.rebased') % numrebased, ui.label(_(b'%d rebased'), b'rebase.rebased') % numrebased,
ui.label(_(b'%d remaining'), b'rebase.remaining') ui.label(_(b'%d remaining'), b'rebase.remaining')
% (len(state) - numrebased), % (len(state) - numrebased),
) )

hgext/remotefilelog/connectionpool.py

# connectionpool.py - class for pooling peer connections for reuse # connectionpool.py - class for pooling peer connections for reuse
# #
# Copyright 2017 Facebook, Inc. # Copyright 2017 Facebook, Inc.
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
from __future__ import absolute_import from __future__ import absolute_import
from mercurial import ( from mercurial import (
extensions, extensions,
hg, hg,
pycompat,
sshpeer, sshpeer,
util, util,
) )
_sshv1peer = sshpeer.sshv1peer _sshv1peer = sshpeer.sshv1peer
class connectionpool(object): class connectionpool(object):
if util.safehasattr(peer, b'cleanup'): if util.safehasattr(peer, b'cleanup'):
extensions.wrapfunction(peer, b'cleanup', _cleanup) extensions.wrapfunction(peer, b'cleanup', _cleanup)
conn = connection(pathpool, peer) conn = connection(pathpool, peer)
return conn return conn
def close(self): def close(self):
for pathpool in self._pool.itervalues(): for pathpool in pycompat.itervalues(self._pool):
for conn in pathpool: for conn in pathpool:
conn.close() conn.close()
del pathpool[:] del pathpool[:]
class connection(object): class connection(object):
def __init__(self, pool, peer): def __init__(self, pool, peer):
self._pool = pool self._pool = pool

hgext/remotefilelog/debugcommands.py

decompress = opts.get(r'decompress') decompress = opts.get(r'decompress')
for root, dirs, files in os.walk(path): for root, dirs, files in os.walk(path):
for file in files: for file in files:
if file == b"repos": if file == b"repos":
continue continue
filepath = os.path.join(root, file) filepath = os.path.join(root, file)
size, firstnode, mapping = parsefileblob(filepath, decompress) size, firstnode, mapping = parsefileblob(filepath, decompress)
for p1, p2, linknode, copyfrom in mapping.itervalues(): for p1, p2, linknode, copyfrom in pycompat.itervalues(mapping):
if linknode == nullid: if linknode == nullid:
actualpath = os.path.relpath(root, path) actualpath = os.path.relpath(root, path)
key = fileserverclient.getcachekey( key = fileserverclient.getcachekey(
b"reponame", actualpath, file b"reponame", actualpath, file
) )
ui.status( ui.status(
b"%s %s\n" % (key, os.path.relpath(filepath, path)) b"%s %s\n" % (key, os.path.relpath(filepath, path))
) )

hgext/remotefilelog/repack.py

nodes += orphans nodes += orphans
return nodes return nodes
def repackdata(self, ledger, target): def repackdata(self, ledger, target):
ui = self.repo.ui ui = self.repo.ui
maxchainlen = ui.configint(b'packs', b'maxchainlen', 1000) maxchainlen = ui.configint(b'packs', b'maxchainlen', 1000)
byfile = {} byfile = {}
for entry in ledger.entries.itervalues(): for entry in pycompat.itervalues(ledger.entries):
if entry.datasource: if entry.datasource:
byfile.setdefault(entry.filename, {})[entry.node] = entry byfile.setdefault(entry.filename, {})[entry.node] = entry
count = 0 count = 0
repackprogress = ui.makeprogress( repackprogress = ui.makeprogress(
_(b"repacking data"), unit=self.unit, total=len(byfile) _(b"repacking data"), unit=self.unit, total=len(byfile)
) )
for filename, entries in sorted(byfile.iteritems()): for filename, entries in sorted(byfile.iteritems()):
repackprogress.complete() repackprogress.complete()
target.close(ledger=ledger) target.close(ledger=ledger)
def repackhistory(self, ledger, target): def repackhistory(self, ledger, target):
ui = self.repo.ui ui = self.repo.ui
byfile = {} byfile = {}
for entry in ledger.entries.itervalues(): for entry in pycompat.itervalues(ledger.entries):
if entry.historysource: if entry.historysource:
byfile.setdefault(entry.filename, {})[entry.node] = entry byfile.setdefault(entry.filename, {})[entry.node] = entry
progress = ui.makeprogress( progress = ui.makeprogress(
_(b"repacking history"), unit=self.unit, total=len(byfile) _(b"repacking history"), unit=self.unit, total=len(byfile)
) )
for filename, entries in sorted(byfile.iteritems()): for filename, entries in sorted(byfile.iteritems()):
ancestors = {} ancestors = {}

hgext/transplant.py

list = self.transplants.setdefault(rnode, []) list = self.transplants.setdefault(rnode, [])
list.append(transplantentry(lnode, rnode)) list.append(transplantentry(lnode, rnode))
def write(self): def write(self):
if self.dirty and self.transplantfile: if self.dirty and self.transplantfile:
if not os.path.isdir(self.path): if not os.path.isdir(self.path):
os.mkdir(self.path) os.mkdir(self.path)
fp = self.opener(self.transplantfile, b'w') fp = self.opener(self.transplantfile, b'w')
for list in self.transplants.itervalues(): for list in pycompat.itervalues(self.transplants):
for t in list: for t in list:
l, r = map(nodemod.hex, (t.lnode, t.rnode)) l, r = map(nodemod.hex, (t.lnode, t.rnode))
fp.write(l + b':' + r + b'\n') fp.write(l + b':' + r + b'\n')
fp.close() fp.close()
self.dirty = False self.dirty = False
def get(self, rnode): def get(self, rnode):
return self.transplants.get(rnode) or [] return self.transplants.get(rnode) or []

mercurial/__init__.py

for i, t in enumerate(tokens): for i, t in enumerate(tokens):
# This looks like a function call. # This looks like a function call.
if t.type == token.NAME and _isop(i + 1, '('): if t.type == token.NAME and _isop(i + 1, '('):
fn = t.string fn = t.string
# It changes iteritems/values to items/values as they are not # It changes iteritems/values to items/values as they are not
# present in Python 3 world. # present in Python 3 world.
if fn in ('iteritems', 'itervalues') and not ( if fn == 'iteritems' and not (
tokens[i - 1].type == token.NAME tokens[i - 1].type == token.NAME
and tokens[i - 1].string == 'def' and tokens[i - 1].string == 'def'
): ):
yield t._replace(string=fn[4:]) yield t._replace(string=fn[4:])
continue continue
# Emit unmodified token. # Emit unmodified token.
yield t yield t
# Header to add to bytecode files. This MUST be changed when # Header to add to bytecode files. This MUST be changed when
# ``replacetoken`` or any mechanism that changes semantics of module # ``replacetoken`` or any mechanism that changes semantics of module
# loading is changed. Otherwise cached bytecode may get loaded without # loading is changed. Otherwise cached bytecode may get loaded without
# the new transformation mechanisms applied. # the new transformation mechanisms applied.
BYTECODEHEADER = b'HG\x00\x14' BYTECODEHEADER = b'HG\x00\x15'
class hgloader(importlib.machinery.SourceFileLoader): class hgloader(importlib.machinery.SourceFileLoader):
"""Custom module loader that transforms source code. """Custom module loader that transforms source code.
When the source code is converted to a code object, we transform When the source code is converted to a code object, we transform
certain patterns to be Python 3 compatible. This allows us to write code certain patterns to be Python 3 compatible. This allows us to write code
that is natively Python 2 and compatible with Python 3 without that is natively Python 2 and compatible with Python 3 without
making the code excessively ugly. making the code excessively ugly.

mercurial/branchmap.py

remote. remote.
""" """
cl = repo.changelog cl = repo.changelog
clrev = cl.rev clrev = cl.rev
clbranchinfo = cl.branchinfo clbranchinfo = cl.branchinfo
rbheads = [] rbheads = []
closed = [] closed = []
for bheads in remotebranchmap.itervalues(): for bheads in pycompat.itervalues(remotebranchmap):
rbheads += bheads rbheads += bheads
for h in bheads: for h in bheads:
r = clrev(h) r = clrev(h)
b, c = clbranchinfo(r) b, c = clbranchinfo(r)
if c: if c:
closed.append(h) closed.append(h)
if rbheads: if rbheads:
def iterbranches(self): def iterbranches(self):
for bn, heads in self.iteritems(): for bn, heads in self.iteritems():
yield (bn, heads) + self._branchtip(heads) yield (bn, heads) + self._branchtip(heads)
def iterheads(self): def iterheads(self):
""" returns all the heads """ """ returns all the heads """
self._verifyall() self._verifyall()
return self._entries.itervalues() return pycompat.itervalues(self._entries)
def copy(self): def copy(self):
"""return an deep copy of the branchcache object""" """return an deep copy of the branchcache object"""
return type(self)( return type(self)(
self._entries, self._entries,
self.tipnode, self.tipnode,
self.tiprev, self.tiprev,
self.filteredhash, self.filteredhash,

mercurial/exchangev2.py

0, 0,
) )
progress.increment() progress.increment()
progress = repo.ui.makeprogress( progress = repo.ui.makeprogress(
_(b'files'), _(b'files'),
unit=_(b'chunks'), unit=_(b'chunks'),
total=sum(len(v) for v in fnodes.itervalues()), total=sum(len(v) for v in pycompat.itervalues(fnodes)),
) )
# TODO make batch size configurable # TODO make batch size configurable
batchsize = 10000 batchsize = 10000
fnodeslist = [x for x in sorted(fnodes.items())] fnodeslist = [x for x in sorted(fnodes.items())]
for i in pycompat.xrange(0, len(fnodeslist), batchsize): for i in pycompat.xrange(0, len(fnodeslist), batchsize):
batch = [x for x in fnodeslist[i : i + batchsize]] batch = [x for x in fnodeslist[i : i + batchsize]]
) )
progress.increment() progress.increment()
remaining -= 1 remaining -= 1
progress = repo.ui.makeprogress( progress = repo.ui.makeprogress(
_(b'files'), _(b'files'),
unit=_(b'chunks'), unit=_(b'chunks'),
total=sum(len(v) for v in fnodes.itervalues()), total=sum(len(v) for v in pycompat.itervalues(fnodes)),
) )
commandmeta = remote.apidescriptor[b'commands'][b'filesdata'] commandmeta = remote.apidescriptor[b'commands'][b'filesdata']
batchsize = commandmeta.get(b'recommendedbatchsize', 50000) batchsize = commandmeta.get(b'recommendedbatchsize', 50000)
shallowfiles = repository.REPO_FEATURE_SHALLOW_FILE_STORAGE in repo.features shallowfiles = repository.REPO_FEATURE_SHALLOW_FILE_STORAGE in repo.features
fields = {b'parents', b'revision'} fields = {b'parents', b'revision'}
clrev = repo.changelog.rev clrev = repo.changelog.rev

mercurial/localrepo.py

return self._tagscache.tagslist return self._tagscache.tagslist
def nodetags(self, node): def nodetags(self, node):
'''return the tags associated with a node''' '''return the tags associated with a node'''
if not self._tagscache.nodetagscache: if not self._tagscache.nodetagscache:
nodetagscache = {} nodetagscache = {}
for t, n in self._tagscache.tags.iteritems(): for t, n in self._tagscache.tags.iteritems():
nodetagscache.setdefault(n, []).append(t) nodetagscache.setdefault(n, []).append(t)
for tags in nodetagscache.itervalues(): for tags in pycompat.itervalues(nodetagscache):
tags.sort() tags.sort()
self._tagscache.nodetagscache = nodetagscache self._tagscache.nodetagscache = nodetagscache
return self._tagscache.nodetagscache.get(node, []) return self._tagscache.nodetagscache.get(node, [])
def nodebookmarks(self, node): def nodebookmarks(self, node):
"""return the list of bookmarks pointing to the specified node""" """return the list of bookmarks pointing to the specified node"""
return self._bookmarks.names(node) return self._bookmarks.names(node)

mercurial/merge.py

Returns the exit code of the merge.""" Returns the exit code of the merge."""
return self._resolve(False, dfile, wctx)[1] return self._resolve(False, dfile, wctx)[1]
def counts(self): def counts(self):
"""return counts for updated, merged and removed files in this """return counts for updated, merged and removed files in this
session""" session"""
updated, merged, removed = 0, 0, 0 updated, merged, removed = 0, 0, 0
for r, action in self._results.itervalues(): for r, action in pycompat.itervalues(self._results):
if r is None: if r is None:
updated += 1 updated += 1
elif r == 0: elif r == 0:
if action == ACTION_REMOVE: if action == ACTION_REMOVE:
removed += 1 removed += 1
else: else:
merged += 1 merged += 1
return updated, merged, removed return updated, merged, removed

mercurial/patch.py

for newhunk in newpatch.hunks: for newhunk in newpatch.hunks:
if fixoffset: if fixoffset:
newhunk.toline += fixoffset newhunk.toline += fixoffset
applied[newhunk.filename()].append(newhunk) applied[newhunk.filename()].append(newhunk)
else: else:
fixoffset += chunk.removed - chunk.added fixoffset += chunk.removed - chunk.added
return ( return (
sum( sum(
[h for h in applied.itervalues() if h[0].special() or len(h) > 1], [
h
for h in pycompat.itervalues(applied)
if h[0].special() or len(h) > 1
],
[], [],
), ),
{}, {},
) )
class hunk(object): class hunk(object):
def __init__(self, desc, num, lr, context): def __init__(self, desc, num, lr, context):

mercurial/pycompat.py

""" """
Takes bytes argument, convert it to str i.e. unicodes, pass that into Takes bytes argument, convert it to str i.e. unicodes, pass that into
shlex.split(), convert the returned value to bytes and return that for shlex.split(), convert the returned value to bytes and return that for
Python 3 compatibility as shelx.split() don't accept bytes on Python 3. Python 3 compatibility as shelx.split() don't accept bytes on Python 3.
""" """
ret = shlex.split(s.decode('latin-1'), comments, posix) ret = shlex.split(s.decode('latin-1'), comments, posix)
return [a.encode('latin-1') for a in ret] return [a.encode('latin-1') for a in ret]
itervalues = lambda x: x.values()
else: else:
import cStringIO import cStringIO
xrange = xrange xrange = xrange
unicode = unicode unicode = unicode
bytechr = chr bytechr = chr
byterepr = repr byterepr = repr
shlexsplit = shlex.split shlexsplit = shlex.split
bytesio = cStringIO.StringIO bytesio = cStringIO.StringIO
stringio = bytesio stringio = bytesio
maplist = map maplist = map
rangelist = range rangelist = range
ziplist = zip ziplist = zip
rawinput = raw_input rawinput = raw_input
getargspec = inspect.getargspec getargspec = inspect.getargspec
itervalues = lambda x: x.itervalues()
isjython = sysplatform.startswith(b'java') isjython = sysplatform.startswith(b'java')
isdarwin = sysplatform.startswith(b'darwin') isdarwin = sysplatform.startswith(b'darwin')
islinux = sysplatform.startswith(b'linux') islinux = sysplatform.startswith(b'linux')
isposix = osname == b'posix' isposix = osname == b'posix'
iswindows = osname == b'nt' iswindows = osname == b'nt'

mercurial/statprof.py

sitestat = SiteStats(site) sitestat = SiteStats(site)
stats[site] = sitestat stats[site] = sitestat
sitestat.addtotal() sitestat.addtotal()
if i == 0: if i == 0:
sitestat.addself() sitestat.addself()
return [s for s in stats.itervalues()] return [s for s in pycompat.itervalues(stats)]
class DisplayFormats: class DisplayFormats:
ByLine = 0 ByLine = 0
ByMethod = 1 ByMethod = 1
AboutMethod = 2 AboutMethod = 2
Hotpath = 3 Hotpath = 3
FlameGraph = 4 FlameGraph = 4
root.add(sample.stack[::-1], sample.time - lasttime) root.add(sample.stack[::-1], sample.time - lasttime)
lasttime = sample.time lasttime = sample.time
showtime = kwargs.get(r'showtime', True) showtime = kwargs.get(r'showtime', True)
def _write(node, depth, multiple_siblings): def _write(node, depth, multiple_siblings):
site = node.site site = node.site
visiblechildren = [ visiblechildren = [
c c
for c in node.children.itervalues() for c in pycompat.itervalues(node.children)
if c.count >= (limit * root.count) if c.count >= (limit * root.count)
] ]
if site: if site:
indent = depth * 2 - 1 indent = depth * 2 - 1
filename = b'' filename = b''
function = b'' function = b''
if len(node.children) > 0: if len(node.children) > 0:
childsite = list(node.children.itervalues())[0].site childsite = list(pycompat.itervalues(node.children))[0].site
filename = (childsite.filename() + b':').ljust(15) filename = (childsite.filename() + b':').ljust(15)
function = childsite.function function = childsite.function
# lots of string formatting # lots of string formatting
listpattern = ( listpattern = (
b''.ljust(indent) b''.ljust(indent)
+ (b'\\' if multiple_siblings else b'|') + (b'\\' if multiple_siblings else b'|')
+ b' %4.1f%%' + b' %4.1f%%'
+ (b' %5.2fs' % node.count if showtime else b'') + (b' %5.2fs' % node.count if showtime else b'')
+ b' %s %s' + b' %s %s'
) )
liststring = listpattern % ( liststring = listpattern % (
node.count / root.count * 100, node.count / root.count * 100,
filename, filename,
function, function,
) )
codepattern = b'%' + (b'%d' % (55 - len(liststring))) + b's %d: %s' codepattern = b'%' + (b'%d' % (55 - len(liststring))) + b's %d: %s'
codestring = codepattern % ( codestring = codepattern % (
b'line', b'line',
site.lineno, site.lineno,
site.getsource(30), site.getsource(30),
) )
finalstring = liststring + codestring finalstring = liststring + codestring
childrensamples = sum([c.count for c in node.children.itervalues()]) childrensamples = sum(
[c.count for c in pycompat.itervalues(node.children)]
)
# Make frames that performed more than 10% of the operation red # Make frames that performed more than 10% of the operation red
if node.count - childrensamples > (0.1 * root.count): if node.count - childrensamples > (0.1 * root.count):
finalstring = b'\033[91m' + finalstring + b'\033[0m' finalstring = b'\033[91m' + finalstring + b'\033[0m'
# Make frames that didn't actually perform work dark grey # Make frames that didn't actually perform work dark grey
elif node.count - childrensamples == 0: elif node.count - childrensamples == 0:
finalstring = b'\033[90m' + finalstring + b'\033[0m' finalstring = b'\033[90m' + finalstring + b'\033[0m'
fp.write(finalstring + b'\n') fp.write(finalstring + b'\n')

mercurial/ui.py

msgfmt should be a newline-terminated format string to log, and msgfmt should be a newline-terminated format string to log, and
*msgargs are %-formatted into it. *msgargs are %-formatted into it.
**opts currently has no defined meanings. **opts currently has no defined meanings.
''' '''
if not self._loggers: if not self._loggers:
return return
activeloggers = [ activeloggers = [
l for l in self._loggers.itervalues() if l.tracked(event) l for l in pycompat.itervalues(self._loggers) if l.tracked(event)
] ]
if not activeloggers: if not activeloggers:
return return
msg = msgfmt % msgargs msg = msgfmt % msgargs
opts = pycompat.byteskwargs(opts) opts = pycompat.byteskwargs(opts)
# guard against recursion from e.g. ui.debug() # guard against recursion from e.g. ui.debug()
registeredloggers = self._loggers registeredloggers = self._loggers
self._loggers = {} self._loggers = {}

tests/test-pathencode.py

if line[-2:] in ('.i', '.d'): if line[-2:] in ('.i', '.d'):
line = line[:-2] line = line[:-2]
if line.startswith('data/'): if line.startswith('data/'):
line = line[5:] line = line[5:]
for c in line: for c in line:
counts[c] += 1 counts[c] += 1
for c in '\r/\n': for c in '\r/\n':
counts.pop(c, None) counts.pop(c, None)
t = sum(counts.itervalues()) / 100.0 t = sum(pycompat.itervalues(counts)) / 100.0
fp.write('probtable = (') fp.write('probtable = (')
for i, (k, v) in enumerate( for i, (k, v) in enumerate(
sorted(counts.items(), key=lambda x: x[1], reverse=True) sorted(counts.items(), key=lambda x: x[1], reverse=True)
): ):
if (i % 5) == 0: if (i % 5) == 0:
fp.write('\n ') fp.write('\n ')
vt = v / t vt = v / t
if vt < 0.0005: if vt < 0.0005: