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

[Martin Packman]

Make iterator objects and use of next Python 3 compatible

Most of the changes are the 2to3 fixer.

What I changed on top after:

* Pick an appropriate next in _dirstate_helpers_py
* Make all iterator objects have alias the __next__ method as next for Python 2
* Change a bunch of assertRaises tests from `... iterator.__next__)` to `... next, iterator)`
* Fixed doctest in breezy.iterablefile

[Jelmer Vernooij (jelmer)]

review: Approve

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

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

[Martin Packman (gz)]

Fixed single failing test and made it 90% less horrible.

=== modified file 'breezy/_annotator_py.py'
--- breezy/_annotator_py.py	2017-05-22 00:56:52 +0000
+++ breezy/_annotator_py.py	2017-05-26 09:27:07 +0000
@@ -281,7 +281,7 @@
             # Backwards compatibility, break up the heads into pairs and
             # resolve the result
             next_head = iter(the_heads)
-            head = next_head.next()
+            head = next(next_head)
             for possible_head in next_head:
                 annotated_lines = ((head, line), (possible_head, line))
                 head = tiebreaker(annotated_lines)[0]
 
=== modified file 'breezy/_dirstate_helpers_py.py'
--- breezy/_dirstate_helpers_py.py	2017-05-22 00:56:52 +0000
+++ breezy/_dirstate_helpers_py.py	2017-05-26 09:27:07 +0000
@@ -262,7 +262,11 @@
         # them. Grab an straight iterator over the fields. (We use an
         # iterator because we don't want to do a lot of additions, nor
         # do we want to do a lot of slicing)
-        next = iter(fields).next
+        _iter = iter(fields)
+        # Get a local reference to the compatible next method
+        next = getattr(_iter, '__next__', None)
+        if next is None:
+            next = _iter.next
         # Move the iterator to the current position
         for x in xrange(cur):
             next()
 
=== modified file 'breezy/annotate.py'
--- breezy/annotate.py	2017-05-22 00:56:52 +0000
+++ breezy/annotate.py	2017-05-26 09:27:07 +0000
@@ -367,7 +367,7 @@
                 else:
                     heads = heads_provider.heads((left[0], right[0]))
                     if len(heads) == 1:
-                        output_append((iter(heads).next(), left[1]))
+                        output_append((next(iter(heads)), left[1]))
                     else:
                         # Both claim different origins, get a stable result.
                         # If the result is not stable, there is a risk a
 
=== modified file 'breezy/branch.py'
--- breezy/branch.py	2017-05-22 00:56:52 +0000
+++ breezy/branch.py	2017-05-26 09:27:07 +0000
@@ -621,7 +621,7 @@
         # ancestry. Given the order guaranteed by the merge sort, we will see
         # uninteresting descendants of the first parent of our tip before the
         # tip itself.
-        first = rev_iter.next()
+        first = next(rev_iter)
         (rev_id, merge_depth, revno, end_of_merge) = first
         yield first
         if not merge_depth:
 
=== modified file 'breezy/btree_index.py'
--- breezy/btree_index.py	2017-05-25 21:59:11 +0000
+++ breezy/btree_index.py	2017-05-26 09:27:07 +0000
@@ -265,7 +265,7 @@
         current_values = []
         for iterator in iterators_to_combine:
             try:
-                current_values.append(iterator.next())
+                current_values.append(next(iterator))
             except StopIteration:
                 current_values.append(None)
         last = None
@@ -285,7 +285,7 @@
             yield (self,) + selected[1][1:]
             pos = selected[0]
             try:
-                current_values[pos] = iterators_to_combine[pos].next()
+                current_values[pos] = next(iterators_to_combine[pos])
             except StopIteration:
                 current_values[pos] = None
 
@@ -576,7 +576,7 @@
                 while dicts:
                     key_dict = dicts.pop(-1)
                     # can't be empty or would not exist
-                    item, value = key_dict.iteritems().next()
+                    item, value = next(key_dict.iteritems())
                     if isinstance(value, dict):
                         # push keys
                         dicts.extend(key_dict.itervalues())
@@ -1071,8 +1071,8 @@
         #     return [(o, offsets[o]) for o in sorted(offsets)]
         in_keys_iter = iter(in_keys)
         fixed_keys_iter = enumerate(fixed_keys)
-        cur_in_key = in_keys_iter.next()
-        cur_fixed_offset, cur_fixed_key = fixed_keys_iter.next()
+        cur_in_key = next(in_keys_iter)
+        cur_fixed_offset, cur_fixed_key = next(fixed_keys_iter)
 
         class InputDone(Exception): pass
         class FixedDone(Exception): pass
@@ -1094,7 +1094,7 @@
                     while cur_in_key < cur_fixed_key:
                         cur_keys.append(cur_in_key)
                         try:
-                            cur_in_key = in_keys_iter.next()
+                            cur_in_key = next(in_keys_iter)
                         except StopIteration:
                             raise InputDone
                     # At this point cur_in_key must be >= cur_fixed_key
@@ -1102,7 +1102,7 @@
                 # the end
                 while cur_in_key >= cur_fixed_key:
                     try:
-                        cur_fixed_offset, cur_fixed_key = fixed_keys_iter.next()
+                        cur_fixed_offset, cur_fixed_key = next(fixed_keys_iter)
                     except StopIteration:
                         raise FixedDone
         except InputDone:
@@ -1430,7 +1430,7 @@
                 while dicts:
                     key_dict = dicts.pop(-1)
                     # can't be empty or would not exist
-                    item, value = key_dict.iteritems().next()
+                    item, value = next(key_dict.iteritems())
                     if isinstance(value, dict):
                         # push keys
                         dicts.extend(key_dict.itervalues())
 
=== modified file 'breezy/builtins.py'
--- breezy/builtins.py	2017-05-22 00:56:52 +0000
+++ breezy/builtins.py	2017-05-26 09:27:07 +0000
@@ -432,7 +432,7 @@
 
     def print_revision(self, revisions, revid):
         stream = revisions.get_record_stream([(revid,)], 'unordered', True)
-        record = stream.next()
+        record = next(stream)
         if record.storage_kind == 'absent':
             raise errors.NoSuchRevision(revisions, revid)
         revtext = record.get_bytes_as('fulltext')
 
=== modified file 'breezy/bundle/bundle_data.py'
--- breezy/bundle/bundle_data.py	2017-05-22 00:56:52 +0000
+++ breezy/bundle/bundle_data.py	2017-05-26 09:27:07 +0000
@@ -766,7 +766,7 @@
         entries = inv.iter_entries(from_dir=from_dir_id, recursive=recursive)
         if inv.root is not None and not include_root and from_dir is None:
             # skip the root for compatability with the current apis.
-            entries.next()
+            next(entries)
         for path, entry in entries:
             yield path, 'V', entry.kind, entry.file_id, entry
 
 
=== modified file 'breezy/bundle/serializer/v08.py'
--- breezy/bundle/serializer/v08.py	2017-05-21 18:10:28 +0000
+++ breezy/bundle/serializer/v08.py	2017-05-26 09:27:07 +0000
@@ -360,7 +360,7 @@
         return BundleInfo08()
 
     def _read(self):
-        self._next().next()
+        next(self._next())
         while self._next_line is not None:
             if not self._read_revision_header():
                 break
@@ -537,7 +537,7 @@
                 break
             if not self._next_line.startswith('#'):
                 # Consume the trailing \n and stop processing
-                self._next().next()
+                next(self._next())
                 break
 
 class BundleInfo08(BundleInfo):
 
=== modified file 'breezy/bundle/serializer/v4.py'
--- breezy/bundle/serializer/v4.py	2017-05-22 00:56:52 +0000
+++ breezy/bundle/serializer/v4.py	2017-05-26 09:27:07 +0000
@@ -258,7 +258,7 @@
             if metadata['storage_kind'] == 'header':
                 bytes = None
             else:
-                _unused, bytes = iterator.next()
+                _unused, bytes = next(iterator)
             yield (bytes, metadata) + self.decode_name(names[0][0])
 
 
 
=== modified file 'breezy/cmdline.py'
--- breezy/cmdline.py	2013-05-27 10:22:27 +0000
+++ breezy/cmdline.py	2017-05-26 09:27:07 +0000
@@ -33,11 +33,13 @@
         self._iter = iter(orig)
         self._pushback_buffer = []
 
-    def next(self):
+    def __next__(self):
         if len(self._pushback_buffer) > 0:
             return self._pushback_buffer.pop()
         else:
-            return self._iter.next()
+            return next(self._iter)
+
+    next = __next__
 
     def pushback(self, char):
         self._pushback_buffer.append(char)
@@ -140,12 +142,14 @@
     def __iter__(self):
         return self
 
-    def next(self):
+    def __next__(self):
         quoted, token = self._get_token()
         if token is None:
             raise StopIteration
         return quoted, token
 
+    next = __next__
+
     def _get_token(self):
         self.quoted = False
         self.token = []
 
=== modified file 'breezy/config.py'
--- breezy/config.py	2017-05-24 16:21:50 +0000
+++ breezy/config.py	2017-05-26 09:27:07 +0000
@@ -3691,7 +3691,7 @@
             # sections are part of 'all_sections' and will always be found
             # there.
             while True:
-                section = iter_all_sections.next()
+                section = next(iter_all_sections)
                 if section_id == section.id:
                     section = LocationSection(section, extra_path,
                                               self.branch_name)
 
=== modified file 'breezy/dirstate.py'
--- breezy/dirstate.py	2017-05-24 19:44:00 +0000
+++ breezy/dirstate.py	2017-05-26 09:27:07 +0000
@@ -2703,7 +2703,7 @@
                             new_details.append(DirState.NULL_PARENT_DETAILS)
                         else:
                             # grab any one entry, use it to find the right path.
-                            a_key = iter(entry_keys).next()
+                            a_key = next(iter(entry_keys))
                             if by_path[a_key][lookup_index][0] in ('r', 'a'):
                                 # its a pointer or missing statement, use it as
                                 # is.
@@ -2783,11 +2783,11 @@
         # underlying dirstate.
         old_iterator = iter(list(self._iter_entries()))
         # both must have roots so this is safe:
-        current_new = new_iterator.next()
-        current_old = old_iterator.next()
+        current_new = next(new_iterator)
+        current_old = next(old_iterator)
         def advance(iterator):
             try:
-                return iterator.next()
+                return next(iterator)
             except StopIteration:
                 return None
         while current_new or current_old:
@@ -3906,7 +3906,7 @@
             else:
                 dir_iterator = osutils._walkdirs_utf8(root_abspath, prefix=current_root)
                 try:
-                    current_dir_info = dir_iterator.next()
+                    current_dir_info = next(dir_iterator)
                 except OSError as e:
                     # on win32, python2.4 has e.errno == ERROR_DIRECTORY, but
                     # python 2.5 has e.errno == EINVAL,
@@ -3982,7 +3982,7 @@
 
                         # This dir info has been handled, go to the next
                         try:
-                            current_dir_info = dir_iterator.next()
+                            current_dir_info = next(dir_iterator)
                         except StopIteration:
                             current_dir_info = None
                     else:
@@ -4134,7 +4134,7 @@
                         current_block = None
                 if current_dir_info is not None:
                     try:
-                        current_dir_info = dir_iterator.next()
+                        current_dir_info = next(dir_iterator)
                     except StopIteration:
                         current_dir_info = None
         for result in self._iter_specific_file_parents():
 
=== modified file 'breezy/export/__init__.py'
--- breezy/export/__init__.py	2017-05-22 00:56:52 +0000
+++ breezy/export/__init__.py	2017-05-26 09:27:07 +0000
@@ -205,7 +205,7 @@
     if subdir is not None:
         subdir = subdir.rstrip('/')
     entries = tree.iter_entries_by_dir()
-    entries.next()  # skip root
+    next(entries)  # skip root
     for path, entry in entries:
         # The .bzr* namespace is reserved for "magic" files like
         # .bzrignore and .bzrrules - do not export these
 
=== modified file 'breezy/graph.py'
--- breezy/graph.py	2017-05-22 00:56:52 +0000
+++ breezy/graph.py	2017-05-26 09:27:07 +0000
@@ -481,7 +481,7 @@
         unique_searcher = self._make_breadth_first_searcher(unique_revisions)
         # we know that unique_revisions aren't in common_revisions, so skip
         # past them.
-        unique_searcher.next()
+        next(unique_searcher)
         common_searcher = self._make_breadth_first_searcher(common_revisions)
 
         # As long as we are still finding unique nodes, keep searching
@@ -836,7 +836,7 @@
         active_searchers = dict(searchers)
         # skip over the actual candidate for each searcher
         for searcher in active_searchers.itervalues():
-            searcher.next()
+            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
         # uncommon search point actually meets up with something behind a
@@ -848,7 +848,7 @@
             ancestors = set()
             # advance searches
             try:
-                common_walker.next()
+                next(common_walker)
             except StopIteration:
                 # No common points being searched at this time.
                 pass
@@ -861,7 +861,7 @@
                     # a descendant of another candidate.
                     continue
                 try:
-                    ancestors.update(searcher.next())
+                    ancestors.update(next(searcher))
                 except StopIteration:
                     del active_searchers[candidate]
                     continue
@@ -1384,11 +1384,11 @@
 
     def step(self):
         try:
-            return self.next()
+            return next(self)
         except StopIteration:
             return ()
 
-    def next(self):
+    def __next__(self):
         """Return the next ancestors of this revision.
 
         Ancestors are returned in the order they are seen in a breadth-first
@@ -1414,6 +1414,8 @@
         self.seen.update(self._next_query)
         return self._next_query
 
+    next = __next__
+
     def next_with_ghosts(self):
         """Return the next found ancestors, with ghosts split out.
 
 
=== modified file 'breezy/groupcompress.py'
--- breezy/groupcompress.py	2017-05-25 21:59:11 +0000
+++ breezy/groupcompress.py	2017-05-26 09:27:07 +0000
@@ -1170,7 +1170,7 @@
                 if memos_to_get_stack and memos_to_get_stack[-1] == read_memo:
                     # The next block from _get_blocks will be the block we
                     # need.
-                    block_read_memo, block = blocks.next()
+                    block_read_memo, block = next(blocks)
                     if block_read_memo != read_memo:
                         raise AssertionError(
                             "block_read_memo out of sync with read_memo"
@@ -1412,7 +1412,7 @@
                 yield read_memo, cached[read_memo]
             except KeyError:
                 # Read the block, and cache it.
-                zdata = raw_records.next()
+                zdata = next(raw_records)
                 block = GroupCompressBlock.from_bytes(zdata)
                 self._group_cache[read_memo] = block
                 cached[read_memo] = block
 
=== modified file 'breezy/index.py'
--- breezy/index.py	2017-05-24 16:21:50 +0000
+++ breezy/index.py	2017-05-26 09:27:07 +0000
@@ -750,7 +750,7 @@
                 while dicts:
                     key_dict = dicts.pop(-1)
                     # can't be empty or would not exist
-                    item, value = key_dict.iteritems().next()
+                    item, value = next(key_dict.iteritems())
                     if isinstance(value, dict):
                         # push keys
                         dicts.extend(key_dict.itervalues())
@@ -1726,7 +1726,7 @@
                 while dicts:
                     key_dict = dicts.pop(-1)
                     # can't be empty or would not exist
-                    item, value = key_dict.iteritems().next()
+                    item, value = next(key_dict.iteritems())
                     if isinstance(value, dict):
                         # push keys
                         dicts.extend(key_dict.itervalues())
 
=== modified file 'breezy/inventory_delta.py'
--- breezy/inventory_delta.py	2017-05-22 00:56:52 +0000
+++ breezy/inventory_delta.py	2017-05-26 09:27:07 +0000
@@ -303,7 +303,7 @@
         seen_ids = set()
         line_iter = iter(lines)
         for i in range(5):
-            line_iter.next()
+            next(line_iter)
         for line in line_iter:
             (oldpath_utf8, newpath_utf8, file_id, parent_id, last_modified,
                 content) = line.split('\x00', 5)
 
=== modified file 'breezy/iterablefile.py'
--- breezy/iterablefile.py	2011-12-18 15:28:38 +0000
+++ breezy/iterablefile.py	2017-05-26 09:27:07 +0000
@@ -67,7 +67,7 @@
         result = self._buffer
         while result_length(result) is None:
             try:
-                result += self._iter.next()
+                result += next(self._iter)
             except StopIteration:
                 self.done = True
                 self._buffer = ""
@@ -142,27 +142,29 @@
         """
         self._check_closed()
 
-    def next(self):
+    def __next__(self):
         """Implementation of the iterator protocol's next()
 
         >>> f = IterableFile(['This \\n', 'is ', 'a ', 'test.'])
-        >>> f.next()
+        >>> next(f)
         'This \\n'
         >>> f.close()
-        >>> f.next()
+        >>> next(f)
         Traceback (most recent call last):
         ValueError: File is closed.
         >>> f = IterableFile(['This \\n', 'is ', 'a ', 'test.\\n'])
-        >>> f.next()
+        >>> next(f)
         'This \\n'
-        >>> f.next()
+        >>> next(f)
         'is a test.\\n'
-        >>> f.next()
+        >>> next(f)
         Traceback (most recent call last):
         StopIteration
         """
         self._check_closed()
-        return self._iter.next()
+        return next(self._iter)
+
+    next = __next__
 
     def __iter__(self):
         """
 
=== modified file 'breezy/knit.py'
--- breezy/knit.py	2017-05-24 16:33:08 +0000
+++ breezy/knit.py	2017-05-26 09:27:07 +0000
@@ -191,8 +191,8 @@
         delta = self._annotate_factory.parse_line_delta(contents, rec[1],
             plain=True)
         compression_parent = factory.parents[0]
-        basis_entry = self._basis_vf.get_record_stream(
-            [compression_parent], 'unordered', True).next()
+        basis_entry = next(self._basis_vf.get_record_stream(
+            [compression_parent], 'unordered', True))
         if basis_entry.storage_kind == 'absent':
             raise errors.RevisionNotPresent(compression_parent, self._basis_vf)
         basis_chunks = basis_entry.get_bytes_as('chunked')
@@ -227,8 +227,8 @@
         delta = self._plain_factory.parse_line_delta(contents, rec[1])
         compression_parent = factory.parents[0]
         # XXX: string splitting overhead.
-        basis_entry = self._basis_vf.get_record_stream(
-            [compression_parent], 'unordered', True).next()
+        basis_entry = next(self._basis_vf.get_record_stream(
+            [compression_parent], 'unordered', True))
         if basis_entry.storage_kind == 'absent':
             raise errors.RevisionNotPresent(compression_parent, self._basis_vf)
         basis_chunks = basis_entry.get_bytes_as('chunked')
@@ -619,7 +619,6 @@
         """
         result = []
         lines = iter(lines)
-        next = lines.next
 
         cache = {}
         def cache_and_return(line):
@@ -632,12 +631,13 @@
         if plain:
             for header in lines:
                 start, end, count = [int(n) for n in header.split(',')]
-                contents = [next().split(' ', 1)[1] for i in xrange(count)]
+                contents = [next(lines).split(' ', 1)[1] for _ in range(count)]
                 result.append((start, end, count, contents))
         else:
             for header in lines:
                 start, end, count = [int(n) for n in header.split(',')]
-                contents = [tuple(next().split(' ', 1)) for i in xrange(count)]
+                contents = [tuple(next(lines).split(' ', 1))
+                    for _ in range(count)]
                 result.append((start, end, count, contents))
         return result
 
@@ -652,12 +652,11 @@
         Only the actual content lines.
         """
         lines = iter(lines)
-        next = lines.next
         for header in lines:
             header = header.split(',')
             count = int(header[2])
             for i in xrange(count):
-                origin, text = next().split(' ', 1)
+                origin, text = next(lines).split(' ', 1)
                 yield text
 
     def lower_fulltext(self, content):
@@ -738,12 +737,11 @@
         Only the actual content lines.
         """
         lines = iter(lines)
-        next = lines.next
         for header in lines:
             header = header.split(',')
             count = int(header[2])
             for i in xrange(count):
-                yield next()
+                yield next(lines)
 
     def lower_fulltext(self, content):
         return content.text()
@@ -1967,7 +1965,7 @@
             raw_records = self._access.get_raw_records(needed_offsets)
 
         for key, index_memo in records:
-            data = raw_records.next()
+            data = next(raw_records)
             yield key, data
 
     def _record_to_data(self, key, digest, lines, dense_lines=None):
@@ -2024,7 +2022,7 @@
         # Note that _get_content is only called when the _ContentMapGenerator
         # has been constructed with just one key requested for reconstruction.
         if key in self.nonlocal_keys:
-            record = self.get_record_stream().next()
+            record = next(self.get_record_stream())
             # Create a content object on the fly
             lines = osutils.chunks_to_lines(record.get_bytes_as('chunked'))
             return PlainKnitContent(lines, record.key)
 
=== modified file 'breezy/log.py'
--- breezy/log.py	2017-05-25 22:09:31 +0000
+++ breezy/log.py	2017-05-26 09:27:07 +0000
@@ -1923,7 +1923,7 @@
     while do_new or do_old:
         if do_new:
             try:
-                new_revision = new_iter.next()
+                new_revision = next(new_iter)
             except StopIteration:
                 do_new = False
             else:
@@ -1934,7 +1934,7 @@
                     break
         if do_old:
             try:
-                old_revision = old_iter.next()
+                old_revision = next(old_iter)
             except StopIteration:
                 do_old = False
             else:
 
=== modified file 'breezy/merge_directive.py'
--- breezy/merge_directive.py	2017-05-22 00:56:52 +0000
+++ breezy/merge_directive.py	2017-05-26 09:27:07 +0000
@@ -516,7 +516,7 @@
         patch = None
         bundle = None
         try:
-            start = line_iter.next()
+            start = next(line_iter)
         except StopIteration:
             pass
         else:
 
=== modified file 'breezy/multiparent.py'
--- breezy/multiparent.py	2017-05-22 00:56:52 +0000
+++ breezy/multiparent.py	2017-05-26 09:27:07 +0000
@@ -117,7 +117,7 @@
         diff = MultiParent([])
         def next_block(p):
             try:
-                return block_iter[p].next()
+                return next(block_iter[p])
             except StopIteration:
                 return None
         cur_block = [next_block(p) for p, i in enumerate(block_iter)]
@@ -203,12 +203,12 @@
         cur_line = None
         while(True):
             try:
-                cur_line = line_iter.next()
+                cur_line = next(line_iter)
             except StopIteration:
                 break
             if cur_line[0] == 'i':
                 num_lines = int(cur_line.split(' ')[1])
-                hunk_lines = [line_iter.next() for x in xrange(num_lines)]
+                hunk_lines = [next(line_iter) for x in xrange(num_lines)]
                 hunk_lines[-1] = hunk_lines[-1][:-1]
                 hunks.append(NewText(hunk_lines))
             elif cur_line[0] == '\n':
@@ -646,14 +646,14 @@
                 start, end, kind, data, iterator = self.cursor[req_version_id]
             except KeyError:
                 iterator = self.diffs.get_diff(req_version_id).range_iterator()
-                start, end, kind, data = iterator.next()
+                start, end, kind, data = next(iterator)
             if start > req_start:
                 iterator = self.diffs.get_diff(req_version_id).range_iterator()
-                start, end, kind, data = iterator.next()
+                start, end, kind, data = next(iterator)
 
             # find the first hunk relevant to the request
             while end <= req_start:
-                start, end, kind, data = iterator.next()
+                start, end, kind, data = next(iterator)
             self.cursor[req_version_id] = start, end, kind, data, iterator
             # if the hunk can't satisfy the whole request, split it in two,
             # and leave the second half for later.
 
=== modified file 'breezy/mutabletree.py'
--- breezy/mutabletree.py	2017-05-24 19:44:00 +0000
+++ breezy/mutabletree.py	2017-05-26 09:27:07 +0000
@@ -234,10 +234,10 @@
             _from_tree = self.basis_tree()
         changes = self.iter_changes(_from_tree)
         try:
-            change = changes.next()
+            change = next(changes)
             # Exclude root (talk about black magic... --vila 20090629)
             if change[4] == (None, None):
-                change = changes.next()
+                change = next(changes)
             return True
         except StopIteration:
             # No changes
 
=== modified file 'breezy/pack.py'
--- breezy/pack.py	2017-05-22 00:56:52 +0000
+++ breezy/pack.py	2017-05-26 09:27:07 +0000
@@ -194,7 +194,7 @@
     def _next(self):
         if (self._string is None or
             self._string.tell() == self._string_length):
-            offset, data = self.readv_result.next()
+            offset, data = next(self.readv_result)
             self._string_length = len(data)
             self._string = BytesIO(data)
 
 
=== modified file 'breezy/patches.py'
--- breezy/patches.py	2017-05-22 00:56:52 +0000
+++ breezy/patches.py	2017-05-26 09:27:07 +0000
@@ -33,7 +33,7 @@
 
 
 def get_patch_names(iter_lines):
-    line = iter_lines.next()
+    line = next(iter_lines)
     try:
         match = re.match(binary_files_re, line)
         if match is not None:
@@ -45,7 +45,7 @@
     except StopIteration:
         raise MalformedPatchHeader("No orig line", "")
     try:
-        line = iter_lines.next()
+        line = next(iter_lines)
         if not line.startswith("+++ "):
             raise PatchSyntax("No mod name")
         else:
@@ -244,7 +244,7 @@
         orig_size = 0
         mod_size = 0
         while orig_size < hunk.orig_range or mod_size < hunk.mod_range:
-            hunk_line = parse_line(iter_lines.next())
+            hunk_line = parse_line(next(iter_lines))
             hunk.lines.append(hunk_line)
             if isinstance(hunk_line, (RemoveLine, ContextLine)):
                 orig_size += 1
@@ -483,7 +483,7 @@
         orig_lines = iter(orig_lines)
     for hunk in hunks:
         while line_no < hunk.orig_pos:
-            orig_line = orig_lines.next()
+            orig_line = next(orig_lines)
             yield orig_line
             line_no += 1
         for hunk_line in hunk.lines:
@@ -491,7 +491,7 @@
             if isinstance(hunk_line, InsertLine):
                 yield hunk_line.contents
             elif isinstance(hunk_line, (ContextLine, RemoveLine)):
-                orig_line = orig_lines.next()
+                orig_line = next(orig_lines)
                 if orig_line != hunk_line.contents:
                     raise PatchConflict(line_no, orig_line, "".join(seen_patch))
                 if isinstance(hunk_line, ContextLine):
 
=== modified file 'breezy/plugins/fastimport/revision_store.py'
--- breezy/plugins/fastimport/revision_store.py	2017-05-23 23:21:16 +0000
+++ breezy/plugins/fastimport/revision_store.py	2017-05-26 09:27:07 +0000
@@ -436,7 +436,7 @@
             path_entries = inv.iter_entries()
             # Backwards compatibility hack: skip the root id.
             if not self.repo.supports_rich_root():
-                path, root = path_entries.next()
+                path, root = next(path_entries)
                 if root.revision != revision_id:
                     raise errors.IncompatibleRevision(repr(self.repo))
             entries = iter([ie for path, ie in path_entries])
@@ -602,8 +602,8 @@
             self.repo.texts.add_lines(text_key, text_parents, lines)
 
     def get_file_lines(self, revision_id, file_id):
-        record = self.repo.texts.get_record_stream([(file_id, revision_id)],
-            'unordered', True).next()
+        record = next(self.repo.texts.get_record_stream([(file_id, revision_id)],
+            'unordered', True))
         if record.storage_kind == 'absent':
             raise errors.RevisionNotPresent(record.key, self.repo)
         return osutils.split_lines(record.get_bytes_as('fulltext'))
 
=== modified file 'breezy/plugins/weave_fmt/bzrdir.py'
--- breezy/plugins/weave_fmt/bzrdir.py	2017-05-24 19:44:00 +0000
+++ breezy/plugins/weave_fmt/bzrdir.py	2017-05-26 09:27:07 +0000
@@ -417,7 +417,7 @@
         trace.mutter('converting texts of revision {%s}', rev_id)
         parent_invs = list(map(self._load_updated_inventory, present_parents))
         entries = inv.iter_entries()
-        entries.next()
+        next(entries)
         for path, ie in entries:
             self._convert_file_version(rev, ie, parent_invs)
 
 
=== modified file 'breezy/remote.py'
--- breezy/remote.py	2017-05-22 00:56:52 +0000
+++ breezy/remote.py	2017-05-26 09:27:07 +0000
@@ -1948,7 +1948,7 @@
         prev_inv = Inventory(root_id=None,
             revision_id=_mod_revision.NULL_REVISION)
         # there should be just one substream, with inventory deltas
-        substream_kind, substream = stream.next()
+        substream_kind, substream = next(stream)
         if substream_kind != "inventory-deltas":
             raise AssertionError(
                  "Unexpected stream %r received" % substream_kind)
@@ -2190,7 +2190,7 @@
             yield decompressor.decompress(start)
             while decompressor.unused_data == "":
                 try:
-                    data = byte_stream.next()
+                    data = next(byte_stream)
                 except StopIteration:
                     break
                 yield decompressor.decompress(data)
@@ -2199,7 +2199,7 @@
         unused = ""
         while True:
             while not "\n" in unused:
-                unused += byte_stream.next()
+                unused += next(byte_stream)
             header, rest = unused.split("\n", 1)
             args = header.split("\0")
             if args[0] == "absent":
 
=== modified file 'breezy/repository.py'
--- breezy/repository.py	2017-05-24 19:44:00 +0000
+++ breezy/repository.py	2017-05-26 09:27:07 +0000
@@ -1788,14 +1788,14 @@
         (_mod_revision.NULL_REVISION,))
     try:
         # skip the last revision in the list
-        iterator.next()
+        next(iterator)
         while True:
             if (stop_index is not None and
                 len(partial_history_cache) > stop_index):
                 break
             if partial_history_cache[-1] == stop_revision:
                 break
-            revision_id = iterator.next()
+            revision_id = next(iterator)
             partial_history_cache.append(revision_id)
     except StopIteration:
         # No more history
 
=== modified file 'breezy/revisiontree.py'
--- breezy/revisiontree.py	2017-05-22 00:56:52 +0000
+++ breezy/revisiontree.py	2017-05-26 09:27:07 +0000
@@ -151,7 +151,7 @@
         entries = inv.iter_entries(from_dir=from_dir_id, recursive=recursive)
         if inv.root is not None and not include_root and from_dir is None:
             # skip the root for compatability with the current apis.
-            entries.next()
+            next(entries)
         for path, entry in entries:
             yield path, 'V', entry.kind, entry.file_id, entry
 
 
=== modified file 'breezy/shelf.py'
--- breezy/shelf.py	2017-05-22 00:56:52 +0000
+++ breezy/shelf.py	2017-05-26 09:27:07 +0000
@@ -314,7 +314,7 @@
 
     @staticmethod
     def parse_metadata(records):
-        names, metadata_bytes = records.next()
+        names, metadata_bytes = next(records)
         if names[0] != ('metadata',):
             raise errors.ShelfCorrupt
         metadata = bencode.bdecode(metadata_bytes)
 
=== modified file 'breezy/smart/protocol.py'
--- breezy/smart/protocol.py	2017-05-22 00:56:52 +0000
+++ breezy/smart/protocol.py	2017-05-26 09:27:07 +0000
@@ -1278,7 +1278,7 @@
     iterator = iter(iterable)
     while True:
         try:
-            yield None, iterator.next()
+            yield None, next(iterator)
         except StopIteration:
             return
         except (KeyboardInterrupt, SystemExit):
 
=== modified file 'breezy/smart/repository.py'
--- breezy/smart/repository.py	2017-05-24 19:44:00 +0000
+++ breezy/smart/repository.py	2017-05-26 09:27:07 +0000
@@ -127,7 +127,7 @@
                 start_keys)
             while True:
                 try:
-                    next_revs = search.next()
+                    next_revs = next(search)
                 except StopIteration:
                     break
                 search.stop_searching_any(exclude_keys.intersection(next_revs))
 
=== modified file 'breezy/status.py'
--- breezy/status.py	2017-05-22 00:56:52 +0000
+++ breezy/status.py	2017-05-26 09:27:07 +0000
@@ -334,7 +334,7 @@
         rev_id_iterator = _get_sorted_revisions(merge, merge_extra,
                             branch.repository.get_parent_map(merge_extra))
         # Skip the first node
-        num, first, depth, eom = rev_id_iterator.next()
+        num, first, depth, eom = next(rev_id_iterator)
         if first != merge:
             raise AssertionError('Somehow we misunderstood how'
                 ' iter_topo_order works %s != %s' % (first, merge))
 
=== modified file 'breezy/tests/blackbox/test_export.py'
--- breezy/tests/blackbox/test_export.py	2017-05-22 00:56:52 +0000
+++ breezy/tests/blackbox/test_export.py	2017-05-26 09:27:07 +0000
@@ -163,7 +163,7 @@
 
     def assertTarANameAndContent(self, ball, root=''):
         fname = root + 'a'
-        tar_info = ball.next()
+        tar_info = next(ball)
         self.assertEqual(fname, tar_info.name)
         self.assertEqual(tarfile.REGTYPE, tar_info.type)
         self.assertEqual(len(self._file_content), tar_info.size)
@@ -172,7 +172,7 @@
             self.fail('File content has been corrupted.'
                       ' Check that all streams are handled in binary mode.')
         # There should be no other files in the tarball
-        self.assertIs(None, ball.next())
+        self.assertIs(None, next(ball))
 
     def run_tar_export_disk_and_stdout(self, extension, tarfile_flags):
         tree = self.make_basic_tree()
 
=== modified file 'breezy/tests/per_intertree/test_compare.py'
--- breezy/tests/per_intertree/test_compare.py	2017-05-21 18:10:28 +0000
+++ breezy/tests/per_intertree/test_compare.py	2017-05-26 09:27:07 +0000
@@ -515,7 +515,7 @@
     @staticmethod
     def get_path_entry(tree, file_id):
         iterator = tree.iter_entries_by_dir(specific_file_ids=[file_id])
-        return iterator.next()
+        return next(iterator)
 
     def content_changed(self, tree, file_id):
         path, entry = self.get_path_entry(tree, file_id)
 
=== modified file 'breezy/tests/per_pack_repository.py'
--- breezy/tests/per_pack_repository.py	2017-05-24 19:44:00 +0000
+++ breezy/tests/per_pack_repository.py	2017-05-26 09:27:07 +0000
@@ -328,7 +328,7 @@
         repo.lock_write()
         self.addCleanup(repo.unlock)
         repo.fetch(b.repository, revision_id='B-id')
-        inv = b.repository.iter_inventories(['C-id']).next()
+        inv = next(b.repository.iter_inventories(['C-id']))
         repo.start_write_group()
         repo.add_inventory('C-id', inv, ['B-id'])
         repo.commit_write_group()
@@ -338,7 +338,7 @@
         self.assertEqual([('A-id',), ('B-id',), ('C-id',)],
                          sorted(repo.inventories.keys()))
         # Content should be preserved as well
-        self.assertEqual(inv, repo.iter_inventories(['C-id']).next())
+        self.assertEqual(inv, next(repo.iter_inventories(['C-id'])))
 
     def test_pack_layout(self):
         # Test that the ordering of revisions in pack repositories is
 
=== modified file 'breezy/tests/per_repository_vf/test_write_group.py'
--- breezy/tests/per_repository_vf/test_write_group.py	2017-05-22 00:56:52 +0000
+++ breezy/tests/per_repository_vf/test_write_group.py	2017-05-26 09:27:07 +0000
@@ -563,8 +563,8 @@
         else:
             same_repo = self.reopen_repo(repo)
             same_repo.lock_read()
-            record = same_repo.texts.get_record_stream([key_delta],
-                                                       'unordered', True).next()
+            record = next(same_repo.texts.get_record_stream([key_delta],
+                                                       'unordered', True))
             self.assertEqual('more\nlines\n', record.get_bytes_as('fulltext'))
             return
         # Merely suspending and resuming doesn't make it commitable either.
@@ -607,8 +607,8 @@
             # insert_record_stream already gave it a fulltext.
             same_repo = self.reopen_repo(repo)
             same_repo.lock_read()
-            record = same_repo.texts.get_record_stream([key_delta],
-                                                       'unordered', True).next()
+            record = next(same_repo.texts.get_record_stream([key_delta],
+                                                       'unordered', True))
             self.assertEqual('more\nlines\n', record.get_bytes_as('fulltext'))
             return
         same_repo.abort_write_group()
 
=== modified file 'breezy/tests/per_versionedfile.py'
--- breezy/tests/per_versionedfile.py	2017-05-25 00:04:21 +0000
+++ breezy/tests/per_versionedfile.py	2017-05-26 09:27:07 +0000
@@ -890,8 +890,8 @@
     def test_get_record_stream(self):
         self.setup_abcde()
         def get_record(suffix):
-            return self.plan_merge_vf.get_record_stream(
-                [('root', suffix)], 'unordered', True).next()
+            return next(self.plan_merge_vf.get_record_stream(
+                [('root', suffix)], 'unordered', True))
         self.assertEqual('a', get_record('A').get_bytes_as('fulltext'))
         self.assertEqual('c', get_record('C').get_bytes_as('fulltext'))
         self.assertEqual('e', get_record('E:').get_bytes_as('fulltext'))
@@ -1225,11 +1225,11 @@
         """Grab the interested adapted texts for tests."""
         # origin is a fulltext
         entries = f.get_record_stream([('origin',)], 'unordered', False)
-        base = entries.next()
+        base = next(entries)
         ft_data = ft_adapter.get_bytes(base)
         # merged is both a delta and multiple parents.
         entries = f.get_record_stream([('merged',)], 'unordered', False)
-        merged = entries.next()
+        merged = next(entries)
         delta_data = delta_adapter.get_bytes(merged)
         return ft_data, delta_data
 
@@ -1637,7 +1637,7 @@
                 vf._add_text, new_key, [], ''.join(lines),
                 nostore_sha=sha)
             # and no new version should have been added.
-            record = vf.get_record_stream([new_key], 'unordered', True).next()
+            record = next(vf.get_record_stream([new_key], 'unordered', True))
             self.assertEqual('absent', record.storage_kind)
 
     def test_add_lines_nostoresha(self):
@@ -2002,7 +2002,7 @@
         key = self.get_simple_key('foo')
         files.add_lines(key, (), ['my text\n', 'content'])
         stream = files.get_record_stream([key], 'unordered', False)
-        record = stream.next()
+        record = next(stream)
         if record.storage_kind in ('chunked', 'fulltext'):
             # chunked and fulltext representations are for direct use not wire
             # serialisation: check they are able to be used directly. To send
@@ -2785,14 +2785,14 @@
     def test_get_record_stream(self):
         self._lines["A"] = ["FOO", "BAR"]
         it = self.texts.get_record_stream([("A",)], "unordered", True)
-        record = it.next()
+        record = next(it)
         self.assertEqual("chunked", record.storage_kind)
         self.assertEqual("FOOBAR", record.get_bytes_as("fulltext"))
         self.assertEqual(["FOO", "BAR"], record.get_bytes_as("chunked"))
 
     def test_get_record_stream_absent(self):
         it = self.texts.get_record_stream([("A",)], "unordered", True)
-        record = it.next()
+        record = next(it)
         self.assertEqual("absent", record.storage_kind)
 
     def test_iter_lines_added_or_present_in_keys(self):
 
=== modified file 'breezy/tests/per_workingtree/test_inv.py'
--- breezy/tests/per_workingtree/test_inv.py	2017-05-21 18:10:28 +0000
+++ breezy/tests/per_workingtree/test_inv.py	2017-05-26 09:27:07 +0000
@@ -177,6 +177,6 @@
         # wt.current_dirstate()'s idea about what files are where.
         ie = base.inventory['subdir-id']
         self.assertEqual('directory', ie.kind)
-        path, ie = base.iter_entries_by_dir(['subdir-id']).next()
+        path, ie = next(base.iter_entries_by_dir(['subdir-id']))
         self.assertEqual('subdir', path)
         self.assertEqual('tree-reference', ie.kind)
 
=== modified file 'breezy/tests/per_workingtree/test_nested_specifics.py'
--- breezy/tests/per_workingtree/test_nested_specifics.py	2017-05-21 18:10:28 +0000
+++ breezy/tests/per_workingtree/test_nested_specifics.py	2017-05-26 09:27:07 +0000
@@ -79,5 +79,5 @@
 
     def test_iter_entries_by_dir_autodetects_subtree(self):
         tree = self.prepare_with_subtree()
-        path, ie = tree.iter_entries_by_dir(['subtree-id']).next()
+        path, ie = next(tree.iter_entries_by_dir(['subtree-id']))
         self.assertEqual('tree-reference', ie.kind)
 
=== modified file 'breezy/tests/test__annotator.py'
--- breezy/tests/test__annotator.py	2017-05-23 14:08:03 +0000
+++ breezy/tests/test__annotator.py	2017-05-26 09:27:07 +0000
@@ -137,7 +137,7 @@
         annotation, lines = self.ann.annotate(key)
         self.assertEqual(expected_annotation, annotation)
         if exp_text is None:
-            record = self.vf.get_record_stream([key], 'unordered', True).next()
+            record = next(self.vf.get_record_stream([key], 'unordered', True))
             exp_text = record.get_bytes_as('fulltext')
         self.assertEqualDiff(exp_text, ''.join(lines))
 
 
=== modified file 'breezy/tests/test__simple_set.py'
--- breezy/tests/test__simple_set.py	2017-05-21 18:10:28 +0000
+++ breezy/tests/test__simple_set.py	2017-05-26 09:27:07 +0000
@@ -373,13 +373,13 @@
             all.add(key)
         self.assertEqual(sorted([k1, k2, k3]), sorted(all))
         iterator = iter(obj)
-        iterator.next()
+        next(iterator)
         obj.add(('foo',))
         # Set changed size
-        self.assertRaises(RuntimeError, iterator.next)
+        self.assertRaises(RuntimeError, next, iterator)
         # And even removing an item still causes it to fail
         obj.discard(k2)
-        self.assertRaises(RuntimeError, iterator.next)
+        self.assertRaises(RuntimeError, next, iterator)
 
     def test__sizeof__(self):
         # SimpleSet needs a custom sizeof implementation, because it allocates
 
=== modified file 'breezy/tests/test_bundle.py'
--- breezy/tests/test_bundle.py	2017-05-22 00:56:52 +0000
+++ breezy/tests/test_bundle.py	2017-05-26 09:27:07 +0000
@@ -56,7 +56,7 @@
 def get_text(vf, key):
     """Get the fulltext for a given revision id that is present in the vf"""
     stream = vf.get_record_stream([key], 'unordered', True)
-    record = stream.next()
+    record = next(stream)
     return record.get_bytes_as('fulltext')
 
 
@@ -1764,10 +1764,10 @@
         fileobj.seek(0)
         reader = v4.BundleReader(fileobj, stream_input=True)
         record_iter = reader.iter_records()
-        record = record_iter.next()
+        record = next(record_iter)
         self.assertEqual((None, {'foo': 'bar', 'storage_kind': 'header'},
             'info', None, None), record)
-        record = record_iter.next()
+        record = next(record_iter)
         self.assertEqual(("Record body", {'storage_kind': 'fulltext',
                           'parents': ['1', '3']}, 'file', 'revid', 'fileid'),
                           record)
@@ -1783,10 +1783,10 @@
         fileobj.seek(0)
         reader = v4.BundleReader(fileobj, stream_input=False)
         record_iter = reader.iter_records()
-        record = record_iter.next()
+        record = next(record_iter)
         self.assertEqual((None, {'foo': 'bar', 'storage_kind': 'header'},
             'info', None, None), record)
-        record = record_iter.next()
+        record = next(record_iter)
         self.assertEqual(("Record body", {'storage_kind': 'fulltext',
                           'parents': ['1', '3']}, 'file', 'revid', 'fileid'),
                           record)
@@ -1816,10 +1816,10 @@
         writer.end()
         fileobj.seek(0)
         record_iter = v4.BundleReader(fileobj).iter_records()
-        record = record_iter.next()
+        record = next(record_iter)
         self.assertEqual((None, {'foo': 'bar', 'storage_kind': 'header'},
             'info', None, None), record)
-        self.assertRaises(errors.BadBundle, record_iter.next)
+        self.assertRaises(errors.BadBundle, next, record_iter)
 
 
 class TestReadMergeableFromUrl(tests.TestCaseWithTransport):
 
=== modified file 'breezy/tests/test_chk_map.py'
--- breezy/tests/test_chk_map.py	2017-05-22 00:56:52 +0000
+++ breezy/tests/test_chk_map.py	2017-05-26 09:27:07 +0000
@@ -85,7 +85,7 @@
 
     def read_bytes(self, chk_bytes, key):
         stream = chk_bytes.get_record_stream([key], 'unordered', True)
-        record = stream.next()
+        record = next(stream)
         if record.storage_kind == 'absent':
             self.fail('Store does not contain the key %s' % (key,))
         return record.get_bytes_as("fulltext")
 
=== modified file 'breezy/tests/test_fetch.py'
--- breezy/tests/test_fetch.py	2017-05-22 00:56:52 +0000
+++ breezy/tests/test_fetch.py	2017-05-26 09:27:07 +0000
@@ -368,15 +368,15 @@
         # Ensure that we stored a delta
         source.lock_read()
         self.addCleanup(source.unlock)
-        record = source.revisions.get_record_stream([('rev-two',)],
-            'unordered', False).next()
+        record = next(source.revisions.get_record_stream([('rev-two',)],
+            'unordered', False))
         self.assertEqual('knit-delta-gz', record.storage_kind)
         target.fetch(tree.branch.repository, revision_id='rev-two')
         # The record should get expanded back to a fulltext
         target.lock_read()
         self.addCleanup(target.unlock)
-        record = target.revisions.get_record_stream([('rev-two',)],
-            'unordered', False).next()
+        record = next(target.revisions.get_record_stream([('rev-two',)],
+            'unordered', False))
         self.assertEqual('knit-ft-gz', record.storage_kind)
 
     def test_fetch_with_fallback_and_merge(self):
 
=== modified file 'breezy/tests/test_graph.py'
--- breezy/tests/test_graph.py	2017-05-22 00:56:52 +0000
+++ breezy/tests/test_graph.py	2017-05-26 09:27:07 +0000
@@ -934,8 +934,8 @@
         self.assertRaises(StopIteration, search.next_with_ghosts)
         # next includes them
         search = graph._make_breadth_first_searcher(['a-ghost'])
-        self.assertEqual({'a-ghost'}, search.next())
-        self.assertRaises(StopIteration, search.next)
+        self.assertEqual({'a-ghost'}, next(search))
+        self.assertRaises(StopIteration, next, search)
 
     def test_breadth_first_search_deep_ghosts(self):
         graph = self.make_graph({
@@ -952,11 +952,11 @@
         self.assertRaises(StopIteration, search.next_with_ghosts)
         # next includes them
         search = graph._make_breadth_first_searcher(['head'])
-        self.assertEqual({'head'}, search.next())
-        self.assertEqual({'present'}, search.next())
+        self.assertEqual({'head'}, next(search))
+        self.assertEqual({'present'}, next(search))
         self.assertEqual({'child', 'ghost'},
-            search.next())
-        self.assertRaises(StopIteration, search.next)
+            next(search))
+        self.assertRaises(StopIteration, next, search)
 
     def test_breadth_first_search_change_next_to_next_with_ghosts(self):
         # To make the API robust, we allow calling both next() and
@@ -969,16 +969,16 @@
         # start with next_with_ghosts
         search = graph._make_breadth_first_searcher(['head'])
         self.assertEqual(({'head'}, set()), search.next_with_ghosts())
-        self.assertEqual({'present'}, search.next())
+        self.assertEqual({'present'}, next(search))
         self.assertEqual(({'child'}, {'ghost'}),
             search.next_with_ghosts())
-        self.assertRaises(StopIteration, search.next)
+        self.assertRaises(StopIteration, next, search)
         # start with next
         search = graph._make_breadth_first_searcher(['head'])
-        self.assertEqual({'head'}, search.next())
+        self.assertEqual({'head'}, next(search))
         self.assertEqual(({'present'}, set()), search.next_with_ghosts())
         self.assertEqual({'child', 'ghost'},
-            search.next())
+            next(search))
         self.assertRaises(StopIteration, search.next_with_ghosts)
 
     def test_breadth_first_change_search(self):
@@ -1000,13 +1000,13 @@
         self.assertRaises(StopIteration, search.next_with_ghosts)
         # next includes them
         search = graph._make_breadth_first_searcher(['head'])
-        self.assertEqual({'head'}, search.next())
-        self.assertEqual({'present'}, search.next())
+        self.assertEqual({'head'}, next(search))
+        self.assertEqual({'present'}, next(search))
         self.assertEqual({'present'},
             search.stop_searching_any(['present']))
         search.start_searching(['other', 'other_ghost'])
-        self.assertEqual({'other_2'}, search.next())
-        self.assertRaises(StopIteration, search.next)
+        self.assertEqual({'other_2'}, next(search))
+        self.assertRaises(StopIteration, next, search)
 
     def assertSeenAndResult(self, instructions, search, next):
         """Check the results of .seen and get_result() for a seach.
@@ -1054,7 +1054,7 @@
             ({'head', 'child', NULL_REVISION}, ({'head'}, set(), 3),
              ['head', 'child', NULL_REVISION], None, None),
             ]
-        self.assertSeenAndResult(expected, search, search.next)
+        self.assertSeenAndResult(expected, search, search.__next__)
         # using next_with_ghosts:
         search = graph._make_breadth_first_searcher(['head'])
         self.assertSeenAndResult(expected, search, search.next_with_ghosts)
@@ -1092,7 +1092,7 @@
              ({'head', 'otherhead'}, {'child', 'excluded'}, 3),
              ['head', 'otherhead', 'otherchild'], None, ['excluded']),
             ]
-        self.assertSeenAndResult(expected, search, search.next)
+        self.assertSeenAndResult(expected, search, search.__next__)
         # using next_with_ghosts:
         search = graph._make_breadth_first_searcher([])
         search.start_searching(['head'])
@@ -1118,7 +1118,7 @@
              ({'head'}, {'ghost1', NULL_REVISION}, 2),
              ['head', 'child'], None, [NULL_REVISION, 'ghost1']),
             ]
-        self.assertSeenAndResult(expected, search, search.next)
+        self.assertSeenAndResult(expected, search, search.__next__)
         # using next_with_ghosts:
         search = graph._make_breadth_first_searcher(['head'])
         self.assertSeenAndResult(expected, search, search.next_with_ghosts)
@@ -1145,7 +1145,7 @@
              ({'head'}, {'middle', 'child'}, 1),
              ['head'], None, ['middle', 'child']),
             ]
-        self.assertSeenAndResult(expected, search, search.next)
+        self.assertSeenAndResult(expected, search, search.__next__)
         # using next_with_ghosts:
         search = graph._make_breadth_first_searcher(['head'])
         self.assertSeenAndResult(expected, search, search.next_with_ghosts)
@@ -1166,7 +1166,7 @@
              ({'head'}, {NULL_REVISION, 'ghost'}, 2),
              ['head', 'child'], None, None),
             ]
-        self.assertSeenAndResult(expected, search, search.next)
+        self.assertSeenAndResult(expected, search, search.__next__)
         # using next_with_ghosts:
         search = graph._make_breadth_first_searcher(['head'])
         self.assertSeenAndResult(expected, search, search.next_with_ghosts)
@@ -1187,7 +1187,7 @@
              ({'head', 'ghost'}, {NULL_REVISION, 'ghost'}, 2),
              ['head', 'child'], None, None),
             ]
-        self.assertSeenAndResult(expected, search, search.next)
+        self.assertSeenAndResult(expected, search, search.__next__)
         # using next_with_ghosts:
         search = graph._make_breadth_first_searcher(['head'])
         self.assertSeenAndResult(expected, search, search.next_with_ghosts)
@@ -1207,7 +1207,7 @@
              ({'head'}, set([]), 2),
              ['head', NULL_REVISION], None, None),
             ]
-        self.assertSeenAndResult(expected, search, search.next)
+        self.assertSeenAndResult(expected, search, search.__next__)
         # using next_with_ghosts:
         search = graph._make_breadth_first_searcher(['head'])
         self.assertSeenAndResult(expected, search, search.next_with_ghosts)
@@ -1228,8 +1228,8 @@
              ({'head', 'ghost'}, {'ghost'}, 2),
              ['head', NULL_REVISION], ['ghost'], None),
             ]
-        self.assertSeenAndResult(expected, search, search.next)
-        self.assertRaises(StopIteration, search.next)
+        self.assertSeenAndResult(expected, search, search.__next__)
+        self.assertRaises(StopIteration, next, search)
         self.assertEqual({'head', 'ghost', NULL_REVISION}, search.seen)
         state = search.get_state()
         self.assertEqual(
@@ -1239,7 +1239,7 @@
         # using next_with_ghosts:
         search = graph._make_breadth_first_searcher(['head'])
         self.assertSeenAndResult(expected, search, search.next_with_ghosts)
-        self.assertRaises(StopIteration, search.next)
+        self.assertRaises(StopIteration, next, search)
         self.assertEqual({'head', 'ghost', NULL_REVISION}, search.seen)
         state = search.get_state()
         self.assertEqual(
 
=== modified file 'breezy/tests/test_groupcompress.py'
--- breezy/tests/test_groupcompress.py	2017-05-22 00:56:52 +0000
+++ breezy/tests/test_groupcompress.py	2017-05-26 09:27:07 +0000
@@ -557,7 +557,7 @@
         vf = self.make_test_vf(True, dir='source')
         vf.add_lines(('a',), (), ['lines\n'])
         vf.writer.end()
-        record = vf.get_record_stream([('a',)], 'unordered', True).next()
+        record = next(vf.get_record_stream([('a',)], 'unordered', True))
         self.assertEqual(vf._DEFAULT_COMPRESSOR_SETTINGS,
                          record._manager._get_compressor_settings())
 
@@ -566,7 +566,7 @@
         vf.add_lines(('a',), (), ['lines\n'])
         vf.writer.end()
         vf._max_bytes_to_index = 1234
-        record = vf.get_record_stream([('a',)], 'unordered', True).next()
+        record = next(vf.get_record_stream([('a',)], 'unordered', True))
         self.assertEqual(dict(max_bytes_to_index=1234),
                          record._manager._get_compressor_settings())
 
 
=== modified file 'breezy/tests/test_http.py'
--- breezy/tests/test_http.py	2017-05-24 19:44:00 +0000
+++ breezy/tests/test_http.py	2017-05-26 09:27:07 +0000
@@ -889,7 +889,7 @@
         # Don't collapse readv results into a list so that we leave unread
         # bytes on the socket
         ireadv = iter(t.readv('a', ((0, 1), (1, 1), (2, 4), (6, 4))))
-        self.assertEqual((0, '0'), ireadv.next())
+        self.assertEqual((0, '0'), next(ireadv))
         # The server should have issued one request so far
         self.assertEqual(1, server.GET_request_nb)
         self.assertEqual('0123456789', t.get_bytes('a'))
@@ -1045,14 +1045,14 @@
         # Force separate ranges for each offset
         t._bytes_to_read_before_seek = 0
         ireadv = iter(t.readv('a', ((0, 1), (2, 1), (4, 2), (9, 1))))
-        self.assertEqual((0, '0'), ireadv.next())
-        self.assertEqual((2, '2'), ireadv.next())
+        self.assertEqual((0, '0'), next(ireadv))
+        self.assertEqual((2, '2'), next(ireadv))
         if not self._testing_pycurl():
             # Only one request have been issued so far (except for pycurl that
             # try to read the whole response at once)
             self.assertEqual(1, server.GET_request_nb)
-        self.assertEqual((4, '45'), ireadv.next())
-        self.assertEqual((9, '9'), ireadv.next())
+        self.assertEqual((4, '45'), next(ireadv))
+        self.assertEqual((9, '9'), next(ireadv))
         # Both implementations issue 3 requests but:
         # - urllib does two multiple (4 ranges, then 2 ranges) then a single
         #   range,
@@ -1123,10 +1123,10 @@
         # Force separate ranges for each offset
         t._bytes_to_read_before_seek = 0
         ireadv = iter(t.readv('a', ((0, 1), (2, 1), (4, 2), (9, 1))))
-        self.assertEqual((0, '0'), ireadv.next())
-        self.assertEqual((2, '2'), ireadv.next())
-        self.assertEqual((4, '45'), ireadv.next())
-        self.assertEqual((9, '9'), ireadv.next())
+        self.assertEqual((0, '0'), next(ireadv))
+        self.assertEqual((2, '2'), next(ireadv))
+        self.assertEqual((4, '45'), next(ireadv))
+        self.assertEqual((9, '9'), next(ireadv))
 
 
 class LimitedRangeRequestHandler(http_server.TestingHTTPRequestHandler):
 
=== modified file 'breezy/tests/test_knit.py'
--- breezy/tests/test_knit.py	2017-05-22 00:56:52 +0000
+++ breezy/tests/test_knit.py	2017-05-26 09:27:07 +0000
@@ -205,8 +205,8 @@
         content1 = self._make_content([("", "a"), ("", "b")])
         content2 = self._make_content([("", "a"), ("", "a"), ("", "c")])
         it = content1.line_delta_iter(content2)
-        self.assertEqual(it.next(), (1, 2, 2, ["a", "c"]))
-        self.assertRaises(StopIteration, it.next)
+        self.assertEqual(next(it), (1, 2, 2, ["a", "c"]))
+        self.assertRaises(StopIteration, next, it)
 
 
 class TestAnnotatedKnitContent(TestCase, KnitContentTestsMixin):
@@ -232,8 +232,8 @@
         content1 = self._make_content([("", "a"), ("", "b")])
         content2 = self._make_content([("", "a"), ("", "a"), ("", "c")])
         it = content1.line_delta_iter(content2)
-        self.assertEqual(it.next(), (1, 2, 2, [("", "a"), ("", "c")]))
-        self.assertRaises(StopIteration, it.next)
+        self.assertEqual(next(it), (1, 2, 2, [("", "a"), ("", "c")]))
+        self.assertRaises(StopIteration, next, it)
 
 
 class MockTransport(object):
@@ -648,13 +648,13 @@
         vf, reload_counter = self.make_vf_for_retrying()
         keys = [('rev-1',), ('rev-2',), ('rev-3',)]
         record_stream = vf.get_record_stream(keys, 'topological', False)
-        record = record_stream.next()
+        record = next(record_stream)
         self.assertEqual(('rev-1',), record.key)
         self.assertEqual([0, 0, 0], reload_counter)
-        record = record_stream.next()
+        record = next(record_stream)
         self.assertEqual(('rev-2',), record.key)
         self.assertEqual([1, 1, 0], reload_counter)
-        record = record_stream.next()
+        record = next(record_stream)
         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
@@ -2338,8 +2338,8 @@
                 source = test
             else:
                 source = basis
-            record = source.get_record_stream([result[0]], 'unordered',
-                True).next()
+            record = next(source.get_record_stream([result[0]], 'unordered',
+                True))
             self.assertEqual(record.key, result[0])
             self.assertEqual(record.sha1, result[1])
             # We used to check that the storage kind matched, but actually it
@@ -2425,8 +2425,8 @@
                 source = test
             else:
                 source = basis
-            record = source.get_record_stream([result[0]], 'unordered',
-                False).next()
+            record = next(source.get_record_stream([result[0]], 'unordered',
+                False))
             self.assertEqual(record.key, result[0])
             self.assertEqual(record.sha1, result[1])
             self.assertEqual(record.storage_kind, result[2])
 
=== modified file 'breezy/tests/test_pack.py'
--- breezy/tests/test_pack.py	2017-05-22 00:56:52 +0000
+++ breezy/tests/test_pack.py	2017-05-26 09:27:07 +0000
@@ -265,7 +265,7 @@
             "Bazaar pack format 1 (introduced in 0.18)\n")
         iterator = reader.iter_records()
         self.assertRaises(
-            errors.UnexpectedEndOfContainerError, iterator.next)
+            errors.UnexpectedEndOfContainerError, next, iterator)
 
     def test_unknown_record_type(self):
         """Unknown record types cause UnknownRecordTypeError to be raised."""
@@ -273,7 +273,7 @@
             "Bazaar pack format 1 (introduced in 0.18)\nX")
         iterator = reader.iter_records()
         self.assertRaises(
-            errors.UnknownRecordTypeError, iterator.next)
+            errors.UnknownRecordTypeError, next, iterator)
 
     def test_container_with_one_unnamed_record(self):
         """Read a container with one Bytes record.
 
=== modified file 'breezy/tests/test_patches.py'
--- breezy/tests/test_patches.py	2017-05-22 00:56:52 +0000
+++ breezy/tests/test_patches.py	2017-05-26 09:27:07 +0000
@@ -211,7 +211,6 @@
         self.compare_parsed(patchtext)
 
     def testLineLookup(self):
-        import sys
         """Make sure we can accurately look up mod line from orig"""
         patch = parse_patch(self.datafile("diff"))
         orig = list(self.datafile("orig"))
@@ -227,12 +226,8 @@
         for hunk in patch.hunks:
             for line in hunk.lines:
                 if isinstance(line, RemoveLine):
-                    next = rem_iter.next()
-                    if line.contents != next:
-                        sys.stdout.write(" orig:%spatch:%s" % (next,
-                                         line.contents))
-                    self.assertEqual(line.contents, next)
-        self.assertRaises(StopIteration, rem_iter.next)
+                    self.assertEqual(line.contents, next(rem_iter))
+        self.assertRaises(StopIteration, next, rem_iter)
 
     def testPatching(self):
         """Test a few patch files, and make sure they work."""
 
=== modified file 'breezy/tests/test_repository.py'
--- breezy/tests/test_repository.py	2017-05-22 00:56:52 +0000
+++ breezy/tests/test_repository.py	2017-05-26 09:27:07 +0000
@@ -968,8 +968,8 @@
             return
         empty_repo.lock_read()
         self.addCleanup(empty_repo.unlock)
-        text = empty_repo.texts.get_record_stream(
-            [('file2-id', 'rev3')], 'topological', True).next()
+        text = next(empty_repo.texts.get_record_stream(
+            [('file2-id', 'rev3')], 'topological', True))
         self.assertEqual('line\n', text.get_bytes_as('fulltext'))
 
 
@@ -1275,7 +1275,7 @@
         # and remove another pack (via _remove_pack_from_memory)
         orig_names = packs.names()
         orig_at_load = packs._packs_at_load
-        to_remove_name = iter(orig_names).next()
+        to_remove_name = next(iter(orig_names))
         r.start_write_group()
         self.addCleanup(r.abort_write_group)
         r.texts.insert_record_stream([versionedfile.FulltextContentFactory(
 
=== modified file 'breezy/tests/test_revisiontree.py'
--- breezy/tests/test_revisiontree.py	2017-05-21 18:10:28 +0000
+++ breezy/tests/test_revisiontree.py	2017-05-26 09:27:07 +0000
@@ -74,7 +74,7 @@
             tree.get_file_revision(tree.path2id('a')))
 
     def test_get_file_mtime_ghost(self):
-        file_id = iter(self.rev_tree.all_file_ids()).next()
+        file_id = next(iter(self.rev_tree.all_file_ids()))
         self.rev_tree.root_inventory[file_id].revision = 'ghostrev'
         self.assertRaises(errors.FileTimestampUnavailable, 
             self.rev_tree.get_file_mtime, file_id)
 
=== modified file 'breezy/tests/test_shelf.py'
--- breezy/tests/test_shelf.py	2017-05-21 18:10:28 +0000
+++ breezy/tests/test_shelf.py	2017-05-26 09:27:07 +0000
@@ -190,7 +190,7 @@
 
     def check_shelve_creation(self, creator, tree):
         self.assertRaises(StopIteration,
-                          tree.iter_entries_by_dir(['foo-id']).next)
+                          next, tree.iter_entries_by_dir(['foo-id']))
         s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
         self.assertEqual('foo-id',
                          creator.shelf_transform.final_file_id(s_trans_id))
@@ -308,7 +308,7 @@
         creator.shelve_creation('foo-id')
         creator.transform()
         self.assertRaises(StopIteration,
-                          tree.iter_entries_by_dir(['foo-id']).next)
+                          next, tree.iter_entries_by_dir(['foo-id']))
         self.assertShelvedFileEqual('', creator, 'foo-id')
         s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
         self.assertEqual('foo-id',
@@ -465,7 +465,7 @@
         self.addCleanup(tt.finalize)
         records = iter(parser.read_pending_records())
         #skip revision-id
-        records.next()
+        next(records)
         tt.deserialize(records)
 
     def test_shelve_unversioned(self):
 
=== modified file 'breezy/tests/test_smart_transport.py'
--- breezy/tests/test_smart_transport.py	2017-05-22 00:56:52 +0000
+++ breezy/tests/test_smart_transport.py	2017-05-26 09:27:07 +0000
@@ -2703,7 +2703,7 @@
         smart_protocol.call('foo')
         smart_protocol.read_response_tuple(True)
         stream = smart_protocol.read_streamed_body()
-        self.assertRaises(errors.ConnectionReset, stream.next)
+        self.assertRaises(errors.ConnectionReset, next, stream)
 
     def test_client_read_response_tuple_sets_response_status(self):
         server_bytes = protocol.RESPONSE_VERSION_TWO + "success\nok\n"
@@ -2917,9 +2917,9 @@
     def test_interrupted_by_error(self):
         response_handler = self.make_response_handler(interrupted_body_stream)
         stream = response_handler.read_streamed_body()
-        self.assertEqual('aaa', stream.next())
-        self.assertEqual('bbb', stream.next())
-        exc = self.assertRaises(errors.ErrorFromSmartServer, stream.next)
+        self.assertEqual('aaa', next(stream))
+        self.assertEqual('bbb', next(stream))
+        exc = self.assertRaises(errors.ErrorFromSmartServer, next, stream)
         self.assertEqual(('error', 'Exception', 'Boom!'), exc.error_tuple)
 
     def test_interrupted_by_connection_lost(self):
@@ -2929,7 +2929,7 @@
             'b\0\0\xff\xffincomplete chunk')
         response_handler = self.make_response_handler(interrupted_body_stream)
         stream = response_handler.read_streamed_body()
-        self.assertRaises(errors.ConnectionReset, stream.next)
+        self.assertRaises(errors.ConnectionReset, next, stream)
 
     def test_read_body_bytes_interrupted_by_connection_lost(self):
         interrupted_body_stream = (
 
=== modified file 'breezy/tests/test_tree.py'
--- breezy/tests/test_tree.py	2017-05-21 18:10:28 +0000
+++ breezy/tests/test_tree.py	2017-05-26 09:27:07 +0000
@@ -192,7 +192,7 @@
         :param exp_other_paths: A list of other_path values.
         :param iterator: The iterator to step
         """
-        path, file_id, master_ie, other_values = iterator.next()
+        path, file_id, master_ie, other_values = next(iterator)
         self.assertEqual((exp_path, exp_file_id), (path, file_id),
                          'Master entry did not match')
         if master_has_node:
@@ -244,7 +244,7 @@
         self.assertWalkerNext(u'a', 'a-id', True, [u'a'], iterator)
         self.assertWalkerNext(u'b', 'b-id', True, [u'b'], iterator)
         self.assertWalkerNext(u'b/c', 'c-id', True, [u'b/c'], iterator)
-        self.assertRaises(StopIteration, iterator.next)
+        self.assertRaises(StopIteration, next, iterator)
 
     def test_master_has_extra(self):
         tree = self.make_branch_and_tree('tree')
@@ -263,7 +263,7 @@
         self.assertWalkerNext(u'b', 'b-id', True, [u'b'], iterator)
         self.assertWalkerNext(u'c', 'c-id', True, [None], iterator)
         self.assertWalkerNext(u'd', 'd-id', True, [u'd'], iterator)
-        self.assertRaises(StopIteration, iterator.next)
+        self.assertRaises(StopIteration, next, iterator)
 
     def test_master_renamed_to_earlier(self):
         """The record is still present, it just shows up early."""
@@ -281,7 +281,7 @@
         self.assertWalkerNext(u'a', 'a-id', True, [u'a'], iterator)
         self.assertWalkerNext(u'b', 'd-id', True, [u'd'], iterator)
         self.assertWalkerNext(u'c', 'c-id', True, [u'c'], iterator)
-        self.assertRaises(StopIteration, iterator.next)
+        self.assertRaises(StopIteration, next, iterator)
 
     def test_master_renamed_to_later(self):
         tree = self.make_branch_and_tree('tree')
@@ -298,7 +298,7 @@
         self.assertWalkerNext(u'a', 'a-id', True, [u'a'], iterator)
         self.assertWalkerNext(u'd', 'd-id', True, [u'd'], iterator)
         self.assertWalkerNext(u'e', 'b-id', True, [u'b'], iterator)
-        self.assertRaises(StopIteration, iterator.next)
+        self.assertRaises(StopIteration, next, iterator)
 
     def test_other_extra_in_middle(self):
         tree = self.make_branch_and_tree('tree')
@@ -314,7 +314,7 @@
         self.assertWalkerNext(u'a', 'a-id', True, [u'a'], iterator)
         self.assertWalkerNext(u'd', 'd-id', True, [u'd'], iterator)
         self.assertWalkerNext(u'b', 'b-id', False, [u'b'], iterator)
-        self.assertRaises(StopIteration, iterator.next)
+        self.assertRaises(StopIteration, next, iterator)
 
     def test_other_extra_at_end(self):
         tree = self.make_branch_and_tree('tree')
@@ -330,7 +330,7 @@
         self.assertWalkerNext(u'a', 'a-id', True, [u'a'], iterator)
         self.assertWalkerNext(u'b', 'b-id', True, [u'b'], iterator)
         self.assertWalkerNext(u'd', 'd-id', False, [u'd'], iterator)
-        self.assertRaises(StopIteration, iterator.next)
+        self.assertRaises(StopIteration, next, iterator)
 
     def test_others_extra_at_end(self):
         tree = self.make_branch_and_tree('tree')
@@ -356,7 +356,7 @@
         self.assertWalkerNext(u'c', 'c-id', False, [u'c', u'c', u'c'], iterator)
         self.assertWalkerNext(u'd', 'd-id', False, [None, u'd', u'd'], iterator)
         self.assertWalkerNext(u'e', 'e-id', False, [None, u'e', None], iterator)
-        self.assertRaises(StopIteration, iterator.next)
+        self.assertRaises(StopIteration, next, iterator)
 
     def test_different_file_id_in_others(self):
         tree = self.make_branch_and_tree('tree')
@@ -384,7 +384,7 @@
         self.assertWalkerNext(u'c', 'c-id', True, [u'c', u'c'], iterator)
         self.assertWalkerNext(u'c/d', 'b-id', True, [u'c/d', u'b'], iterator)
         self.assertWalkerNext(u'c/e', 'a-id', True, [u'a', u'a'], iterator)
-        self.assertRaises(StopIteration, iterator.next)
+        self.assertRaises(StopIteration, next, iterator)
 
     def assertCmpByDirblock(self, cmp_val, path1, path2):
         self.assertEqual(cmp_val,
 
=== modified file 'breezy/tests/test_ui.py'
--- breezy/tests/test_ui.py	2017-05-22 00:56:52 +0000
+++ breezy/tests/test_ui.py	2017-05-26 09:27:07 +0000
@@ -39,7 +39,7 @@
 class TestUIConfiguration(tests.TestCase):
 
     def test_output_encoding_configuration(self):
-        enc = fixtures.generate_unicode_encodings().next()
+        enc = next(fixtures.generate_unicode_encodings())
         config.GlobalStack().set('output_encoding', enc)
         IO = ui_testing.BytesIOWithEncoding
         ui = _mod_ui.make_ui_for_terminal(IO(), IO(), IO())
 
=== modified file 'breezy/tests/test_versionedfile.py'
--- breezy/tests/test_versionedfile.py	2017-05-22 00:56:52 +0000
+++ breezy/tests/test_versionedfile.py	2017-05-26 09:27:07 +0000
@@ -88,7 +88,7 @@
         self.assertEqual(sorted([('one',), ('two',), ('three',)]),
                          sorted(gen.needed_keys))
         stream = vf.get_record_stream(gen.needed_keys, 'topological', True)
-        record = stream.next()
+        record = next(stream)
         self.assertEqual(('one',), record.key)
         # one is not needed in the output, but it is needed by children. As
         # such, it should end up in the various caches
@@ -99,7 +99,7 @@
         self.assertEqual([], gen.diffs.keys())
         # Next we get 'two', which is something we output, but also needed for
         # three
-        record = stream.next()
+        record = next(stream)
         self.assertEqual(('two',), record.key)
         gen._process_one_record(record.key, record.get_bytes_as('chunked'))
         # Both are now cached, and the diff for two has been extracted, and
@@ -113,7 +113,7 @@
                          gen.parent_map)
         # Finally 'three', which allows us to remove all parents from the
         # caches
-        record = stream.next()
+        record = next(stream)
         self.assertEqual(('three',), record.key)
         gen._process_one_record(record.key, record.get_bytes_as('chunked'))
         # Both are now cached, and the diff for two has been extracted, and
 
=== modified file 'breezy/transform.py'
--- breezy/transform.py	2017-05-22 00:56:52 +0000
+++ breezy/transform.py	2017-05-26 09:27:07 +0000
@@ -305,7 +305,7 @@
             return self._r_new_id[file_id]
         else:
             try:
-                self._tree.iter_entries_by_dir([file_id]).next()
+                next(self._tree.iter_entries_by_dir([file_id]))
             except StopIteration:
                 if file_id in self._non_present_ids:
                     return self._non_present_ids[file_id]
@@ -1138,7 +1138,7 @@
         :param records: An iterable of (names, content) tuples, as per
             pack.ContainerPushParser.
         """
-        names, content = records.next()
+        names, content = next(records)
         attribs = bencode.bdecode(content)
         self._id_number = attribs['_id_number']
         self._new_name = dict((k, v.decode('utf-8'))
@@ -2675,7 +2675,7 @@
                      in iter if not (c or e[0] != e[1])]
         if accelerator_tree.supports_content_filtering():
             unchanged = [(f, p) for (f, p) in unchanged
-                         if not accelerator_tree.iter_search_rules([p]).next()]
+                         if not next(accelerator_tree.iter_search_rules([p]))]
         unchanged = dict(unchanged)
         new_desired_files = []
         count = 0
@@ -3091,8 +3091,8 @@
                         file_id = tt.final_file_id(trans_id)
                         if file_id is None:
                             file_id = tt.inactive_file_id(trans_id)
-                        _, entry = path_tree.iter_entries_by_dir(
-                            [file_id]).next()
+                        _, entry = next(path_tree.iter_entries_by_dir(
+                            [file_id]))
                         # special-case the other tree root (move its
                         # children to current root)
                         if entry.parent_id is None:
 
=== modified file 'breezy/transport/__init__.py'
--- breezy/transport/__init__.py	2017-05-22 00:56:52 +0000
+++ breezy/transport/__init__.py	2017-05-26 09:27:07 +0000
@@ -703,7 +703,7 @@
 
         # turn the list of offsets into a stack
         offset_stack = iter(offsets)
-        cur_offset_and_size = offset_stack.next()
+        cur_offset_and_size = next(offset_stack)
         coalesced = self._coalesce_offsets(sorted_offsets,
                                limit=self._max_readv_combine,
                                fudge_factor=self._bytes_to_read_before_seek)
@@ -729,7 +729,7 @@
                     this_data = data_map.pop(cur_offset_and_size)
                     this_offset = cur_offset_and_size[0]
                     try:
-                        cur_offset_and_size = offset_stack.next()
+                        cur_offset_and_size = next(offset_stack)
                     except StopIteration:
                         fp.close()
                         cur_offset_and_size = None
 
=== modified file 'breezy/transport/http/__init__.py'
--- breezy/transport/http/__init__.py	2017-05-22 00:56:52 +0000
+++ breezy/transport/http/__init__.py	2017-05-26 09:27:07 +0000
@@ -194,7 +194,7 @@
             # serve the corresponding offsets respecting the initial order. We
             # need an offset iterator for that.
             iter_offsets = iter(offsets)
-            cur_offset_and_size = iter_offsets.next()
+            cur_offset_and_size = next(iter_offsets)
 
             try:
                 for cur_coal, rfile in self._coalesce_readv(relpath, coalesced):
@@ -211,7 +211,7 @@
                             # The offset requested are sorted as the coalesced
                             # ones, no need to cache. Win !
                             yield cur_offset_and_size[0], data
-                            cur_offset_and_size = iter_offsets.next()
+                            cur_offset_and_size = next(iter_offsets)
                         else:
                             # Different sorting. We need to cache.
                             data_map[(start, size)] = data
@@ -223,7 +223,7 @@
                         # vila20071129
                         this_data = data_map.pop(cur_offset_and_size)
                         yield cur_offset_and_size[0], this_data
-                        cur_offset_and_size = iter_offsets.next()
+                        cur_offset_and_size = next(iter_offsets)
 
             except (errors.ShortReadvError, errors.InvalidRange,
                     errors.InvalidHttpRange, errors.HttpBoundaryMissing) as e:
 
=== modified file 'breezy/transport/remote.py'
--- breezy/transport/remote.py	2017-05-22 00:56:52 +0000
+++ breezy/transport/remote.py	2017-05-26 09:27:07 +0000
@@ -354,7 +354,7 @@
         # turn the list of offsets into a single stack to iterate
         offset_stack = iter(offsets)
         # using a list so it can be modified when passing down and coming back
-        next_offset = [offset_stack.next()]
+        next_offset = [next(offset_stack)]
         for cur_request in requests:
             try:
                 result = self._client.call_with_body_readv_array(
@@ -398,7 +398,7 @@
                 #       not have a real string.
                 if key == cur_offset_and_size:
                     yield cur_offset_and_size[0], this_data
-                    cur_offset_and_size = next_offset[0] = offset_stack.next()
+                    cur_offset_and_size = next_offset[0] = next(offset_stack)
                 else:
                     data_map[key] = this_data
             data_offset += c_offset.length
@@ -407,7 +407,7 @@
             while cur_offset_and_size in data_map:
                 this_data = data_map.pop(cur_offset_and_size)
                 yield cur_offset_and_size[0], this_data
-                cur_offset_and_size = next_offset[0] = offset_stack.next()
+                cur_offset_and_size = next_offset[0] = next(offset_stack)
 
     def rename(self, rel_from, rel_to):
         self._call('rename',
 
=== modified file 'breezy/transport/sftp.py'
--- breezy/transport/sftp.py	2017-05-25 00:04:21 +0000
+++ breezy/transport/sftp.py	2017-05-26 09:27:07 +0000
@@ -188,7 +188,7 @@
         """
         requests = self._get_requests()
         offset_iter = iter(self.original_offsets)
-        cur_offset, cur_size = offset_iter.next()
+        cur_offset, cur_size = next(offset_iter)
         # paramiko .readv() yields strings that are in the order of the requests
         # So we track the current request to know where the next data is
         # being returned from.
@@ -262,7 +262,7 @@
                     input_start += cur_size
                     # Yield the requested data
                     yield cur_offset, cur_data
-                    cur_offset, cur_size = offset_iter.next()
+                    cur_offset, cur_size = next(offset_iter)
                 # at this point, we've consumed as much of buffered as we can,
                 # so break off the portion that we consumed
                 if buffered_offset == len(buffered_data):
@@ -311,7 +311,7 @@
                         ' We expected %d bytes, but only found %d'
                         % (cur_size, len(data)))
                 yield cur_offset, data
-                cur_offset, cur_size = offset_iter.next()
+                cur_offset, cur_size = next(offset_iter)
 
 
 class SFTPTransport(ConnectedTransport):
 
=== modified file 'breezy/tree.py'
--- breezy/tree.py	2017-05-22 00:56:52 +0000
+++ breezy/tree.py	2017-05-26 09:27:07 +0000
@@ -641,7 +641,7 @@
             return []
         if path is None:
             path = self.id2path(file_id)
-        prefs = self.iter_search_rules([path], filter_pref_names).next()
+        prefs = next(self.iter_search_rules([path], filter_pref_names))
         stk = filters._get_filter_stack_for(prefs)
         if 'filters' in debug.debug_flags:
             trace.note(gettext("*** {0} content-filter: {1} => {2!r}").format(path,prefs,stk))
@@ -731,7 +731,7 @@
         :return: The input path adjusted to account for existing elements
         that match case insensitively.
         """
-        return self._yield_canonical_inventory_paths([path]).next()
+        return next(self._yield_canonical_inventory_paths([path]))
 
     def _yield_canonical_inventory_paths(self, paths):
         for path in paths:
@@ -1439,7 +1439,7 @@
             If has_more is False, path and ie will be None.
         """
         try:
-            path, ie = iterator.next()
+            path, ie = next(iterator)
         except StopIteration:
             return False, None, None
         else:
 
=== modified file 'breezy/vf_repository.py'
--- breezy/vf_repository.py	2017-05-24 19:44:00 +0000
+++ breezy/vf_repository.py	2017-05-26 09:27:07 +0000
@@ -1728,7 +1728,7 @@
     @needs_read_lock
     def get_inventory(self, revision_id):
         """Get Inventory object by revision id."""
-        return self.iter_inventories([revision_id]).next()
+        return next(self.iter_inventories([revision_id]))
 
     def iter_inventories(self, revision_ids, ordering=None):
         """Get many inventories by revision_ids.
@@ -1771,7 +1771,7 @@
             return
         if order_as_requested:
             key_iter = iter(keys)
-            next_key = key_iter.next()
+            next_key = next(key_iter)
         stream = self.inventories.get_record_stream(keys, ordering, True)
         text_chunks = {}
         for record in stream:
@@ -1789,7 +1789,7 @@
                     chunks = text_chunks.pop(next_key)
                     yield ''.join(chunks), next_key[-1]
                     try:
-                        next_key = key_iter.next()
+                        next_key = next(key_iter)
                     except StopIteration:
                         # We still want to fully consume the get_record_stream,
                         # just in case it is not actually finished at this point
@@ -1817,7 +1817,7 @@
     def _get_inventory_xml(self, revision_id):
         """Get serialized inventory as a string."""
         texts = self._iter_inventory_xmls([revision_id], 'unordered')
-        text, revision_id = texts.next()
+        text, revision_id = next(texts)
         if text is None:
             raise errors.NoSuchRevision(self, revision_id)
         return text
@@ -1943,7 +1943,7 @@
         """Return the text for a signature."""
         stream = self.signatures.get_record_stream([(revision_id,)],
             'unordered', True)
-        record = stream.next()
+        record = next(stream)
         if record.storage_kind == 'absent':
             raise errors.NoSuchRevision(self, revision_id)
         return record.get_bytes_as('fulltext')
@@ -3149,7 +3149,7 @@
     entries = inv.iter_entries()
     # backwards compatibility hack: skip the root id.
     if not repository.supports_rich_root():
-        path, root = entries.next()
+        path, root = next(entries)
         if root.revision != rev.revision_id:
             raise errors.IncompatibleRevision(repr(repository))
     text_keys = {}
 
=== modified file 'breezy/vf_search.py'
--- breezy/vf_search.py	2017-05-22 00:56:52 +0000
+++ breezy/vf_search.py	2017-05-26 09:27:07 +0000
@@ -417,7 +417,7 @@
     found_heads = set()
     while True:
         try:
-            next_revs = s.next()
+            next_revs = next(s)
         except StopIteration:
             break
         for parents in s._current_parents.itervalues():
 
=== modified file 'breezy/weavefile.py'
--- breezy/weavefile.py	2017-05-24 19:44:00 +0000
+++ breezy/weavefile.py	2017-05-26 09:27:07 +0000
@@ -122,7 +122,7 @@
         f.close()
 
     try:
-        l = lines.next()
+        l = next(lines)
     except StopIteration:
         raise WeaveFormatError('invalid weave file: no header')
 
@@ -132,7 +132,7 @@
     ver = 0
     # read weave header.
     while True:
-        l = lines.next()
+        l = next(lines)
         if l[0] == 'i':
             if len(l) > 2:
                 w._parents.append(list(map(int, l[2:].split(' '))))
@@ -140,11 +140,11 @@
                 w._parents.append([])
             l = lines.next()[:-1]
             w._sha1s.append(l[2:])
-            l = lines.next()
+            l = next(lines)
             name = l[2:-1]
             w._names.append(name)
             w._name_map[name] = ver
-            l = lines.next()
+            l = next(lines)
             ver += 1
         elif l == 'w\n':
             break
@@ -153,7 +153,7 @@
 
     # read weave body
     while True:
-        l = lines.next()
+        l = next(lines)
         if l == 'W\n':
             break
         elif '. ' == l[0:2]:
 
=== modified file 'breezy/workingtree.py'
--- breezy/workingtree.py	2017-05-22 00:56:52 +0000
+++ breezy/workingtree.py	2017-05-26 09:27:07 +0000
@@ -1594,7 +1594,7 @@
         inventory_iterator = self._walkdirs(prefix)
         disk_iterator = osutils.walkdirs(disk_top, prefix)
         try:
-            current_disk = disk_iterator.next()
+            current_disk = next(disk_iterator)
             disk_finished = False
         except OSError as e:
             if not (e.errno == errno.ENOENT or
@@ -1603,7 +1603,7 @@
             current_disk = None
             disk_finished = True
         try:
-            current_inv = inventory_iterator.next()
+            current_inv = next(inventory_iterator)
             inv_finished = False
         except StopIteration:
             current_inv = None
@@ -1644,7 +1644,7 @@
                     cur_disk_dir_content]
                 yield (cur_disk_dir_relpath, None), dirblock
                 try:
-                    current_disk = disk_iterator.next()
+                    current_disk = next(disk_iterator)
                 except StopIteration:
                     disk_finished = True
             elif direction < 0:
@@ -1654,7 +1654,7 @@
                     current_inv[1]]
                 yield (current_inv[0][0], current_inv[0][1]), dirblock
                 try:
-                    current_inv = inventory_iterator.next()
+                    current_inv = next(inventory_iterator)
                 except StopIteration:
                     inv_finished = True
             else:
@@ -1686,11 +1686,11 @@
                         raise NotImplementedError('unreachable code')
                 yield current_inv[0], dirblock
                 try:
-                    current_inv = inventory_iterator.next()
+                    current_inv = next(inventory_iterator)
                 except StopIteration:
                     inv_finished = True
                 try:
-                    current_disk = disk_iterator.next()
+                    current_disk = next(disk_iterator)
                 except StopIteration:
                     disk_finished = True
 
@@ -2073,7 +2073,7 @@
             return _mod_conflicts.ConflictList()
         try:
             try:
-                if confile.next() != CONFLICT_HEADER_1 + '\n':
+                if next(confile) != CONFLICT_HEADER_1 + '\n':
                     raise errors.ConflictFormatError()
             except StopIteration:
                 raise errors.ConflictFormatError()
@@ -2370,7 +2370,7 @@
         try:
             merge_hashes = {}
             try:
-                if hashfile.next() != MERGE_MODIFIED_HEADER_1 + '\n':
+                if next(hashfile) != MERGE_MODIFIED_HEADER_1 + '\n':
                     raise errors.MergeModifiedFormatError()
             except StopIteration:
                 raise errors.MergeModifiedFormatError()
 
=== modified file 'breezy/workingtree_4.py'
--- breezy/workingtree_4.py	2017-05-24 16:21:50 +0000
+++ breezy/workingtree_4.py	2017-05-26 09:27:07 +0000
@@ -1288,7 +1288,7 @@
                 ids_to_unversion.remove(entry[0][2])
             block_index += 1
         if ids_to_unversion:
-            raise errors.NoSuchId(self, iter(ids_to_unversion).next())
+            raise errors.NoSuchId(self, next(iter(ids_to_unversion)))
         self._make_dirty(reset_inventory=False)
         # have to change the legacy inventory too.
         if self._inventory is not None:
@@ -2014,7 +2014,7 @@
         # FIXME: Support nested trees
         entries = inv.iter_entries(from_dir=from_dir_id, recursive=recursive)
         if inv.root is not None and not include_root and from_dir is None:
-            entries.next()
+            next(entries)
         for path, entry in entries:
             yield path, 'V', entry.kind, entry.file_id, entry
 
 
=== modified file 'breezy/xml_serializer.py'
--- breezy/xml_serializer.py	2017-05-22 00:56:52 +0000
+++ breezy/xml_serializer.py	2017-05-26 09:27:07 +0000
@@ -367,7 +367,7 @@
     """
     entries = inv.iter_entries()
     # Skip the root
-    root_path, root_ie = entries.next()
+    root_path, root_ie = next(entries)
     for path, ie in entries:
         if ie.parent_id != root_id:
             parent_str = ' parent_id="'