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

[Martin Packman]

Apply 2to3 dict fixer and clean up with sixish view methods

One of the few remaining big-bang 2to3 changes, this branch runs the dict fixer.

The basic scheme is iter(items|values) gets the iter stripped, plus other futzing to try and keep semantics. The plain methods get wrapped in list() which is often not the right thing, but the fixer is being conservative due to changes during iteration.

Unfortunately, we have a bunch of types that have some dict-like methods but aren't dict:

* chk_map: CHKMap.iteritems LeafNode.iteritems
* lru_cache: LRUCache.keys
* registry: Registry methods keys iteritems items
* versionedfile: VersionedFiles.keys
* groupcompress: GroupCompressVersionedFiles.keys _GCGraphIndex.keys
* knit: _KndxIndex.keys _KnitGraphIndex.keys KnitVersionedFiles.keys

Which had lead to a bunch of bogus changes.

For general sanity, I switched uses of items/values over the the sixish view helpers which is the new Python 3 behaviour, and have non-horrible 2.7 performance.

There's a small amount of other drive-by stuff, but mostly this branch can just be verified by the tests passing.

[Jelmer Vernooij (jelmer)]

review: Approve

[The Breezy Bot (the-breezy-bot)]

Running landing tests failed
http://10.242.247.184:8080/job/brz-dev/66/

[The Breezy Bot (the-breezy-bot)]

Running landing tests failed
http://10.242.247.184:8080/job/brz-dev/67/

=== modified file 'breezy/_annotator_py.py'
--- breezy/_annotator_py.py	2017-06-04 18:09:30 +0000
+++ breezy/_annotator_py.py	2017-06-05 21:41:38 +0000
@@ -33,6 +33,7 @@
     )
 from .sixish import (
     range,
+    viewitems,
     )
 
 
@@ -92,7 +93,7 @@
                     vf_keys_needed.add(key)
             needed_keys = set()
             next_parent_map.update(self._vf.get_parent_map(parent_lookup))
-            for key, parent_keys in next_parent_map.iteritems():
+            for key, parent_keys in viewitems(next_parent_map):
                 if parent_keys is None: # No graph versionedfile
                     parent_keys = ()
                     next_parent_map[key] = ()
 
=== modified file 'breezy/_known_graph_py.py'
--- breezy/_known_graph_py.py	2017-05-22 00:56:52 +0000
+++ breezy/_known_graph_py.py	2017-06-05 21:41:38 +0000
@@ -24,6 +24,10 @@
     errors,
     revision,
     )
+from .sixish import (
+    viewitems,
+    viewvalues,
+    )
 
 
 class _KnownGraphNode(object):
@@ -81,7 +85,7 @@
           child_keys,
         """
         nodes = self._nodes
-        for key, parent_keys in parent_map.iteritems():
+        for key, parent_keys in viewitems(parent_map):
             if key in nodes:
                 node = nodes[key]
                 node.parent_keys = parent_keys
@@ -97,11 +101,11 @@
                 parent_node.child_keys.append(key)
 
     def _find_tails(self):
-        return [node for node in self._nodes.itervalues()
+        return [node for node in viewvalues(self._nodes)
                 if not node.parent_keys]
 
     def _find_tips(self):
-        return [node for node in self._nodes.itervalues()
+        return [node for node in viewvalues(self._nodes)
                       if not node.child_keys]
 
     def _find_gdfo(self):
@@ -234,7 +238,7 @@
         seen = set()
         pending = []
         min_gdfo = None
-        for node in candidate_nodes.values():
+        for node in viewvalues(candidate_nodes):
             if node.parent_keys:
                 pending.extend(node.parent_keys)
             if min_gdfo is None or node.gdfo < min_gdfo:
@@ -261,7 +265,7 @@
 
         All parents must occur before all children.
         """
-        for node in self._nodes.itervalues():
+        for node in viewvalues(self._nodes):
             if node.gdfo is None:
                 raise errors.GraphCycleError(self._nodes)
         pending = self._find_tails()
@@ -339,7 +343,7 @@
         """Compute the merge sorted graph output."""
         from breezy import tsort
         as_parent_map = dict((node.key, node.parent_keys)
-                             for node in self._nodes.itervalues()
+                             for node in viewvalues(self._nodes)
                               if node.parent_keys is not None)
         # We intentionally always generate revnos and never force the
         # mainline_revisions
 
=== modified file 'breezy/branch.py'
--- breezy/branch.py	2017-05-30 19:32:13 +0000
+++ breezy/branch.py	2017-06-05 21:41:38 +0000
@@ -66,6 +66,7 @@
 from .lock import _RelockDebugMixin, LogicalLockResult
 from .sixish import (
     BytesIO,
+    viewitems,
     )
 from .trace import mutter, mutter_callsite, note, is_quiet
 
@@ -397,7 +398,7 @@
             return self.get_rev_id(revno[0])
         revision_id_to_revno = self.get_revision_id_to_revno_map()
         revision_ids = [revision_id for revision_id, this_revno
-                        in revision_id_to_revno.iteritems()
+                        in viewitems(revision_id_to_revno)
                         if revno == this_revno]
         if len(revision_ids) == 1:
             return revision_ids[0]
@@ -1330,8 +1331,7 @@
         old_base = self.base
         new_base = target.base
         target_reference_dict = target._get_all_reference_info()
-        for file_id, (tree_path, branch_location) in (
-            reference_dict.items()):
+        for file_id, (tree_path, branch_location) in viewitems(reference_dict):
             branch_location = urlutils.rebase_url(branch_location,
                                                   old_base, new_base)
             target_reference_dict.setdefault(
@@ -2735,7 +2735,7 @@
         """
         s = BytesIO()
         writer = rio.RioWriter(s)
-        for key, (tree_path, branch_location) in info_dict.iteritems():
+        for key, (tree_path, branch_location) in viewitems(info_dict):
             stanza = rio.Stanza(file_id=key, tree_path=tree_path,
                                 branch_location=branch_location)
             writer.write_stanza(stanza)
 
=== modified file 'breezy/branchbuilder.py'
--- breezy/branchbuilder.py	2017-05-22 00:56:52 +0000
+++ breezy/branchbuilder.py	2017-06-05 21:41:38 +0000
@@ -25,6 +25,9 @@
     memorytree,
     revision,
     )
+from .sixish import (
+    viewitems,
+    )
 
 
 class BranchBuilder(object):
@@ -277,7 +280,7 @@
         if pending.to_unversion_ids:
             tree.unversion(pending.to_unversion_ids)
         tree.add(pending.to_add_files, pending.to_add_file_ids, pending.to_add_kinds)
-        for file_id, content in pending.new_contents.iteritems():
+        for file_id, content in viewitems(pending.new_contents):
             tree.put_file_bytes_non_atomic(file_id, content)
 
     def get_branch(self):
 
=== modified file 'breezy/btree_index.py'
--- breezy/btree_index.py	2017-06-05 01:46:14 +0000
+++ breezy/btree_index.py	2017-06-05 21:41:38 +0000
@@ -44,6 +44,9 @@
     BytesIO,
     map,
     range,
+    viewitems,
+    viewkeys,
+    viewvalues,
     )
 
 
@@ -557,13 +560,13 @@
         if self._nodes_by_key is None:
             nodes_by_key = {}
             if self.reference_lists:
-                for key, (references, value) in self._nodes.iteritems():
+                for key, (references, value) in viewitems(self._nodes):
                     key_dict = nodes_by_key
                     for subkey in key[:-1]:
                         key_dict = key_dict.setdefault(subkey, {})
                     key_dict[key[-1]] = key, value, references
             else:
-                for key, (references, value) in self._nodes.iteritems():
+                for key, (references, value) in viewitems(self._nodes):
                     key_dict = nodes_by_key
                     for subkey in key[:-1]:
                         key_dict = key_dict.setdefault(subkey, {})
@@ -905,7 +908,8 @@
 
     def _get_offsets_to_cached_pages(self):
         """Determine what nodes we already have cached."""
-        cached_offsets = set(self._internal_node_cache.keys())
+        cached_offsets = set(self._internal_node_cache)
+        # cache may be dict or LRUCache, keys() is the common method
         cached_offsets.update(self._leaf_node_cache.keys())
         if self._root_node is not None:
             cached_offsets.add(0)
@@ -944,7 +948,7 @@
     def _cache_leaf_values(self, nodes):
         """Cache directly from key => value, skipping the btree."""
         if self._leaf_value_cache is not None:
-            for node in nodes.itervalues():
+            for node in viewvalues(nodes):
                 for key, value in node.all_items():
                     if key in self._leaf_value_cache:
                         # Don't add the rest of the keys, we've seen this node
 
=== modified file 'breezy/builtins.py'
--- breezy/builtins.py	2017-06-04 21:47:02 +0000
+++ breezy/builtins.py	2017-06-05 21:41:38 +0000
@@ -81,6 +81,8 @@
 from .sixish import (
     BytesIO,
     text_type,
+    viewitems,
+    viewvalues,
 )
 from .trace import mutter, note, warning, is_quiet, get_verbosity_level
 
@@ -201,7 +203,7 @@
         reference = control_dir.get_branch_reference()
     except errors.NotBranchError:
         # There is no active branch, just return the colocated branches.
-        for name, branch in control_dir.get_branches().iteritems():
+        for name, branch in viewitems(control_dir.get_branches()):
             yield name, branch
         return
     if reference is not None:
@@ -212,7 +214,7 @@
     if ref_branch is None or ref_branch.name:
         if ref_branch is not None:
             control_dir = ref_branch.bzrdir
-        for name, branch in control_dir.get_branches().iteritems():
+        for name, branch in viewitems(control_dir.get_branches()):
             yield name, branch
     else:
         repo = ref_branch.bzrdir.find_repository()
@@ -845,7 +847,7 @@
         self.cleanup_now()
         if len(ignored) > 0:
             if verbose:
-                for glob in sorted(ignored.keys()):
+                for glob in sorted(ignored):
                     for path in ignored[glob]:
                         self.outf.write(
                          gettext("ignored {0} matching \"{1}\"\n").format(
@@ -1583,9 +1585,9 @@
                 names[name] = active
             # Only mention the current branch explicitly if it's not
             # one of the colocated branches
-            if not any(names.values()) and active_branch is not None:
+            if not any(viewvalues(names)) and active_branch is not None:
                 self.outf.write("* %s\n" % gettext("(default)"))
-            for name in sorted(names.keys()):
+            for name in sorted(names):
                 active = names[name]
                 if active:
                     prefix = "*"
@@ -3963,7 +3965,7 @@
     def print_aliases(self):
         """Print out the defined aliases in a similar format to bash."""
         aliases = _mod_config.GlobalConfig().get_aliases()
-        for key, value in sorted(aliases.iteritems()):
+        for key, value in sorted(viewitems(aliases)):
             self.outf.write('brz alias %s="%s"\n' % (key, value))
 
     @display_command
@@ -6004,7 +6006,7 @@
         from .tag import tag_sort_methods
         branch, relpath = Branch.open_containing(directory)
 
-        tags = branch.tags.get_tag_dict().items()
+        tags = list(viewitems(branch.tags.get_tag_dict()))
         if not tags:
             return
 
@@ -6648,7 +6650,7 @@
         if tree is None:
             tree = branch.basis_tree()
         if path is None:
-            info = branch._get_all_reference_info().iteritems()
+            info = viewitems(branch._get_all_reference_info())
             self._display_reference_info(tree, branch, info)
         else:
             file_id = tree.path2id(path)
 
=== modified file 'breezy/bundle/bundle_data.py'
--- breezy/bundle/bundle_data.py	2017-05-30 19:32:13 +0000
+++ breezy/bundle/bundle_data.py	2017-06-05 21:41:38 +0000
@@ -42,6 +42,7 @@
 from ..revision import Revision, NULL_REVISION
 from ..sixish import (
     BytesIO,
+    viewitems,
     )
 from ..testament import StrictTestament
 from ..trace import mutter, warning
@@ -106,7 +107,7 @@
         revision_info.timestamp = revision.timestamp
         revision_info.message = revision.message.split('\n')
         revision_info.properties = [': '.join(p) for p in
-                                    revision.properties.iteritems()]
+                                    viewitems(revision.properties)]
         return revision_info
 
 
@@ -252,7 +253,7 @@
 
         count = 0
         missing = {}
-        for revision_id, sha1 in rev_to_sha.iteritems():
+        for revision_id, sha1 in viewitems(rev_to_sha):
             if repository.has_revision(revision_id):
                 testament = StrictTestament.from_revision(repository,
                                                           revision_id)
@@ -772,7 +773,7 @@
 
     def sorted_path_id(self):
         paths = []
-        for result in self._new_id.iteritems():
+        for result in viewitems(self._new_id):
             paths.append(result)
         for id in self.base_tree.all_file_ids():
             path = self.id2path(id)
 
=== modified file 'breezy/bundle/commands.py'
--- breezy/bundle/commands.py	2017-05-22 00:56:52 +0000
+++ breezy/bundle/commands.py	2017-06-05 21:41:38 +0000
@@ -39,6 +39,7 @@
 from ..commands import Command
 from ..sixish import (
     BytesIO,
+    viewitems,
     )
 
 
@@ -76,7 +77,7 @@
             if file_id is not None:
                 file_ids.add(file_id)
         self.outf.write(gettext('Records\n'))
-        for kind, records in sorted(by_kind.iteritems()):
+        for kind, records in sorted(viewitems(by_kind)):
             multiparent = sum(1 for b, m, k, r, f in records if
                               len(m.get('parents', [])) > 1)
             self.outf.write(gettext('{0}: {1} ({2} multiparent)\n').format(
 
=== modified file 'breezy/bundle/serializer/v4.py'
--- breezy/bundle/serializer/v4.py	2017-05-25 01:35:55 +0000
+++ breezy/bundle/serializer/v4.py	2017-06-05 21:41:38 +0000
@@ -37,6 +37,7 @@
 from ...i18n import ngettext
 from ...sixish import (
     BytesIO,
+    viewitems,
     )
 
 
@@ -352,7 +353,7 @@
         text_keys = []
         altered_fileids = self.repository.fileids_altered_by_revision_ids(
                 self.revision_ids)
-        for file_id, revision_ids in altered_fileids.iteritems():
+        for file_id, revision_ids in viewitems(altered_fileids):
             for revision_id in revision_ids:
                 text_keys.append((file_id, revision_id))
         self._add_mp_records_keys('file', self.repository.texts, text_keys)
 
=== modified file 'breezy/bzrdir.py'
--- breezy/bzrdir.py	2017-05-30 19:16:23 +0000
+++ breezy/bzrdir.py	2017-06-05 21:41:38 +0000
@@ -1140,7 +1140,7 @@
 
     def check_support_status(self, allow_unsupported, recommend_upgrade=True,
             basedir=None):
-        for name, necessity in self.features.iteritems():
+        for name, necessity in self.features.items():
             if name in self._present_features:
                 continue
             if necessity == "optional":
@@ -1179,7 +1179,7 @@
         """
         lines = [self.get_format_string()]
         lines.extend([("%s %s\n" % (item[1], item[0])) for item in
-            self.features.iteritems()])
+            self.features.items()])
         return "".join(lines)
 
     @classmethod
@@ -1210,7 +1210,7 @@
 
         :param updated_flags: Updated feature flags
         """
-        for name, necessity in updated_flags.iteritems():
+        for name, necessity in updated_flags.items():
             if necessity is None:
                 try:
                     del self.features[name]
@@ -1246,7 +1246,7 @@
     @classmethod
     def known_formats(cls):
         result = set()
-        for name, format in cls.formats.iteritems():
+        for name, format in cls.formats.items():
             if callable(format):
                 format = format()
             result.add(format)
 
=== modified file 'breezy/check.py'
--- breezy/check.py	2017-05-22 00:56:52 +0000
+++ breezy/check.py	2017-06-05 21:41:38 +0000
@@ -56,6 +56,9 @@
 from .branch import Branch
 from .controldir import ControlDir
 from .revision import NULL_REVISION
+from .sixish import (
+    viewitems,
+    )
 from .trace import note
 from .workingtree import WorkingTree
 from .i18n import gettext
@@ -128,7 +131,7 @@
                 # landing].
                 distances = set()
                 existences = set()
-                for ref, wantlist in callback_refs.iteritems():
+                for ref, wantlist in viewitems(callback_refs):
                     wanting_items.update(wantlist)
                     kind, value = ref
                     if kind == 'trees':
@@ -141,7 +144,7 @@
                         raise AssertionError(
                             'unknown ref kind for ref %s' % ref)
                 node_distances = repo.get_graph().find_lefthand_distances(distances)
-                for key, distance in node_distances.iteritems():
+                for key, distance in viewitems(node_distances):
                     refs[('lefthand-distance', key)] = distance
                     if key in existences and distance > 0:
                         refs[('revision-existence', key)] = True
@@ -229,7 +232,7 @@
             note(gettext('%6d revisions missing parents in ancestry'),
                  len(self.missing_parent_links))
             if verbose:
-                for link, linkers in self.missing_parent_links.items():
+                for link, linkers in viewitems(self.missing_parent_links):
                     note(gettext('      %s should be in the ancestry for:'), link)
                     for linker in linkers:
                         note('       * %s', linker)
@@ -320,12 +323,10 @@
                 text_key_references=self.text_key_references,
                 ancestors=self.ancestors)
         storebar.update('file-graph', 1)
-        result = weave_checker.check_file_version_parents(
+        wrongs, unused_versions = weave_checker.check_file_version_parents(
             self.repository.texts)
         self.checked_weaves = weave_checker.file_ids
-        bad_parents, unused_versions = result
-        bad_parents = bad_parents.items()
-        for text_key, (stored_parents, correct_parents) in bad_parents:
+        for text_key, (stored_parents, correct_parents) in viewitems(wrongs):
             # XXX not ready for id join/split operations.
             weave_id = text_key[0]
             revision_id = text_key[-1]
 
=== modified file 'breezy/chk_map.py'
--- breezy/chk_map.py	2017-06-04 18:09:30 +0000
+++ breezy/chk_map.py	2017-06-05 21:41:38 +0000
@@ -56,6 +56,10 @@
     static_tuple,
     trace,
     )
+from .sixish import (
+    viewitems,
+    viewvalues,
+    )
 from .static_tuple import StaticTuple
 
 # approx 4MB
@@ -212,11 +216,11 @@
         if isinstance(node, InternalNode):
             # Trigger all child nodes to get loaded
             list(node._iter_nodes(self._store))
-            for prefix, sub in sorted(node._items.iteritems()):
+            for prefix, sub in sorted(viewitems(node._items)):
                 result.extend(self._dump_tree_node(sub, prefix, indent + '  ',
                                                    include_keys=include_keys))
         else:
-            for key, value in sorted(node._items.iteritems()):
+            for key, value in sorted(viewitems(node._items)):
                 # Don't use prefix nor indent here to line up when used in
                 # tests in conjunction with assertEqualDiff
                 result.append('      %r %r' % (tuple(key), value))
@@ -255,7 +259,7 @@
         result._root_node.set_maximum_size(maximum_size)
         result._root_node._key_width = key_width
         delta = []
-        for key, value in initial_value.items():
+        for key, value in viewitems(initial_value):
             delta.append((None, key, value))
         root_key = result.apply_delta(delta)
         return root_key
@@ -267,10 +271,10 @@
         node.set_maximum_size(maximum_size)
         node._key_width = key_width
         as_st = StaticTuple.from_sequence
-        node._items = dict([(as_st(key), val) for key, val
-                                               in initial_value.iteritems()])
-        node._raw_size = sum([node._key_value_len(key, value)
-                              for key,value in node._items.iteritems()])
+        node._items = dict((as_st(key), val)
+            for key, val in viewitems(initial_value))
+        node._raw_size = sum(node._key_value_len(key, value)
+            for key, value in viewitems(node._items))
         node._len = len(node._items)
         node._compute_search_prefix()
         node._compute_serialised_prefix()
@@ -333,7 +337,7 @@
             node = a_map._get_node(node)
             if isinstance(node, LeafNode):
                 path = (node._key, path)
-                for key, value in node._items.items():
+                for key, value in viewitems(node._items):
                     # For a LeafNode, the key is a serialized_key, rather than
                     # a search_key, but the heap is using search_keys
                     search_key = node._search_key_func(key)
@@ -341,11 +345,11 @@
             else:
                 # type(node) == InternalNode
                 path = (node._key, path)
-                for prefix, child in node._items.items():
+                for prefix, child in viewitems(node._items):
                     heapq.heappush(pending, (prefix, None, child, path))
         def process_common_internal_nodes(self_node, basis_node):
-            self_items = set(self_node._items.items())
-            basis_items = set(basis_node._items.items())
+            self_items = set(viewitems(self_node._items))
+            basis_items = set(viewitems(basis_node._items))
             path = (self_node._key, None)
             for prefix, child in self_items - basis_items:
                 heapq.heappush(self_pending, (prefix, None, child, path))
@@ -353,8 +357,8 @@
             for prefix, child in basis_items - self_items:
                 heapq.heappush(basis_pending, (prefix, None, child, path))
         def process_common_leaf_nodes(self_node, basis_node):
-            self_items = set(self_node._items.items())
-            basis_items = set(basis_node._items.items())
+            self_items = set(viewitems(self_node._items))
+            basis_items = set(viewitems(basis_node._items))
             path = (self_node._key, None)
             for key, value in self_items - basis_items:
                 prefix = self._search_key_func(key)
@@ -766,17 +770,16 @@
                         pass
                 else:
                     # Short items, we need to match based on a prefix
-                    length_filter = filters.setdefault(len(key), set())
-                    length_filter.add(key)
+                    filters.setdefault(len(key), set()).add(key)
             if filters:
-                filters = filters.items()
-                for item in self._items.iteritems():
-                    for length, length_filter in filters:
+                filters_itemview = viewitems(filters)
+                for item in viewitems(self._items):
+                    for length, length_filter in filters_itemview:
                         if item[0][:length] in length_filter:
                             yield item
                             break
         else:
-            for item in self._items.iteritems():
+            for item in viewitems(self._items):
                 yield item
 
     def _key_value_len(self, key, value):
@@ -838,7 +841,7 @@
         common_prefix = self._search_prefix
         split_at = len(common_prefix) + 1
         result = {}
-        for key, value in self._items.iteritems():
+        for key, value in viewitems(self._items):
             search_key = self._search_key(key)
             prefix = search_key[:split_at]
             # TODO: Generally only 1 key can be exactly the right length,
@@ -871,7 +874,7 @@
                 for split, node in node_details:
                     new_node.add_node(split, node)
                 result[prefix] = new_node
-        return common_prefix, result.items()
+        return common_prefix, list(viewitems(result))
 
     def map(self, store, key, value):
         """Map key to value."""
@@ -906,7 +909,7 @@
         else:
             lines.append('%s\n' % (self._common_serialised_prefix,))
             prefix_len = len(self._common_serialised_prefix)
-        for key, value in sorted(self._items.items()):
+        for key, value in sorted(viewitems(self._items)):
             # Always add a final newline
             value_lines = osutils.chunks_to_lines([value + '\n'])
             serialized = "%s\x00%s\n" % (self._serialise_key(key),
@@ -1071,7 +1074,7 @@
             # yielding all nodes, yield whatever we have, and queue up a read
             # for whatever we are missing
             shortcut = True
-            for prefix, node in self._items.iteritems():
+            for prefix, node in viewitems(self._items):
                 if node.__class__ is StaticTuple:
                     keys[node] = (prefix, None)
                 else:
@@ -1147,10 +1150,10 @@
             else:
                 # The slow way. We walk every item in self._items, and check to
                 # see if there are any matches
-                length_filters = length_filters.items()
-                for prefix, node in self._items.iteritems():
+                length_filters_itemview = viewitems(length_filters)
+                for prefix, node in viewitems(self._items):
                     node_key_filter = []
-                    for length, length_filter in length_filters:
+                    for length, length_filter in length_filters_itemview:
                         sub_prefix = prefix[:length]
                         if sub_prefix in length_filter:
                             node_key_filter.extend(prefix_to_keys[sub_prefix])
@@ -1292,7 +1295,7 @@
         :param store: A VersionedFiles honouring the CHK extensions.
         :return: An iterable of the keys inserted by this operation.
         """
-        for node in self._items.itervalues():
+        for node in viewvalues(self._items):
             if isinstance(node, StaticTuple):
                 # Never deserialised.
                 continue
@@ -1309,7 +1312,7 @@
             raise AssertionError("_search_prefix should not be None")
         lines.append('%s\n' % (self._search_prefix,))
         prefix_len = len(self._search_prefix)
-        for prefix, node in sorted(self._items.items()):
+        for prefix, node in sorted(viewitems(self._items)):
             if isinstance(node, StaticTuple):
                 key = node[0]
             else:
@@ -1342,19 +1345,16 @@
             prefix for reaching node.
         """
         if offset >= self._node_width:
-            for node in self._items.values():
+            for node in valueview(self._items):
                 for result in node._split(offset):
                     yield result
-            return
-        for key, node in self._items.items():
-            pass
 
     def refs(self):
         """Return the references to other CHK's held by this node."""
         if self._key is None:
             raise AssertionError("unserialised nodes have no refs.")
         refs = []
-        for value in self._items.itervalues():
+        for value in viewvalues(self._items):
             if isinstance(value, StaticTuple):
                 refs.append(value)
             else:
@@ -1393,7 +1393,7 @@
             self._items[search_key] = unmapped
         if len(self._items) == 1:
             # this node is no longer needed:
-            return self._items.values()[0]
+            return list(viewvalues(self._items))[0]
         if isinstance(unmapped, InternalNode):
             return self
         if check_remap:
@@ -1443,7 +1443,7 @@
             if isinstance(node, InternalNode):
                 # Without looking at any leaf nodes, we are sure
                 return self
-            for key, value in node._items.iteritems():
+            for key, value in viewitems(node._items):
                 if new_leaf._map_no_split(key, value):
                     return self
         trace.mutter("remap generated a new LeafNode")
@@ -1532,15 +1532,14 @@
                 #       indicate that we keep 100k prefix_refs around while
                 #       processing. They *should* be shorter lived than that...
                 #       It does cost us ~10s of processing time
-                #prefix_refs = [as_st(item) for item in node._items.iteritems()]
-                prefix_refs = node._items.items()
+                prefix_refs = list(viewitems(node._items))
                 items = []
             else:
                 prefix_refs = []
                 # Note: We don't use a StaticTuple here. Profiling showed a
                 #       minor memory improvement (0.8MB out of 335MB peak 0.2%)
                 #       But a significant slowdown (15s / 145s, or 10%)
-                items = node._items.items()
+                items = list(viewitems(node._items))
             yield record, node, prefix_refs, items
 
     def _read_old_roots(self):
 
=== modified file 'breezy/chk_serializer.py'
--- breezy/chk_serializer.py	2017-05-22 00:56:52 +0000
+++ breezy/chk_serializer.py	2017-06-05 21:41:38 +0000
@@ -41,7 +41,7 @@
 def _validate_properties(props, _decode=cache_utf8._utf8_decode):
     # TODO: we really want an 'isascii' check for key
     # Cast the utf8 properties into Unicode 'in place'
-    for key, value in props.iteritems():
+    for key, value in props.items():
         props[key] = _decode(value)[0]
     return props
 
@@ -90,7 +90,7 @@
         # For bzr revisions, the most common property is just 'branch-nick'
         # which changes infrequently.
         revprops = {}
-        for key, value in rev.properties.iteritems():
+        for key, value in rev.properties.items():
             revprops[key] = encode_utf8(value)[0]
         ret.append(('properties', revprops))
         ret.extend([
@@ -131,7 +131,7 @@
                 value = validator(value)
             bits[var_name] = value
         if len(bits) != len(schema):
-            missing = [key for key, (var_name, _, _) in schema.iteritems()
+            missing = [key for key, (var_name, _, _) in schema.items()
                        if var_name not in bits]
             raise ValueError('Revision text was missing expected keys %s.'
                              ' text %r' % (missing, text))
 
=== modified file 'breezy/commands.py'
--- breezy/commands.py	2017-06-02 23:50:41 +0000
+++ breezy/commands.py	2017-06-05 21:41:38 +0000
@@ -169,18 +169,16 @@
         # only load once
         return
     import breezy.builtins
-    for cmd_class in _scan_module_for_commands(breezy.builtins).values():
+    for cmd_class in _scan_module_for_commands(breezy.builtins):
         builtin_command_registry.register(cmd_class)
     breezy.builtins._register_lazy_builtins()
 
 
 def _scan_module_for_commands(module):
-    r = {}
-    for name, obj in module.__dict__.items():
+    module_dict = module.__dict__
+    for name in module_dict:
         if name.startswith("cmd_"):
-            real_name = _unsquish_command_name(name)
-            r[real_name] = obj
-    return r
+            yield module_dict[name]
 
 
 def _list_bzr_commands(names):
@@ -628,7 +626,7 @@
 
         Maps from long option name to option object."""
         r = Option.STD_OPTIONS.copy()
-        std_names = r.keys()
+        std_names = set(r)
         for o in self.takes_options:
             if isinstance(o, string_types):
                 o = option.Option.OPTIONS[o]
@@ -824,8 +822,8 @@
         raise errors.BzrCommandError(
             gettext('Only ASCII permitted in option names'))
 
-    opts = dict([(k, v) for k, v in options.__dict__.items() if
-                 v is not option.OptionParser.DEFAULT_VALUE])
+    opts = dict((k, v) for k, v in options.__dict__.items() if
+                v is not option.OptionParser.DEFAULT_VALUE)
     return args, opts
 
 
 
=== modified file 'breezy/config.py'
--- breezy/config.py	2017-05-30 19:32:13 +0000
+++ breezy/config.py	2017-06-05 21:41:38 +0000
@@ -1722,7 +1722,7 @@
              certificate should be verified, False otherwise.
         """
         credentials = None
-        for auth_def_name, auth_def in self._get_config().items():
+        for auth_def_name, auth_def in self._get_config().iteritems():
             if not isinstance(auth_def, configobj.Section):
                 raise ValueError("%s defined outside a section" % auth_def_name)
 
@@ -1824,7 +1824,7 @@
             values['realm'] = realm
         config = self._get_config()
         for_deletion = []
-        for section, existing_values in config.items():
+        for section, existing_values in config.iteritems():
             for key in ('scheme', 'host', 'port', 'path', 'realm'):
                 if existing_values.get(key) != values.get(key):
                     break
@@ -2854,7 +2854,7 @@
         return self.options.get(name, default)
 
     def iter_option_names(self):
-        for k in self.options.iterkeys():
+        for k in self.options.keys():
             yield k
 
     def __repr__(self):
@@ -2901,7 +2901,7 @@
 
         :param store: the store containing the section
         """
-        for k, expected in dirty.orig.iteritems():
+        for k, expected in dirty.orig.items():
             actual = dirty.get(k, _DeletedOption)
             reloaded = self.get(k, _NewlyCreatedOption)
             if actual is _DeletedOption:
@@ -3009,7 +3009,7 @@
         # get_mutable_section() call below.
         self.unload()
         # Apply the changes from the preserved dirty sections
-        for section_id, dirty in dirty_sections.iteritems():
+        for section_id, dirty in dirty_sections.items():
             clean = self.get_mutable_section(section_id)
             clean.apply_changes(dirty, self)
         # Everything is clean now
@@ -3153,7 +3153,7 @@
         if not self._need_saving():
             return
         # Preserve the current version
-        dirty_sections = dict(self.dirty_sections.items())
+        dirty_sections = self.dirty_sections.copy()
         self.apply_changes(dirty_sections)
         # Save to the persistent storage
         self.save()
@@ -3780,7 +3780,7 @@
             global _shared_stores_at_exit_installed
             stores = _shared_stores
             def save_config_changes():
-                for k, store in stores.items():
+                for k, store in stores.iteritems():
                     store.save_changes()
             if not _shared_stores_at_exit_installed:
                 # FIXME: Ugly hack waiting for library_state to always be
 
=== modified file 'breezy/controldir.py'
--- breezy/controldir.py	2017-05-22 00:56:52 +0000
+++ breezy/controldir.py	2017-06-05 21:41:38 +0000
@@ -108,7 +108,7 @@
         """Return a sequence of all branches local to this control directory.
 
         """
-        return self.get_branches().values()
+        return list(self.get_branches().values())
 
     def get_branches(self):
         """Get all branches in this control directory, as a dictionary.
 
=== modified file 'breezy/dirstate.py'
--- breezy/dirstate.py	2017-06-04 18:09:30 +0000
+++ breezy/dirstate.py	2017-06-05 21:41:38 +0000
@@ -244,6 +244,8 @@
     )
 from .sixish import (
     range,
+    viewitems,
+    viewvalues,
     )
 
 
@@ -975,7 +977,7 @@
             # Directories that need to be read
             pending_dirs = set()
             paths_to_search = set()
-            for entry_list in newly_found.itervalues():
+            for entry_list in viewvalues(newly_found):
                 for dir_name_id, trees_info in entry_list:
                     found[dir_name_id] = trees_info
                     found_dir_names.add(dir_name_id[:2])
@@ -1386,8 +1388,8 @@
                                                fingerprint, new_child_path)
         self._check_delta_ids_absent(new_ids, delta, 0)
         try:
-            self._apply_removals(removals.iteritems())
-            self._apply_insertions(insertions.values())
+            self._apply_removals(viewitems(removals))
+            self._apply_insertions(viewvalues(insertions))
             # Validate parents
             self._after_delta_check_parents(parents, 0)
         except errors.BzrError as e:
@@ -2723,7 +2725,7 @@
         # --- end generation of full tree mappings
 
         # sort and output all the entries
-        new_entries = self._sort_entries(by_path.items())
+        new_entries = self._sort_entries(viewitems(by_path))
         self._entries_to_current_state(new_entries)
         self._parents = [rev_id for rev_id, tree in trees]
         self._ghosts = list(ghosts)
@@ -3288,7 +3290,7 @@
                 raise AssertionError(
                     "entry %r has no data for any tree." % (entry,))
         if self._id_index is not None:
-            for file_id, entry_keys in self._id_index.iteritems():
+            for file_id, entry_keys in viewitems(self._id_index):
                 for entry_key in entry_keys:
                     # Check that the entry in the map is pointing to the same
                     # file_id
 
=== modified file 'breezy/export_pot.py'
--- breezy/export_pot.py	2017-06-05 01:21:55 +0000
+++ breezy/export_pot.py	2017-06-05 21:41:38 +0000
@@ -202,7 +202,7 @@
 def _standard_options(exporter):
     OPTIONS = option.Option.OPTIONS
     context = exporter.get_context(option)
-    for name in sorted(OPTIONS.keys()):
+    for name in sorted(OPTIONS):
         opt = OPTIONS[name]
         _write_option(exporter, context.from_string(name), opt, "option")
 
 
=== modified file 'breezy/fetch.py'
--- breezy/fetch.py	2017-05-22 00:56:52 +0000
+++ breezy/fetch.py	2017-06-05 21:41:38 +0000
@@ -40,6 +40,9 @@
     )
 from .i18n import gettext
 from .revision import NULL_REVISION
+from .sixish import (
+    viewvalues,
+    )
 from .trace import mutter
 
 
@@ -215,12 +218,11 @@
             revision_id = tree.get_file_revision(root_id, u"")
             revision_root[revision_id] = root_id
         # Find out which parents we don't already know root ids for
-        parents = set()
-        for revision_parents in parent_map.itervalues():
-            parents.update(revision_parents)
-        parents.difference_update(revision_root.keys() + [NULL_REVISION])
+        parents = set(viewvalues(parent_map))
+        parents.difference_update(revision_root)
+        parents.discard(NULL_REVISION)
         # Limit to revisions present in the versionedfile
-        parents = graph.get_parent_map(parents).keys()
+        parents = graph.get_parent_map(parents)
         for tree in self.iter_rev_trees(parents):
             root_id = tree.get_root_id()
             revision_root[tree.get_revision_id()] = root_id
 
=== modified file 'breezy/fifo_cache.py'
--- breezy/fifo_cache.py	2011-12-19 13:23:58 +0000
+++ breezy/fifo_cache.py	2017-06-05 21:41:38 +0000
@@ -158,8 +158,8 @@
         if len(args) == 1:
             arg = args[0]
             if isinstance(arg, dict):
-                for key, val in arg.iteritems():
-                    self.add(key, val)
+                for key in arg:
+                    self.add(key, arg[key])
             else:
                 for key, val in args[0]:
                     self.add(key, val)
@@ -167,8 +167,8 @@
             raise TypeError('update expected at most 1 argument, got %d'
                             % len(args))
         if kwargs:
-            for key, val in kwargs.iteritems():
-                self.add(key, val)
+            for key in kwargs:
+                self.add(key, kwargs[key])
 
 
 class FIFOSizeCache(FIFOCache):
 
=== modified file 'breezy/gpg.py'
--- breezy/gpg.py	2017-05-30 19:16:23 +0000
+++ breezy/gpg.py	2017-06-05 21:41:38 +0000
@@ -449,7 +449,7 @@
             signers.setdefault(fingerprint, 0)
             signers[fingerprint] += 1
     result = []
-    for fingerprint, number in signers.items():
+    for fingerprint, number in list(signers.items()):
         result.append(ngettext(u"Unknown key {0} signed {1} commit",
                                u"Unknown key {0} signed {1} commits",
                                number).format(fingerprint, number))
 
=== modified file 'breezy/graph.py'
--- breezy/graph.py	2017-05-25 01:35:55 +0000
+++ breezy/graph.py	2017-06-05 21:41:38 +0000
@@ -25,6 +25,10 @@
     revision,
     trace,
     )
+from .sixish import (
+    viewitems,
+    viewvalues,
+    )
 
 STEP_UNIQUE_SEARCHER_EVERY = 5
 
@@ -335,7 +339,7 @@
         """
         parent_map = self._parents_provider.get_parent_map(keys)
         parent_child = {}
-        for child, parents in sorted(parent_map.items()):
+        for child, parents in sorted(viewitems(parent_map)):
             for parent in parents:
                 parent_child.setdefault(parent, []).append(child)
         return parent_child
@@ -358,7 +362,7 @@
         NULL_REVISION = revision.NULL_REVISION
         known_revnos[NULL_REVISION] = 0
 
-        searching_known_tips = list(known_revnos.keys())
+        searching_known_tips = list(known_revnos)
 
         unknown_searched = {}
 
@@ -645,7 +649,7 @@
         # TODO: it might be possible to collapse searchers faster when they
         #       only have *some* search tips in common.
         next_unique_searchers = []
-        for searchers in unique_search_tips.itervalues():
+        for searchers in viewvalues(unique_search_tips):
             if len(searchers) == 1:
                 # Searching unique tips, go for it
                 next_unique_searchers.append(searchers[0])
@@ -835,7 +839,7 @@
                           for c in candidate_heads)
         active_searchers = dict(searchers)
         # skip over the actual candidate for each searcher
-        for searcher in active_searchers.itervalues():
+        for searcher in viewvalues(active_searchers):
             next(searcher)
         # The common walker finds nodes that are common to two or more of the
         # input keys, so that we don't access all history when a currently
@@ -852,7 +856,7 @@
             except StopIteration:
                 # No common points being searched at this time.
                 pass
-            for candidate in active_searchers.keys():
+            for candidate in list(active_searchers):
                 try:
                     searcher = active_searchers[candidate]
                 except KeyError:
@@ -878,11 +882,11 @@
                     # some searcher has encountered our known common nodes:
                     # just stop it
                     ancestor_set = {ancestor}
-                    for searcher in searchers.itervalues():
+                    for searcher in viewvalues(searchers):
                         searcher.stop_searching_any(ancestor_set)
                 else:
                     # or it may have been just reached by all the searchers:
-                    for searcher in searchers.itervalues():
+                    for searcher in viewvalues(searchers):
                         if ancestor not in searcher.seen:
                             break
                     else:
@@ -890,7 +894,7 @@
                         # making it be known as a descendant of all candidates,
                         # so we can stop searching it, and any seen ancestors
                         new_common.add(ancestor)
-                        for searcher in searchers.itervalues():
+                        for searcher in viewvalues(searchers):
                             seen_ancestors =\
                                 searcher.find_seen_ancestors([ancestor])
                             searcher.stop_searching_any(seen_ancestors)
@@ -1013,7 +1017,7 @@
             processed.update(pending)
             next_map = self.get_parent_map(pending)
             next_pending = set()
-            for item in next_map.iteritems():
+            for item in viewitems(next_map):
                 yield item
                 next_pending.update(p for p in item[1] if p not in processed)
             ghosts = pending.difference(next_map)
@@ -1249,7 +1253,7 @@
         ## for revision in revisions.intersection(descendants):
         ##   simple_ancestors.difference_update(descendants[revision])
         ## return simple_ancestors
-        for revision, parent_ids in parent_map.iteritems():
+        for revision, parent_ids in viewitems(parent_map):
             if parent_ids is None:
                 continue
             for parent_id in parent_ids:
@@ -1468,7 +1472,7 @@
         seen.update(revisions)
         parent_map = self._parents_provider.get_parent_map(revisions)
         found_revisions.update(parent_map)
-        for rev_id, parents in parent_map.iteritems():
+        for rev_id, parents in viewitems(parent_map):
             if parents is None:
                 continue
             new_found_parents = [p for p in parents if p not in seen]
@@ -1511,7 +1515,7 @@
             all_parents = []
             # We don't care if it is a ghost, since it can't be seen if it is
             # a ghost
-            for parent_ids in parent_map.itervalues():
+            for parent_ids in viewvalues(parent_map):
                 all_parents.extend(parent_ids)
             next_pending = all_seen.intersection(all_parents).difference(seen_ancestors)
             seen_ancestors.update(next_pending)
@@ -1556,14 +1560,14 @@
                     stop_rev_references[parent_id] += 1
             # if only the stopped revisions reference it, the ref count will be
             # 0 after this loop
-            for parents in self._current_parents.itervalues():
+            for parents in viewvalues(self._current_parents):
                 for parent_id in parents:
                     try:
                         stop_rev_references[parent_id] -= 1
                     except KeyError:
                         pass
             stop_parents = set()
-            for rev_id, refs in stop_rev_references.iteritems():
+            for rev_id, refs in viewitems(stop_rev_references):
                 if refs == 0:
                     stop_parents.add(rev_id)
             self._next_query.difference_update(stop_parents)
@@ -1599,7 +1603,7 @@
 def invert_parent_map(parent_map):
     """Given a map from child => parents, create a map of parent=>children"""
     child_map = {}
-    for child, parents in parent_map.iteritems():
+    for child, parents in viewitems(parent_map):
         for p in parents:
             # Any given parent is likely to have only a small handful
             # of children, many will have only one. So we avoid mem overhead of
@@ -1651,7 +1655,7 @@
     # Will not have any nodes removed, even though you do have an
     # 'uninteresting' linear D->B and E->C
     children = {}
-    for child, parents in parent_map.iteritems():
+    for child, parents in viewitems(parent_map):
         children.setdefault(child, [])
         for p in parents:
             children.setdefault(p, []).append(child)
 
=== modified file 'breezy/groupcompress.py'
--- breezy/groupcompress.py	2017-06-04 18:09:30 +0000
+++ breezy/groupcompress.py	2017-06-05 21:41:38 +0000
@@ -45,6 +45,7 @@
 from .sixish import (
     map,
     range,
+    viewitems,
     )
 from .versionedfile import (
     _KeyRefs,
@@ -73,7 +74,7 @@
     # groupcompress ordering is approximately reverse topological,
     # properly grouped by file-id.
     per_prefix_map = {}
-    for key, value in parent_map.iteritems():
+    for key, value in viewitems(parent_map):
         if isinstance(key, str) or len(key) == 1:
             prefix = ''
         else:
@@ -1541,10 +1542,10 @@
             # This is the group the bytes are stored in, followed by the
             # location in the group
             return locations[key][0]
-        present_keys = sorted(locations.iterkeys(), key=get_group)
         # We don't have an ordering for keys in the in-memory object, but
         # lets process the in-memory ones first.
-        present_keys = list(unadded_keys) + present_keys
+        present_keys = list(unadded_keys)
+        present_keys.extend(sorted(locations, key=get_group))
         # Now grab all of the ones from other sources
         source_keys = [(self, present_keys)]
         source_keys.extend(source_result)
@@ -1574,7 +1575,7 @@
             # start with one key, recurse to its oldest parent, then grab
             # everything in the same group, etc.
             parent_map = dict((key, details[2]) for key, details in
-                locations.iteritems())
+                viewitems(locations))
             for key in unadded_keys:
                 parent_map[key] = self._unadded_refs[key]
             parent_map.update(fallback_parent_map)
@@ -2032,10 +2033,10 @@
         if changed:
             result = []
             if self._parents:
-                for key, (value, node_refs) in keys.iteritems():
+                for key, (value, node_refs) in viewitems(keys):
                     result.append((key, value, node_refs))
             else:
-                for key, (value, node_refs) in keys.iteritems():
+                for key, (value, node_refs) in viewitems(keys):
                     result.append((key, value))
             records = result
         key_dependencies = self._key_dependencies
 
=== modified file 'breezy/hashcache.py'
--- breezy/hashcache.py	2017-05-22 00:56:52 +0000
+++ breezy/hashcache.py	2017-06-05 21:41:38 +0000
@@ -44,6 +44,7 @@
     )
 from .sixish import (
     text_type,
+    viewitems,
     )
 
 
@@ -132,14 +133,12 @@
         # Stat in inode order as optimisation for at least linux.
         def inode_order(path_and_cache):
             return path_and_cache[1][1][3]
-        for inum, path, cache_entry in sorted(self._cache, key=inode_order):
+        for path, cache_val in sorted(viewitems(self._cache), key=inode_order):
             abspath = osutils.pathjoin(self.root, path)
             fp = self._fingerprint(abspath)
             self.stat_count += 1
 
-            cache_fp = cache_entry[1]
-
-            if (not fp) or (cache_fp != fp):
+            if not fp or cache_val[1] != fp:
                 # not here or not a regular file anymore
                 self.removed_count += 1
                 self.needs_write = True
@@ -229,7 +228,7 @@
         try:
             outf.write(CACHE_HEADER)
 
-            for path, c  in self._cache.iteritems():
+            for path, c  in viewitems(self._cache):
                 line_info = [path.encode('utf-8'), '// ', c[0], ' ']
                 line_info.append(' '.join([str(fld) for fld in c[1]]))
                 line_info.append('\n')
 
=== modified file 'breezy/help.py'
--- breezy/help.py	2017-05-22 00:56:52 +0000
+++ breezy/help.py	2017-06-05 21:41:38 +0000
@@ -143,12 +143,12 @@
 
     def _check_prefix_uniqueness(self):
         """Ensure that the index collection is able to differentiate safely."""
-        prefixes = {}
+        prefixes = set()
         for index in self.search_path:
-            prefixes.setdefault(index.prefix, []).append(index)
-        for prefix, indices in prefixes.items():
-            if len(indices) > 1:
+            prefix = index.prefix
+            if prefix in prefixes:
                 raise errors.DuplicateHelpPrefix(prefix)
+            prefixes.add(prefix)
 
     def search(self, topic):
         """Search for topic across the help search path.
 
=== modified file 'breezy/help_topics/__init__.py'
--- breezy/help_topics/__init__.py	2017-06-02 21:28:05 +0000
+++ breezy/help_topics/__init__.py	2017-06-05 21:41:38 +0000
@@ -233,7 +233,7 @@
 
     protl = []
     decl = []
-    protos = transport_list_registry.keys( )
+    protos = transport_list_registry.keys()
     protos.sort(sort_func)
     for proto in protos:
         shorthelp = transport_list_registry.get_help(proto)
 
=== modified file 'breezy/index.py'
--- breezy/index.py	2017-06-05 01:46:14 +0000
+++ breezy/index.py	2017-06-05 21:41:38 +0000
@@ -45,6 +45,7 @@
 from .sixish import (
     BytesIO,
     viewvalues,
+    viewitems,
     )
 from .static_tuple import StaticTuple
 
@@ -144,7 +145,7 @@
         if self._nodes_by_key is None:
             nodes_by_key = {}
             if self.reference_lists:
-                for key, (absent, references, value) in self._nodes.iteritems():
+                for key, (absent, references, value) in viewitems(self._nodes):
                     if absent:
                         continue
                     key_dict = nodes_by_key
@@ -152,7 +153,7 @@
                         key_dict = key_dict.setdefault(subkey, {})
                     key_dict[key[-1]] = key, value, references
             else:
-                for key, (absent, references, value) in self._nodes.iteritems():
+                for key, (absent, references, value) in viewitems(self._nodes):
                     if absent:
                         continue
                     key_dict = nodes_by_key
@@ -276,7 +277,7 @@
         # forward sorted by key. In future we may consider topological sorting,
         # at the cost of table scans for direct lookup, or a second index for
         # direct lookup
-        nodes = sorted(self._nodes.items())
+        nodes = sorted(viewitems(self._nodes))
         # if we do not prepass, we don't know how long it will be up front.
         expected_bytes = None
         # we only need to pre-pass if we have reference lists at all.
@@ -479,7 +480,7 @@
         stream.close()
         del lines[-1]
         _, _, _, trailers = self._parse_lines(lines, pos)
-        for key, absent, references, value in self._keys_by_offset.itervalues():
+        for key, absent, references, value in viewvalues(self._keys_by_offset):
             if absent:
                 continue
             # resolve references:
@@ -510,7 +511,7 @@
                 % (ref_list_num, self.node_ref_lists))
         refs = set()
         nodes = self._nodes
-        for key, (value, ref_lists) in nodes.iteritems():
+        for key, (value, ref_lists) in viewitems(nodes):
             ref_list = ref_lists[ref_list_num]
             refs.update([ref for ref in ref_list if ref not in nodes])
         return refs
@@ -519,13 +520,13 @@
         if self._nodes_by_key is None:
             nodes_by_key = {}
             if self.node_ref_lists:
-                for key, (value, references) in self._nodes.iteritems():
+                for key, (value, references) in viewitems(self._nodes):
                     key_dict = nodes_by_key
                     for subkey in key[:-1]:
                         key_dict = key_dict.setdefault(subkey, {})
                     key_dict[key[-1]] = key, value, references
             else:
-                for key, value in self._nodes.iteritems():
+                for key, value in viewitems(self._nodes):
                     key_dict = nodes_by_key
                     for subkey in key[:-1]:
                         key_dict = key_dict.setdefault(subkey, {})
@@ -548,10 +549,10 @@
         if self._nodes is None:
             self._buffer_all()
         if self.node_ref_lists:
-            for key, (value, node_ref_lists) in self._nodes.iteritems():
+            for key, (value, node_ref_lists) in viewitems(self._nodes):
                 yield self, key, value, node_ref_lists
         else:
-            for key, value in self._nodes.iteritems():
+            for key, value in viewitems(self._nodes):
                 yield self, key, value
 
     def _read_prefix(self, stream):
@@ -1599,11 +1600,11 @@
             trace.mutter_callsite(3,
                 "iter_all_entries scales with size of history.")
         if self.reference_lists:
-            for key, (absent, references, value) in self._nodes.iteritems():
+            for key, (absent, references, value) in viewitems(self._nodes):
                 if not absent:
                     yield self, key, value, references
         else:
-            for key, (absent, references, value) in self._nodes.iteritems():
+            for key, (absent, references, value) in viewitems(self._nodes):
                 if not absent:
                     yield self, key, value
 
 
=== modified file 'breezy/inventory.py'
--- breezy/inventory.py	2017-05-30 19:16:23 +0000
+++ breezy/inventory.py	2017-06-05 21:41:38 +0000
@@ -48,7 +48,10 @@
     lazy_regex,
     trace,
     )
-
+from .sixish import (
+    viewitems,
+    viewvalues,
+    )
 from .static_tuple import StaticTuple
 
 
@@ -227,9 +230,6 @@
 
     known_kinds = ('file', 'directory', 'symlink')
 
-    def sorted_children(self):
-        return sorted(self.children.items())
-
     @staticmethod
     def versionable_kind(kind):
         return (kind in ('file', 'directory', 'symlink', 'tree-reference'))
@@ -402,6 +402,9 @@
         super(InventoryDirectory, self).__init__(file_id, name, parent_id)
         self.children = {}
 
+    def sorted_children(self):
+        return sorted(viewitems(self.children))
+
     def kind_character(self):
         """See InventoryEntry.kind_character."""
         return '/'
@@ -665,7 +668,7 @@
 
         # unrolling the recursive called changed the time from
         # 440ms/663ms (inline/total) to 116ms/116ms
-        children = sorted(from_dir.children.items())
+        children = sorted(viewitems(from_dir.children))
         if not recursive:
             for name, ie in children:
                 yield name, ie
@@ -690,7 +693,7 @@
                     continue
 
                 # But do this child first
-                new_children = sorted(ie.children.items())
+                new_children = sorted(viewitems(ie.children))
                 new_children = collections.deque(new_children)
                 stack.append((path, new_children))
                 # Break out of inner loop, so that we start outer loop with child
@@ -771,7 +774,7 @@
             cur_relpath, cur_dir = stack.pop()
 
             child_dirs = []
-            for child_name, child_ie in sorted(cur_dir.children.iteritems()):
+            for child_name, child_ie in sorted(viewitems(cur_dir.children)):
 
                 child_relpath = cur_relpath + child_name
 
@@ -814,7 +817,7 @@
         """
         accum = []
         def descend(dir_ie, dir_path):
-            kids = sorted(dir_ie.children.items())
+            kids = sorted(viewitems(dir_ie.children))
             for name, ie in kids:
                 child_path = osutils.pathjoin(dir_path, name)
                 accum.append((child_path, ie))
@@ -1102,9 +1105,8 @@
         XXX: We may not want to merge this into bzr.dev.
         """
         if self.root is None:
-            return
-        for _, ie in self._byid.iteritems():
-            yield ie
+            return ()
+        return iter(viewvalues(self._byid))
 
     def __len__(self):
         """Returns number of entries."""
@@ -1138,8 +1140,10 @@
                 "inventory already contains entry with id {%s}" %
                 entry.file_id)
         self._byid[entry.file_id] = entry
-        for child in getattr(entry, 'children', {}).itervalues():
-            self._add_child(child)
+        children = getattr(entry, 'children', {})
+        if children is not None:
+            for child in viewvalues(children):
+                self._add_child(child)
         return entry
 
     def add(self, entry):
@@ -1288,7 +1292,7 @@
             ie = to_find_delete.pop()
             to_delete.append(ie.file_id)
             if ie.kind == 'directory':
-                to_find_delete.extend(ie.children.values())
+                to_find_delete.extend(viewvalues(ie.children))
         for file_id in reversed(to_delete):
             ie = self[file_id]
             del self._byid[file_id]
@@ -1589,7 +1593,7 @@
         result = CHKInventory(self._search_key_name)
         if propagate_caches:
             # Just propagate the path-to-fileid cache for now
-            result._path_to_fileid_cache = dict(self._path_to_fileid_cache.iteritems())
+            result._path_to_fileid_cache = self._path_to_fileid_cache.copy()
         search_key_func = chk_map.search_key_registry.get(self._search_key_name)
         self.id_to_entry._ensure_root()
         maximum_size = self.id_to_entry._root_node.maximum_size
@@ -1708,7 +1712,7 @@
                 continue
             # This loop could potentially be better by using the id_basename
             # map to just get the child file ids.
-            for child in entry.children.values():
+            for child in viewvalues(entry.children):
                 if child.file_id not in altered:
                     raise errors.InconsistentDelta(self.id2path(child.file_id),
                         child.file_id, "Child not deleted or reparented when "
@@ -1720,7 +1724,7 @@
             # re-keying, but its simpler to just output that as a delete+add
             # to spend less time calculating the delta.
             delta_list = []
-            for key, (old_key, value) in parent_id_basename_delta.iteritems():
+            for key, (old_key, value) in viewitems(parent_id_basename_delta):
                 if value is not None:
                     delta_list.append((old_key, key, value))
                 else:
 
=== modified file 'breezy/knit.py'
--- breezy/knit.py	2017-06-04 18:09:30 +0000
+++ breezy/knit.py	2017-06-05 21:41:38 +0000
@@ -99,6 +99,8 @@
 from .sixish import (
     BytesIO,
     range,
+    viewitems,
+    viewvalues,
     )
 from .versionedfile import (
     _KeyRefs,
@@ -843,8 +845,8 @@
             if compression_parent not in all_build_index_memos:
                 next_keys.add(compression_parent)
         build_keys = next_keys
-    return sum([index_memo[2] for index_memo
-                in all_build_index_memos.itervalues()])
+    return sum(index_memo[2]
+               for index_memo in viewvalues(all_build_index_memos))
 
 
 class KnitVersionedFiles(VersionedFilesWithFallbacks):
@@ -1173,7 +1175,7 @@
             build_details = self._index.get_build_details(pending_components)
             current_components = set(pending_components)
             pending_components = set()
-            for key, details in build_details.iteritems():
+            for key, details in viewitems(build_details):
                 (index_memo, compression_parent, parents,
                  record_details) = details
                 method = record_details[0]
@@ -1280,7 +1282,7 @@
                 # key = component_id, r = record_details, i_m = index_memo,
                 # n = next
                 records = [(key, i_m) for key, (r, i_m, n)
-                                       in position_map.iteritems()]
+                                       in viewitems(position_map)]
                 # Sort by the index memo, so that we request records from the
                 # same pack file together, and in forward-sorted order
                 records.sort(key=operator.itemgetter(1))
@@ -1411,7 +1413,7 @@
             # map from key to
             # (record_details, access_memo, compression_parent_key)
             positions = dict((key, self._build_details_to_components(details))
-                for key, details in build_details.iteritems())
+                for key, details in viewitems(build_details))
         absent_keys = keys.difference(set(positions))
         # There may be more absent keys : if we're missing the basis component
         # and are trying to include the delta closure.
@@ -1525,7 +1527,7 @@
         missing = set(keys)
         record_map = self._get_record_map(missing, allow_missing=True)
         result = {}
-        for key, details in record_map.iteritems():
+        for key, details in viewitems(record_map):
             if key not in missing:
                 continue
             # record entry 2 is the 'digest'.
@@ -1757,7 +1759,7 @@
                 # we need key, position, length
                 key_records = []
                 build_details = self._index.get_build_details(keys)
-                for key, details in build_details.iteritems():
+                for key, details in viewitems(build_details):
                     if key in keys:
                         key_records.append((key, details[0]))
                 records_iter = enumerate(self._read_records_iter(key_records))
@@ -2165,8 +2167,8 @@
         # one line with next ('' for None)
         # one line with byte count of the record bytes
         # the record bytes
-        for key, (record_bytes, (method, noeol), next) in \
-            self._raw_record_map.iteritems():
+        for key, (record_bytes, (method, noeol), next) in viewitems(
+                self._raw_record_map):
             key_bytes = '\x00'.join(key)
             parents = self.global_map.get(key, None)
             if parents is None:
@@ -2890,10 +2892,10 @@
                 del keys[key]
         result = []
         if self._parents:
-            for key, (value, node_refs) in keys.iteritems():
+            for key, (value, node_refs) in viewitems(keys):
                 result.append((key, value, node_refs))
         else:
-            for key, (value, node_refs) in keys.iteritems():
+            for key, (value, node_refs) in viewitems(keys):
                 result.append((key, value))
         self._add_callback(result)
         if missing_compression_parents:
@@ -3269,7 +3271,7 @@
             self._all_build_details.update(build_details)
             # new_nodes = self._vf._index._get_entries(this_iteration)
             pending = set()
-            for key, details in build_details.iteritems():
+            for key, details in viewitems(build_details):
                 (index_memo, compression_parent, parent_keys,
                  record_details) = details
                 self._parent_map[key] = parent_keys
@@ -3290,7 +3292,7 @@
                     else:
                         self._num_compression_children[compression_parent] = 1
 
-            missing_versions = this_iteration.difference(build_details.keys())
+            missing_versions = this_iteration.difference(build_details)
             if missing_versions:
                 for key in missing_versions:
                     if key in self._parent_map and key in self._text_cache:
 
=== modified file 'breezy/log.py'
--- breezy/log.py	2017-06-04 18:09:30 +0000
+++ breezy/log.py	2017-06-05 21:41:38 +0000
@@ -864,7 +864,7 @@
     if match is None:
         return log_rev_iterator
     searchRE = [(k, [re.compile(x, re.IGNORECASE) for x in v])
-                for (k,v) in match.iteritems()]
+                for k, v in match.items()]
     return _filter_re(searchRE, log_rev_iterator)
 
 
@@ -881,7 +881,7 @@
                'author': (rev.get_apparent_authors()),
                'bugs': list(rev.iter_bugs())
                }
-    strings[''] = [item for inner_list in strings.itervalues()
+    strings[''] = [item for inner_list in strings.values()
                    for item in inner_list]
     for (k,v) in searchRE:
         if k in strings and not _match_any_filter(strings[k], v):
 
=== modified file 'breezy/lru_cache.py'
--- breezy/lru_cache.py	2017-05-30 19:16:23 +0000
+++ breezy/lru_cache.py	2017-06-05 21:41:38 +0000
@@ -21,6 +21,11 @@
 from . import (
     trace,
     )
+from .sixish import (
+    viewitems,
+    viewkeys,
+    )
+
 
 _null_key = object()
 
@@ -129,11 +134,12 @@
 
         :return: An unordered list of keys that are currently cached.
         """
-        return self._cache.keys()
+        # GZ 2016-06-04: Maybe just make this return the view?
+        return list(viewkeys(self._cache))
 
     def as_dict(self):
         """Get a new dict with the same key:value pairs as the cache"""
-        return dict((k, n.value) for k, n in self._cache.iteritems())
+        return dict((k, n.value) for k, n in viewitems(self._cache))
 
     def cleanup(self):
         """Clear the cache until it shrinks to the requested size.
 
=== modified file 'breezy/mail_client.py'
--- breezy/mail_client.py	2017-05-22 00:56:52 +0000
+++ breezy/mail_client.py	2017-06-05 21:41:38 +0000
@@ -252,7 +252,7 @@
         if body is not None:
             message_options['body'] = body
         options_list = ['%s=%s' % (k, urlutils.escape(v)) for (k, v) in
-                        sorted(message_options.iteritems())]
+                        sorted(message_options.items())]
         return ['mailto:%s?%s' % (self._encode_safe(to or ''),
             '&'.join(options_list))]
 mail_client_registry.register('evolution', Evolution,
@@ -316,7 +316,7 @@
         else:
             options_list = []
         options_list.extend(["%s='%s'" % (k, v) for k, v in
-                        sorted(message_options.iteritems())])
+                        sorted(message_options.items())])
         return ['-compose', ','.join(options_list)]
 mail_client_registry.register('thunderbird', Thunderbird,
                               help=Thunderbird.__doc__)
 
=== modified file 'breezy/merge.py'
--- breezy/merge.py	2017-05-30 19:16:23 +0000
+++ breezy/merge.py	2017-06-05 21:41:38 +0000
@@ -48,6 +48,9 @@
     hooks,
     registry,
     )
+from .sixish import (
+    viewitems,
+    )
 # TODO: Report back as changes are merged in
 
 
@@ -2289,7 +2292,7 @@
         filtered_parent_map = {}
         child_map = {}
         tails = []
-        for key, parent_keys in parent_map.iteritems():
+        for key, parent_keys in viewitems(parent_map):
             culled_parent_keys = [p for p in parent_keys if p in parent_map]
             if not culled_parent_keys:
                 tails.append(key)
 
=== modified file 'breezy/mutabletree.py'
--- breezy/mutabletree.py	2017-05-30 19:32:13 +0000
+++ breezy/mutabletree.py	2017-06-05 21:41:38 +0000
@@ -42,6 +42,9 @@
 """)
 
 from .decorators import needs_read_lock, needs_write_lock
+from .sixish import (
+    viewvalues,
+    )
 
 
 def needs_tree_write_lock(unbound):
@@ -551,7 +554,9 @@
     """Helper for MutableTree.smart_add."""
 
     def get_inventory_delta(self):
-        return self._invdelta.values()
+        # GZ 2016-06-05: Returning view would probably be fine but currently
+        # Inventory.apply_delta is documented as requiring a list of changes.
+        return list(viewvalues(self._invdelta))
 
     def _get_ie(self, inv_path):
         """Retrieve the most up to date inventory entry for a path.
@@ -633,12 +638,12 @@
         prev_dir = None
 
         is_inside = osutils.is_inside_or_parent_of_any
-        for path, (inv_path, this_ie) in sorted(
-                user_dirs.iteritems(), key=operator.itemgetter(0)):
+        for path in sorted(user_dirs):
             if (prev_dir is None or not is_inside([prev_dir], path)):
+                inv_path, this_ie = user_dirs[path]
                 yield (path, inv_path, this_ie, None)
             prev_dir = path
-        
+
     def __init__(self, tree, action, conflicts_related=None):
         self.tree = tree
         if action is None:
 
=== modified file 'breezy/plugins/bash_completion/bashcomp.py'
--- breezy/plugins/bash_completion/bashcomp.py	2017-05-22 00:56:52 +0000
+++ breezy/plugins/bash_completion/bashcomp.py	2017-06-05 21:41:38 +0000
@@ -189,7 +189,7 @@
             brz_version += "."
         else:
             brz_version += " and the following plugins:"
-            for name, plugin in sorted(self.data.plugins.iteritems()):
+            for name, plugin in sorted(self.data.plugins.items()):
                 brz_version += "\n# %s" % plugin
         return brz_version
 
@@ -314,7 +314,7 @@
                 self.data.global_options.add(short)
 
     def aliases(self):
-        for alias, expansion in config.GlobalConfig().get_aliases().iteritems():
+        for alias, expansion in config.GlobalConfig().get_aliases().items():
             for token in cmdline.split(expansion):
                 if not token.startswith("-"):
                     self.user_aliases.setdefault(token, set()).add(alias)
@@ -352,7 +352,7 @@
             if useralias not in cmd_data.aliases]))
 
         opts = cmd.options()
-        for optname, opt in sorted(opts.iteritems()):
+        for optname, opt in sorted(opts.items()):
             cmd_data.options.extend(self.option(opt))
 
         if 'help' == name or 'help' in cmd.aliases:
@@ -471,7 +471,7 @@
     if args:
         parser.error("script does not take positional arguments")
     kwargs = dict()
-    for name, value in opts.__dict__.iteritems():
+    for name, value in opts.__dict__.items():
         if value is not None:
             kwargs[name] = value
 
 
=== modified file 'breezy/plugins/bisect/tests.py'
--- breezy/plugins/bisect/tests.py	2017-05-24 14:51:33 +0000
+++ breezy/plugins/bisect/tests.py	2017-06-05 21:41:38 +0000
@@ -44,10 +44,10 @@
                         1.3: "one dot three", 2: "two", 3: "three",
                         4: "four", 5: "five"}
 
-        test_file = open("test_file")
-        content = test_file.read().strip()
+        with open("test_file") as f:
+            content = f.read().strip()
         if content != rev_contents[rev]:
-            rev_ids = dict((rev_contents[k], k) for k in rev_contents.keys())
+            rev_ids = dict((rev_contents[k], k) for k in rev_contents)
             found_rev = rev_ids[content]
             raise AssertionError("expected rev %0.1f, found rev %0.1f"
                                  % (rev, found_rev))
 
=== modified file 'breezy/plugins/fastimport/branch_updater.py'
--- breezy/plugins/fastimport/branch_updater.py	2017-05-23 23:21:16 +0000
+++ breezy/plugins/fastimport/branch_updater.py	2017-06-05 21:41:38 +0000
@@ -77,7 +77,7 @@
         """
         branch_tips = []
         lost_heads = []
-        ref_names = self.heads_by_ref.keys()
+        ref_names = list(self.heads_by_ref)
         if self.branch is not None:
             trunk = self.select_trunk(ref_names)
             default_tip = self.heads_by_ref[trunk][0]
 
=== modified file 'breezy/plugins/fastimport/cache_manager.py'
--- breezy/plugins/fastimport/cache_manager.py	2017-05-23 23:21:16 +0000
+++ breezy/plugins/fastimport/cache_manager.py	2017-06-05 21:41:38 +0000
@@ -51,7 +51,7 @@
 
     def finalize(self):
         if self.disk_blobs is not None:
-            for info in self.disk_blobs.itervalues():
+            for info in self.disk_blobs.values():
                 if info[-1] is not None:
                     os.unlink(info[-1])
             self.disk_blobs = None
@@ -145,17 +145,17 @@
         #self._show_stats_for(self._blobs, "other blobs", note=note)
         #self.reftracker.dump_stats(note=note)
 
-    def _show_stats_for(self, dict, label, note=trace.note, tuple_key=False):
+    def _show_stats_for(self, a_dict, label, note, tuple_key=False):
         """Dump statistics about a given dictionary.
 
         By the key and value need to support len().
         """
-        count = len(dict)
+        count = len(a_dict)
         if tuple_key:
-            size = sum(map(len, (''.join(k) for k in dict.keys())))
+            size = sum(map(len, (''.join(k) for k in a_dict)))
         else:
-            size = sum(map(len, dict.keys()))
-        size += sum(map(len, dict.values()))
+            size = sum(map(len, a_dict))
+        size += sum(map(len, a_dict.values()))
         size = size * 1.0 / 1024
         unit = 'K'
         if size > 1024:
@@ -176,7 +176,7 @@
         self.inventories.clear()
 
     def _flush_blobs_to_disk(self):
-        blobs = self._sticky_blobs.keys()
+        blobs = list(self._sticky_blobs)
         sticky_blobs = self._sticky_blobs
         total_blobs = len(sticky_blobs)
         blobs.sort(key=lambda k:len(sticky_blobs[k]))
@@ -275,16 +275,3 @@
         if self._decref(id, self._sticky_blobs, None):
             self._sticky_memory_bytes -= len(content)
         return content
-
-
-def invert_dictset(d):
-    """Invert a dictionary with keys matching a set of values, turned into lists."""
-    # Based on recipe from ASPN
-    result = {}
-    for k, c in d.iteritems():
-        for v in c:
-            keys = result.setdefault(v, [])
-            keys.append(k)
-    return result
-
-
 
=== modified file 'breezy/plugins/fastimport/exporter.py'
--- breezy/plugins/fastimport/exporter.py	2017-05-23 23:37:18 +0000
+++ breezy/plugins/fastimport/exporter.py	2017-06-05 21:41:38 +0000
@@ -292,7 +292,7 @@
         if self.export_marks_file:
             revision_ids = dict((m, r) for r, m in self.revid_to_mark.items())
             marks_file.export_marks(self.export_marks_file, revision_ids)
- 
+
     def is_empty_dir(self, tree, path):
         path_id = tree.path2id(path)
         if path_id is None:
 
=== modified file 'breezy/plugins/fastimport/helpers.py'
--- breezy/plugins/fastimport/helpers.py	2017-05-23 23:21:16 +0000
+++ breezy/plugins/fastimport/helpers.py	2017-06-05 21:41:38 +0000
@@ -181,7 +181,7 @@
     """Invert a dictionary with keys matching a set of values, turned into lists."""
     # Based on recipe from ASPN
     result = {}
-    for k, c in d.iteritems():
+    for k, c in d.items():
         for v in c:
             keys = result.setdefault(v, [])
             keys.append(k)
@@ -192,7 +192,7 @@
     """Invert a dictionary with keys matching each value turned into a list."""
     # Based on recipe from ASPN
     result = {}
-    for k, v in d.iteritems():
+    for k, v in d.items():
         keys = result.setdefault(v, [])
         keys.append(k)
     return result
 
=== modified file 'breezy/plugins/fastimport/idmapfile.py'
--- breezy/plugins/fastimport/idmapfile.py	2017-05-23 23:21:16 +0000
+++ breezy/plugins/fastimport/idmapfile.py	2017-06-05 21:41:38 +0000
@@ -29,13 +29,9 @@
     :param filename: name of the file to save the data to
     :param revision_ids: a dictionary of commit ids to revision ids.
     """
-    f = open(filename, 'wb')
-    try:
-        for commit_id, rev_id in revision_ids.iteritems():
-            f.write("%s %s\n" % (commit_id, rev_id))
-        f.flush()
-    finally:
-        f.close()
+    with open(filename, 'wb') as f:
+        for commit_id in revision_ids:
+            f.write("%s %s\n" % (commit_id, revision_ids[commit_id]))
 
 
 def load_id_map(filename):
 
=== modified file 'breezy/plugins/fastimport/marks_file.py'
--- breezy/plugins/fastimport/marks_file.py	2017-05-23 23:21:16 +0000
+++ breezy/plugins/fastimport/marks_file.py	2017-06-05 21:41:38 +0000
@@ -74,6 +74,6 @@
         return
 
     # Write the revision info
-    for mark, revid in revision_ids.iteritems():
-        f.write(':%s %s\n' % (str(mark).lstrip(':'), revid))
+    for mark in revision_ids:
+        f.write(':%s %s\n' % (str(mark).lstrip(':'), revision_ids[mark]))
     f.close()
 
=== modified file 'breezy/plugins/fastimport/processors/info_processor.py'
--- breezy/plugins/fastimport/processors/info_processor.py	2017-06-04 18:09:30 +0000
+++ breezy/plugins/fastimport/processors/info_processor.py	2017-06-05 21:41:38 +0000
@@ -87,11 +87,11 @@
         # Commit stats
         if self.cmd_counts['commit']:
             p_items = []
-            for _ in range(self.max_parent_count + 1):
+            for i in range(self.max_parent_count + 1):
                 if i in self.parent_counts:
                     count = self.parent_counts[i]
                     p_items.append(("parents-%d" % i, count))
-            merges_count = len(self.merges.keys())
+            merges_count = len(self.merges)
             p_items.append(('total revisions merged', merges_count))
             flags = {
                 'separate authors found': self.separate_authors_found,
@@ -100,21 +100,21 @@
                 'blobs referenced by SHA': self.sha_blob_references,
                 }
             self._dump_stats_group("Parent counts", p_items, str)
-            self._dump_stats_group("Commit analysis", flags.iteritems(), _found)
+            self._dump_stats_group("Commit analysis", flags.items(), _found)
             heads = invert_dictset(self.reftracker.heads)
-            self._dump_stats_group("Head analysis", heads.iteritems(), None,
+            self._dump_stats_group("Head analysis", heads.items(), None,
                                     _iterable_as_config_list)
             # note("\t%d\t%s" % (len(self.committers), 'unique committers'))
-            self._dump_stats_group("Merges", self.merges.iteritems(), None)
+            self._dump_stats_group("Merges", self.merges.items(), None)
             # We only show the rename old path and copy source paths when -vv
             # (verbose=2) is specified. The output here for mysql's data can't
             # be parsed currently so this bit of code needs more work anyhow ..
             if self.verbose >= 2:
                 self._dump_stats_group("Rename old paths",
-                    self.rename_old_paths.iteritems(), len,
+                    self.rename_old_paths.items(), len,
                     _iterable_as_config_list)
                 self._dump_stats_group("Copy source paths",
-                    self.copy_source_paths.iteritems(), len,
+                    self.copy_source_paths.items(), len,
                     _iterable_as_config_list)
 
         # Blob stats
@@ -123,11 +123,10 @@
             if self.verbose:
                 del self.blobs['used']
             self._dump_stats_group("Blob usage tracking",
-                self.blobs.iteritems(), len, _iterable_as_config_list)
+                self.blobs.items(), len, _iterable_as_config_list)
         if self.blob_ref_counts:
             blobs_by_count = invert_dict(self.blob_ref_counts)
-            blob_items = blobs_by_count.items()
-            blob_items.sort()
+            blob_items = sorted(blobs_by_count.items())
             self._dump_stats_group("Blob reference counts",
                 blob_items, len, _iterable_as_config_list)
 
@@ -136,7 +135,7 @@
             reset_stats = {
                 'lightweight tags': self.lightweight_tags,
                 }
-            self._dump_stats_group("Reset analysis", reset_stats.iteritems())
+            self._dump_stats_group("Reset analysis", reset_stats.items())
 
     def _dump_stats_group(self, title, items, normal_formatter=None,
         verbose_formatter=None):
 
=== modified file 'breezy/plugins/fastimport/revision_store.py'
--- breezy/plugins/fastimport/revision_store.py	2017-05-30 23:57:10 +0000
+++ breezy/plugins/fastimport/revision_store.py	2017-06-05 21:41:38 +0000
@@ -269,7 +269,7 @@
         # repository.CommitBuilder.record_entry_contents().
         parent_candidate_entries = ie.parent_candidates(self._rev_parent_invs)
         head_set = self._commit_builder._heads(ie.file_id,
-            parent_candidate_entries.keys())
+            list(parent_candidate_entries))
         heads = []
         for inv in self._rev_parent_invs:
             if inv.has_id(ie.file_id):
 
=== modified file 'breezy/plugins/launchpad/lp_api_lite.py'
--- breezy/plugins/launchpad/lp_api_lite.py	2017-05-22 00:56:52 +0000
+++ breezy/plugins/launchpad/lp_api_lite.py	2017-06-05 21:41:38 +0000
@@ -194,7 +194,7 @@
     # Note: this assumes that a given rev won't get tagged multiple times. But
     #       it should be valid for the package importer branches that we care
     #       about
-    reverse_dict = dict((rev, tag) for tag, rev in tag_dict.iteritems())
+    reverse_dict = dict((rev, tag) for tag, rev in tag_dict.items())
     the_branch.lock_read()
     try:
         last_rev = the_branch.last_revision()
 
=== modified file 'breezy/plugins/launchpad/lp_registration.py'
--- breezy/plugins/launchpad/lp_registration.py	2017-06-02 01:01:21 +0000
+++ breezy/plugins/launchpad/lp_registration.py	2017-06-05 21:41:38 +0000
@@ -94,7 +94,7 @@
     # NB: these should always end in a slash to avoid xmlrpclib appending
     # '/RPC2'
     LAUNCHPAD_INSTANCE = {}
-    for instance, domain in LAUNCHPAD_DOMAINS.iteritems():
+    for instance, domain in LAUNCHPAD_DOMAINS.items():
         LAUNCHPAD_INSTANCE[instance] = 'https://xmlrpc.%s/bazaar/' % domain
 
     # We use production as the default because edge has been deprecated circa
@@ -197,7 +197,7 @@
         else:
             domains = (
                 'bazaar.%s' % domain
-                for domain in self.LAUNCHPAD_DOMAINS.itervalues())
+                for domain in self.LAUNCHPAD_DOMAINS.values())
             if hostinfo not in domains:
                 raise NotLaunchpadBranch(branch_url)
         return path.lstrip('/')
 
=== modified file 'breezy/plugins/stats/cmds.py'
--- breezy/plugins/stats/cmds.py	2017-06-01 23:52:12 +0000
+++ breezy/plugins/stats/cmds.py	2017-06-05 21:41:38 +0000
@@ -60,7 +60,7 @@
             info[1][email] = info[1].setdefault(email, 0) + 1
             info[2][username] = info[2].setdefault(username, 0) + 1
     res = [(len(revs), revs, emails, fnames)
-           for revs, emails, fnames in committer_to_info.itervalues()]
+           for revs, emails, fnames in committer_to_info.values()]
     res.sort(reverse=True)
     return res
 
@@ -89,7 +89,7 @@
                 old_email_id = email_to_id[old_email]
                 assert old_email_id in (old_id, new_id)
                 email_to_id[old_email] = cur_id
-    for email, usernames in email_users.iteritems():
+    for email, usernames in email_users.items():
         assert email not in email_to_id
         if not email:
             # We use a different algorithm for usernames that have no email
@@ -131,7 +131,7 @@
                     collapse_ids(user_id, cur_id, id_combos)
             username_to_id[low_user] = cur_id
     combo_to_best_combo = {}
-    for cur_id, combos in id_to_combos.iteritems():
+    for cur_id, combos in id_to_combos.items():
         best_combo = sorted(combos,
                             key=lambda x:combo_count[x],
                             reverse=True)[0]
@@ -206,10 +206,10 @@
     for count, revs, emails, fullnames in info:
         # Get the most common email name
         sorted_emails = sorted(((count, email)
-                               for email,count in emails.iteritems()),
+                               for email, count in emails.items()),
                                reverse=True)
         sorted_fullnames = sorted(((count, fullname)
-                                  for fullname,count in fullnames.iteritems()),
+                                  for fullname, count in fullnames.items()),
                                   reverse=True)
         if sorted_fullnames[0][1] == '' and sorted_emails[0][1] == '':
             to_file.write('%4d %s\n'
@@ -237,7 +237,7 @@
         if gather_class_stats is not None:
             to_file.write('     Contributions:\n')
             classes, total = gather_class_stats(revs)
-            for name,count in sorted(classes.items(), lambda x,y: cmp((x[1], x[0]), (y[1], y[0]))):
+            for name, count in sorted(classes.items(), key=classify_key):
                 if name is None:
                     name = "Unknown"
                 to_file.write("     %4.0f%% %s\n" % ((float(count) / total) * 100.0, name))
@@ -342,6 +342,11 @@
     return ret, total
 
 
+def classify_key(item):
+    """Sort key for item of (author, count) from classify_delta."""
+    return -item[1], item[0]
+
+
 def display_credits(credits, to_file):
     (coders, documenters, artists, translators) = credits
     def print_section(name, lst):
@@ -392,8 +397,8 @@
     finally:
         repository.unlock()
     def sort_class(name):
-        return map(lambda (x,y): x,
-               sorted(ret[name].items(), lambda x,y: cmp((x[1], x[0]), (y[1], y[0])), reverse=True))
+        return [author
+            for author, _  in sorted(ret[name].items(), key=classify_key)]
     return (sort_class("code"), sort_class("documentation"), sort_class("art"), sort_class("translation"))
 
 
 
=== modified file 'breezy/plugins/weave_fmt/bzrdir.py'
--- breezy/plugins/weave_fmt/bzrdir.py	2017-05-30 19:32:13 +0000
+++ breezy/plugins/weave_fmt/bzrdir.py	2017-06-05 21:41:38 +0000
@@ -435,7 +435,7 @@
             self.text_weaves[file_id] = w
         text_changed = False
         parent_candiate_entries = ie.parent_candidates(parent_invs)
-        heads = graph.Graph(self).heads(parent_candiate_entries.keys())
+        heads = graph.Graph(self).heads(parent_candiate_entries)
         # XXX: Note that this is unordered - and this is tolerable because
         # the previous code was also unordered.
         previous_entries = dict((head, parent_candiate_entries[head]) for head
@@ -457,7 +457,7 @@
         # save against.
         #ie.snapshot(rev, PATH, previous_revisions, REVISION_TREE, InMemoryWeaveStore(self.text_weaves))
         if len(previous_revisions) == 1:
-            previous_ie = previous_revisions.values()[0]
+            previous_ie = next(iter(previous_revisions.values()))
             if ie._unchanged(previous_ie):
                 ie.revision = previous_ie.revision
                 return
@@ -479,7 +479,7 @@
         The order must be such that an revision is imported after all
         its (present) parents.
         """
-        todo = set(self.revisions.keys())
+        todo = set(self.revisions)
         done = self.absent_revisions.copy()
         order = []
         while todo:
 
=== modified file 'breezy/reconcile.py'
--- breezy/reconcile.py	2017-05-22 00:56:52 +0000
+++ breezy/reconcile.py	2017-06-05 21:41:38 +0000
@@ -430,7 +430,7 @@
             # NB: This is really not needed, reconcile != pack.
             per_id_bad_parents[key[0]] = {}
         # Generate per-knit/weave data.
-        for key, details in bad_parents.iteritems():
+        for key, details in bad_parents.items():
             file_id = key[0]
             rev_id = key[1]
             knit_parents = tuple([parent[-1] for parent in details[0]])
 
=== modified file 'breezy/registry.py'
--- breezy/registry.py	2017-05-22 00:56:52 +0000
+++ breezy/registry.py	2017-06-05 21:41:38 +0000
@@ -227,17 +227,16 @@
 
     def keys(self):
         """Get a list of registered entries"""
-        return sorted(self._dict.keys())
+        return sorted(self._dict)
 
     def iteritems(self):
-        for key, getter in self._dict.iteritems():
-            yield key, getter.get_obj()
+        for key in self._dict:
+            yield key, self._dict[key].get_obj()
 
     def items(self):
         # We should not use the iteritems() implementation below (see bug
         # #430510)
-        return sorted([(key, getter.get_obj())
-                       for key, getter in self._dict.items()])
+        return [(key, self._dict[key].get_obj()) for key in self.keys()]
 
     def _set_default_key(self, key):
         if key not in self._dict:
 
=== modified file 'breezy/remote.py'
--- breezy/remote.py	2017-05-30 19:32:13 +0000
+++ breezy/remote.py	2017-06-05 21:41:38 +0000
@@ -51,6 +51,10 @@
 from .i18n import gettext
 from .inventory import Inventory
 from .lockable_files import LockableFiles
+from .sixish import (
+    viewitems,
+    viewvalues,
+    )
 from .smart import client, vfs, repository as smart_repo
 from .smart.client import _SmartClient
 from .revision import NULL_REVISION
@@ -698,7 +702,7 @@
             raise errors.UnexpectedSmartServerResponse(response)
         body = bencode.bdecode(handler.read_body_bytes())
         ret = {}
-        for (name, value) in body.iteritems():
+        for name, value in viewitems(body):
             ret[name] = self._open_branch(name, value[0], value[1],
                 possible_transports=possible_transports,
                 ignore_fallbacks=ignore_fallbacks)
@@ -2088,8 +2092,7 @@
     def revision_ids_to_search_result(self, result_set):
         """Convert a set of revision ids to a graph SearchResult."""
         result_parents = set()
-        for parents in self.get_graph().get_parent_map(
-            result_set).itervalues():
+        for parents in viewvalues(self.get_graph().get_parent_map(result_set)):
             result_parents.update(parents)
         included_keys = result_set.intersection(result_parents)
         start_keys = result_set.difference(included_keys)
@@ -2214,15 +2217,15 @@
             for fallback in self._fallback_repositories:
                 if not absent:
                     break
-                desired_files = [(key[0], key[1], identifier) for
-                    (identifier, key) in absent.iteritems()]
+                desired_files = [(key[0], key[1], identifier)
+                    for identifier, key in viewitems(absent)]
                 for (identifier, bytes_iterator) in fallback.iter_files_bytes(desired_files):
                     del absent[identifier]
                     yield identifier, bytes_iterator
             if absent:
                 # There may be more missing items, but raise an exception
                 # for just one.
-                missing_identifier = absent.keys()[0]
+                missing_identifier = next(iter(absent))
                 missing_key = absent[missing_identifier]
                 raise errors.RevisionNotPresent(revision_id=missing_key[1],
                     file_id=missing_key[0])
@@ -2262,7 +2265,7 @@
             # There is one other "bug" which is that ghosts in
             # get_revision_graph() are not returned at all. But we won't worry
             # about that for now.
-            for node_id, parent_ids in rg.iteritems():
+            for node_id, parent_ids in viewitems(rg):
                 if parent_ids == ():
                     rg[node_id] = (NULL_REVISION,)
             rg[NULL_REVISION] = ()
 
=== modified file 'breezy/rename_map.py'
--- breezy/rename_map.py	2017-05-22 00:56:52 +0000
+++ breezy/rename_map.py	2017-06-05 21:41:38 +0000
@@ -25,6 +25,7 @@
 from .i18n import gettext
 from .sixish import (
     BytesIO,
+    viewitems,
     )
 from .ui import ui_factory
 
@@ -109,7 +110,7 @@
                 task.update(gettext('Determining hash hits'), num, len(paths))
                 hits = self.hitcounts(self.tree.get_file_lines(None,
                                                                path=path))
-                all_hits.extend((v, path, k) for k, v in hits.items())
+                all_hits.extend((v, path, k) for k, v in viewitems(hits))
         finally:
             task.finished()
         return all_hits
@@ -150,7 +151,7 @@
                     break
                 required_parents.setdefault(path, []).append(child)
         require_ids = {}
-        for parent, children in required_parents.iteritems():
+        for parent, children in viewitems(required_parents):
             child_file_ids = set()
             for child in children:
                 file_id = matches.get(child)
@@ -167,8 +168,8 @@
         parent directories.
         """
         all_hits = []
-        for file_id, file_id_children in missing_parents.iteritems():
-            for path, path_children in required_parents.iteritems():
+        for file_id, file_id_children in viewitems(missing_parents):
+            for path, path_children in viewitems(required_parents):
                 hits = len(path_children.intersection(file_id_children))
                 if hits > 0:
                     all_hits.append((hits, path, file_id))
@@ -250,8 +251,8 @@
 
     def _make_inventory_delta(self, matches):
         delta = []
-        file_id_matches = dict((f, p) for p, f in matches.items())
-        for old_path, entry in self.tree.iter_entries_by_dir(matches.values()):
+        file_id_matches = dict((f, p) for p, f in viewitems(matches))
+        for old_path, entry in self.tree.iter_entries_by_dir(file_id_matches):
             new_path = file_id_matches[entry.file_id]
             parent_path, new_name = osutils.split(new_path)
             parent_id = matches.get(parent_path)
 
=== modified file 'breezy/repofmt/groupcompress_repo.py'
--- breezy/repofmt/groupcompress_repo.py	2017-05-22 00:56:52 +0000
+++ breezy/repofmt/groupcompress_repo.py	2017-06-05 21:41:38 +0000
@@ -58,6 +58,10 @@
 from ..vf_repository import (
     StreamSource,
     )
+from ..sixish import (
+    viewitems,
+    viewvalues,
+    )
 from ..static_tuple import StaticTuple
 
 
@@ -276,7 +280,7 @@
                 remaining_keys.difference_update(cur_keys)
                 next_keys = set()
                 def handle_internal_node(node):
-                    for prefix, value in node._items.iteritems():
+                    for prefix, value in viewitems(node._items):
                         # We don't want to request the same key twice, and we
                         # want to order it by the first time it is seen.
                         # Even further, we don't want to request a key which is
@@ -543,7 +547,7 @@
         ancestor_keys = revision_vf.get_parent_map(revision_vf.keys())
         # Strip keys back into revision_ids.
         ancestors = dict((k[0], tuple([p[0] for p in parents]))
-                         for k, parents in ancestor_keys.iteritems())
+                         for k, parents in viewitems(ancestor_keys))
         del ancestor_keys
         # TODO: _generate_text_key_index should be much cheaper to generate from
         #       a chk repository, rather than the current implementation
@@ -665,7 +669,7 @@
                 if search_key_name is None:
                     # Find the name corresponding to the search_key_func
                     search_key_reg = chk_map.search_key_registry
-                    for search_key_name, func in search_key_reg.iteritems():
+                    for search_key_name, func in viewitems(search_key_reg):
                         if func == chk_inv.id_to_entry._search_key_func:
                             break
                 canonical_inv = inventory.CHKInventory.from_inventory(
@@ -741,7 +745,7 @@
         # any present parent inventories, which may be used when calculating
         # deltas for streaming.
         all_inv_keys = set(corresponding_invs)
-        for parent_inv_keys in inv_parent_map.itervalues():
+        for parent_inv_keys in viewvalues(inv_parent_map):
             all_inv_keys.update(parent_inv_keys)
         # Filter out ghost parents.
         all_inv_keys.intersection_update(
 
=== modified file 'breezy/repofmt/knitpack_repo.py'
--- breezy/repofmt/knitpack_repo.py	2017-05-25 21:59:11 +0000
+++ breezy/repofmt/knitpack_repo.py	2017-06-05 21:41:38 +0000
@@ -68,6 +68,7 @@
     RepositoryPackCollection,
     )
 from ..sixish import (
+    viewitems,
     zip
     )
 from ..vf_repository import (
@@ -642,7 +643,7 @@
             request_groups[index].append((key, value))
         record_index = 0
         pb.update("Copied record", record_index, len(nodes))
-        for index, items in request_groups.iteritems():
+        for index, items in viewitems(request_groups):
             pack_readv_requests = []
             for key, value in items:
                 # ---- KnitGraphIndex.get_position
@@ -740,7 +741,7 @@
         fileid_revisions = repo._find_file_ids_from_xml_inventory_lines(
             inv_lines, self.revision_keys)
         text_filter = []
-        for fileid, file_revids in fileid_revisions.iteritems():
+        for fileid, file_revids in viewitems(fileid_revisions):
             text_filter.extend([(fileid, file_revid) for file_revid in file_revids])
         self._text_filter = text_filter
 
@@ -934,7 +935,7 @@
                 request_groups[index] = []
             request_groups[index].append((key, value, references))
         result = []
-        for index, items in request_groups.iteritems():
+        for index, items in viewitems(request_groups):
             pack_readv_requests = []
             for key, value, references in items:
                 # ---- KnitGraphIndex.get_position
 
=== modified file 'breezy/repofmt/pack_repo.py'
--- breezy/repofmt/pack_repo.py	2017-05-22 00:56:52 +0000
+++ breezy/repofmt/pack_repo.py	2017-06-05 21:41:38 +0000
@@ -1288,10 +1288,10 @@
 
     def _remove_pack_indices(self, pack, ignore_missing=False):
         """Remove the indices for pack from the aggregated indices.
-        
+
         :param ignore_missing: Suppress KeyErrors from calling remove_index.
         """
-        for index_type in Pack.index_definitions.keys():
+        for index_type in Pack.index_definitions:
             attr_name = index_type + '_index'
             aggregate_index = getattr(self, attr_name)
             if aggregate_index is not None:
@@ -1344,7 +1344,7 @@
 
         # do a two-way diff against our original content
         current_nodes = set()
-        for name, sizes in self._names.iteritems():
+        for name, sizes in self._names.items():
             current_nodes.add(
                 ((name, ), ' '.join(str(size) for size in sizes)))
 
 
=== modified file 'breezy/repository.py'
--- breezy/repository.py	2017-05-30 19:32:13 +0000
+++ breezy/repository.py	2017-06-05 21:41:38 +0000
@@ -48,6 +48,10 @@
 from .decorators import needs_read_lock, needs_write_lock, only_raises
 from .inter import InterObject
 from .lock import _RelockDebugMixin, LogicalLockResult
+from .sixish import (
+    viewitems,
+    viewvalues,
+    )
 from .trace import (
     log_exception_quietly, note, mutter, mutter_callsite, warning)
 
@@ -141,7 +145,7 @@
             raise ValueError('Invalid value for %s: %r' % (context, text))
 
     def _validate_revprops(self, revprops):
-        for key, value in revprops.iteritems():
+        for key, value in viewitems(revprops):
             # We know that the XML serializers do not round trip '\r'
             # correctly, so refuse to accept them
             if not isinstance(value, basestring):
@@ -911,9 +915,8 @@
         :return: set of revisions that are parents of revision_ids which are
             not part of revision_ids themselves
         """
-        parent_map = self.get_parent_map(revision_ids)
-        parent_ids = set(itertools.chain.from_iterable(
-            parent_map.itervalues()))
+        parent_ids = set(itertools.chain.from_iterable(viewvalues(
+                self.get_parent_map(revision_ids))))
         parent_ids.difference_update(revision_ids)
         parent_ids.discard(_mod_revision.NULL_REVISION)
         return parent_ids
@@ -1053,8 +1056,8 @@
             else:
                 query_keys.append((revision_id ,))
         vf = self.revisions.without_fallbacks()
-        for ((revision_id,), parent_keys) in \
-                vf.get_parent_map(query_keys).iteritems():
+        for (revision_id,), parent_keys in viewitems(
+                vf.get_parent_map(query_keys)):
             if parent_keys:
                 result[revision_id] = tuple([parent_revid
                     for (parent_revid,) in parent_keys])
@@ -1747,7 +1750,7 @@
     # Filter ghosts, and null:
     if _mod_revision.NULL_REVISION in revision_graph:
         del revision_graph[_mod_revision.NULL_REVISION]
-    for key, parents in revision_graph.items():
+    for key, parents in viewitems(revision_graph):
         revision_graph[key] = tuple(parent for parent in parents if parent
             in revision_graph)
     return revision_graph
 
=== modified file 'breezy/revision.py'
--- breezy/revision.py	2017-05-30 19:16:23 +0000
+++ breezy/revision.py	2017-06-05 21:41:38 +0000
@@ -85,7 +85,7 @@
 
     def _check_properties(self):
         """Verify that all revision properties are OK."""
-        for name, value in self.properties.iteritems():
+        for name, value in self.properties.items():
             if not isinstance(name, basestring) or contains_whitespace(name):
                 raise ValueError("invalid property name %r" % name)
             if not isinstance(value, basestring):
 
=== modified file 'breezy/smart/bzrdir.py'
--- breezy/smart/bzrdir.py	2017-05-22 00:56:52 +0000
+++ breezy/smart/bzrdir.py	2017-06-05 21:41:38 +0000
@@ -441,7 +441,7 @@
         """
         branches = self._bzrdir.get_branches()
         ret = {}
-        for name, b in branches.iteritems():
+        for name, b in branches.items():
             if name is None:
                 name = ""
             ret[name] = ("branch", b._format.network_name())
 
=== modified file 'breezy/smart/client.py'
--- breezy/smart/client.py	2017-05-22 00:56:52 +0000
+++ breezy/smart/client.py	2017-06-05 21:41:38 +0000
@@ -339,7 +339,7 @@
         self.medium = medium
 
     def __repr__(self):
-        attrs = dict((k, v) for (k, v) in self.__dict__.iteritems()
+        attrs = dict((k, v) for k, v in self.__dict__.items()
                      if v is not None)
         return '<%s %r>' % (self.__class__.__name__, attrs)
 
 
=== modified file 'breezy/smtp_connection.py'
--- breezy/smtp_connection.py	2017-05-22 00:56:52 +0000
+++ breezy/smtp_connection.py	2017-06-05 21:41:38 +0000
@@ -183,7 +183,7 @@
                                       message.as_string())
         except smtplib.SMTPRecipientsRefused as e:
             raise SMTPError('server refused recipient: %d %s' %
-                    e.recipients.values()[0])
+                    next(iter(e.recipients.values())))
         except smtplib.SMTPResponseException as e:
             raise SMTPError('%d %s' % (e.smtp_code, e.smtp_error))
         except smtplib.SMTPException as e:
 
=== modified file 'breezy/tag.py'
--- breezy/tag.py	2017-05-30 19:16:23 +0000
+++ breezy/tag.py	2017-06-05 21:41:38 +0000
@@ -226,7 +226,7 @@
 
     def _serialize_tag_dict(self, tag_dict):
         td = dict((k.encode('utf-8'), v)
-                  for k,v in tag_dict.items())
+                  for k, v in tag_dict.items())
         return bencode.bencode(td)
 
     def _deserialize_tag_dict(self, tag_content):
@@ -324,7 +324,7 @@
         :param rename_map: Dictionary mapping old revids to new revids
         """
         reverse_tags = self.get_reverse_tag_dict()
-        for revid, names in reverse_tags.iteritems():
+        for revid, names in reverse_tags.items():
             if revid in rename_map:
                 for name in names:
                     self.set_tag(name, rename_map[revid])
 
=== modified file 'breezy/tests/per_branch/test_check.py'
--- breezy/tests/per_branch/test_check.py	2017-05-30 19:16:23 +0000
+++ breezy/tests/per_branch/test_check.py	2017-06-05 21:41:38 +0000
@@ -96,7 +96,7 @@
                     'unknown ref kind for ref %s' % ref)
         node_distances = branch.repository.get_graph().find_lefthand_distances(
             distances)
-        for key, distance in node_distances.iteritems():
+        for key, distance in node_distances.items():
             refs[('lefthand-distance', key)] = distance
             if key in existences and distance > 0:
                 refs[('revision-existence', key)] = True
 
=== modified file 'breezy/tests/per_bzrdir/test_bzrdir.py'
--- breezy/tests/per_bzrdir/test_bzrdir.py	2017-05-22 00:56:52 +0000
+++ breezy/tests/per_bzrdir/test_bzrdir.py	2017-06-05 21:41:38 +0000
@@ -160,7 +160,7 @@
                 self.assertEqual(text_index,
                     right_repo._generate_text_key_index())
                 desired_files = []
-                for file_id, revision_id in text_index.iterkeys():
+                for file_id, revision_id in text_index:
                     desired_files.append(
                         (file_id, revision_id, (file_id, revision_id)))
                 left_texts = [(identifier, "".join(bytes_iterator)) for
 
=== modified file 'breezy/tests/per_controldir/test_controldir.py'
--- breezy/tests/per_controldir/test_controldir.py	2017-05-24 16:33:08 +0000
+++ breezy/tests/per_controldir/test_controldir.py	2017-06-05 21:41:38 +0000
@@ -1250,7 +1250,7 @@
     def test_get_branches(self):
         repo = self.make_repository('branch-1')
         target_branch = repo.bzrdir.create_branch()
-        self.assertEqual([""], repo.bzrdir.get_branches().keys())
+        self.assertEqual([""], list(repo.bzrdir.get_branches()))
 
     def test_create_repository(self):
         # a bzrdir can construct a repository for itself.
 
=== modified file 'breezy/tests/per_controldir_colo/test_supported.py'
--- breezy/tests/per_controldir_colo/test_supported.py	2017-05-21 18:10:28 +0000
+++ breezy/tests/per_controldir_colo/test_supported.py	2017-06-05 21:41:38 +0000
@@ -131,7 +131,7 @@
     def test_get_branches(self):
         repo = self.make_repository('branch-1')
         target_branch = repo.bzrdir.create_branch(name='foo')
-        self.assertEqual(['foo'], repo.bzrdir.get_branches().keys())
+        self.assertEqual(['foo'], list(repo.bzrdir.get_branches()))
         self.assertEqual(target_branch.base,
                          repo.bzrdir.get_branches()['foo'].base)
 
@@ -142,7 +142,7 @@
         except errors.InvalidBranchName:
             raise tests.TestNotApplicable(
                 "format does not support branches with / in their name")
-        self.assertEqual(['foo/bar'], repo.bzrdir.get_branches().keys())
+        self.assertEqual(['foo/bar'], list(repo.bzrdir.get_branches()))
         self.assertEqual(
             target_branch.base, repo.bzrdir.open_branch(name='foo/bar').base)
 
 
=== modified file 'breezy/tests/per_controldir_colo/test_unsupported.py'
--- breezy/tests/per_controldir_colo/test_unsupported.py	2017-05-21 18:10:28 +0000
+++ breezy/tests/per_controldir_colo/test_unsupported.py	2017-06-05 21:41:38 +0000
@@ -79,5 +79,4 @@
     def test_get_branches(self):
         made_control = self.make_bzrdir_with_repo()
         made_control.create_branch()
-        self.assertEqual(made_control.get_branches().keys(),
-                         [""])
+        self.assertEqual(list(made_control.get_branches()), [""])
 
=== modified file 'breezy/tests/per_foreign_vcs/__init__.py'
--- breezy/tests/per_foreign_vcs/__init__.py	2017-05-23 14:08:03 +0000
+++ breezy/tests/per_foreign_vcs/__init__.py	2017-06-05 21:41:38 +0000
@@ -27,7 +27,7 @@
 
 def vcs_scenarios():
     scenarios = []
-    for name, vcs in foreign.foreign_vcs_registry.iteritems():
+    for name, vcs in foreign.foreign_vcs_registry.items():
         scenarios.append((vcs.__class__.__name__, {
             "branch_factory": vcs.branch_format.get_foreign_tests_branch_factory(),
             "repository_factory": vcs.repository_format.get_foreign_tests_repository_factory(),
 
=== modified file 'breezy/tests/per_pack_repository.py'
--- breezy/tests/per_pack_repository.py	2017-06-04 18:09:30 +0000
+++ breezy/tests/per_pack_repository.py	2017-06-05 21:41:38 +0000
@@ -253,10 +253,11 @@
                     repo.abort_write_group()
                     raise
                 else:
-                    old_names = repo._pack_collection._names.keys()
+                    old_names = set(repo._pack_collection._names)
                     result = repo.commit_write_group()
-                    cur_names = repo._pack_collection._names.keys()
-                    new_names = list(set(cur_names) - set(old_names))
+                    cur_names = set(repo._pack_collection._names)
+                    # In this test, len(result) is always 1, so unordered is ok
+                    new_names = list(cur_names - old_names)
                     self.assertEqual(new_names, result)
         finally:
             repo.unlock()
 
=== modified file 'breezy/tests/per_workingtree/test_parents.py'
--- breezy/tests/per_workingtree/test_parents.py	2017-05-22 00:56:52 +0000
+++ breezy/tests/per_workingtree/test_parents.py	2017-06-05 21:41:38 +0000
@@ -371,8 +371,8 @@
 
     def make_inv_delta(self, old, new):
         """Make an inventory delta from two inventories."""
-        old_ids = set(old._byid.iterkeys())
-        new_ids = set(new._byid.iterkeys())
+        old_ids = set(old._byid)
+        new_ids = set(new._byid)
         adds = new_ids - old_ids
         deletes = old_ids - new_ids
         common = old_ids.intersection(new_ids)
 
=== modified file 'breezy/tests/test_btree_index.py'
--- breezy/tests/test_btree_index.py	2017-06-04 18:09:30 +0000
+++ breezy/tests/test_btree_index.py	2017-06-05 21:41:38 +0000
@@ -643,7 +643,7 @@
         self.assertEqual(1, len(list(index.iter_entries([nodes[30][0]]))))
         self.assertEqual([1, 4], index._row_lengths)
         self.assertIsNot(None, index._root_node)
-        internal_node_pre_clear = index._internal_node_cache.keys()
+        internal_node_pre_clear = set(index._internal_node_cache)
         self.assertTrue(len(index._leaf_node_cache) > 0)
         index.clear_cache()
         # We don't touch _root_node or _internal_node_cache, both should be
@@ -655,7 +655,7 @@
         #       becuase without a 3-level index, we don't have any internal
         #       nodes cached.
         self.assertEqual(internal_node_pre_clear,
-                         index._internal_node_cache.keys())
+                         set(index._internal_node_cache))
         self.assertEqual(0, len(index._leaf_node_cache))
 
     def test_trivial_constructor(self):
@@ -737,7 +737,7 @@
         index = btree_index.BTreeGraphIndex(trans, 'index', None)
         del trans._activity[:]
         nodes = dict(index._read_nodes([0]))
-        self.assertEqual([0], nodes.keys())
+        self.assertEqual({0}, set(nodes))
         node = nodes[0]
         self.assertEqual([('key',)], node.all_keys())
         self.assertEqual([('get', 'index')], trans._activity)
 
=== modified file 'breezy/tests/test_bundle.py'
--- breezy/tests/test_bundle.py	2017-05-25 01:35:55 +0000
+++ breezy/tests/test_bundle.py	2017-06-05 21:41:38 +0000
@@ -105,7 +105,7 @@
         return self.ids[parent_dir]
 
     def iter_entries(self):
-        for path, file_id in self.ids.iteritems():
+        for path, file_id in self.ids.items():
             yield path, self[file_id]
 
     def kind(self, file_id):
 
=== modified file 'breezy/tests/test_fifo_cache.py'
--- breezy/tests/test_fifo_cache.py	2017-05-22 00:56:52 +0000
+++ breezy/tests/test_fifo_cache.py	2017-06-05 21:41:38 +0000
@@ -20,6 +20,11 @@
     fifo_cache,
     tests,
     )
+from ..sixish import (
+    viewitems,
+    viewkeys,
+    viewvalues,
+    )
 
 
 class TestFIFOCache(tests.TestCase):
@@ -33,12 +38,10 @@
         self.assertEqual(2, c[1])
         self.assertEqual(2, c.get(1))
         self.assertEqual(2, c.get(1, None))
-        self.assertEqual([1], c.keys())
-        self.assertEqual([1], list(c.iterkeys()))
-        self.assertEqual([(1, 2)], c.items())
-        self.assertEqual([(1, 2)], list(c.iteritems()))
-        self.assertEqual([2], c.values())
-        self.assertEqual([2], list(c.itervalues()))
+        self.assertEqual([1], list(c))
+        self.assertEqual({1}, viewkeys(c))
+        self.assertEqual([(1, 2)], sorted(viewitems(c)))
+        self.assertEqual([2], sorted(viewvalues(c)))
         self.assertEqual({1: 2}, c)
 
     def test_cache_size(self):
@@ -54,12 +57,10 @@
         self.assertEqual(0, len(c))
         self.assertEqual(None, c.get(1))
         self.assertEqual(None, c.get(1, None))
-        self.assertEqual([], c.keys())
-        self.assertEqual([], list(c.iterkeys()))
-        self.assertEqual([], c.items())
-        self.assertEqual([], list(c.iteritems()))
-        self.assertEqual([], c.values())
-        self.assertEqual([], list(c.itervalues()))
+        self.assertEqual([], list(c))
+        self.assertEqual(set(), viewkeys(c))
+        self.assertEqual([], list(viewitems(c)))
+        self.assertEqual([], list(viewvalues(c)))
         self.assertEqual({}, c)
 
     def test_add_maintains_fifo(self):
@@ -68,16 +69,16 @@
         c[2] = 3
         c[3] = 4
         c[4] = 5
-        self.assertEqual([1, 2, 3, 4], sorted(c.keys()))
+        self.assertEqual({1, 2, 3, 4}, viewkeys(c))
         c[5] = 6
         # This should pop out the oldest entry
-        self.assertEqual([2, 3, 4, 5], sorted(c.keys()))
+        self.assertEqual({2, 3, 4, 5}, viewkeys(c))
         # Replacing an item doesn't change the stored keys
         c[2] = 7
-        self.assertEqual([2, 3, 4, 5], sorted(c.keys()))
+        self.assertEqual({2, 3, 4, 5}, viewkeys(c))
         # But it does change the position in the FIFO
         c[6] = 7
-        self.assertEqual([2, 4, 5, 6], sorted(c.keys()))
+        self.assertEqual({2, 4, 5, 6}, viewkeys(c))
         self.assertEqual([4, 5, 2, 6], list(c._queue))
 
     def test_default_after_cleanup_count(self):
@@ -89,10 +90,10 @@
         c[4] = 5
         c[5] = 6
         # So far, everything fits
-        self.assertEqual([1, 2, 3, 4, 5], sorted(c.keys()))
+        self.assertEqual({1, 2, 3, 4, 5}, viewkeys(c))
         c[6] = 7
         # But adding one more should shrink down to after_cleanup_count
-        self.assertEqual([3, 4, 5, 6], sorted(c.keys()))
+        self.assertEqual({3, 4, 5, 6}, viewkeys(c))
 
     def test_clear(self):
         c = fifo_cache.FIFOCache(5)
@@ -102,9 +103,9 @@
         c[4] = 5
         c[5] = 6
         c.cleanup()
-        self.assertEqual([2, 3, 4, 5], sorted(c.keys()))
+        self.assertEqual({2, 3, 4, 5}, viewkeys(c))
         c.clear()
-        self.assertEqual([], c.keys())
+        self.assertEqual(set(), viewkeys(c))
         self.assertEqual([], list(c._queue))
         self.assertEqual({}, c)
 
@@ -246,12 +247,10 @@
         self.assertEqual('2', c[1])
         self.assertEqual('2', c.get(1))
         self.assertEqual('2', c.get(1, None))
-        self.assertEqual([1], c.keys())
-        self.assertEqual([1], list(c.iterkeys()))
-        self.assertEqual([(1, '2')], c.items())
-        self.assertEqual([(1, '2')], list(c.iteritems()))
-        self.assertEqual(['2'], c.values())
-        self.assertEqual(['2'], list(c.itervalues()))
+        self.assertEqual([1], list(c))
+        self.assertEqual({1}, viewkeys(c))
+        self.assertEqual([(1, '2')], sorted(viewitems(c)))
+        self.assertEqual(['2'], sorted(viewvalues(c)))
         self.assertEqual({1: '2'}, c)
         self.assertEqual(1024*1024, c.cache_size())
 
@@ -262,12 +261,10 @@
         self.assertEqual(0, len(c))
         self.assertEqual(None, c.get(1))
         self.assertEqual(None, c.get(1, None))
-        self.assertEqual([], c.keys())
-        self.assertEqual([], list(c.iterkeys()))
-        self.assertEqual([], c.items())
-        self.assertEqual([], list(c.iteritems()))
-        self.assertEqual([], c.values())
-        self.assertEqual([], list(c.itervalues()))
+        self.assertEqual([], list(c))
+        self.assertEqual(set(), viewkeys(c))
+        self.assertEqual([], list(viewitems(c)))
+        self.assertEqual([], list(viewvalues(c)))
         self.assertEqual({}, c)
 
     def test_add_maintains_fifo(self):
 
=== modified file 'breezy/tests/test_graph.py'
--- breezy/tests/test_graph.py	2017-05-25 01:35:55 +0000
+++ breezy/tests/test_graph.py	2017-06-05 21:41:38 +0000
@@ -497,7 +497,7 @@
         """
         pending = [NULL_REVISION]
         descendants = {}
-        for descendant, parents in ancestors.iteritems():
+        for descendant, parents in ancestors.items():
             for parent in parents:
                 descendants.setdefault(parent, []).append(descendant)
         while len(pending) > 0:
 
=== modified file 'breezy/tests/test_groupcompress.py'
--- breezy/tests/test_groupcompress.py	2017-06-04 18:09:30 +0000
+++ breezy/tests/test_groupcompress.py	2017-06-05 21:41:38 +0000
@@ -304,7 +304,7 @@
         for key in sorted(key_to_text):
             compressor.compress(key, key_to_text[key], None)
         locs = dict((key, (start, end)) for key, (start, _, end, _)
-                    in compressor.labels_deltas.iteritems())
+                    in compressor.labels_deltas.items())
         block = compressor.flush()
         raw_bytes = block.to_bytes()
         # Go through from_bytes(to_bytes()) so that we start with a compressed
@@ -961,7 +961,7 @@
         for key in sorted(key_to_text):
             compressor.compress(key, key_to_text[key], None)
         locs = dict((key, (start, end)) for key, (start, _, end, _)
-                    in compressor.labels_deltas.iteritems())
+                    in compressor.labels_deltas.items())
         block = compressor.flush()
         raw_bytes = block.to_bytes()
         return locs, groupcompress.GroupCompressBlock.from_bytes(raw_bytes)
 
=== modified file 'breezy/tests/test_inv.py'
--- breezy/tests/test_inv.py	2017-05-22 00:56:52 +0000
+++ breezy/tests/test_inv.py	2017-06-05 21:41:38 +0000
@@ -939,7 +939,7 @@
         new_inv = CHKInventory.deserialise(chk_bytes, bytes, ("revid",))
         root_entry = new_inv[inv.root.file_id]
         self.assertEqual(None, root_entry._children)
-        self.assertEqual(['file'], root_entry.children.keys())
+        self.assertEqual({'file'}, set(root_entry.children))
         file_direct = new_inv["fileid"]
         file_found = root_entry.children['file']
         self.assertEqual(file_direct.kind, file_found.kind)
@@ -1472,9 +1472,9 @@
             s = expected_children.setdefault(entry.parent_id, [])
             s.append(entry.file_id)
         val_children = dict((k, sorted(v)) for k, v
-                            in val_children.iteritems())
+                            in val_children.items())
         expected_children = dict((k, sorted(v)) for k, v
-                            in expected_children.iteritems())
+                            in expected_children.items())
         self.assertEqual(expected_children, val_children)
 
     def test_make_simple_inventory(self):
 
=== modified file 'breezy/tests/test_knit.py'
--- breezy/tests/test_knit.py	2017-05-25 01:35:55 +0000
+++ breezy/tests/test_knit.py	2017-06-05 21:41:38 +0000
@@ -626,7 +626,7 @@
             self.fail('Annotation was not identical with reloading.')
         # Now delete the packs-in-use, which should trigger another reload, but
         # this time we just raise an exception because we can't recover
-        for trans, name in vf._access._indices.itervalues():
+        for trans, name in vf._access._indices.values():
             trans.delete(name)
         self.assertRaises(errors.NoSuchFile, vf.annotate, key)
         self.assertEqual([2, 1, 1], reload_counter)
@@ -639,7 +639,7 @@
         self.assertEqual([1, 1, 0], reload_counter)
         # Now delete the packs-in-use, which should trigger another reload, but
         # this time we just raise an exception because we can't recover
-        for trans, name in vf._access._indices.itervalues():
+        for trans, name in vf._access._indices.values():
             trans.delete(name)
         self.assertRaises(errors.NoSuchFile, vf._get_record_map, keys)
         self.assertEqual([2, 1, 1], reload_counter)
@@ -658,7 +658,7 @@
         self.assertEqual(('rev-3',), record.key)
         self.assertEqual([1, 1, 0], reload_counter)
         # Now delete all pack files, and see that we raise the right error
-        for trans, name in vf._access._indices.itervalues():
+        for trans, name in vf._access._indices.values():
             trans.delete(name)
         self.assertListRaises(errors.NoSuchFile,
             vf.get_record_stream, keys, 'topological', False)
@@ -682,7 +682,7 @@
         self.assertEqual(plain_lines, reload_lines)
         self.assertEqual(21, len(plain_lines))
         # Now delete all pack files, and see that we raise the right error
-        for trans, name in vf._access._indices.itervalues():
+        for trans, name in vf._access._indices.values():
             trans.delete(name)
         self.assertListRaises(errors.NoSuchFile,
             vf.iter_lines_added_or_present_in_keys, keys)
 
=== modified file 'breezy/tests/test_merge.py'
--- breezy/tests/test_merge.py	2017-05-22 00:56:52 +0000
+++ breezy/tests/test_merge.py	2017-06-05 21:41:38 +0000
@@ -1043,7 +1043,7 @@
 
     def assertPruneTails(self, pruned_map, tails, parent_map):
         child_map = {}
-        for key, parent_keys in parent_map.iteritems():
+        for key, parent_keys in parent_map.items():
             child_map.setdefault(key, [])
             for pkey in parent_keys:
                 child_map.setdefault(pkey, []).append(key)
 
=== modified file 'breezy/tests/test_merge_core.py'
--- breezy/tests/test_merge_core.py	2017-05-22 00:56:52 +0000
+++ breezy/tests/test_merge_core.py	2017-06-05 21:41:38 +0000
@@ -179,7 +179,7 @@
 
     def apply_inv_change(self, inventory_change, orig_inventory):
         orig_inventory_by_path = {}
-        for file_id, path in orig_inventory.iteritems():
+        for file_id, path in orig_inventory.items():
             orig_inventory_by_path[path] = file_id
 
         def parent_id(file_id):
@@ -203,13 +203,13 @@
                 return pathjoin(dirname, os.path.basename(orig_inventory[file_id]))
 
         new_inventory = {}
-        for file_id in orig_inventory.iterkeys():
+        for file_id in orig_inventory:
             path = new_path(file_id)
             if path is None:
                 continue
             new_inventory[file_id] = path
 
-        for file_id, path in inventory_change.iteritems():
+        for file_id, path in inventory_change.items():
             if file_id in orig_inventory:
                 continue
             new_inventory[file_id] = path
 
=== modified file 'breezy/tests/test_remote.py'
--- breezy/tests/test_remote.py	2017-05-30 19:16:23 +0000
+++ breezy/tests/test_remote.py	2017-06-05 21:41:38 +0000
@@ -3928,13 +3928,13 @@
         # the public implementation of get_parent_map obeys stacking
         _, branch = self.prepare_stacked_remote_branch()
         repo = branch.repository
-        self.assertEqual(['rev1'], repo.get_parent_map(['rev1']).keys())
+        self.assertEqual({'rev1'}, set(repo.get_parent_map(['rev1'])))
 
     def test_unstacked_get_parent_map(self):
         # _unstacked_provider.get_parent_map ignores stacking
         _, branch = self.prepare_stacked_remote_branch()
         provider = branch.repository._unstacked_provider
-        self.assertEqual([], provider.get_parent_map(['rev1']).keys())
+        self.assertEqual(set(), set(provider.get_parent_map(['rev1'])))
 
     def fetch_stream_to_rev_order(self, stream):
         result = []
 
=== modified file 'breezy/tests/test_versionedfile.py'
--- breezy/tests/test_versionedfile.py	2017-05-25 01:35:55 +0000
+++ breezy/tests/test_versionedfile.py	2017-06-05 21:41:38 +0000
@@ -94,9 +94,9 @@
         # such, it should end up in the various caches
         gen._process_one_record(record.key, record.get_bytes_as('chunked'))
         # The chunks should be cached, the refcount untouched
-        self.assertEqual([('one',)], gen.chunks.keys())
+        self.assertEqual({('one',)}, set(gen.chunks))
         self.assertEqual({('one',): 2, ('two',): 1}, gen.refcounts)
-        self.assertEqual([], gen.diffs.keys())
+        self.assertEqual(set(), set(gen.diffs))
         # Next we get 'two', which is something we output, but also needed for
         # three
         record = next(stream)
@@ -105,10 +105,9 @@
         # Both are now cached, and the diff for two has been extracted, and
         # one's refcount has been updated. two has been removed from the
         # parent_map
-        self.assertEqual(sorted([('one',), ('two',)]),
-                         sorted(gen.chunks.keys()))
+        self.assertEqual({('one',), ('two',)}, set(gen.chunks))
         self.assertEqual({('one',): 1, ('two',): 1}, gen.refcounts)
-        self.assertEqual([('two',)], gen.diffs.keys())
+        self.assertEqual({('two',)}, set(gen.diffs))
         self.assertEqual({('three',): (('one',), ('two',))},
                          gen.parent_map)
         # Finally 'three', which allows us to remove all parents from the
@@ -118,10 +117,9 @@
         gen._process_one_record(record.key, record.get_bytes_as('chunked'))
         # Both are now cached, and the diff for two has been extracted, and
         # one's refcount has been updated
-        self.assertEqual([], gen.chunks.keys())
+        self.assertEqual(set(), set(gen.chunks))
         self.assertEqual({}, gen.refcounts)
-        self.assertEqual(sorted([('two',), ('three',)]),
-                         sorted(gen.diffs.keys()))
+        self.assertEqual({('two',), ('three',)}, set(gen.diffs))
 
     def test_compute_diffs(self):
         vf = self.make_three_vf()
 
=== modified file 'breezy/transform.py'
--- breezy/transform.py	2017-05-30 19:32:13 +0000
+++ breezy/transform.py	2017-06-05 21:41:38 +0000
@@ -61,6 +61,10 @@
     splitpath,
     )
 from .progress import ProgressPhase
+from .sixish import (
+    viewitems,
+    viewvalues,
+    )
 
 
 ROOT_PARENT = "root-parent"
@@ -228,8 +232,8 @@
         irrelevant.
 
         """
-        new_roots = [k for k, v in self._new_parent.iteritems() if v ==
-                     ROOT_PARENT]
+        new_roots = [k for k, v in viewitems(self._new_parent)
+                     if v == ROOT_PARENT]
         if len(new_roots) < 1:
             return
         if len(new_roots) != 1:
@@ -479,7 +483,7 @@
         file_id = self.tree_file_id(trans_id)
         if file_id is not None:
             return file_id
-        for key, value in self._non_present_ids.iteritems():
+        for key, value in viewitems(self._non_present_ids):
             if value == trans_id:
                 return key
 
@@ -509,9 +513,9 @@
         Only new paths and parents of tree files with assigned ids are used.
         """
         by_parent = {}
-        items = list(self._new_parent.iteritems())
-        items.extend((t, self.final_parent(t)) for t in
-                      self._tree_id_paths.keys())
+        items = list(viewitems(self._new_parent))
+        items.extend((t, self.final_parent(t))
+            for t in list(self._tree_id_paths))
         for trans_id, parent_id in items:
             if parent_id not in by_parent:
                 by_parent[parent_id] = set()
@@ -555,7 +559,7 @@
         Active parents are those which gain children, and those which are
         removed.  This is a necessary first step in detecting conflicts.
         """
-        parents = self.by_parent().keys()
+        parents = list(self.by_parent())
         parents.extend([t for t in self._removed_contents if
                         self.tree_kind(t) == 'directory'])
         for trans_id in self._removed_id:
@@ -634,7 +638,7 @@
     def _unversioned_parents(self, by_parent):
         """If parent directories are versioned, children must be versioned."""
         conflicts = []
-        for parent_id, children in by_parent.iteritems():
+        for parent_id, children in viewitems(by_parent):
             if parent_id == ROOT_PARENT:
                 continue
             if self.final_file_id(parent_id) is not None:
@@ -651,7 +655,7 @@
         However, existing entries with no contents are okay.
         """
         conflicts = []
-        for trans_id in self._new_id.iterkeys():
+        for trans_id in self._new_id:
             kind = self.final_kind(trans_id)
             if kind is None:
                 conflicts.append(('versioning no contents', trans_id))
@@ -693,7 +697,7 @@
         conflicts = []
         if (self._new_name, self._new_parent) == ({}, {}):
             return conflicts
-        for children in by_parent.itervalues():
+        for children in viewvalues(by_parent):
             name_ids = []
             for child_tid in children:
                 name = self.final_name(child_tid)
@@ -724,7 +728,7 @@
                                 self._removed_id))
         all_ids = self._tree.all_file_ids()
         active_tree_ids = all_ids.difference(removed_tree_ids)
-        for trans_id, file_id in self._new_id.iteritems():
+        for trans_id, file_id in viewitems(self._new_id):
             if file_id in active_tree_ids:
                 old_trans_id = self.trans_id_tree_file_id(file_id)
                 conflicts.append(('duplicate id', old_trans_id, trans_id))
@@ -733,7 +737,7 @@
     def _parent_type_conflicts(self, by_parent):
         """Children must have a directory parent"""
         conflicts = []
-        for parent_id, children in by_parent.iteritems():
+        for parent_id, children in viewitems(by_parent):
             if parent_id == ROOT_PARENT:
                 continue
             no_children = True
@@ -868,12 +872,12 @@
     def _affected_ids(self):
         """Return the set of transform ids affected by the transform"""
         trans_ids = set(self._removed_id)
-        trans_ids.update(self._new_id.keys())
+        trans_ids.update(self._new_id)
         trans_ids.update(self._removed_contents)
-        trans_ids.update(self._new_contents.keys())
-        trans_ids.update(self._new_executability.keys())
-        trans_ids.update(self._new_name.keys())
-        trans_ids.update(self._new_parent.keys())
+        trans_ids.update(self._new_contents)
+        trans_ids.update(self._new_executability)
+        trans_ids.update(self._new_name)
+        trans_ids.update(self._new_parent)
         return trans_ids
 
     def _get_file_id_maps(self):
@@ -953,7 +957,7 @@
         from_trans_ids, to_trans_ids = self._get_file_id_maps()
         results = []
         # Now iterate through all active file_ids
-        for file_id in set(from_trans_ids.keys() + to_trans_ids.keys()):
+        for file_id in set(from_trans_ids).union(to_trans_ids):
             modified = False
             from_trans_id = from_trans_ids.get(file_id)
             # find file ids, and determine versioning state
@@ -1096,11 +1100,11 @@
         :param serializer: A Serialiser like pack.ContainerSerializer.
         """
         new_name = dict((k, v.encode('utf-8')) for k, v in
-                        self._new_name.items())
+                        viewitems(self._new_name))
         new_executability = dict((k, int(v)) for k, v in
-                                 self._new_executability.items())
+                                 viewitems(self._new_executability))
         tree_path_ids = dict((k.encode('utf-8'), v)
-                             for k, v in self._tree_path_ids.items())
+                             for k, v in viewitems(self._tree_path_ids))
         attribs = {
             '_id_number': self._id_number,
             '_new_name': new_name,
@@ -1114,7 +1118,7 @@
             }
         yield serializer.bytes_record(bencode.bencode(attribs),
                                       (('attribs',),))
-        for trans_id, kind in self._new_contents.items():
+        for trans_id, kind in viewitems(self._new_contents):
             if kind == 'file':
                 lines = osutils.chunks_to_lines(
                     self._read_file_chunks(trans_id))
@@ -1137,15 +1141,15 @@
         attribs = bencode.bdecode(content)
         self._id_number = attribs['_id_number']
         self._new_name = dict((k, v.decode('utf-8'))
-                            for k, v in attribs['_new_name'].items())
+                              for k, v in viewitems(attribs['_new_name']))
         self._new_parent = attribs['_new_parent']
-        self._new_executability = dict((k, bool(v)) for k, v in
-            attribs['_new_executability'].items())
+        self._new_executability = dict((k, bool(v))
+            for k, v in viewitems(attribs['_new_executability']))
         self._new_id = attribs['_new_id']
-        self._r_new_id = dict((v, k) for k, v in self._new_id.items())
+        self._r_new_id = dict((v, k) for k, v in viewitems(self._new_id))
         self._tree_path_ids = {}
         self._tree_id_paths = {}
-        for bytepath, trans_id in attribs['_tree_path_ids'].items():
+        for bytepath, trans_id in viewitems(attribs['_tree_path_ids']):
             path = bytepath.decode('utf-8')
             self._tree_path_ids[path] = trans_id
             self._tree_id_paths[trans_id] = path
@@ -1201,9 +1205,9 @@
         if self._tree is None:
             return
         try:
-            limbo_paths = self._limbo_files.values() + list(
-                self._possibly_stale_limbo_files)
-            limbo_paths = sorted(limbo_paths, reverse=True)
+            limbo_paths = list(viewvalues(self._limbo_files))
+            limbo_paths.extend(self._possibly_stale_limbo_files)
+            limbo_paths.sort(reverse=True)
             for path in limbo_paths:
                 try:
                     delete_any(path)
@@ -1676,8 +1680,8 @@
                         in (trans_id, None)):
                         use_direct_path = True
                 else:
-                    for l_filename, l_trans_id in\
-                        self._limbo_children_names[parent].iteritems():
+                    for l_filename, l_trans_id in viewitems(
+                            self._limbo_children_names[parent]):
                         if l_trans_id == trans_id:
                             continue
                         if l_filename.lower() == filename.lower():
@@ -1767,7 +1771,7 @@
             new_path_file_ids = dict((t, self.final_file_id(t)) for p, t in
                                      new_paths)
             entries = self._tree.iter_entries_by_dir(
-                new_path_file_ids.values())
+                viewvalues(new_path_file_ids))
             old_paths = dict((e.file_id, p) for p, e in entries)
             final_kinds = {}
             for num, (path, trans_id) in enumerate(new_paths):
@@ -1814,8 +1818,7 @@
 
         If inventory_delta is None, no inventory delta generation is performed.
         """
-        tree_paths = list(self._tree_path_ids.iteritems())
-        tree_paths.sort(reverse=True)
+        tree_paths = sorted(viewitems(self._tree_path_ids), reverse=True)
         child_pb = ui.ui_factory.nested_progress_bar()
         try:
             for num, (path, trans_id) in enumerate(tree_paths):
@@ -1907,7 +1910,7 @@
         #       problems. (we could observe start time, and finish time, and if
         #       it is less than eg 10% overhead, add a sleep call.)
         paths = FinalPaths(self)
-        for trans_id, observed in self._observed_sha1s.iteritems():
+        for trans_id, observed in viewitems(self._observed_sha1s):
             path = paths.get_path(trans_id)
             # We could get the file_id, but dirstate prefers to use the path
             # anyway, and it is 'cheaper' to determine.
@@ -2057,7 +2060,7 @@
         tree_ids = set(self._transform._tree.all_file_ids())
         tree_ids.difference_update(self._transform.tree_file_id(t)
                                    for t in self._transform._removed_id)
-        tree_ids.update(self._transform._new_id.values())
+        tree_ids.update(viewvalues(self._transform._new_id))
         return tree_ids
 
     def __iter__(self):
@@ -2120,7 +2123,7 @@
             return children
         children = set(self._transform.iter_tree_children(trans_id))
         # children in the _new_parent set are provided by _by_parent.
-        children.difference_update(self._transform._new_parent.keys())
+        children.difference_update(self._transform._new_parent)
         children.update(self._by_parent.get(trans_id, []))
         self._all_children_cache[trans_id] = children
         return children
 
=== modified file 'breezy/transport/http/_urllib2_wrappers.py'
--- breezy/transport/http/_urllib2_wrappers.py	2017-06-01 23:13:43 +0000
+++ breezy/transport/http/_urllib2_wrappers.py	2017-06-05 21:41:38 +0000
@@ -190,7 +190,7 @@
     def getheaders(self):
         if self.headers is None:
             raise httplib.ResponseNotReady()
-        return self.headers.items()
+        return list(self.headers.items())
 
 
 class _ReportingFileSocket(object):
@@ -761,7 +761,7 @@
         # before sending the request. And not all versions of python 2.5 do
         # that. Since we replace urllib2.AbstractHTTPHandler.do_open we do it
         # ourself below.
-        headers = dict((name.title(), val) for name, val in headers.iteritems())
+        headers = dict((name.title(), val) for name, val in headers.items())
 
         try:
             method = request.get_method()
@@ -774,7 +774,7 @@
             if 'http' in debug.debug_flags:
                 trace.mutter('> %s %s' % (method, url))
                 hdrs = []
-                for k,v in headers.iteritems():
+                for k,v in headers.items():
                     # People are often told to paste -Dhttp output to help
                     # debug. Don't compromise credentials.
                     if k in ('Authorization', 'Proxy-Authorization'):
 
=== modified file 'breezy/transport/ssh.py'
--- breezy/transport/ssh.py	2017-05-22 00:56:52 +0000
+++ breezy/transport/ssh.py	2017-06-05 21:41:38 +0000
@@ -629,8 +629,8 @@
     try:
         f = open(bzr_hostkey_path, 'w')
         f.write('# SSH host keys collected by bzr\n')
-        for hostname, keys in BRZ_HOSTKEYS.iteritems():
-            for keytype, key in keys.iteritems():
+        for hostname, keys in BRZ_HOSTKEYS.items():
+            for keytype, key in keys.items():
                 f.write('%s %s %s\n' % (hostname, keytype, key.get_base64()))
         f.close()
     except IOError as e:
 
=== modified file 'breezy/tree.py'
--- breezy/tree.py	2017-06-04 18:09:30 +0000
+++ breezy/tree.py	2017-06-05 21:41:38 +0000
@@ -42,6 +42,9 @@
 
 from .decorators import needs_read_lock
 from .inter import InterObject
+from .sixish import (
+    viewvalues,
+    )
 
 
 class Tree(object):
@@ -864,12 +867,12 @@
     @needs_read_lock
     def iter_child_entries(self, file_id, path=None):
         inv, inv_file_id = self._unpack_file_id(file_id)
-        return inv[inv_file_id].children.itervalues()
+        return iter(viewvalues(inv[inv_file_id].children))
 
     def iter_children(self, file_id, path=None):
         """See Tree.iter_children."""
         entry = self.iter_entries_by_dir([file_id]).next()[1]
-        for child in getattr(entry, 'children', {}).itervalues():
+        for child in viewvalues(getattr(entry, 'children', {})):
             yield child.file_id
 
 
@@ -1592,7 +1595,7 @@
         #       might ensure better ordering, in case a caller strictly
         #       requires parents before children.
         for idx, other_extra in enumerate(self._others_extra):
-            others = sorted(other_extra.itervalues(),
+            others = sorted(viewvalues(other_extra),
                             key=lambda x: self._path_to_key(x[0]))
             for other_path, other_ie in others:
                 file_id = other_ie.file_id
 
=== modified file 'breezy/tsort.py'
--- breezy/tsort.py	2017-05-22 00:56:52 +0000
+++ breezy/tsort.py	2017-06-05 21:41:38 +0000
@@ -363,7 +363,7 @@
         # we need to do a check late in the process to detect end-of-merges
         # which requires the parents to be accessible: its easier for now
         # to just keep the original graph around.
-        self._original_graph = dict(self._graph.items())
+        self._original_graph = self._graph.copy()
         # we need to know the revision numbers of revisions to determine
         # the revision numbers of their descendants
         # this is a graph from node to [revno_tuple, first_child]
 
=== modified file 'breezy/uncommit.py'
--- breezy/uncommit.py	2017-05-22 00:56:52 +0000
+++ breezy/uncommit.py	2017-06-05 21:41:38 +0000
@@ -40,7 +40,7 @@
     reverse_tags = branch.tags.get_reverse_tag_dict()
     ancestors = graph.find_unique_ancestors(old_tip, parents)
     removed_tags = []
-    for revid, tags in reverse_tags.iteritems():
+    for revid, tags in reverse_tags.items():
         if not revid in ancestors:
             continue
         for tag in tags:
 
=== modified file 'breezy/urlutils.py'
--- breezy/urlutils.py	2017-06-04 18:09:30 +0000
+++ breezy/urlutils.py	2017-06-05 21:41:38 +0000
@@ -578,7 +578,7 @@
     (base, existing_parameters) = split_segment_parameters(url)
     new_parameters = {}
     new_parameters.update(existing_parameters)
-    for key, value in parameters.iteritems():
+    for key, value in parameters.items():
         if not isinstance(key, str):
             raise TypeError("parameter key %r is not a bytestring" % key)
         if not isinstance(value, str):
 
=== modified file 'breezy/versionedfile.py'
--- breezy/versionedfile.py	2017-05-25 21:59:11 +0000
+++ breezy/versionedfile.py	2017-06-05 21:41:38 +0000
@@ -44,6 +44,8 @@
 from .registry import Registry
 from .sixish import (
     BytesIO,
+    viewitems,
+    viewvalues,
     zip,
     )
 from .textmerge import TextMerge
@@ -250,7 +252,7 @@
         refcounts = {}
         setdefault = refcounts.setdefault
         just_parents = set()
-        for child_key, parent_keys in parent_map.iteritems():
+        for child_key, parent_keys in viewitems(parent_map):
             if not parent_keys:
                 # parent_keys may be None if a given VersionedFile claims to
                 # not support graph operations.
@@ -491,7 +493,7 @@
             except KeyError:
                 raise errors.RevisionNotPresent(version_id, self)
         # We need to filter out ghosts, because we can't diff against them.
-        knit_versions = set(self.get_parent_map(knit_versions).keys())
+        knit_versions = set(self.get_parent_map(knit_versions))
         lines = dict(zip(knit_versions,
             self._get_lf_split_line_list(knit_versions)))
         diffs = []
@@ -535,7 +537,7 @@
         for version, parent_ids, expected_sha1, mpdiff in records:
             needed_parents.update(p for p in parent_ids
                                   if not mpvf.has_version(p))
-        present_parents = set(self.get_parent_map(needed_parents).keys())
+        present_parents = set(self.get_parent_map(needed_parents))
         for parent_id, lines in zip(present_parents,
                 self._get_lf_split_line_list(present_parents)):
             mpvf.add_version(lines, parent_id, [])
@@ -1095,7 +1097,7 @@
             this_parent_map = self.get_parent_map(pending)
             parent_map.update(this_parent_map)
             pending = set(itertools.chain.from_iterable(
-                this_parent_map.itervalues()))
+                viewvalues(this_parent_map)))
             pending.difference_update(parent_map)
         kg = _mod_graph.KnownGraph(parent_map)
         return kg
@@ -1297,11 +1299,11 @@
         """
         prefixes = self._partition_keys(keys)
         result = {}
-        for prefix, suffixes in prefixes.items():
+        for prefix, suffixes in viewitems(prefixes):
             path = self._mapper.map(prefix)
             vf = self._get_vf(path)
             parent_map = vf.get_parent_map(suffixes)
-            for key, parents in parent_map.items():
+            for key, parents in viewitems(parent_map):
                 result[prefix + (key,)] = tuple(
                     prefix + (parent,) for parent in parents)
         return result
@@ -1353,7 +1355,7 @@
     def _iter_keys_vf(self, keys):
         prefixes = self._partition_keys(keys)
         sha1s = {}
-        for prefix, suffixes in prefixes.items():
+        for prefix, suffixes in viewitems(prefixes):
             path = self._mapper.map(prefix)
             vf = self._get_vf(path)
             yield prefix, suffixes, vf
@@ -1363,7 +1365,7 @@
         sha1s = {}
         for prefix,suffixes, vf in self._iter_keys_vf(keys):
             vf_sha1s = vf.get_sha1s(suffixes)
-            for suffix, sha1 in vf_sha1s.iteritems():
+            for suffix, sha1 in viewitems(vf_sha1s):
                 sha1s[prefix + (suffix,)] = sha1
         return sha1s
 
@@ -1553,7 +1555,7 @@
         result.update(
             _mod_graph.StackedParentsProvider(
                 self._providers).get_parent_map(keys))
-        for key, parents in result.iteritems():
+        for key, parents in viewitems(result):
             if parents == ():
                 result[key] = (revision.NULL_REVISION,)
         return result
@@ -1732,8 +1734,8 @@
 
     def get_parent_map(self, keys):
         """See VersionedFiles.get_parent_map."""
-        return dict([((k,), tuple([(p,) for p in v]))
-            for k,v in self._get_parent_map([k for (k,) in keys]).iteritems()])
+        parent_view = viewitems(self._get_parent_map(k for (k,) in keys))
+        return dict(((k,), tuple((p,) for p in v)) for k, v in parent_view)
 
     def get_sha1s(self, keys):
         """See VersionedFiles.get_sha1s."""
@@ -1889,7 +1891,7 @@
     # gc-optimal ordering is approximately reverse topological,
     # properly grouped by file-id.
     per_prefix_map = {}
-    for item in parent_map.iteritems():
+    for item in viewitems(parent_map):
         key = item[0]
         if isinstance(key, str) or len(key) == 1:
             prefix = ''
@@ -1936,9 +1938,9 @@
 
     def get_new_keys(self):
         return self.new_keys
-    
+
     def get_unsatisfied_refs(self):
-        return self.refs.iterkeys()
+        return self.refs.keys()
 
     def _satisfy_refs_for_key(self, key):
         try:
@@ -1958,10 +1960,7 @@
             self._satisfy_refs_for_key(key)
 
     def get_referrers(self):
-        result = set()
-        for referrers in self.refs.itervalues():
-            result.update(referrers)
-        return result
+        return set(itertools.chain.from_iterable(viewvalues(self.refs)))
 
 
 
 
=== modified file 'breezy/vf_repository.py'
--- breezy/vf_repository.py	2017-06-04 18:09:30 +0000
+++ breezy/vf_repository.py	2017-06-05 21:41:38 +0000
@@ -75,6 +75,8 @@
 
 from .sixish import (
     range,
+    viewitems,
+    viewvalues,
     )
 
 from .trace import (
@@ -434,7 +436,7 @@
         # XXX: Friction: parent_candidates should return a list not a dict
         #      so that we don't have to walk the inventories again.
         parent_candidate_entries = ie.parent_candidates(parent_invs)
-        head_set = self._heads(ie.file_id, parent_candidate_entries.keys())
+        head_set = self._heads(ie.file_id, parent_candidate_entries)
         heads = []
         for inv in parent_invs:
             if inv.has_id(ie.file_id):
@@ -692,12 +694,12 @@
         seen_root = False # Is the root in the basis delta?
         inv_delta = self._basis_delta
         modified_rev = self._new_revision_id
-        for change, head_candidates in changes.values():
+        for change, head_candidates in viewvalues(changes):
             if change[3][1]: # versioned in target.
                 # Several things may be happening here:
                 # We may have a fork in the per-file graph
                 #  - record a change with the content from tree
-                # We may have a change against < all trees  
+                # We may have a change against < all trees
                 #  - carry over the tree that hasn't changed
                 # We may have a change against all trees
                 #  - record the change with the content from tree
@@ -1196,7 +1198,7 @@
         graph = self.get_graph()
         parent_map = graph.get_parent_map(revision_ids)
         # The old API returned a list, should this actually be a set?
-        return parent_map.keys()
+        return list(parent_map)
 
     def __init__(self, _format, a_bzrdir, control_files):
         """Instantiate a VersionedFileRepository.
@@ -1351,7 +1353,7 @@
         referrers = frozenset(r[0] for r in key_deps.get_referrers())
         file_ids = self.fileids_altered_by_revision_ids(referrers)
         missing_texts = set()
-        for file_id, version_ids in file_ids.iteritems():
+        for file_id, version_ids in viewitems(file_ids):
             missing_texts.update(
                 (file_id, version_id) for version_id in version_ids)
         present_texts = self.texts.get_parent_map(missing_texts)
@@ -1499,8 +1501,7 @@
             revision_ids. Each altered file-ids has the exact revision_ids that
             altered it listed explicitly.
         """
-        seen = set(self._serializer._find_text_key_references(
-                line_iterator).iterkeys())
+        seen = set(self._serializer._find_text_key_references(line_iterator))
         parent_keys = self._find_parent_keys_of_revisions(revision_keys)
         parent_seen = set(self._serializer._find_text_key_references(
             self._inventory_xml_lines_for_keys(parent_keys)))
@@ -1520,7 +1521,7 @@
         """
         parent_map = self.revisions.get_parent_map(revision_keys)
         parent_keys = set(itertools.chain.from_iterable(
-            parent_map.itervalues()))
+            viewvalues(parent_map)))
         parent_keys.difference_update(revision_keys)
         parent_keys.discard(_mod_revision.NULL_REVISION)
         return parent_keys
@@ -1603,7 +1604,7 @@
         # a cache of the text keys to allow reuse; costs a dict of all the
         # keys, but saves a 2-tuple for every child of a given key.
         text_key_cache = {}
-        for text_key, valid in text_key_references.iteritems():
+        for text_key, valid in viewitems(text_key_references):
             if not valid:
                 invalid_keys.add(text_key)
             else:
@@ -1705,7 +1706,7 @@
         file_ids = self.fileids_altered_by_revision_ids(revision_ids, inv_w)
         count = 0
         num_file_ids = len(file_ids)
-        for file_id, altered_versions in file_ids.iteritems():
+        for file_id, altered_versions in viewitems(file_ids):
             if pb is not None:
                 pb.update(gettext("Fetch texts"), count, num_file_ids)
             count += 1
@@ -1880,8 +1881,8 @@
                 raise ValueError('get_parent_map(None) is not valid')
             else:
                 query_keys.append((revision_id ,))
-        for ((revision_id,), parent_keys) in \
-                self.revisions.get_parent_map(query_keys).iteritems():
+        for (revision_id,), parent_keys in viewitems(
+                self.revisions.get_parent_map(query_keys)):
             if parent_keys:
                 result[revision_id] = tuple([parent_revid
                     for (parent_revid,) in parent_keys])
@@ -1905,10 +1906,8 @@
 
     def revision_ids_to_search_result(self, result_set):
         """Convert a set of revision ids to a graph SearchResult."""
-        result_parents = set()
-        for parents in self.get_graph().get_parent_map(
-            result_set).itervalues():
-            result_parents.update(parents)
+        result_parents = set(itertools.chain.from_iterable(viewvalues(
+            self.get_graph().get_parent_map(result_set))))
         included_keys = result_set.intersection(result_parents)
         start_keys = result_set.difference(included_keys)
         exclude_keys = result_parents.difference(result_set)
@@ -2334,7 +2333,7 @@
             raise AssertionError(
                 'cannot copy revisions to fill in missing deltas %s' % (
                     keys['revisions'],))
-        for substream_kind, keys in keys.iteritems():
+        for substream_kind, keys in viewitems(keys):
             vf = getattr(self.from_repository, substream_kind)
             if vf is None and keys:
                     raise AssertionError(
@@ -2531,8 +2530,7 @@
     def _check_file_version_parents(self, texts, progress_bar):
         """See check_file_version_parents."""
         wrong_parents = {}
-        self.file_ids = {file_id for file_id, _ in
-            self.text_index.iterkeys()}
+        self.file_ids = {file_id for file_id, _ in self.text_index}
         # text keys is now grouped by file_id
         n_versions = len(self.text_index)
         progress_bar.update(gettext('loading text store'), 0, n_versions)
@@ -2540,7 +2538,7 @@
         # On unlistable transports this could well be empty/error...
         text_keys = self.repository.texts.keys()
         unused_keys = frozenset(text_keys) - set(self.text_index)
-        for num, key in enumerate(self.text_index.iterkeys()):
+        for num, key in enumerate(self.text_index):
             progress_bar.update(gettext('checking text graph'), num, n_versions)
             correct_parents = self.calculate_file_version_parents(key)
             try:
@@ -2814,11 +2812,10 @@
         source may be not have _fallback_repositories even though it is
         stacked.)
         """
-        parent_revs = set()
-        for parents in parent_map.values():
-            parent_revs.update(parents)
+        parent_revs = set(itertools.chain.from_iterable(viewvalues(
+            parent_map)))
         present_parents = self.source.get_parent_map(parent_revs)
-        absent_parents = set(parent_revs).difference(present_parents)
+        absent_parents = parent_revs.difference(present_parents)
         parent_invs_keys_for_stacking = self.source.inventories.get_parent_map(
             (rev_id,) for rev_id in absent_parents)
         parent_inv_ids = [key[-1] for key in parent_invs_keys_for_stacking]
@@ -3154,7 +3151,7 @@
         # commit to determine parents. There is a latent/real bug here where
         # the parents inserted are not those commit would do - in particular
         # they are not filtered by heads(). RBC, AB
-        for revision, tree in parent_trees.iteritems():
+        for revision, tree in viewitems(parent_trees):
             if not tree.has_id(ie.file_id):
                 continue
             parent_id = tree.get_file_revision(ie.file_id)
 
=== modified file 'breezy/vf_search.py'
--- breezy/vf_search.py	2017-05-25 01:35:55 +0000
+++ breezy/vf_search.py	2017-06-05 21:41:38 +0000
@@ -18,6 +18,8 @@
 
 from __future__ import absolute_import
 
+import itertools
+
 from . import (
     debug,
     revision,
@@ -29,11 +31,14 @@
     Graph,
     invert_parent_map,
     )
+from .sixish import (
+    viewvalues,
+    )
 
 
 class AbstractSearchResult(object):
     """The result of a search, describing a set of keys.
-    
+
     Search results are typically used as the 'fetch_spec' parameter when
     fetching revisions.
 
@@ -380,9 +385,7 @@
     # start_set is all the keys in the cache
     start_set = set(parent_map)
     # result set is all the references to keys in the cache
-    result_parents = set()
-    for parents in parent_map.itervalues():
-        result_parents.update(parents)
+    result_parents = set(itertools.chain.from_iterable(viewvalues(parent_map)))
     stop_keys = result_parents.difference(start_set)
     # We don't need to send ghosts back to the server as a position to
     # stop either.
@@ -420,14 +423,14 @@
             next_revs = next(s)
         except StopIteration:
             break
-        for parents in s._current_parents.itervalues():
+        for parents in viewvalues(s._current_parents):
             f_heads = heads.intersection(parents)
             if f_heads:
                 found_heads.update(f_heads)
         stop_keys = exclude_keys.intersection(next_revs)
         if stop_keys:
             s.stop_searching_any(stop_keys)
-    for parents in s._current_parents.itervalues():
+    for parents in viewvalues(s._current_parents):
         f_heads = heads.intersection(parents)
         if f_heads:
             found_heads.update(f_heads)
 
=== modified file 'breezy/weave.py'
--- breezy/weave.py	2017-06-04 18:09:30 +0000
+++ breezy/weave.py	2017-06-05 21:41:38 +0000
@@ -990,7 +990,7 @@
     # map from version name -> all parent names
     combined_parents = _reweave_parent_graphs(wa, wb)
     mutter("combined parents: %r", combined_parents)
-    order = tsort.topo_sort(combined_parents.iteritems())
+    order = tsort.topo_sort(combined_parents.items())
     mutter("order to reweave: %r", order)
 
     if pb and not msg:
 
=== modified file 'breezy/workingtree.py'
--- breezy/workingtree.py	2017-05-30 19:32:13 +0000
+++ breezy/workingtree.py	2017-06-05 21:41:38 +0000
@@ -2343,9 +2343,9 @@
     @needs_tree_write_lock
     def set_merge_modified(self, modified_hashes):
         def iter_stanzas():
-            for file_id, hash in modified_hashes.iteritems():
+            for file_id in modified_hashes:
                 yield _mod_rio.Stanza(file_id=file_id.decode('utf8'),
-                    hash=hash)
+                    hash=modified_hashes[file_id])
         self._put_rio('merge-hashes', iter_stanzas(), MERGE_MODIFIED_HEADER_1)
 
     @needs_read_lock
 
=== modified file 'breezy/workingtree_4.py'
--- breezy/workingtree_4.py	2017-05-30 19:32:13 +0000
+++ breezy/workingtree_4.py	2017-06-05 21:41:38 +0000
@@ -71,6 +71,7 @@
     )
 from .sixish import (
     BytesIO,
+    viewitems,
     )
 from .transport.local import LocalTransport
 from .tree import (
@@ -1018,7 +1019,7 @@
                     raise errors.PathsNotVersionedError(
                         [p.decode('utf-8') for p in paths])
 
-        for dir_name_id, trees_info in found.iteritems():
+        for dir_name_id, trees_info in viewitems(found):
             for index in search_indexes:
                 if trees_info[index][0] not in ('r', 'a'):
                     found_ids.add(dir_name_id[2])