Merge lp:~gz/brz/unmapped into lp:brz

[Martin Packman]

Make use of map Python 3 compatible

Cope with the builtin map function becoming imap in Python 3.

Worse case the fixer throws in an extra pointless list copy, where it looked like that might matter I refactored or pulled in the iterator version from future_builtins.

There are a few changes on somewhat hot paths, where larger refactors/rewrites are probably called for, but avoided doing so for now.

The static tuple intern change is somewhat driveby, we can't use sys.intern on bytestrings in Python 3 anyway, and a better interface would be constructing the tuple with a new method like from_bytes_interned or something to mega-intern the result.

[Jelmer Vernooij (jelmer)]

review: Approve

=== modified file 'breezy/btree_index.py'
--- breezy/btree_index.py	2017-05-22 00:56:52 +0000
+++ breezy/btree_index.py	2017-05-24 19:44:24 +0000
@@ -19,6 +19,8 @@
 
 from __future__ import absolute_import
 
+from future_builtins import map
+
 from .lazy_import import lazy_import
 lazy_import(globals(), """
 import bisect
@@ -662,7 +664,9 @@
         for line in lines[2:]:
             if line == '':
                 break
-            nodes.append(as_st(map(intern, line.split('\0'))).intern())
+            # GZ 2017-05-24: Used to intern() each chunk of line as well, need
+            # to recheck performance and perhaps adapt StaticTuple to adjust.
+            nodes.append(as_st(line.split(b'\0')).intern())
         return nodes
 
 
@@ -1497,9 +1501,9 @@
         if not options_line.startswith(_OPTION_ROW_LENGTHS):
             raise errors.BadIndexOptions(self)
         try:
-            self._row_lengths = map(int, [length for length in
+            self._row_lengths = [int(length) for length in
                 options_line[len(_OPTION_ROW_LENGTHS):].split(',')
-                if len(length)])
+                if length]
         except ValueError:
             raise errors.BadIndexOptions(self)
         self._compute_row_offsets()

=== modified file 'breezy/config.py'
--- breezy/config.py	2017-05-22 00:56:52 +0000
+++ breezy/config.py	2017-05-24 19:44:24 +0000
@@ -1191,8 +1191,7 @@
         else:
             # Rely on zip truncating in length to the length of the shortest
             # argument sequence.
-            names = zip(location_parts, section_parts)
-            for name in names:
+            for name in zip(location_parts, section_parts):
                 if not fnmatch.fnmatch(name[0], name[1]):
                     matched = False
                     break

=== modified file 'breezy/dirstate.py'
--- breezy/dirstate.py	2017-05-22 11:22:28 +0000
+++ breezy/dirstate.py	2017-05-24 19:44:24 +0000
@@ -1953,7 +1953,7 @@
         lines = []
         lines.append(self._get_parents_line(self.get_parent_ids()))
         lines.append(self._get_ghosts_line(self._ghosts))
-        lines.extend(self._get_entry_lines())
+        lines.extend(self._iter_entry_lines())
         return self._get_output_lines(lines)
 
     def _get_ghosts_line(self, ghost_ids):
@@ -1964,7 +1964,7 @@
         """Create a line for the state file for parents information."""
         return '\0'.join([str(len(parent_ids))] + parent_ids)
 
-    def _get_entry_lines(self):
+    def _iter_entry_lines(self):
         """Create lines for entries."""
         return map(self._entry_to_line, self._iter_entries())
 

=== modified file 'breezy/export_pot.py'
--- breezy/export_pot.py	2017-05-22 00:56:52 +0000
+++ breezy/export_pot.py	2017-05-24 19:44:24 +0000
@@ -65,9 +65,8 @@
         if not lines[-1]:
             del lines[-1]
             lines[-1] = lines[-1] + '\n'
-        lines = map(_escape, lines)
         lineterm = '\\n"\n"'
-        s = '""\n"' + lineterm.join(lines) + '"'
+        s = '""\n"' + lineterm.join(map(_escape, lines)) + '"'
     return s
 
 

=== modified file 'breezy/groupcompress.py'
--- breezy/groupcompress.py	2017-05-22 00:56:52 +0000
+++ breezy/groupcompress.py	2017-05-24 19:44:24 +0000
@@ -18,6 +18,7 @@
 
 from __future__ import absolute_import
 
+from future_builtins import map
 import time
 import zlib
 
@@ -300,7 +301,7 @@
         compressor = zlib.compressobj(zlib.Z_DEFAULT_COMPRESSION)
         # Peak in this point is 1 fulltext, 1 compressed text, + zlib overhead
         # (measured peak is maybe 30MB over the above...)
-        compressed_chunks = map(compressor.compress, chunks)
+        compressed_chunks = list(map(compressor.compress, chunks))
         compressed_chunks.append(compressor.flush())
         # Ignore empty chunks
         self._z_content_chunks = [c for c in compressed_chunks if c]

=== modified file 'breezy/index.py'
--- breezy/index.py	2017-05-22 00:56:52 +0000
+++ breezy/index.py	2017-05-24 19:44:24 +0000
@@ -1449,6 +1449,7 @@
         """
         indices_info = zip(self._index_names, self._indices)
         if 'index' in debug.debug_flags:
+            indices_info = list(indices_info)
             trace.mutter('CombinedGraphIndex reordering: currently %r, '
                          'promoting %r', indices_info, hit_indices)
         hit_names = []

=== modified file 'breezy/knit.py'
--- breezy/knit.py	2017-05-22 00:56:52 +0000
+++ breezy/knit.py	2017-05-24 19:44:24 +0000
@@ -53,8 +53,6 @@
 
 from __future__ import absolute_import
 
-
-from itertools import izip
 import operator
 import os
 
@@ -471,7 +469,7 @@
 
     def __init__(self, lines):
         KnitContent.__init__(self)
-        self._lines = lines
+        self._lines = list(lines)
 
     def annotate(self):
         """Return a list of (origin, text) for each content line."""
@@ -504,7 +502,7 @@
         return lines
 
     def copy(self):
-        return AnnotatedKnitContent(self._lines[:])
+        return AnnotatedKnitContent(self._lines)
 
 
 class PlainKnitContent(KnitContent):
@@ -599,7 +597,7 @@
         #       but the code itself doesn't really depend on that.
         #       Figure out a way to not require the overhead of turning the
         #       list back into tuples.
-        lines = [tuple(line.split(' ', 1)) for line in content]
+        lines = (tuple(line.split(' ', 1)) for line in content)
         return AnnotatedKnitContent(lines)
 
     def parse_line_delta_iter(self, lines):
@@ -1933,8 +1931,7 @@
         raw_data = self._access.get_raw_records(
             [index_memo for key, index_memo in needed_records])
 
-        for (key, index_memo), data in \
-                izip(iter(needed_records), raw_data):
+        for (key, index_memo), data in zip(needed_records, raw_data):
             content, digest = self._parse_record(key[-1], data)
             yield key, content, digest
 

=== modified file 'breezy/log.py'
--- breezy/log.py	2017-05-22 00:56:52 +0000
+++ breezy/log.py	2017-05-24 19:44:24 +0000
@@ -51,6 +51,7 @@
 
 import codecs
 import itertools
+from future_builtins import zip
 import re
 import sys
 from warnings import (
@@ -91,12 +92,6 @@
     )
 
 
-if PY3:
-    izip = zip
-else:
-    izip = itertools.izip
-
-
 def find_touching_revisions(branch, file_id):
     """Yield a description of revisions which affect the file_id.
 
@@ -834,7 +829,7 @@
         # A single batch conversion is faster than many incremental ones.
         # As we have all the data, do a batch conversion.
         nones = [None] * len(view_revisions)
-        log_rev_iterator = iter([zip(view_revisions, nones, nones)])
+        log_rev_iterator = iter([list(zip(view_revisions, nones, nones))])
     else:
         def _convert():
             for view in view_revisions:
@@ -945,11 +940,11 @@
         new_revs = []
         if delta_type == 'full' and not check_fileids:
             deltas = repository.get_deltas_for_revisions(revisions)
-            for rev, delta in izip(revs, deltas):
+            for rev, delta in zip(revs, deltas):
                 new_revs.append((rev[0], rev[1], delta))
         else:
             deltas = repository.get_deltas_for_revisions(revisions, fileid_set)
-            for rev, delta in izip(revs, deltas):
+            for rev, delta in zip(revs, deltas):
                 if check_fileids:
                     if delta is None or not delta.has_changed():
                         continue
@@ -1005,7 +1000,7 @@
         revision_ids = [view[0] for view, _, _ in revs]
         revisions = repository.get_revisions(revision_ids)
         revs = [(rev[0], revision, rev[2]) for rev, revision in
-            izip(revs, revisions)]
+            zip(revs, revisions)]
         yield revs
 
 

=== modified file 'breezy/mutabletree.py'
--- breezy/mutabletree.py	2017-05-22 00:56:52 +0000
+++ breezy/mutabletree.py	2017-05-24 19:44:24 +0000
@@ -667,7 +667,7 @@
         # filename alone
         # only expanding if symlinks are supported avoids windows path bugs
         if osutils.has_symlinks():
-            file_list = map(osutils.normalizepath, file_list)
+            file_list = list(map(osutils.normalizepath, file_list))
 
         user_dirs = {}
         # validate user file paths and convert all paths to tree

=== modified file 'breezy/osutils.py'
--- breezy/osutils.py	2017-05-22 00:56:52 +0000
+++ breezy/osutils.py	2017-05-24 19:44:24 +0000
@@ -811,7 +811,8 @@
 def sha_strings(strings, _factory=sha):
     """Return the sha-1 of concatenation of strings"""
     s = _factory()
-    map(s.update, strings)
+    for string in strings:
+        s.update(string)
     return s.hexdigest()
 
 

=== modified file 'breezy/plugin.py'
--- breezy/plugin.py	2017-05-22 00:56:52 +0000
+++ breezy/plugin.py	2017-05-24 19:44:24 +0000
@@ -266,7 +266,7 @@
 
     # Get rid of trailing slashes, since Python can't handle them when
     # it tries to import modules.
-    paths = map(_strip_trailing_sep, paths)
+    paths = list(map(_strip_trailing_sep, paths))
     return paths
 
 
@@ -317,7 +317,7 @@
     # this function, and since it sets plugins.__path__, it should set it to
     # something that will be valid for Python to use (in case people try to
     # run "import breezy.plugins.PLUGINNAME" after calling this function).
-    _mod_plugins.__path__ = map(_strip_trailing_sep, dirs)
+    _mod_plugins.__path__ = list(map(_strip_trailing_sep, dirs))
     for d in dirs:
         if not d:
             continue

=== modified file 'breezy/plugins/changelog_merge/changelog_merge.py'
--- breezy/plugins/changelog_merge/changelog_merge.py	2017-05-22 00:56:52 +0000
+++ breezy/plugins/changelog_merge/changelog_merge.py	2017-05-24 19:44:24 +0000
@@ -18,6 +18,8 @@
 
 from __future__ import absolute_import
 
+from future_builtins import map
+
 import difflib
 
 from ... import (
@@ -48,7 +50,7 @@
                 entries.append([])
                 entry = entries[-1]
             entry.append(line)
-    return map(tuple, entries)
+    return list(map(tuple, entries))
 
 
 def entries_to_lines(entries):
@@ -106,8 +108,8 @@
     This algorithm does O(N^2 * logN) SequenceMatcher.ratio() calls, which is
     pretty bad, but it shouldn't be used very often.
     """
-    deleted_entries_as_strs = map(entry_as_str, deleted_entries)
-    new_entries_as_strs = map(entry_as_str, new_entries)
+    deleted_entries_as_strs = list(map(entry_as_str, deleted_entries))
+    new_entries_as_strs = list(map(entry_as_str, new_entries))
     result_new = list(new_entries)
     result_deleted = list(deleted_entries)
     result_edits = []

=== modified file 'breezy/plugins/weave_fmt/bzrdir.py'
--- breezy/plugins/weave_fmt/bzrdir.py	2017-05-22 00:56:52 +0000
+++ breezy/plugins/weave_fmt/bzrdir.py	2017-05-24 19:44:24 +0000
@@ -415,7 +415,7 @@
         Also upgrade the inventory to refer to the text revision ids."""
         rev_id = rev.revision_id
         trace.mutter('converting texts of revision {%s}', rev_id)
-        parent_invs = map(self._load_updated_inventory, present_parents)
+        parent_invs = list(map(self._load_updated_inventory, present_parents))
         entries = inv.iter_entries()
         entries.next()
         for path, ie in entries:

=== modified file 'breezy/repofmt/knitpack_repo.py'
--- breezy/repofmt/knitpack_repo.py	2017-05-22 00:56:52 +0000
+++ breezy/repofmt/knitpack_repo.py	2017-05-24 19:44:24 +0000
@@ -18,9 +18,10 @@
 
 from __future__ import absolute_import
 
+from future_builtins import zip
+
 from ..lazy_import import lazy_import
 lazy_import(globals(), """
-from itertools import izip
 import time
 
 from breezy import (
@@ -659,8 +660,8 @@
                 if self._reload_func is not None:
                     self._reload_func()
                 raise
-            for (names, read_func), (_1, _2, (key, eol_flag)) in \
-                izip(reader.iter_records(), pack_readv_requests):
+            for (names, read_func), (_1, _2, (key, eol_flag)) in zip(
+                    reader.iter_records(), pack_readv_requests):
                 raw_data = read_func(None)
                 # check the header only
                 if output_lines is not None:
@@ -711,8 +712,8 @@
                 if self._reload_func is not None:
                     self._reload_func()
                 raise
-            for (names, read_func), (key, eol_flag, references) in \
-                izip(reader.iter_records(), node_vector):
+            for (names, read_func), (key, eol_flag, references) in zip(
+                    reader.iter_records(), node_vector):
                 raw_data = read_func(None)
                 if output_lines:
                     # read the entire thing

=== modified file 'breezy/repository.py'
--- breezy/repository.py	2017-05-22 00:56:52 +0000
+++ breezy/repository.py	2017-05-24 19:44:24 +0000
@@ -924,8 +924,8 @@
             not part of revision_ids themselves
         """
         parent_map = self.get_parent_map(revision_ids)
-        parent_ids = set()
-        map(parent_ids.update, parent_map.itervalues())
+        parent_ids = set(itertools.chain.from_iterable(
+            parent_map.itervalues()))
         parent_ids.difference_update(revision_ids)
         parent_ids.discard(_mod_revision.NULL_REVISION)
         return parent_ids

=== modified file 'breezy/smart/repository.py'
--- breezy/smart/repository.py	2017-05-22 00:56:52 +0000
+++ breezy/smart/repository.py	2017-05-24 19:44:24 +0000
@@ -19,6 +19,7 @@
 from __future__ import absolute_import
 
 import bz2
+import itertools
 import os
 try:
     import queue
@@ -307,8 +308,7 @@
         else:
             search_ids = repository.all_revision_ids()
         search = graph._make_breadth_first_searcher(search_ids)
-        transitive_ids = set()
-        map(transitive_ids.update, list(search))
+        transitive_ids = set(itertools.chain.from_iterable(search))
         parent_map = graph.get_parent_map(transitive_ids)
         revision_graph = _strip_NULL_ghosts(parent_map)
         if revision_id and revision_id not in revision_graph:

=== modified file 'breezy/tests/__init__.py'
--- breezy/tests/__init__.py	2017-05-22 00:56:52 +0000
+++ breezy/tests/__init__.py	2017-05-24 19:44:24 +0000
@@ -3456,7 +3456,7 @@
     # than the fastest.
     partitions = [list() for i in range(count)]
     tests = iter_suite_tests(suite)
-    for partition, test in itertools.izip(itertools.cycle(partitions), tests):
+    for partition, test in zip(itertools.cycle(partitions), tests):
         partition.append(test)
     return partitions
 

=== modified file 'breezy/tests/blackbox/test_log.py'
--- breezy/tests/blackbox/test_log.py	2017-05-21 18:10:28 +0000
+++ breezy/tests/blackbox/test_log.py	2017-05-24 19:44:24 +0000
@@ -17,7 +17,6 @@
 
 """Black-box tests for brz log."""
 
-from itertools import izip
 import os
 
 from breezy import (
@@ -693,8 +692,8 @@
                            for r in self.get_captured_revisions()])
         # Now check the diffs, adding the revno  in case of failure
         fmt = 'In revno %s\n%s'
-        for expected_rev, actual_rev in izip(expected,
-                                             self.get_captured_revisions()):
+        for expected_rev, actual_rev in zip(expected,
+                                            self.get_captured_revisions()):
             revno, depth, expected_diff = expected_rev
             actual_diff = actual_rev.diff
             self.assertEqualDiff(fmt % (revno, expected_diff),

=== modified file 'breezy/tests/per_controldir/test_controldir.py'
--- breezy/tests/per_controldir/test_controldir.py	2017-05-22 00:56:52 +0000
+++ breezy/tests/per_controldir/test_controldir.py	2017-05-24 19:44:24 +0000
@@ -16,8 +16,6 @@
 
 """Tests for control directory implementations - tests a controldir format."""
 
-from itertools import izip
-
 import breezy.branch
 from breezy import (
     bzrdir as _mod_bzrdir,
@@ -1560,7 +1558,7 @@
         self.assertPathExists(old_path)
         self.assertPathExists(new_path)
         for (((dir_relpath1, _), entries1),
-             ((dir_relpath2, _), entries2)) in izip(
+             ((dir_relpath2, _), entries2)) in zip(
                 osutils.walkdirs(old_path),
                 osutils.walkdirs(new_path)):
             self.assertEqual(dir_relpath1, dir_relpath2)

=== modified file 'breezy/tests/per_pack_repository.py'
--- breezy/tests/per_pack_repository.py	2017-05-23 14:08:03 +0000
+++ breezy/tests/per_pack_repository.py	2017-05-24 19:44:24 +0000
@@ -358,7 +358,7 @@
         for _1, key, val, refs in pack.revision_index.iter_all_entries():
             if isinstance(format.repository_format, RepositoryFormat2a):
                 # group_start, group_len, internal_start, internal_len
-                pos = map(int, val.split())
+                pos = list(map(int, val.split()))
             else:
                 # eol_flag, start, len
                 pos = int(val[1:].split()[0])

=== modified file 'breezy/tests/per_repository/test_repository.py'
--- breezy/tests/per_repository/test_repository.py	2017-05-22 00:56:52 +0000
+++ breezy/tests/per_repository/test_repository.py	2017-05-24 19:44:24 +0000
@@ -421,7 +421,7 @@
         revision_ids = ['a-rev', 'b-rev', 'c-rev']
         revisions = repo.get_revisions(revision_ids)
         self.assertEqual(len(revisions), 3)
-        zipped = zip(revisions, revision_ids)
+        zipped = list(zip(revisions, revision_ids))
         self.assertEqual(len(zipped), 3)
         for revision, revision_id in zipped:
             self.assertEqual(revision.revision_id, revision_id)

=== modified file 'breezy/tests/per_transport.py'
--- breezy/tests/per_transport.py	2017-05-23 14:08:03 +0000
+++ breezy/tests/per_transport.py	2017-05-24 19:44:24 +0000
@@ -20,7 +20,7 @@
 TransportTestProviderAdapter.
 """
 
-import itertools
+from future_builtins import zip
 import os
 import stat
 import sys
@@ -191,15 +191,15 @@
         self.build_tree(files, transport=t, line_endings='binary')
         self.check_transport_contents('contents of a\n', t, 'a')
         content_f = t.get_multi(files)
-        # Use itertools.izip() instead of use zip() or map(), since they fully
+        # Use future iter zip instead of use zip() or map(), since they fully
         # evaluate their inputs, the transport requests should be issued and
         # handled sequentially (we don't want to force transport to buffer).
-        for content, f in itertools.izip(contents, content_f):
+        for content, f in zip(contents, content_f):
             self.assertEqual(content, f.read())
 
         content_f = t.get_multi(iter(files))
-        # Use itertools.izip() for the same reason
-        for content, f in itertools.izip(contents, content_f):
+        # Again need iter version of zip for the same reason
+        for content, f in zip(contents, content_f):
             self.assertEqual(content, f.read())
 
     def test_get_unknown_file(self):

=== modified file 'breezy/tests/per_versionedfile.py'
--- breezy/tests/per_versionedfile.py	2017-05-22 00:56:52 +0000
+++ breezy/tests/per_versionedfile.py	2017-05-24 19:44:24 +0000
@@ -944,9 +944,9 @@
             return x + '\n'
 
         w = self.get_file()
-        w.add_lines('text0', [], map(addcrlf, base))
-        w.add_lines('text1', ['text0'], map(addcrlf, a))
-        w.add_lines('text2', ['text0'], map(addcrlf, b))
+        w.add_lines('text0', [], list(map(addcrlf, base)))
+        w.add_lines('text1', ['text0'], list(map(addcrlf, a)))
+        w.add_lines('text2', ['text0'], list(map(addcrlf, b)))
 
         self.log_contents(w)
 
@@ -962,7 +962,7 @@
         mt.seek(0)
         self.log(mt.getvalue())
 
-        mp = map(addcrlf, mp)
+        mp = list(map(addcrlf, mp))
         self.assertEqual(mt.readlines(), mp)
 
 
@@ -2030,7 +2030,7 @@
         """
         # We make assertions during copying to catch things early for
         # easier debugging.
-        for record, ref_record in izip(stream, expected):
+        for record, ref_record in zip(stream, expected):
             records.append(record)
             self.assertEqual(ref_record.key, record.key)
             self.assertEqual(ref_record.storage_kind, record.storage_kind)

=== modified file 'breezy/tests/per_workingtree/test_paths2ids.py'
--- breezy/tests/per_workingtree/test_paths2ids.py	2017-05-21 18:10:28 +0000
+++ breezy/tests/per_workingtree/test_paths2ids.py	2017-05-24 19:44:24 +0000
@@ -21,8 +21,6 @@
 find_ids_across_trees.
 """
 
-from operator import attrgetter
-
 from breezy import errors
 from breezy.tests import features
 from breezy.tests.per_workingtree import TestCaseWithWorkingTree
@@ -47,10 +45,12 @@
         """Run paths2ids for tree, and check the result."""
         tree.lock_read()
         if trees:
-            map(apply, map(attrgetter('lock_read'), trees))
+            for t in trees:
+                t.lock_read()
             result = tree.paths2ids(paths, trees,
                 require_versioned=require_versioned)
-            map(apply, map(attrgetter('unlock'), trees))
+            for t in trees:
+                t.unlock()
         else:
             result = tree.paths2ids(paths,
                 require_versioned=require_versioned)

=== modified file 'breezy/tests/test_diff.py'
--- breezy/tests/test_diff.py	2017-05-22 00:56:52 +0000
+++ breezy/tests/test_diff.py	2017-05-24 19:44:24 +0000
@@ -1194,8 +1194,8 @@
                           ]
                           , list(unified_diff(txt_a, txt_b,
                                  sequencematcher=psm)))
-        txt_a = map(lambda x: x+'\n', 'abcdefghijklmnop')
-        txt_b = map(lambda x: x+'\n', 'abcdefxydefghijklmnop')
+        txt_a = [x+'\n' for x in 'abcdefghijklmnop']
+        txt_b = [x+'\n' for x in 'abcdefxydefghijklmnop']
         # This is the result with LongestCommonSubstring matching
         self.assertEqual(['--- \n',
                            '+++ \n',
@@ -1307,8 +1307,8 @@
                           , list(unified_diff_files('a1', 'b1',
                                  sequencematcher=psm)))
 
-        txt_a = map(lambda x: x+'\n', 'abcdefghijklmnop')
-        txt_b = map(lambda x: x+'\n', 'abcdefxydefghijklmnop')
+        txt_a = [x+'\n' for x in 'abcdefghijklmnop']
+        txt_b = [x+'\n' for x in 'abcdefxydefghijklmnop']
         with open('a2', 'wb') as f: f.writelines(txt_a)
         with open('b2', 'wb') as f: f.writelines(txt_b)
 

=== modified file 'breezy/tests/test_http.py'
--- breezy/tests/test_http.py	2017-05-22 00:56:52 +0000
+++ breezy/tests/test_http.py	2017-05-24 19:44:24 +0000
@@ -1391,8 +1391,8 @@
 
     def test_range_header(self):
         # Valid ranges
-        map(self.assertEqual,['0', '234'],
-            list(self._file_contents('a', [(0,0), (2,4)])),)
+        self.assertEqual(
+            ['0', '234'], list(self._file_contents('a', [(0,0), (2,4)])))
 
     def test_range_header_tail(self):
         self.assertEqual('789', self._file_tail('a', 3))

=== modified file 'breezy/tests/test_rio.py'
--- breezy/tests/test_rio.py	2017-05-21 18:10:28 +0000
+++ breezy/tests/test_rio.py	2017-05-24 19:44:24 +0000
@@ -130,8 +130,8 @@
             s.add(k, v)
         s2 = read_stanza(s.to_lines())
         self.assertEqual(s, s2)
-        self.assertEqual(s.get_all('a'), map(str, [10, 100, 1000]))
-        self.assertEqual(s.get_all('b'), map(str, [20, 200, 2000]))
+        self.assertEqual(s.get_all('a'), ['10', '100', '1000'])
+        self.assertEqual(s.get_all('b'), ['20', '200', '2000'])
 
     def test_backslash(self):
         s = Stanza(q='\\')

=== modified file 'breezy/transport/memory.py'
--- breezy/transport/memory.py	2017-05-22 00:56:52 +0000
+++ breezy/transport/memory.py	2017-05-24 19:44:24 +0000
@@ -193,8 +193,8 @@
                 if path.startswith(_abspath):
                     trailing = path[len(_abspath):]
                     if trailing and '/' not in trailing:
-                        result.append(trailing)
-        return map(urlutils.escape, result)
+                        result.append(urlutils.escape(trailing))
+        return result
 
     def rename(self, rel_from, rel_to):
         """Rename a file or directory; fail if the destination exists"""

=== modified file 'breezy/transport/sftp.py'
--- breezy/transport/sftp.py	2017-05-22 00:56:52 +0000
+++ breezy/transport/sftp.py	2017-05-24 19:44:24 +0000
@@ -27,6 +27,7 @@
 
 import bisect
 import errno
+from future_builtins import zip
 import itertools
 import os
 import random
@@ -202,7 +203,7 @@
         # short readv.
         data_stream = itertools.chain(fp.readv(requests),
                                       itertools.repeat(None))
-        for (start, length), data in itertools.izip(requests, data_stream):
+        for (start, length), data in zip(requests, data_stream):
             if data is None:
                 if cur_coalesced is not None:
                     raise errors.ShortReadvError(self.relpath,
@@ -279,7 +280,7 @@
         if data_chunks:
             if 'sftp' in debug.debug_flags:
                 mutter('SFTP readv left with %d out-of-order bytes',
-                    sum(map(lambda x: len(x[1]), data_chunks)))
+                    sum(len(x[1]) for x in data_chunks))
             # We've processed all the readv data, at this point, anything we
             # couldn't process is in data_chunks. This doesn't happen often, so
             # this code path isn't optimized

=== modified file 'breezy/util/simplemapi.py'
--- breezy/util/simplemapi.py	2017-02-05 16:35:58 +0000
+++ breezy/util/simplemapi.py	2017-05-24 19:44:24 +0000
@@ -233,10 +233,9 @@
 
     attach = []
     AttachWork = attachfiles.split(';')
-    for file in AttachWork:
-        if os.path.exists(file):
-            attach.append(file)
-    attach = map(os.path.abspath, attach)
+    for f in AttachWork:
+        if os.path.exists(f):
+            attach.append(os.path.abspath(f))
 
     restore = os.getcwd()
     try:

=== modified file 'breezy/versionedfile.py'
--- breezy/versionedfile.py	2017-05-22 00:56:52 +0000
+++ breezy/versionedfile.py	2017-05-24 19:44:24 +0000
@@ -19,6 +19,8 @@
 from __future__ import absolute_import
 
 from copy import copy
+from future_builtins import zip
+import itertools
 import os
 import struct
 from zlib import adler32
@@ -535,10 +537,10 @@
                                   if not mpvf.has_version(p))
         present_parents = set(self.get_parent_map(needed_parents).keys())
         for parent_id, lines in zip(present_parents,
-                                 self._get_lf_split_line_list(present_parents)):
+                self._get_lf_split_line_list(present_parents)):
             mpvf.add_version(lines, parent_id, [])
-        for (version, parent_ids, expected_sha1, mpdiff), lines in\
-            zip(records, mpvf.get_line_list(versions)):
+        for (version, parent_ids, expected_sha1, mpdiff), lines in zip(
+                records, mpvf.get_line_list(versions)):
             if len(parent_ids) == 1:
                 left_matching_blocks = list(mpdiff.get_matching_blocks(0,
                     mpvf.get_diff(parent_ids[0]).num_lines()))
@@ -1027,8 +1029,8 @@
                 continue
             mpvf.add_version(chunks_to_lines(record.get_bytes_as('chunked')),
                 record.key, [])
-        for (key, parent_keys, expected_sha1, mpdiff), lines in\
-            zip(records, mpvf.get_line_list(versions)):
+        for (key, parent_keys, expected_sha1, mpdiff), lines in zip(
+                records, mpvf.get_line_list(versions)):
             if len(parent_keys) == 1:
                 left_matching_blocks = list(mpdiff.get_matching_blocks(0,
                     mpvf.get_diff(parent_keys[0]).num_lines()))
@@ -1092,9 +1094,9 @@
         while pending:
             this_parent_map = self.get_parent_map(pending)
             parent_map.update(this_parent_map)
-            pending = set()
-            map(pending.update, this_parent_map.itervalues())
-            pending = pending.difference(parent_map)
+            pending = set(itertools.chain.from_iterable(
+                this_parent_map.itervalues()))
+            pending.difference_update(parent_map)
         kg = _mod_graph.KnownGraph(parent_map)
         return kg
 
@@ -1318,7 +1320,7 @@
             prefix_keys.append(key[-1])
         return result
 
-    def _get_all_prefixes(self):
+    def _iter_all_prefixes(self):
         # Identify all key prefixes.
         # XXX: A bit hacky, needs polish.
         if isinstance(self._mapper, ConstantMapper):
@@ -1413,7 +1415,7 @@
                 yield line, prefix + (version,)
 
     def _iter_all_components(self):
-        for path, prefix in self._get_all_prefixes():
+        for path, prefix in self._iter_all_prefixes():
             yield prefix, self._get_vf(path)
 
     def keys(self):

=== modified file 'breezy/vf_repository.py'
--- breezy/vf_repository.py	2017-05-22 00:56:52 +0000
+++ breezy/vf_repository.py	2017-05-24 19:44:24 +0000
@@ -1516,8 +1516,8 @@
             revision_keys
         """
         parent_map = self.revisions.get_parent_map(revision_keys)
-        parent_keys = set()
-        map(parent_keys.update, parent_map.itervalues())
+        parent_keys = set(itertools.chain.from_iterable(
+            parent_map.itervalues()))
         parent_keys.difference_update(revision_keys)
         parent_keys.discard(_mod_revision.NULL_REVISION)
         return parent_keys

=== modified file 'breezy/weave.py'
--- breezy/weave.py	2017-05-22 00:56:52 +0000
+++ breezy/weave.py	2017-05-24 19:44:24 +0000
@@ -393,7 +393,7 @@
     def _add_lines(self, version_id, parents, lines, parent_texts,
        left_matching_blocks, nostore_sha, random_id, check_content):
         """See VersionedFile.add_lines."""
-        idx = self._add(version_id, lines, map(self._lookup, parents),
+        idx = self._add(version_id, lines, list(map(self._lookup, parents)),
             nostore_sha=nostore_sha)
         return sha_strings(lines), sum(map(len, lines)), idx
 

=== modified file 'breezy/weavefile.py'
--- breezy/weavefile.py	2017-05-22 00:56:52 +0000
+++ breezy/weavefile.py	2017-05-24 19:44:24 +0000
@@ -135,7 +135,7 @@
         l = lines.next()
         if l[0] == 'i':
             if len(l) > 2:
-                w._parents.append(map(int, l[2:].split(' ')))
+                w._parents.append(list(map(int, l[2:].split(' '))))
             else:
                 w._parents.append([])
             l = lines.next()[:-1]

=== modified file 'breezy/workingtree_4.py'
--- breezy/workingtree_4.py	2017-05-22 00:56:52 +0000
+++ breezy/workingtree_4.py	2017-05-24 19:44:24 +0000
@@ -1353,8 +1353,8 @@
                 _mod_revision.NULL_REVISION)
             trees = []
         else:
-            trees = zip(revision_ids,
-                        self.branch.repository.revision_trees(revision_ids))
+            trees = list(zip(revision_ids,
+                        self.branch.repository.revision_trees(revision_ids)))
             base_tree = trees[0][1]
         state = self.current_dirstate()
         # We don't support ghosts yet