Merge lp:~jelmer/brz/more-cleanups into lp:brz

[Jelmer Vernooij]

Sprinkle some PEP8iness.

Sprinkle some PEP8iness.

[Martin Packman (gz)]

Lets trust the autopep8 isn't too far off and do another manual pass later.

review: Approve

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

Merging failed
https://ci.breezy-vcs.org/job/brz/job/brz-land/35/

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

Running landing tests failed
https://ci.breezy-vcs.org/job/brz/job/brz-land/37/

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

Running landing tests failed
https://ci.breezy-vcs.org/job/brz/job/brz-land/38/

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

Merging failed
https://ci.breezy-vcs.org/job/brz/job/brz-land/40/

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

Running landing tests failed
https://ci.breezy-vcs.org/job/brz/job/brz-land/41/

=== modified file 'breezy/__init__.py'
--- breezy/__init__.py	2018-09-16 09:45:55 +0000
+++ breezy/__init__.py	2018-11-16 18:34:24 +0000
@@ -53,6 +53,7 @@
 
 version_info = (3, 0, 0, 'alpha', 1)
 
+
 def _format_version_tuple(version_info):
     """Turn a version number 2, 3 or 5-tuple into a short string.
 
@@ -129,7 +130,7 @@
 
 def _patch_filesystem_default_encoding(new_enc):
     """Change the Python process global encoding for filesystem names
-    
+
     The effect is to change how open() and other builtin functions handle
     unicode filenames on posix systems. This should only be done near startup.
 
@@ -142,15 +143,15 @@
     try:
         import ctypes
         old_ptr = ctypes.c_void_p.in_dll(ctypes.pythonapi,
-            "Py_FileSystemDefaultEncoding")
+                                         "Py_FileSystemDefaultEncoding")
         if is_py3:
             has_enc = ctypes.c_int.in_dll(ctypes.pythonapi,
-                "Py_HasFileSystemDefaultEncoding")
+                                          "Py_HasFileSystemDefaultEncoding")
             as_utf8 = ctypes.PYFUNCTYPE(
                 ctypes.POINTER(ctypes.c_char), ctypes.py_object)(
                     ("PyUnicode_AsUTF8", ctypes.pythonapi))
     except (ImportError, ValueError):
-        return # No ctypes or not CPython implementation, do nothing
+        return  # No ctypes or not CPython implementation, do nothing
     if is_py3:
         new_enc = sys.intern(new_enc)
         enc_ptr = as_utf8(new_enc)

=== modified file 'breezy/_annotator_py.py'
--- breezy/_annotator_py.py	2018-02-24 15:50:23 +0000
+++ breezy/_annotator_py.py	2018-11-16 18:34:24 +0000
@@ -94,15 +94,15 @@
             needed_keys = set()
             next_parent_map.update(self._vf.get_parent_map(parent_lookup))
             for key, parent_keys in viewitems(next_parent_map):
-                if parent_keys is None: # No graph versionedfile
+                if parent_keys is None:  # No graph versionedfile
                     parent_keys = ()
                     next_parent_map[key] = ()
                 self._update_needed_children(key, parent_keys)
                 needed_keys.update([key for key in parent_keys
-                                         if key not in parent_map])
+                                    if key not in parent_map])
             parent_map.update(next_parent_map)
-            # _heads_provider does some graph caching, so it is only valid while
-            # self._parent_map hasn't changed
+            # _heads_provider does some graph caching, so it is only valid
+            # while self._parent_map hasn't changed
             self._heads_provider = None
         return vf_keys_needed, ann_keys_needed
 
@@ -118,7 +118,7 @@
         keys, ann_keys = self._get_needed_keys(key)
         if pb is not None:
             pb.update('getting stream', 0, len(keys))
-        stream  = self._vf.get_record_stream(keys, 'topological', True)
+        stream = self._vf.get_record_stream(keys, 'topological', True)
         for idx, record in enumerate(stream):
             if pb is not None:
                 pb.update('extracting', 0, len(keys))
@@ -148,8 +148,8 @@
         parent_lines = self._text_cache[parent_key]
         parent_annotations = self._annotations_cache[parent_key]
         # PatienceSequenceMatcher should probably be part of Policy
-        matcher = patiencediff.PatienceSequenceMatcher(None,
-            parent_lines, text)
+        matcher = patiencediff.PatienceSequenceMatcher(
+            None, parent_lines, text)
         matching_blocks = matcher.get_matching_blocks()
         return parent_annotations, matching_blocks
 
@@ -157,7 +157,7 @@
         """Reannotate this text relative to its first parent."""
         (parent_annotations,
          matching_blocks) = self._get_parent_annotations_and_matches(
-                                key, lines, parent_key)
+             key, lines, parent_key)
 
         for parent_idx, lines_idx, match_len in matching_blocks:
             # For all matching regions we copy across the parent annotations
@@ -169,7 +169,7 @@
         """Reannotate this text relative to a second (or more) parent."""
         (parent_annotations,
          matching_blocks) = self._get_parent_annotations_and_matches(
-                                key, lines, parent_key)
+             key, lines, parent_key)
 
         last_ann = None
         last_parent = None
@@ -262,7 +262,8 @@
             lines the text of "key" as a list of lines
         """
         with ui.ui_factory.nested_progress_bar() as pb:
-            for text_key, text, num_lines in self._get_needed_texts(key, pb=pb):
+            for text_key, text, num_lines in self._get_needed_texts(
+                    key, pb=pb):
                 self._annotate_one(text_key, text, num_lines)
         try:
             annotations = self._annotations_cache[key]
@@ -306,7 +307,8 @@
             else:
                 the_heads = heads(annotation)
                 if len(the_heads) == 1:
-                    for head in the_heads: break # get the item out of the set
+                    for head in the_heads:
+                        break  # get the item out of the set
                 else:
                     head = self._resolve_annotation_tie(the_heads, line,
                                                         custom_tiebreaker)

=== modified file 'breezy/_known_graph_py.py'
--- breezy/_known_graph_py.py	2017-10-28 12:46:54 +0000
+++ breezy/_known_graph_py.py	2018-11-16 18:34:24 +0000
@@ -106,7 +106,7 @@
 
     def _find_tips(self):
         return [node for node in viewvalues(self._nodes)
-                      if not node.child_keys]
+                if not node.child_keys]
 
     def _find_gdfo(self):
         nodes = self._nodes
@@ -144,7 +144,7 @@
 
         If this fills in a ghost, then the gdfos of all children will be
         updated accordingly.
-        
+
         :param key: The node being added. If this is a duplicate, this is a
             no-op.
         :param parent_keys: The parents of the given node.
@@ -163,9 +163,10 @@
                 parent_keys = list(parent_keys)
                 existing_parent_keys = list(node.parent_keys)
                 if parent_keys == existing_parent_keys:
-                    return # Identical content
+                    return  # Identical content
                 else:
-                    raise ValueError('Parent key mismatch, existing node %s'
+                    raise ValueError(
+                        'Parent key mismatch, existing node %s'
                         ' has parents of %s not %s'
                         % (key, existing_parent_keys, parent_keys))
         else:
@@ -319,7 +320,7 @@
 
         result = []
         for prefix in sorted(prefix_tips):
-            pending = sorted(prefix_tips[prefix], key=lambda n:n.key,
+            pending = sorted(prefix_tips[prefix], key=lambda n: n.key,
                              reverse=True)
             while pending:
                 node = pending.pop()
@@ -344,23 +345,23 @@
         from breezy import tsort
         as_parent_map = dict((node.key, node.parent_keys)
                              for node in viewvalues(self._nodes)
-                              if node.parent_keys is not None)
+                             if node.parent_keys is not None)
         # We intentionally always generate revnos and never force the
         # mainline_revisions
         # Strip the sequence_number that merge_sort generates
         return [_MergeSortNode(key, merge_depth, revno, end_of_merge)
                 for _, key, merge_depth, revno, end_of_merge
-                 in tsort.merge_sort(as_parent_map, tip_key,
-                                     mainline_revisions=None,
-                                     generate_revno=True)]
-    
+                in tsort.merge_sort(as_parent_map, tip_key,
+                                    mainline_revisions=None,
+                                    generate_revno=True)]
+
     def get_parent_keys(self, key):
         """Get the parents for a key
-        
+
         Returns a list containg the parents keys. If the key is a ghost,
         None is returned. A KeyError will be raised if the key is not in
         the graph.
-        
+
         :param keys: Key to check (eg revision_id)
         :return: A list of parents
         """
@@ -368,10 +369,10 @@
 
     def get_child_keys(self, key):
         """Get the children for a key
-        
+
         Returns a list containg the children keys. A KeyError will be raised
         if the key is not in the graph.
-        
+
         :param keys: Key to check (eg revision_id)
         :return: A list of children
         """

=== modified file 'breezy/_patiencediff_py.py'
--- breezy/_patiencediff_py.py	2017-06-04 18:09:30 +0000
+++ breezy/_patiencediff_py.py	2018-11-16 18:34:24 +0000
@@ -23,9 +23,6 @@
 from .trace import mutter
 
 
-__all__ = ['PatienceSequenceMatcher', 'unified_diff', 'unified_diff_files']
-
-
 def unique_lcs_py(a, b):
     """Find the longest common subset for unique lines.
 

=== modified file 'breezy/_rio_py.py'
--- breezy/_rio_py.py	2017-06-10 01:57:00 +0000
+++ breezy/_rio_py.py	2018-11-16 18:34:24 +0000
@@ -25,6 +25,8 @@
     )
 
 _tag_re = re.compile(r'^[-a-zA-Z0-9_]+$')
+
+
 def _valid_tag(tag):
     if not isinstance(tag, str):
         raise TypeError(tag)
@@ -55,11 +57,11 @@
         if line == u'\n':
             break       # end of stanza
         real_l = line
-        if line[0] == u'\t': # continues previous value
+        if line[0] == u'\t':  # continues previous value
             if tag is None:
                 raise ValueError('invalid continuation line %r' % real_l)
             accum_value.append(u'\n' + line[1:-1])
-        else: # new tag:value line
+        else:  # new tag:value line
             if tag is not None:
                 stanza.add(tag, u''.join(accum_value))
             try:
@@ -70,9 +72,9 @@
             tag = str(line[:colon_index])
             if not _valid_tag(tag):
                 raise ValueError("invalid rio tag %r" % (tag,))
-            accum_value = [line[colon_index+2:-1]]
+            accum_value = [line[colon_index + 2:-1]]
 
-    if tag is not None: # add last tag-value
+    if tag is not None:  # add last tag-value
         stanza.add(tag, u''.join(accum_value))
         return stanza
     else:     # didn't see any content

=== modified file 'breezy/_static_tuple_py.py'
--- breezy/_static_tuple_py.py	2017-11-12 13:53:51 +0000
+++ breezy/_static_tuple_py.py	2018-11-16 18:34:24 +0000
@@ -44,8 +44,8 @@
         for bit in args:
             if type(bit) not in _valid_types:
                 raise TypeError('StaticTuple can only point to'
-                    ' StaticTuple, str, unicode, int, float, bool, or'
-                    ' None not %s' % (type(bit),))
+                                ' StaticTuple, str, unicode, int, float, bool, or'
+                                ' None not %s' % (type(bit),))
         # We don't need to pass args to tuple.__init__, because that was
         # already handled in __new__.
         tuple.__init__(self)

=== modified file 'breezy/_termcolor.py'
--- breezy/_termcolor.py	2012-08-23 15:04:34 +0000
+++ breezy/_termcolor.py	2018-11-16 18:34:24 +0000
@@ -75,4 +75,3 @@
         return curses.tigetnum('colors') > 2
     except curses.error:
         return False
-

=== modified file 'breezy/annotate.py'
--- breezy/annotate.py	2018-11-16 12:35:23 +0000
+++ breezy/annotate.py	2018-11-16 18:34:24 +0000
@@ -93,8 +93,8 @@
         current_rev.timezone = osutils.local_time_offset()
     else:
         current_rev = None
-    annotation = list(_expand_annotations(annotations, branch,
-        current_rev))
+    annotation = list(_expand_annotations(
+        annotations, branch, current_rev))
     _print_annotations(annotation, verbose, to_file, full, encoding)
 
 
@@ -144,8 +144,8 @@
             this = origin
         else:
             this = b''
-        to_file.write('%*s | %s' % (max_origin_len, this.decode('utf-8'),
-            text.decode(encoding)))
+        to_file.write('%*s | %s' % (
+            max_origin_len, this.decode('utf-8'), text.decode(encoding)))
         last_rev_id = origin
     return
 
@@ -172,8 +172,9 @@
         #      Once KnownGraph gets an 'add_node()' function, we can use
         #      VF.get_known_graph_ancestry().
         graph = repository.get_graph()
-        revision_graph = dict(((key, value) for key, value in
-            graph.iter_ancestry(current_rev.parent_ids) if value is not None))
+        revision_graph = {
+            key: value for key, value in
+            graph.iter_ancestry(current_rev.parent_ids) if value is not None}
         revision_graph = _strip_NULL_ghosts(revision_graph)
         revision_graph[last_revision] = current_rev.parent_ids
         merge_sorted_revisions = tsort.merge_sort(
@@ -181,9 +182,10 @@
             last_revision,
             None,
             generate_revno=True)
-        revision_id_to_revno = dict((rev_id, revno)
+        revision_id_to_revno = {
+            rev_id: revno
             for seq_num, rev_id, depth, revno, end_of_merge in
-                merge_sorted_revisions)
+            merge_sorted_revisions}
     else:
         # TODO(jelmer): Only look up the revision ids that we need (i.e. those
         # in revision_ids). Possibly add a HPSS call that can look those up
@@ -196,9 +198,9 @@
             "%d?" % (branch.revno() + 1),)
         revisions[CURRENT_REVISION] = current_rev
     revisions.update(
-            entry for entry in
-            repository.iter_revisions(revision_ids)
-            if entry[1] is not None)
+        entry for entry in
+        repository.iter_revisions(revision_ids)
+        if entry[1] is not None)
     for origin, text in annotations:
         text = text.rstrip(b'\r\n')
         if origin == last_origin:
@@ -208,8 +210,8 @@
             if origin not in revisions:
                 (revno_str, author, date_str) = ('?', '?', '?')
             else:
-                revno_str = '.'.join(str(i) for i in
-                                            revision_id_to_revno[origin])
+                revno_str = '.'.join(
+                    str(i) for i in revision_id_to_revno[origin])
             rev = revisions[origin]
             tz = rev.timezone or 0
             date_str = time.strftime('%Y%m%d',
@@ -280,8 +282,8 @@
     new_cur = 0
     if matching_blocks is None:
         plain_parent_lines = [l for r, l in parent_lines]
-        matcher = patiencediff.PatienceSequenceMatcher(None,
-            plain_parent_lines, new_lines)
+        matcher = patiencediff.PatienceSequenceMatcher(
+            None, plain_parent_lines, new_lines)
         matching_blocks = matcher.get_matching_blocks()
     lines = []
     for i, j, n in matching_blocks:
@@ -356,11 +358,11 @@
     for right_idx, child_idx, match_len in match_blocks:
         # All the lines that don't match are just passed along
         if child_idx > last_child_idx:
-            output_extend(child_lines[start_child + last_child_idx
-                                      :start_child + child_idx])
+            output_extend(child_lines[start_child + last_child_idx:
+                                      start_child + child_idx])
         for offset in range(match_len):
-            left = child_lines[start_child+child_idx+offset]
-            right = right_lines[start_right+right_idx+offset]
+            left = child_lines[start_child + child_idx + offset]
+            right = right_lines[start_right + right_idx + offset]
             if left[0] == right[0]:
                 # The annotations match, just return the left one
                 output_append(left)
@@ -410,7 +412,8 @@
     # be the bulk of the lines, and they will need no further processing.
     lines = []
     lines_extend = lines.extend
-    last_right_idx = 0  # The line just after the last match from the right side
+    # The line just after the last match from the right side
+    last_right_idx = 0
     last_left_idx = 0
     matching_left_and_right = _get_matching_blocks(right_parent_lines,
                                                    annotated_lines)

=== modified file 'breezy/archive/__init__.py'
--- breezy/archive/__init__.py	2018-05-20 12:21:54 +0000
+++ breezy/archive/__init__.py	2018-11-16 18:34:24 +0000
@@ -52,13 +52,13 @@
         """Register an archive format.
         """
         registry.Registry.register(self, key, factory, help,
-            ArchiveFormatInfo(extensions))
+                                   ArchiveFormatInfo(extensions))
         self._register_extensions(key, extensions)
 
     def register_lazy(self, key, module_name, member_name, extensions,
                       help=None):
         registry.Registry.register_lazy(self, key, module_name, member_name,
-            help, ArchiveFormatInfo(extensions))
+                                        help, ArchiveFormatInfo(extensions))
         self._register_extensions(key, extensions)
 
     def _register_extensions(self, name, extensions):
@@ -94,7 +94,7 @@
 format_registry.register_lazy('tgz', 'breezy.archive.tar',
                               'tgz_generator', ['.tar.gz', '.tgz'])
 format_registry.register_lazy('tbz2', 'breezy.archive.tar',
-                              'tbz_generator',  ['.tar.bz2', '.tbz2'])
+                              'tbz_generator', ['.tar.bz2', '.tbz2'])
 format_registry.register_lazy('tlzma', 'breezy.archive.tar',
                               'tar_lzma_generator', ['.tar.lzma'])
 format_registry.register_lazy('txz', 'breezy.archive.tar',

=== modified file 'breezy/archive/tar.py'
--- breezy/archive/tar.py	2018-10-29 11:27:33 +0000
+++ breezy/archive/tar.py	2018-11-16 18:34:24 +0000
@@ -138,7 +138,7 @@
         zipstream = gzip.GzipFile(basename, 'w', fileobj=buf,
                                   mtime=root_mtime)
         for chunk in tarball_generator(
-            tree, root, subdir, force_mtime):
+                tree, root, subdir, force_mtime):
             zipstream.write(chunk)
             # Yield the data that was written so far, rinse, repeat.
             yield buf.getvalue()
@@ -160,7 +160,7 @@
 
 
 def plain_tar_generator(tree, dest, root, subdir,
-    force_mtime=None):
+                        force_mtime=None):
     """Export this tree to a new tar file.
 
     `dest` will be created holding the contents of this tree; if it
@@ -188,13 +188,13 @@
 
     if sys.version_info[0] == 2:
         compressor = lzma.LZMACompressor(
-                options={"format": compression_format})
+            options={"format": compression_format})
     else:
         compressor = lzma.LZMACompressor(
-                format={
-                    'xz': lzma.FORMAT_XZ,
-                    'raw': lzma.FORMAT_RAW,
-                    'alone': lzma.FORMAT_ALONE,
+            format={
+                'xz': lzma.FORMAT_XZ,
+                'raw': lzma.FORMAT_RAW,
+                'alone': lzma.FORMAT_ALONE,
                 }[compression_format])
 
     for chunk in tarball_generator(

=== modified file 'breezy/archive/zip.py'
--- breezy/archive/zip.py	2018-10-29 11:27:33 +0000
+++ breezy/archive/zip.py	2018-11-16 18:34:24 +0000
@@ -45,7 +45,7 @@
 
 
 def zip_archive_generator(tree, dest, root, subdir=None,
-    force_mtime=None):
+                          force_mtime=None):
     """ Export this tree to a new zip file.
 
     `dest` will be created holding the contents of this tree; if it
@@ -54,7 +54,7 @@
     compression = zipfile.ZIP_DEFLATED
     with tempfile.SpooledTemporaryFile() as buf:
         with closing(zipfile.ZipFile(buf, "w", compression)) as zipf, \
-             tree.lock_read():
+                tree.lock_read():
             for dp, tp, ie in _export_iter_entries(tree, subdir):
                 mutter("  export {%s} kind %s to %s", tp, ie.kind, dest)
 
@@ -68,8 +68,8 @@
                 filename = osutils.pathjoin(root, dp)
                 if ie.kind == "file":
                     zinfo = zipfile.ZipInfo(
-                                filename=filename,
-                                date_time=date_time)
+                        filename=filename,
+                        date_time=date_time)
                     zinfo.compress_type = compression
                     zinfo.external_attr = _FILE_ATTR
                     content = tree.get_file_text(tp)
@@ -79,15 +79,15 @@
                     # to the zip routine that they are really directories and
                     # not just empty files.
                     zinfo = zipfile.ZipInfo(
-                                filename=filename + '/',
-                                date_time=date_time)
+                        filename=filename + '/',
+                        date_time=date_time)
                     zinfo.compress_type = compression
                     zinfo.external_attr = _DIR_ATTR
                     zipf.writestr(zinfo, '')
                 elif ie.kind == "symlink":
                     zinfo = zipfile.ZipInfo(
-                                filename=(filename + '.lnk'),
-                                date_time=date_time)
+                        filename=(filename + '.lnk'),
+                        date_time=date_time)
                     zinfo.compress_type = compression
                     zinfo.external_attr = _FILE_ATTR
                     zipf.writestr(zinfo, tree.get_symlink_target(tp))

=== modified file 'breezy/bencode.py'
--- breezy/bencode.py	2018-11-10 17:52:47 +0000
+++ breezy/bencode.py	2018-11-16 18:34:24 +0000
@@ -24,4 +24,9 @@
     from ._bencode_pyx import bdecode, bdecode_as_tuple, bencode, Bencached
 except ImportError as e:
     osutils.failed_to_load_extension(e)
-    from .util._bencode_py import bdecode, bdecode_as_tuple, bencode, Bencached  # noqa: F401
+    from .util._bencode_py import (  # noqa: F401
+        bdecode,
+        bdecode_as_tuple,
+        bencode,
+        Bencached,
+        )

=== modified file 'breezy/bisect.py'
--- breezy/bisect.py	2018-11-10 17:52:47 +0000
+++ breezy/bisect.py	2018-11-16 18:34:24 +0000
@@ -138,8 +138,8 @@
         repo = self._branch.repository
         with repo.lock_read():
             graph = repo.get_graph()
-            rev_sequence = graph.iter_lefthand_ancestry(last_revid,
-                (_mod_revision.NULL_REVISION,))
+            rev_sequence = graph.iter_lefthand_ancestry(
+                last_revid, (_mod_revision.NULL_REVISION,))
             high_revid = None
             low_revid = None
             between_revs = []
@@ -247,9 +247,9 @@
         self._find_range_and_middle()
         # If we've found the "final" revision, check for a
         # merge point.
-        while ((self._middle_revid == self._high_revid
-                or self._middle_revid == self._low_revid)
-                and self.is_merge_point(self._middle_revid)):
+        while ((self._middle_revid == self._high_revid or
+                self._middle_revid == self._low_revid) and
+                self.is_merge_point(self._middle_revid)):
             for parent in self.get_parent_revids(self._middle_revid):
                 if parent == self._low_revid:
                     continue
@@ -340,7 +340,8 @@
         bisect_log.save()
         return False
 
-    def run(self, subcommand, args_list, directory='.', revision=None, output=None):
+    def run(self, subcommand, args_list, directory='.', revision=None,
+            output=None):
         """Handle the bisect command."""
 
         log_fn = None
@@ -401,7 +402,7 @@
         self._set_state(controldir, revspec, "yes")
 
     def no(self, controldir, revspec):
-        """Mark that a given revision does not have the state we're looking for."""
+        """Mark a given revision as wrong."""
         self._set_state(controldir, revspec, "no")
 
     def move(self, controldir, revspec):

=== modified file 'breezy/bisect_multi.py'
--- breezy/bisect_multi.py	2011-12-19 13:23:58 +0000
+++ breezy/bisect_multi.py	2018-11-16 18:34:24 +0000
@@ -58,7 +58,7 @@
                 search_keys.append((location - delta, key))
             elif status == 1:
                 search_keys.append((location + delta, key))
-            elif status == False:
+            elif status is False:
                 # not present, stop searching
                 continue
             else:

=== modified file 'breezy/branch.py'
--- breezy/branch.py	2018-11-16 12:35:23 +0000
+++ breezy/branch.py	2018-11-16 18:34:24 +0000
@@ -56,7 +56,7 @@
 class UnstackableBranchFormat(errors.BzrError):
 
     _fmt = ("The branch '%(url)s'(%(format)s) is not a stackable format. "
-        "You will need to upgrade the branch to permit branch stacking.")
+            "You will need to upgrade the branch to permit branch stacking.")
 
     def __init__(self, format, url):
         errors.BzrError.__init__(self)
@@ -154,7 +154,8 @@
         repository._iter_for_revno(
             self.repository, self._partial_revision_history_cache,
             stop_index=stop_index, stop_revision=stop_revision)
-        if self._partial_revision_history_cache[-1] == _mod_revision.NULL_REVISION:
+        if self._partial_revision_history_cache[-1] == \
+                _mod_revision.NULL_REVISION:
             self._partial_revision_history_cache.pop()
 
     def _get_check_refs(self):
@@ -172,17 +173,21 @@
         For instance, if the branch is at URL/.bzr/branch,
         Branch.open(URL) -> a Branch instance.
         """
-        control = controldir.ControlDir.open(base,
-            possible_transports=possible_transports, _unsupported=_unsupported)
-        return control.open_branch(unsupported=_unsupported,
+        control = controldir.ControlDir.open(
+            base, possible_transports=possible_transports,
+            _unsupported=_unsupported)
+        return control.open_branch(
+            unsupported=_unsupported,
             possible_transports=possible_transports)
 
     @staticmethod
     def open_from_transport(transport, name=None, _unsupported=False,
-            possible_transports=None):
+                            possible_transports=None):
         """Open the branch rooted at transport"""
-        control = controldir.ControlDir.open_from_transport(transport, _unsupported)
-        return control.open_branch(name=name, unsupported=_unsupported,
+        control = controldir.ControlDir.open_from_transport(
+            transport, _unsupported)
+        return control.open_branch(
+            name=name, unsupported=_unsupported,
             possible_transports=possible_transports)
 
     @staticmethod
@@ -193,12 +198,13 @@
 
         Basically we keep looking up until we find the control directory or
         run into the root.  If there isn't one, raises NotBranchError.
-        If there is one and it is either an unrecognised format or an unsupported
-        format, UnknownFormatError or UnsupportedFormatError are raised.
-        If there is one, it is returned, along with the unused portion of url.
+        If there is one and it is either an unrecognised format or an
+        unsupported format, UnknownFormatError or UnsupportedFormatError are
+        raised.  If there is one, it is returned, along with the unused portion
+        of url.
         """
-        control, relpath = controldir.ControlDir.open_containing(url,
-                                                         possible_transports)
+        control, relpath = controldir.ControlDir.open_containing(
+            url, possible_transports)
         branch = control.open_branch(possible_transports=possible_transports)
         return (branch, relpath)
 
@@ -270,7 +276,7 @@
                 # Silently fall back to local implicit nick if the master is
                 # unavailable
                 mutter("Could not connect to bound branch, "
-                    "falling back to local nick.\n " + str(e))
+                       "falling back to local nick.\n " + str(e))
         return config.get_nickname()
 
     def _set_nick(self, nick):
@@ -299,8 +305,8 @@
         new_history = []
         check_not_reserved_id = _mod_revision.check_not_reserved_id
         # Do not include ghosts or graph origin in revision_history
-        while (current_rev_id in parents_map and
-               len(parents_map[current_rev_id]) > 0):
+        while (current_rev_id in parents_map
+               and len(parents_map[current_rev_id]) > 0):
             check_not_reserved_id(current_rev_id)
             new_history.append(current_rev_id)
             current_rev_id = parents_map[current_rev_id][0]
@@ -407,17 +413,18 @@
             This dictionary should not be modified by the caller.
         """
         if 'evil' in debug.debug_flags:
-            mutter_callsite(3, "get_revision_id_to_revno_map scales with ancestry.")
+            mutter_callsite(
+                3, "get_revision_id_to_revno_map scales with ancestry.")
         with self.lock_read():
             if self._revision_id_to_revno_cache is not None:
                 mapping = self._revision_id_to_revno_cache
             else:
                 mapping = self._gen_revno_map()
                 self._cache_revision_id_to_revno(mapping)
-            # TODO: jam 20070417 Since this is being cached, should we be returning
-            #       a copy?
-            # I would rather not, and instead just declare that users should not
-            # modify the return value.
+            # TODO: jam 20070417 Since this is being cached, should we be
+            # returning a copy?
+            # I would rather not, and instead just declare that users should
+            # not modify the return value.
             return mapping
 
     def _gen_revno_map(self):
@@ -430,13 +437,14 @@
 
         :return: A dictionary mapping revision_id => dotted revno.
         """
-        revision_id_to_revno = dict((rev_id, revno)
-            for rev_id, depth, revno, end_of_merge
-             in self.iter_merge_sorted_revisions())
+        revision_id_to_revno = {
+            rev_id: revno for rev_id, depth, revno, end_of_merge
+            in self.iter_merge_sorted_revisions()}
         return revision_id_to_revno
 
     def iter_merge_sorted_revisions(self, start_revision_id=None,
-            stop_revision_id=None, stop_rule='exclude', direction='reverse'):
+                                    stop_revision_id=None,
+                                    stop_rule='exclude', direction='reverse'):
         """Walk the revisions for a branch in merge sorted order.
 
         Merge sorted order is the output from a merge-aware,
@@ -454,7 +462,7 @@
             * 'include' - the stop revision is the last item in the result
             * 'with-merges' - include the stop revision and all of its
               merged revisions in the result
-            * 'with-merges-without-common-ancestry' - filter out revisions 
+            * 'with-merges-without-common-ancestry' - filter out revisions
               that are in both ancestries
         :param direction: either 'reverse' or 'forward':
 
@@ -503,7 +511,8 @@
                 raise ValueError('invalid direction %r' % direction)
 
     def _filter_merge_sorted_revisions(self, merge_sorted_revisions,
-        start_revision_id, stop_revision_id, stop_rule):
+                                       start_revision_id, stop_revision_id,
+                                       stop_rule):
         """Iterate over an inclusive range of sorted revisions."""
         rev_iter = iter(merge_sorted_revisions)
         if start_revision_id is not None:
@@ -564,10 +573,10 @@
                 if rev_id == left_parent:
                     # reached the left parent after the stop_revision
                     return
-                if (not reached_stop_revision_id or
-                        rev_id in revision_id_whitelist):
+                if (not reached_stop_revision_id
+                        or rev_id in revision_id_whitelist):
                     yield (rev_id, node.merge_depth, node.revno,
-                       node.end_of_merge)
+                           node.end_of_merge)
                     if reached_stop_revision_id or rev_id == stop_revision_id:
                         # only do the merged revs of rev_id from now on
                         rev = self.repository.get_revision(rev_id)
@@ -629,7 +638,8 @@
         """Tell this branch object not to release the physical lock when this
         object is unlocked.
 
-        If lock_write doesn't return a token, then this method is not supported.
+        If lock_write doesn't return a token, then this method is not
+        supported.
         """
         self.control_files.leave_in_place()
 
@@ -637,7 +647,8 @@
         """Tell this branch object to release the physical lock when this
         object is unlocked, even if it didn't originally acquire it.
 
-        If lock_write doesn't return a token, then this method is not supported.
+        If lock_write doesn't return a token, then this method is not
+        supported.
         """
         self.control_files.dont_leave_in_place()
 
@@ -680,7 +691,7 @@
         """
         with self.lock_write():
             return InterBranch.get(from_branch, self).fetch(
-                    last_revision, limit=limit)
+                last_revision, limit=limit)
 
     def get_bound_location(self):
         """Return the URL of the branch we are bound to.
@@ -708,15 +719,15 @@
         :param revprops: Optional dictionary of revision properties.
         :param revision_id: Optional revision id.
         :param lossy: Whether to discard data that can not be natively
-            represented, when pushing to a foreign VCS 
+            represented, when pushing to a foreign VCS
         """
 
         if config_stack is None:
             config_stack = self.get_config_stack()
 
-        return self.repository.get_commit_builder(self, parents, config_stack,
-            timestamp, timezone, committer, revprops, revision_id,
-            lossy)
+        return self.repository.get_commit_builder(
+            self, parents, config_stack, timestamp, timezone, committer,
+            revprops, revision_id, lossy)
 
     def get_master_branch(self, possible_transports=None):
         """Return the branch we are bound to.
@@ -761,7 +772,8 @@
                 if not graph.is_ancestor(last_rev, revision_id):
                     # our previous tip is not merged into stop_revision
                     raise errors.DivergedBranches(self, other_branch)
-            revno = graph.find_distance_to_null(revision_id, known_revision_ids)
+            revno = graph.find_distance_to_null(
+                revision_id, known_revision_ids)
             self.set_last_revision_info(revno, revision_id)
 
     def set_parent(self, url):
@@ -775,8 +787,8 @@
                 try:
                     url.encode('ascii')
                 except UnicodeEncodeError:
-                    raise urlutils.InvalidURL(url,
-                        "Urls must be 7-bit ascii, "
+                    raise urlutils.InvalidURL(
+                        url, "Urls must be 7-bit ascii, "
                         "use breezy.urlutils.escape")
             url = urlutils.relative_url(self.base, url)
         with self.lock_write():
@@ -793,20 +805,20 @@
         if not self._format.supports_stacking():
             raise UnstackableBranchFormat(self._format, self.user_url)
         with self.lock_write():
-            # XXX: Changing from one fallback repository to another does not check
-            # that all the data you need is present in the new fallback.
+            # XXX: Changing from one fallback repository to another does not
+            # check that all the data you need is present in the new fallback.
             # Possibly it should.
             self._check_stackable_repo()
             if not url:
                 try:
-                    old_url = self.get_stacked_on_url()
+                    self.get_stacked_on_url()
                 except (errors.NotStacked, UnstackableBranchFormat,
-                    errors.UnstackableRepositoryFormat):
+                        errors.UnstackableRepositoryFormat):
                     return
                 self._unstack()
             else:
-                self._activate_fallback_location(url,
-                    possible_transports=[self.controldir.root_transport])
+                self._activate_fallback_location(
+                    url, possible_transports=[self.controldir.root_transport])
             # write this out after the repository is stacked to avoid setting a
             # stacked config that doesn't work.
             self._set_config_location('stacked_on_location', url)
@@ -820,15 +832,16 @@
             pb.update(gettext("Unstacking"))
             # The basic approach here is to fetch the tip of the branch,
             # including all available ghosts, from the existing stacked
-            # repository into a new repository object without the fallbacks. 
+            # repository into a new repository object without the fallbacks.
             #
             # XXX: See <https://launchpad.net/bugs/397286> - this may not be
             # correct for CHKMap repostiories
             old_repository = self.repository
             if len(old_repository._fallback_repositories) != 1:
-                raise AssertionError("can't cope with fallback repositories "
-                    "of %r (fallbacks: %r)" % (old_repository,
-                        old_repository._fallback_repositories))
+                raise AssertionError(
+                    "can't cope with fallback repositories "
+                    "of %r (fallbacks: %r)" % (
+                        old_repository, old_repository._fallback_repositories))
             # Open the new repository object.
             # Repositories don't offer an interface to remove fallback
             # repositories today; take the conceptually simpler option and just
@@ -841,8 +854,8 @@
                 self.controldir.root_transport.base)
             new_repository = new_bzrdir.find_repository()
             if new_repository._fallback_repositories:
-                raise AssertionError("didn't expect %r to have "
-                    "fallback_repositories"
+                raise AssertionError(
+                    "didn't expect %r to have fallback_repositories"
                     % (self.repository,))
             # Replace self.repository with the new repository.
             # Do our best to transfer the lock state (i.e. lock-tokens and
@@ -875,7 +888,7 @@
             if old_lock_count == 0:
                 raise AssertionError(
                     'old_repository should have been locked at least once.')
-            for i in range(old_lock_count-1):
+            for i in range(old_lock_count - 1):
                 self.repository.lock_write()
             # Fetch from the old repository into the new.
             with old_repository.lock_read():
@@ -886,8 +899,9 @@
                     tags_to_fetch = set(self.tags.get_reverse_tag_dict())
                 except errors.TagsNotSupported:
                     tags_to_fetch = set()
-                fetch_spec = vf_search.NotInOtherForRevs(self.repository,
-                    old_repository, required_ids=[self.last_revision()],
+                fetch_spec = vf_search.NotInOtherForRevs(
+                    self.repository, old_repository,
+                    required_ids=[self.last_revision()],
                     if_present_ids=tags_to_fetch, find_ghosts=True).execute()
                 self.repository.fetch(old_repository, fetch_spec=fetch_spec)
 
@@ -975,7 +989,8 @@
         """
         with self.lock_read():
             if self._last_revision_info_cache is None:
-                self._last_revision_info_cache = self._read_last_revision_info()
+                self._last_revision_info_cache = (
+                    self._read_last_revision_info())
             return self._last_revision_info_cache
 
     def _read_last_revision_info(self):
@@ -1035,18 +1050,18 @@
 
         :returns: PullResult instance
         """
-        return InterBranch.get(source, self).pull(overwrite=overwrite,
-            stop_revision=stop_revision,
+        return InterBranch.get(source, self).pull(
+            overwrite=overwrite, stop_revision=stop_revision,
             possible_transports=possible_transports, *args, **kwargs)
 
     def push(self, target, overwrite=False, stop_revision=None, lossy=False,
-            *args, **kwargs):
+             *args, **kwargs):
         """Mirror this branch into target.
 
         This branch is considered to be 'local', having low latency.
         """
-        return InterBranch.get(self, target).push(overwrite, stop_revision,
-            lossy, *args, **kwargs)
+        return InterBranch.get(self, target).push(
+            overwrite, stop_revision, lossy, *args, **kwargs)
 
     def basis_tree(self):
         """Return `Tree` object for last revision."""
@@ -1068,7 +1083,7 @@
             parent = urlutils.local_path_to_url(parent)
         try:
             return urlutils.join(self.base[:-1], parent)
-        except urlutils.InvalidURLJoin as e:
+        except urlutils.InvalidURLJoin:
             raise errors.InaccessibleParent(parent, self.user_url)
 
     def _get_parent_location(self):
@@ -1200,7 +1215,7 @@
         return result
 
     def sprout(self, to_controldir, revision_id=None, repository_policy=None,
-            repository=None, lossy=False):
+               repository=None, lossy=False):
         """Create a new line of development from the branch, into to_controldir.
 
         to_controldir controls the branch format.
@@ -1208,8 +1223,8 @@
         revision_id: if not None, the revision history in the new branch will
                      be truncated to end with revision_id.
         """
-        if (repository_policy is not None and
-            repository_policy.requires_stacking()):
+        if (repository_policy is not None
+                and repository_policy.requires_stacking()):
             to_controldir._format.require_stacking(_skip_repo=True)
         result = to_controldir.create_branch(repository=repository)
         if lossy:
@@ -1243,8 +1258,8 @@
         else:
             graph = self.repository.get_graph()
             try:
-                revno = graph.find_distance_to_null(revision_id, 
-                    [(source_revision_id, source_revno)])
+                revno = graph.find_distance_to_null(
+                    revision_id, [(source_revision_id, source_revno)])
             except errors.GhostRevisionsHaveNoRevno:
                 # Default to 1, if we can't find anything else
                 revno = 1
@@ -1295,12 +1310,12 @@
             if actual_revno != last_revno:
                 result.errors.append(errors.BzrCheckError(
                     'revno does not match len(mainline) %s != %s' % (
-                    last_revno, actual_revno)))
+                        last_revno, actual_revno)))
             # TODO: We should probably also check that self.revision_history
             # matches the repository for older branch formats.
-            # If looking for the code that cross-checks repository parents against
-            # the Graph.iter_lefthand_ancestry output, that is now a repository
-            # specific check.
+            # If looking for the code that cross-checks repository parents
+            # against the Graph.iter_lefthand_ancestry output, that is now a
+            # repository specific check.
             return result
 
     def _get_checkout_format(self, lightweight=False):
@@ -1312,8 +1327,8 @@
         return format
 
     def create_clone_on_transport(self, to_transport, revision_id=None,
-        stacked_on=None, create_prefix=False, use_existing_dir=False,
-        no_tree=None):
+                                  stacked_on=None, create_prefix=False,
+                                  use_existing_dir=False, no_tree=None):
         """Create a clone of this branch and its bzrdir.
 
         :param to_transport: The transport to clone onto.
@@ -1326,12 +1341,12 @@
         """
         # XXX: Fix the bzrdir API to allow getting the branch back from the
         # clone call. Or something. 20090224 RBC/spiv.
-        # XXX: Should this perhaps clone colocated branches as well, 
+        # XXX: Should this perhaps clone colocated branches as well,
         # rather than just the default branch? 20100319 JRV
         if revision_id is None:
             revision_id = self.last_revision()
-        dir_to = self.controldir.clone_on_transport(to_transport,
-            revision_id=revision_id, stacked_on=stacked_on,
+        dir_to = self.controldir.clone_on_transport(
+            to_transport, revision_id=revision_id, stacked_on=stacked_on,
             create_prefix=create_prefix, use_existing_dir=use_existing_dir,
             no_tree=no_tree)
         return dir_to.open_branch()
@@ -1368,7 +1383,8 @@
                 pass
             else:
                 raise errors.AlreadyControlDirError(t.base)
-            if checkout.control_transport.base == self.controldir.control_transport.base:
+            if (checkout.control_transport.base
+                    == self.controldir.control_transport.base):
                 # When checking out to the same control directory,
                 # always create a lightweight checkout
                 lightweight = True
@@ -1377,7 +1393,7 @@
             from_branch = checkout.set_branch_reference(target_branch=self)
         else:
             policy = checkout.determine_repository_policy()
-            repo = policy.acquire_repository()[0]
+            policy.acquire_repository()
             checkout_branch = checkout.create_branch()
             checkout_branch.bind(self)
             # pull up to the specified revision_id to set the initial
@@ -1601,7 +1617,7 @@
         raise NotImplementedError(self.network_name)
 
     def open(self, controldir, name=None, _found=False, ignore_fallbacks=False,
-            found_repository=None, possible_transports=None):
+             found_repository=None, possible_transports=None):
         """Return the branch object for controldir.
 
         :param controldir: A ControlDir that contains a branch.
@@ -1623,7 +1639,7 @@
 
     def supports_leaving_lock(self):
         """True if this format supports leaving locks in place."""
-        return False # by default
+        return False  # by default
 
     def __str__(self):
         return self.get_format_description().rstrip()
@@ -1659,18 +1675,22 @@
         notified.
         """
         Hooks.__init__(self, "breezy.branch", "Branch.hooks")
-        self.add_hook('open',
+        self.add_hook(
+            'open',
             "Called with the Branch object that has been opened after a "
             "branch is opened.", (1, 8))
-        self.add_hook('post_push',
+        self.add_hook(
+            'post_push',
             "Called after a push operation completes. post_push is called "
-            "with a breezy.branch.BranchPushResult object and only runs in the "
-            "bzr client.", (0, 15))
-        self.add_hook('post_pull',
+            "with a breezy.branch.BranchPushResult object and only runs in "
+            "the bzr client.", (0, 15))
+        self.add_hook(
+            'post_pull',
             "Called after a pull operation completes. post_pull is called "
             "with a breezy.branch.PullResult object and only runs in the "
             "bzr client.", (0, 15))
-        self.add_hook('pre_commit',
+        self.add_hook(
+            'pre_commit',
             "Called after a commit is calculated but before it is "
             "completed. pre_commit is called with (local, master, old_revno, "
             "old_revid, future_revno, future_revid, tree_delta, future_tree"
@@ -1680,28 +1700,33 @@
             " future_tree is an in-memory tree obtained from "
             "CommitBuilder.revision_tree() and hooks MUST NOT modify this "
             "tree.", (0, 91))
-        self.add_hook('post_commit',
+        self.add_hook(
+            'post_commit',
             "Called in the bzr client after a commit has completed. "
             "post_commit is called with (local, master, old_revno, old_revid, "
             "new_revno, new_revid). old_revid is NULL_REVISION for the first "
             "commit to a branch.", (0, 15))
-        self.add_hook('post_uncommit',
+        self.add_hook(
+            'post_uncommit',
             "Called in the bzr client after an uncommit completes. "
             "post_uncommit is called with (local, master, old_revno, "
             "old_revid, new_revno, new_revid) where local is the local branch "
             "or None, master is the target branch, and an empty branch "
             "receives new_revno of 0, new_revid of None.", (0, 15))
-        self.add_hook('pre_change_branch_tip',
+        self.add_hook(
+            'pre_change_branch_tip',
             "Called in bzr client and server before a change to the tip of a "
             "branch is made. pre_change_branch_tip is called with a "
             "breezy.branch.ChangeBranchTipParams. Note that push, pull, "
             "commit, uncommit will all trigger this hook.", (1, 6))
-        self.add_hook('post_change_branch_tip',
+        self.add_hook(
+            'post_change_branch_tip',
             "Called in bzr client and server after a change to the tip of a "
             "branch is made. post_change_branch_tip is called with a "
             "breezy.branch.ChangeBranchTipParams. Note that push, pull, "
             "commit, uncommit will all trigger this hook.", (1, 4))
-        self.add_hook('transform_fallback_location',
+        self.add_hook(
+            'transform_fallback_location',
             "Called when a stacked branch is activating its fallback "
             "locations. transform_fallback_location is called with (branch, "
             "url), and should return a new url. Returning the same url "
@@ -1713,25 +1738,27 @@
             "multiple hooks installed for transform_fallback_location, "
             "all are called with the url returned from the previous hook."
             "The order is however undefined.", (1, 9))
-        self.add_hook('automatic_tag_name',
+        self.add_hook(
+            'automatic_tag_name',
             "Called to determine an automatic tag name for a revision. "
             "automatic_tag_name is called with (branch, revision_id) and "
             "should return a tag name or None if no tag name could be "
             "determined. The first non-None tag name returned will be used.",
             (2, 2))
-        self.add_hook('post_branch_init',
+        self.add_hook(
+            'post_branch_init',
             "Called after new branch initialization completes. "
             "post_branch_init is called with a "
             "breezy.branch.BranchInitHookParams. "
             "Note that init, branch and checkout (both heavyweight and "
             "lightweight) will all trigger this hook.", (2, 2))
-        self.add_hook('post_switch',
+        self.add_hook(
+            'post_switch',
             "Called after a checkout switches branch. "
             "post_switch is called with a "
             "breezy.branch.SwitchHookParams.", (2, 2))
 
 
-
 # install the default hooks into the Branch class.
 Branch.hooks = BranchHooks()
 
@@ -1842,8 +1869,8 @@
         return self.__dict__ == other.__dict__
 
     def __repr__(self):
-        return "<%s for %s to (%s, %s)>" % (self.__class__.__name__,
-            self.control_dir, self.to_branch,
+        return "<%s for %s to (%s, %s)>" % (
+            self.__class__.__name__, self.control_dir, self.to_branch,
             self.revision_id)
 
 
@@ -1857,8 +1884,8 @@
 
     def get_default(self):
         """Return the current default format."""
-        if (self._default_format_key is not None and
-            self._default_format is None):
+        if (self._default_format_key is not None
+                and self._default_format is None):
             self._default_format = self.get(self._default_format_key)
         return self._default_format
 
@@ -1993,7 +2020,8 @@
             if self.old_revid != self.new_revid:
                 note(gettext('Pushed up to revision %d.') % self.new_revno)
             if tag_updates:
-                note(ngettext('%d tag updated.', '%d tags updated.', len(tag_updates)) % len(tag_updates))
+                note(ngettext('%d tag updated.', '%d tags updated.',
+                              len(tag_updates)) % len(tag_updates))
             if self.old_revid == self.new_revid and not tag_updates:
                 if not tag_conflicts:
                     note(gettext('No new revisions or tags to push.'))
@@ -2019,7 +2047,7 @@
             if any.
         """
         note(gettext('checked branch {0} format {1}').format(
-                                self.branch.user_url, self.branch._format))
+            self.branch.user_url, self.branch._format))
         for error in self.errors:
             note(gettext('found error:%s'), error)
 
@@ -2038,7 +2066,7 @@
     @classmethod
     def _get_branch_formats_to_test(klass):
         """Return an iterable of format tuples for testing.
-        
+
         :return: An iterable of (from_format, to_format) to use when testing
             this InterBranch class. Each InterBranch class should define this
             method itself.
@@ -2136,18 +2164,19 @@
             fetch_spec_factory.source_branch_stop_revision_id = stop_revision
             fetch_spec_factory.source_repo = self.source.repository
             fetch_spec_factory.target_repo = self.target.repository
-            fetch_spec_factory.target_repo_kind = fetch.TargetRepoKinds.PREEXISTING
+            fetch_spec_factory.target_repo_kind = (
+                fetch.TargetRepoKinds.PREEXISTING)
             fetch_spec_factory.limit = limit
             fetch_spec = fetch_spec_factory.make_fetch_spec()
             return self.target.repository.fetch(
-                    self.source.repository,
-                    fetch_spec=fetch_spec)
+                self.source.repository,
+                fetch_spec=fetch_spec)
 
     def _update_revisions(self, stop_revision=None, overwrite=False,
-            graph=None):
+                          graph=None):
         with self.source.lock_read(), self.target.lock_write():
             other_revno, other_last_revision = self.source.last_revision_info()
-            stop_revno = None # unknown
+            stop_revno = None  # unknown
             if stop_revision is None:
                 stop_revision = other_last_revision
                 if _mod_revision.is_null(stop_revision):
@@ -2176,10 +2205,10 @@
                 if graph is None:
                     graph = self.target.repository.get_graph()
                 this_revno, this_last_revision = \
-                        self.target.last_revision_info()
-                stop_revno = graph.find_distance_to_null(stop_revision,
-                                [(other_last_revision, other_revno),
-                                 (this_last_revision, this_revno)])
+                    self.target.last_revision_info()
+                stop_revno = graph.find_distance_to_null(
+                    stop_revision, [(other_last_revision, other_revno),
+                                    (this_last_revision, this_revno)])
             self.target.set_last_revision_info(stop_revno, stop_revision)
 
     def pull(self, overwrite=False, stop_revision=None,
@@ -2208,15 +2237,16 @@
                     source_is_master = False
             if not local and bound_location and not source_is_master:
                 # not pulling from master, so we need to update master.
-                master_branch = self.target.get_master_branch(possible_transports)
+                master_branch = self.target.get_master_branch(
+                    possible_transports)
                 master_branch.lock_write()
             try:
                 if master_branch:
                     # pull from source into master.
-                    master_branch.pull(self.source, overwrite, stop_revision,
-                        run_hooks=False)
-                return self._pull(overwrite,
-                    stop_revision, _hook_master=master_branch,
+                    master_branch.pull(
+                        self.source, overwrite, stop_revision, run_hooks=False)
+                return self._pull(
+                    overwrite, stop_revision, _hook_master=master_branch,
                     run_hooks=run_hooks,
                     _override_hook_target=_override_hook_target,
                     merge_tags_to_master=not source_is_master)
@@ -2239,6 +2269,7 @@
             raise errors.LossyPushToSameVCS(self.source, self.target)
         # TODO: Public option to disable running hooks - should be trivial but
         # needs tests.
+
         def _run_hooks():
             if _override_hook_source_branch:
                 result.source_branch = _override_hook_source_branch
@@ -2250,16 +2281,16 @@
             if bound_location and self.target.base != bound_location:
                 # there is a master branch.
                 #
-                # XXX: Why the second check?  Is it even supported for a branch to
-                # be bound to itself? -- mbp 20070507
+                # XXX: Why the second check?  Is it even supported for a branch
+                # to be bound to itself? -- mbp 20070507
                 master_branch = self.target.get_master_branch()
                 with master_branch.lock_write():
                     # push into the master from the source branch.
                     master_inter = InterBranch.get(self.source, master_branch)
                     master_inter._basic_push(overwrite, stop_revision)
-                    # and push into the target branch from the source. Note that
-                    # we push from the source branch again, because it's considered
-                    # the highest bandwidth repository.
+                    # and push into the target branch from the source. Note
+                    # that we push from the source branch again, because it's
+                    # considered the highest bandwidth repository.
                     result = self._basic_push(overwrite, stop_revision)
                     result.master_branch = master_branch
                     result.local_branch = self.target
@@ -2291,20 +2322,19 @@
             # We assume that during 'push' this repository is closer than
             # the target.
             graph = self.source.repository.get_graph(self.target.repository)
-            self._update_revisions(stop_revision,
-                overwrite=("history" in overwrite),
-                graph=graph)
+            self._update_revisions(
+                stop_revision, overwrite=("history" in overwrite), graph=graph)
         if self.source._push_should_merge_tags():
             result.tag_updates, result.tag_conflicts = (
                 self.source.tags.merge_to(
-                self.target.tags, "tags" in overwrite))
+                    self.target.tags, "tags" in overwrite))
         result.new_revno, result.new_revid = self.target.last_revision_info()
         return result
 
     def _pull(self, overwrite=False, stop_revision=None,
-             possible_transports=None, _hook_master=None, run_hooks=True,
-             _override_hook_target=None, local=False,
-             merge_tags_to_master=True):
+              possible_transports=None, _hook_master=None, run_hooks=True,
+              _override_hook_target=None, local=False,
+              merge_tags_to_master=True):
         """See Branch.pull.
 
         This function is the core worker, used by GenericInterBranch.pull to
@@ -2335,23 +2365,23 @@
             # the source one.
             self.source.update_references(self.target)
             graph = self.target.repository.get_graph(self.source.repository)
-            # TODO: Branch formats should have a flag that indicates 
+            # TODO: Branch formats should have a flag that indicates
             # that revno's are expensive, and pull() should honor that flag.
             # -- JRV20090506
             result.old_revno, result.old_revid = \
                 self.target.last_revision_info()
             overwrite = _fix_overwrite_type(overwrite)
-            self._update_revisions(stop_revision,
-                overwrite=("history" in overwrite),
-                graph=graph)
-            # TODO: The old revid should be specified when merging tags, 
-            # so a tags implementation that versions tags can only 
+            self._update_revisions(
+                stop_revision, overwrite=("history" in overwrite), graph=graph)
+            # TODO: The old revid should be specified when merging tags,
+            # so a tags implementation that versions tags can only
             # pull in the most recent changes. -- JRV20090506
             result.tag_updates, result.tag_conflicts = (
-                self.source.tags.merge_to(self.target.tags,
-                    "tags" in overwrite,
+                self.source.tags.merge_to(
+                    self.target.tags, "tags" in overwrite,
                     ignore_master=not merge_tags_to_master))
-            result.new_revno, result.new_revid = self.target.last_revision_info()
+            result.new_revno, result.new_revid = (
+                self.target.last_revision_info())
             if _hook_master:
                 result.master_branch = _hook_master
                 result.local_branch = result.target_branch

=== modified file 'breezy/branchbuilder.py'
--- breezy/branchbuilder.py	2018-11-16 10:50:21 +0000
+++ breezy/branchbuilder.py	2018-11-16 18:34:24 +0000
@@ -109,12 +109,13 @@
             else:
                 base_id = parent_ids[0]
             if base_id != self._branch.last_revision():
-                self._move_branch_pointer(base_id,
-                    allow_leftmost_as_ghost=allow_leftmost_as_ghost)
+                self._move_branch_pointer(
+                    base_id, allow_leftmost_as_ghost=allow_leftmost_as_ghost)
         tree = self._branch.create_memorytree()
         with tree.lock_write():
             if parent_ids is not None:
-                tree.set_parent_ids(parent_ids,
+                tree.set_parent_ids(
+                    parent_ids,
                     allow_leftmost_as_ghost=allow_leftmost_as_ghost)
             tree.add('')
             return self._do_commit(tree, **commit_kwargs)
@@ -124,11 +125,10 @@
         if message is None and message_callback is None:
             message = u'commit %d' % (self._branch.revno() + 1,)
         return tree.commit(message, message_callback=message_callback,
-            reporter=reporter,
-            **kwargs)
+                           reporter=reporter, **kwargs)
 
     def _move_branch_pointer(self, new_revision_id,
-        allow_leftmost_as_ghost=False):
+                             allow_leftmost_as_ghost=False):
         """Point self._branch to a different revision id."""
         with self._branch.lock_write():
             # We don't seem to have a simple set_last_revision(), so we
@@ -136,8 +136,8 @@
             cur_revno, cur_revision_id = self._branch.last_revision_info()
             try:
                 g = self._branch.repository.get_graph()
-                new_revno = g.find_distance_to_null(new_revision_id,
-                    [(cur_revision_id, cur_revno)])
+                new_revno = g.find_distance_to_null(
+                    new_revision_id, [(cur_revision_id, cur_revno)])
                 self._branch.set_last_revision_info(new_revno, new_revision_id)
             except errors.GhostRevisionsHaveNoRevno:
                 if not allow_leftmost_as_ghost:
@@ -174,8 +174,8 @@
         self._tree = None
 
     def build_snapshot(self, parent_ids, actions, message=None, timestamp=None,
-            allow_leftmost_as_ghost=False, committer=None, timezone=None,
-            message_callback=None, revision_id=None):
+                       allow_leftmost_as_ghost=False, committer=None,
+                       timezone=None, message_callback=None, revision_id=None):
         """Build a commit, shaped in a specific way.
 
         Most of the actions are self-explanatory.  'flush' is special action to
@@ -210,8 +210,8 @@
             else:
                 base_id = parent_ids[0]
             if base_id != self._branch.last_revision():
-                self._move_branch_pointer(base_id,
-                    allow_leftmost_as_ghost=allow_leftmost_as_ghost)
+                self._move_branch_pointer(
+                    base_id, allow_leftmost_as_ghost=allow_leftmost_as_ghost)
 
         if self._tree is not None:
             tree = self._tree
@@ -219,7 +219,8 @@
             tree = self._branch.create_memorytree()
         with tree.lock_write():
             if parent_ids is not None:
-                tree.set_parent_ids(parent_ids,
+                tree.set_parent_ids(
+                    parent_ids,
                     allow_leftmost_as_ghost=allow_leftmost_as_ghost)
             # Unfortunately, MemoryTree.add(directory) just creates an
             # inventory entry. And the only public function to create a
@@ -251,15 +252,17 @@
                 else:
                     raise ValueError('Unknown build action: "%s"' % (action,))
             self._flush_pending(tree, pending)
-            return self._do_commit(tree, message=message, rev_id=revision_id,
+            return self._do_commit(
+                tree, message=message, rev_id=revision_id,
                 timestamp=timestamp, timezone=timezone, committer=committer,
                 message_callback=message_callback)
 
     def _flush_pending(self, tree, pending):
-        """Flush the pending actions in 'pending', i.e. apply them to 'tree'."""
+        """Flush the pending actions in 'pending', i.e. apply them to tree."""
         for path, file_id in pending.to_add_directories:
             if path == '':
-                if tree.has_filename(path) and path in pending.to_unversion_paths:
+                if tree.has_filename(path) \
+                        and path in pending.to_unversion_paths:
                     # We're overwriting this path, no need to unversion
                     pending.to_unversion_paths.discard(path)
                 # Special case, because the path already exists
@@ -270,7 +273,8 @@
             tree.rename_one(from_relpath, to_relpath)
         if pending.to_unversion_paths:
             tree.unversion(pending.to_unversion_paths)
-        tree.add(pending.to_add_files, pending.to_add_file_ids, pending.to_add_kinds)
+        tree.add(pending.to_add_files, pending.to_add_file_ids,
+                 pending.to_add_kinds)
         for path, content in viewitems(pending.new_contents):
             tree.put_file_bytes_non_atomic(path, content)
 
@@ -294,4 +298,3 @@
         self.new_contents = {}
         self.to_unversion_paths = set()
         self.to_rename = []
-

=== modified file 'breezy/breakin.py'
--- breezy/breakin.py	2017-05-21 14:47:52 +0000
+++ breezy/breakin.py	2018-11-16 18:34:24 +0000
@@ -28,9 +28,9 @@
     import pdb
     import sys
     sys.stderr.write("** %s received, entering debugger\n"
-            "** Type 'c' to continue or 'q' to stop the process\n"
-            "** Or %s again to quit (and possibly dump core)\n"
-            % (_breakin_signal_name, _breakin_signal_name))
+                     "** Type 'c' to continue or 'q' to stop the process\n"
+                     "** Or %s again to quit (and possibly dump core)\n"
+                     % (_breakin_signal_name, _breakin_signal_name))
     # It seems that on Windows, when sys.stderr is to a PIPE, then we need to
     # flush. Not sure why it is buffered, but that seems to be the case.
     sys.stderr.flush()

=== modified file 'breezy/bugtracker.py'
--- breezy/bugtracker.py	2018-09-30 18:50:06 +0000
+++ breezy/bugtracker.py	2018-11-16 18:34:24 +0000
@@ -42,8 +42,8 @@
 """
 
 
-_bugs_help = \
-"""When making a commit, metadata about bugs fixed by that change can be
+_bugs_help = """\
+When making a commit, metadata about bugs fixed by that change can be
 recorded by using the ``--fixes`` option. For each bug marked as fixed, an
 entry is included in the 'bugs' revision property stating '<url> <status>'.
 (The only ``status`` value currently supported is ``fixed.``)
@@ -216,8 +216,8 @@
             tracker = tracker_type.get(abbreviated_bugtracker_name, branch)
             if tracker is not None:
                 return tracker
-        raise UnknownBugTrackerAbbreviation(abbreviated_bugtracker_name,
-                branch)
+        raise UnknownBugTrackerAbbreviation(
+            abbreviated_bugtracker_name, branch)
 
     def help_topic(self, topic):
         return _bugs_help
@@ -316,7 +316,7 @@
         if '{project}' not in self._base_url:
             raise InvalidBugTrackerURL(self._abbreviation, self._base_url)
         return self._base_url.replace(
-                '{project}', project).replace('{id}', str(bug_id))
+            '{project}', project).replace('{id}', str(bug_id))
 
 
 tracker_registry.register(
@@ -327,9 +327,9 @@
     'debian', UniqueIntegerBugTracker('deb', 'http://bugs.debian.org/'))
 
 
-tracker_registry.register('gnome',
-    UniqueIntegerBugTracker('gnome',
-                            'http://bugzilla.gnome.org/show_bug.cgi?id='))
+tracker_registry.register(
+    'gnome', UniqueIntegerBugTracker(
+        'gnome', 'http://bugzilla.gnome.org/show_bug.cgi?id='))
 
 
 tracker_registry.register(
@@ -377,6 +377,7 @@
     'squid' or 'apache').
     """
 
+
 tracker_registry.register(
     'trac', URLParametrizedIntegerBugTracker('trac', 'ticket/'))
 

=== modified file 'breezy/builtins.py'
--- breezy/builtins.py	2018-11-16 12:35:23 +0000
+++ breezy/builtins.py	2018-11-16 18:34:24 +0000
@@ -117,12 +117,12 @@
         and the full URL to the actual branch
     """
     # This path is meant to be relative to the existing branch
-    this_url = _get_branch_location(control_dir,
-        possible_transports=possible_transports)
+    this_url = _get_branch_location(
+        control_dir, possible_transports=possible_transports)
     # Perhaps the target control dir supports colocated branches?
     try:
-        root = controldir.ControlDir.open(this_url,
-            possible_transports=possible_transports)
+        root = controldir.ControlDir.open(
+            this_url, possible_transports=possible_transports)
     except errors.NotBranchError:
         return (False, this_url)
     else:
@@ -149,8 +149,8 @@
         (colocated, this_url) = _is_colocated(control_dir, possible_transports)
 
         if colocated:
-            return urlutils.join_segment_parameters(this_url,
-                {"branch": urlutils.escape(location)})
+            return urlutils.join_segment_parameters(
+                this_url, {"branch": urlutils.escape(location)})
         else:
             return urlutils.join(this_url, '..', urlutils.escape(location))
     return location
@@ -166,8 +166,8 @@
     """
     try:
         # Perhaps it's a colocated branch?
-        return control_dir.open_branch(location, 
-            possible_transports=possible_transports)
+        return control_dir.open_branch(
+            location, possible_transports=possible_transports)
     except (errors.NotBranchError, errors.NoColocatedBranchSupport):
         this_url = _get_branch_location(control_dir)
         return Branch.open(
@@ -186,14 +186,14 @@
         if location is None:
             location = "."
         try:
-            return Branch.open(location,
-                possible_transports=possible_transports)
+            return Branch.open(
+                location, possible_transports=possible_transports)
         except errors.NotBranchError:
             near = "."
-    cdir = controldir.ControlDir.open(near,
-        possible_transports=possible_transports)
-    return open_sibling_branch(cdir, location,
-        possible_transports=possible_transports)
+    cdir = controldir.ControlDir.open(
+        near, possible_transports=possible_transports)
+    return open_sibling_branch(
+        cdir, location, possible_transports=possible_transports)
 
 
 def iter_sibling_branches(control_dir, possible_transports=None):
@@ -210,8 +210,8 @@
             yield name, branch
         return
     if reference is not None:
-        ref_branch = Branch.open(reference,
-            possible_transports=possible_transports)
+        ref_branch = Branch.open(
+            reference, possible_transports=possible_transports)
     else:
         ref_branch = None
     if ref_branch is None or ref_branch.name:
@@ -222,8 +222,8 @@
     else:
         repo = ref_branch.controldir.find_repository()
         for branch in repo.find_branches(using=True):
-            name = urlutils.relative_url(repo.user_url,
-                branch.user_url).rstrip("/")
+            name = urlutils.relative_url(
+                repo.user_url, branch.user_url).rstrip("/")
             yield name, branch
 
 
@@ -255,7 +255,8 @@
             if view_files:
                 file_list = view_files
                 view_str = views.view_display_str(view_files)
-                note(gettext("Ignoring files outside view. View is %s") % view_str)
+                note(gettext("Ignoring files outside view. View is %s"),
+                     view_str)
     return tree, file_list
 
 
@@ -383,11 +384,9 @@
                             short_name='S'),
                      Option('versioned', help='Only show versioned files.',
                             short_name='V'),
-                     Option('no-pending', help='Don\'t show pending merges.',
-                           ),
+                     Option('no-pending', help='Don\'t show pending merges.'),
                      Option('no-classify',
-                            help='Do not mark object type using indicator.',
-                           ),
+                            help='Do not mark object type using indicator.'),
                      ]
     aliases = ['st', 'stat']
 
@@ -401,8 +400,9 @@
         from .status import show_tree_status
 
         if revision and len(revision) > 2:
-            raise errors.BzrCommandError(gettext('brz status --revision takes exactly'
-                                         ' one or two revision specifiers'))
+            raise errors.BzrCommandError(
+                gettext('brz status --revision takes exactly'
+                        ' one or two revision specifiers'))
 
         tree, relfile_list = WorkingTree.open_containing_paths(file_list)
         # Avoid asking for specific files when that is not needed.
@@ -446,17 +446,18 @@
     def run(self, revision_id=None, revision=None, directory=u'.'):
         if revision_id is not None and revision is not None:
             raise errors.BzrCommandError(gettext('You can only supply one of'
-                                         ' revision_id or --revision'))
+                                                 ' revision_id or --revision'))
         if revision_id is None and revision is None:
-            raise errors.BzrCommandError(gettext('You must supply either'
-                                         ' --revision or a revision_id'))
+            raise errors.BzrCommandError(
+                gettext('You must supply either --revision or a revision_id'))
 
         b = controldir.ControlDir.open_containing_tree_or_branch(directory)[1]
 
         revisions = b.repository.revisions
         if revisions is None:
-            raise errors.BzrCommandError(gettext('Repository %r does not support '
-                'access to raw revision texts'))
+            raise errors.BzrCommandError(
+                gettext('Repository %r does not support '
+                        'access to raw revision texts'))
 
         with b.repository.lock_read():
             # TODO: jam 20060112 should cat-revision always output utf-8?
@@ -465,8 +466,9 @@
                 try:
                     self.print_revision(revisions, revision_id)
                 except errors.NoSuchRevision:
-                    msg = gettext("The repository {0} contains no revision {1}.").format(
-                        b.repository.base, revision_id.decode('utf-8'))
+                    msg = gettext(
+                        "The repository {0} contains no revision {1}.").format(
+                            b.repository.base, revision_id.decode('utf-8'))
                     raise errors.BzrCommandError(msg)
             elif revision is not None:
                 for rev in revision:
@@ -503,10 +505,12 @@
             try:
                 working = d.open_workingtree()
             except errors.NoWorkingTree:
-                raise errors.BzrCommandError(gettext("No working tree to remove"))
+                raise errors.BzrCommandError(
+                    gettext("No working tree to remove"))
             except errors.NotLocalUrl:
-                raise errors.BzrCommandError(gettext("You cannot remove the working tree"
-                                             " of a remote path"))
+                raise errors.BzrCommandError(
+                    gettext("You cannot remove the working tree"
+                            " of a remote path"))
             if not force:
                 if (working.has_changes()):
                     raise errors.UncommittedChanges(working)
@@ -514,8 +518,9 @@
                     raise errors.ShelvedChanges(working)
 
             if working.user_url != working.branch.user_url:
-                raise errors.BzrCommandError(gettext("You cannot remove the working tree"
-                                             " from a lightweight checkout"))
+                raise errors.BzrCommandError(
+                    gettext("You cannot remove the working tree"
+                            " from a lightweight checkout"))
 
             d.destroy_workingtree()
 
@@ -536,7 +541,8 @@
     that, you can supply --revision to force the state of the tree.
     """
 
-    takes_options = ['revision', 'directory',
+    takes_options = [
+        'revision', 'directory',
         Option('force',
                help='Reset the tree even if it doesn\'t appear to be'
                     ' corrupted.'),
@@ -565,11 +571,12 @@
             tree.reset_state(revision_ids)
         except errors.BzrError:
             if revision_ids is None:
-                extra = (gettext(', the header appears corrupt, try passing -r -1'
-                         ' to set the state to the last commit'))
+                extra = gettext(', the header appears corrupt, try passing '
+                                '-r -1 to set the state to the last commit')
             else:
                 extra = ''
-            raise errors.BzrCommandError(gettext('failed to reset the tree state{0}').format(extra))
+            raise errors.BzrCommandError(
+                gettext('failed to reset the tree state{0}').format(extra))
 
 
 class cmd_revno(Command):
@@ -588,8 +595,8 @@
     @display_command
     def run(self, tree=False, location=u'.', revision=None):
         if revision is not None and tree:
-            raise errors.BzrCommandError(gettext("--tree and --revision can "
-                "not be used together"))
+            raise errors.BzrCommandError(
+                gettext("--tree and --revision can not be used together"))
 
         if tree:
             try:
@@ -626,9 +633,8 @@
     takes_args = ['revision_info*']
     takes_options = [
         'revision',
-        custom_help('directory',
-            help='Branch to examine, '
-                 'rather than the one containing the working directory.'),
+        custom_help('directory', help='Branch to examine, '
+                    'rather than the one containing the working directory.'),
         Option('tree', help='Show revno of working tree.'),
         ]
 
@@ -673,7 +679,8 @@
 
         self.cleanup_now()
         for revno, revid in revinfos:
-            self.outf.write('%*s %s\n' % (maxlen, revno, revid.decode('utf-8')))
+            self.outf.write(
+                '%*s %s\n' % (maxlen, revno, revid.decode('utf-8')))
 
 
 class cmd_add(Command):
@@ -716,7 +723,7 @@
     Any files matching patterns in the ignore list will not be added
     unless they are explicitly mentioned.
 
-    In recursive mode, files larger than the configuration option 
+    In recursive mode, files larger than the configuration option
     add.maximum_file_size will be skipped. Named items are never skipped due
     to file size.
     """
@@ -726,7 +733,8 @@
                help="Don't recursively add the contents of directories.",
                short_name='N'),
         Option('dry-run',
-               help="Show what would be done, but don't actually do anything."),
+               help="Show what would be done, but don't actually do "
+                    "anything."),
         'verbose',
         Option('file-ids-from',
                type=text_type,
@@ -743,31 +751,32 @@
         if file_ids_from is not None:
             try:
                 base_tree, base_path = WorkingTree.open_containing(
-                                            file_ids_from)
+                    file_ids_from)
             except errors.NoWorkingTree:
                 base_branch, base_path = Branch.open_containing(
-                                            file_ids_from)
+                    file_ids_from)
                 base_tree = base_branch.basis_tree()
 
-            action = breezy.add.AddFromBaseAction(base_tree, base_path,
-                          to_file=self.outf, should_print=(not is_quiet()))
-        else:
-            action = breezy.add.AddWithSkipLargeAction(to_file=self.outf,
+            action = breezy.add.AddFromBaseAction(
+                base_tree, base_path, to_file=self.outf,
                 should_print=(not is_quiet()))
+        else:
+            action = breezy.add.AddWithSkipLargeAction(
+                to_file=self.outf, should_print=(not is_quiet()))
 
         if base_tree:
             self.add_cleanup(base_tree.lock_read().unlock)
         tree, file_list = tree_files_for_add(file_list)
-        added, ignored = tree.smart_add(file_list, not
-            no_recurse, action=action, save=not dry_run)
+        added, ignored = tree.smart_add(
+            file_list, not no_recurse, action=action, save=not dry_run)
         self.cleanup_now()
         if len(ignored) > 0:
             if verbose:
                 for glob in sorted(ignored):
                     for path in ignored[glob]:
                         self.outf.write(
-                         gettext("ignored {0} matching \"{1}\"\n").format(
-                         path, glob))
+                            gettext("ignored {0} matching \"{1}\"\n").format(
+                                path, glob))
 
 
 class cmd_mkdir(Command):
@@ -848,7 +857,8 @@
         'revision',
         'show-ids',
         Option('kind',
-               help='List entries of a particular kind: file, directory, symlink.',
+               help='List entries of a particular kind: file, directory, '
+                    'symlink.',
                type=text_type),
         ]
     takes_args = ['file*']
@@ -856,7 +866,8 @@
     @display_command
     def run(self, revision=None, show_ids=False, kind=None, file_list=None):
         if kind and kind not in ['file', 'directory', 'symlink']:
-            raise errors.BzrCommandError(gettext('invalid kind %r specified') % (kind,))
+            raise errors.BzrCommandError(
+                gettext('invalid kind %r specified') % (kind,))
 
         revision = _get_one_revision('inventory', revision)
         work_tree, file_list = WorkingTree.open_containing_paths(file_list)
@@ -873,7 +884,7 @@
         self.add_cleanup(tree.lock_read().unlock)
         if file_list is not None:
             paths = tree.find_related_paths_across_trees(
-                    file_list, extra_trees, require_versioned=True)
+                file_list, extra_trees, require_versioned=True)
             # find_ids_across_trees may include some paths that don't
             # exist in 'tree'.
             entries = tree.iter_entries_by_dir(specific_files=paths)
@@ -886,7 +897,8 @@
             if path == "":
                 continue
             if show_ids:
-                self.outf.write('%-50s %s\n' % (path, entry.file_id.decode('utf-8')))
+                self.outf.write('%-50s %s\n' % (
+                    path, entry.file_id.decode('utf-8')))
             else:
                 self.outf.write(path)
                 self.outf.write('\n')
@@ -918,51 +930,55 @@
             names_list = []
         if len(names_list) < 2:
             raise errors.BzrCommandError(gettext("missing file argument"))
-        tree, rel_names = WorkingTree.open_containing_paths(names_list, canonicalize=False)
+        tree, rel_names = WorkingTree.open_containing_paths(
+            names_list, canonicalize=False)
         for file_name in rel_names[0:-1]:
             if file_name == '':
-                raise errors.BzrCommandError(gettext("can not copy root of branch"))
+                raise errors.BzrCommandError(
+                    gettext("can not copy root of branch"))
         self.add_cleanup(tree.lock_tree_write().unlock)
         into_existing = osutils.isdir(names_list[-1])
         if not into_existing:
             try:
                 (src, dst) = rel_names
             except IndexError:
-                raise errors.BzrCommandError(gettext('to copy multiple files the'
-                                                     ' destination must be a versioned'
-                                                     ' directory'))
+                raise errors.BzrCommandError(
+                    gettext('to copy multiple files the'
+                            ' destination must be a versioned'
+                            ' directory'))
             pairs = [(src, dst)]
         else:
-            pairs = [(n, osutils.joinpath([rel_names[-1], osutils.basename(n)]))
-                     for n in rel_names[:-1]]
+            pairs = [
+                (n, osutils.joinpath([rel_names[-1], osutils.basename(n)]))
+                for n in rel_names[:-1]]
 
         for src, dst in pairs:
             try:
                 src_kind = tree.stored_kind(src)
             except errors.NoSuchFile:
                 raise errors.BzrCommandError(
-                        gettext('Could not copy %s => %s: %s is not versioned.')
-                        % (src, dst, src))
+                    gettext('Could not copy %s => %s: %s is not versioned.')
+                    % (src, dst, src))
             if src_kind is None:
                 raise errors.BzrCommandError(
                     gettext('Could not copy %s => %s . %s is not versioned\\.'
-                        % (src, dst, src)))
+                            % (src, dst, src)))
             if src_kind == 'directory':
                 raise errors.BzrCommandError(
                     gettext('Could not copy %s => %s . %s is a directory.'
-                        % (src, dst, src)))
+                            % (src, dst, src)))
             dst_parent = osutils.split(dst)[0]
             if dst_parent != '':
                 try:
                     dst_parent_kind = tree.stored_kind(dst_parent)
                 except errors.NoSuchFile:
                     raise errors.BzrCommandError(
-                            gettext('Could not copy %s => %s: %s is not versioned.')
-                            % (src, dst, dst_parent))
+                        gettext('Could not copy %s => %s: %s is not versioned.')
+                        % (src, dst, dst_parent))
                 if dst_parent_kind != 'directory':
                     raise errors.BzrCommandError(
-                            gettext('Could not copy to %s: %s is not a directory.')
-                            % (dst_parent, dst_parent))
+                        gettext('Could not copy to %s: %s is not a directory.')
+                        % (dst_parent, dst_parent))
 
             tree.copy_one(src, dst)
 
@@ -990,10 +1006,11 @@
 
     takes_args = ['names*']
     takes_options = [Option("after", help="Move only the brz identifier"
-        " of the file, because the file has already been moved."),
-        Option('auto', help='Automatically guess renames.'),
-        Option('dry-run', help='Avoid making changes when guessing renames.'),
-        ]
+                            " of the file, because the file has already been moved."),
+                     Option('auto', help='Automatically guess renames.'),
+                     Option(
+                         'dry-run', help='Avoid making changes when guessing renames.'),
+                     ]
     aliases = ['move', 'rename']
     encoding_type = 'replace'
 
@@ -1006,25 +1023,27 @@
             names_list = []
         if len(names_list) < 2:
             raise errors.BzrCommandError(gettext("missing file argument"))
-        tree, rel_names = WorkingTree.open_containing_paths(names_list, canonicalize=False)
+        tree, rel_names = WorkingTree.open_containing_paths(
+            names_list, canonicalize=False)
         for file_name in rel_names[0:-1]:
             if file_name == '':
-                raise errors.BzrCommandError(gettext("can not move root of branch"))
+                raise errors.BzrCommandError(
+                    gettext("can not move root of branch"))
         self.add_cleanup(tree.lock_tree_write().unlock)
         self._run(tree, names_list, rel_names, after)
 
     def run_auto(self, names_list, after, dry_run):
         if names_list is not None and len(names_list) > 1:
-            raise errors.BzrCommandError(gettext('Only one path may be specified to'
-                                         ' --auto.'))
+            raise errors.BzrCommandError(
+                gettext('Only one path may be specified to --auto.'))
         if after:
-            raise errors.BzrCommandError(gettext('--after cannot be specified with'
-                                         ' --auto.'))
+            raise errors.BzrCommandError(
+                gettext('--after cannot be specified with --auto.'))
         work_tree, file_list = WorkingTree.open_containing_paths(
             names_list, default_directory='.')
         self.add_cleanup(work_tree.lock_tree_write().unlock)
         rename_map.RenameMap.guess_renames(
-                work_tree.basis_tree(), work_tree, dry_run)
+            work_tree.basis_tree(), work_tree, dry_run)
 
     def _run(self, tree, names_list, rel_names, after):
         into_existing = osutils.isdir(names_list[-1])
@@ -1035,14 +1054,14 @@
             #    a directory, but now doesn't exist in the working tree
             #    and the target is an existing directory, just rename it)
             if (not tree.case_sensitive
-                and rel_names[0].lower() == rel_names[1].lower()):
+                    and rel_names[0].lower() == rel_names[1].lower()):
                 into_existing = False
             else:
                 # 'fix' the case of a potential 'from'
                 from_path = tree.get_canonical_path(rel_names[0])
                 if (not osutils.lexists(names_list[0]) and
                     tree.is_versioned(from_path) and
-                    tree.stored_kind(from_path) == "directory"):
+                        tree.stored_kind(from_path) == "directory"):
                     into_existing = False
         # move/rename
         if into_existing:
@@ -1056,8 +1075,8 @@
         else:
             if len(names_list) != 2:
                 raise errors.BzrCommandError(gettext('to mv multiple files the'
-                                             ' destination must be a versioned'
-                                             ' directory'))
+                                                     ' destination must be a versioned'
+                                                     ' directory'))
 
             # for cicp file-systems: the src references an existing inventory
             # item:
@@ -1084,15 +1103,16 @@
                 if after:
                     # If 'after' is specified, the tail must refer to a file on disk.
                     if dest_parent:
-                        dest_parent_fq = osutils.pathjoin(tree.basedir, dest_parent)
+                        dest_parent_fq = osutils.pathjoin(
+                            tree.basedir, dest_parent)
                     else:
                         # pathjoin with an empty tail adds a slash, which breaks
                         # relpath :(
                         dest_parent_fq = tree.basedir
 
                     dest_tail = osutils.canonical_relpath(
-                                    dest_parent_fq,
-                                    osutils.pathjoin(dest_parent_fq, spec_tail))
+                        dest_parent_fq,
+                        osutils.pathjoin(dest_parent_fq, spec_tail))
                 else:
                     # not 'after', so case as specified is used
                     dest_tail = spec_tail
@@ -1110,8 +1130,8 @@
     __doc__ = """Turn this branch into a mirror of another branch.
 
     By default, this command only works on branches that have not diverged.
-    Branches are considered diverged if the destination branch's most recent 
-    commit is one that has not been merged (directly or indirectly) into the 
+    Branches are considered diverged if the destination branch's most recent
+    commit is one that has not been merged (directly or indirectly) into the
     parent.
 
     If branches have diverged, you can use 'brz merge' to integrate the changes
@@ -1138,21 +1158,21 @@
 
     _see_also = ['push', 'update', 'status-flags', 'send']
     takes_options = ['remember', 'overwrite', 'revision',
-        custom_help('verbose',
-            help='Show logs of pulled revisions.'),
-        custom_help('directory',
-            help='Branch to pull into, '
-                 'rather than the one containing the working directory.'),
-        Option('local',
-            help="Perform a local pull in a bound "
-                 "branch.  Local pulls are not applied to "
-                 "the master branch."
-            ),
-        Option('show-base',
-            help="Show base revision text in conflicts."),
-        Option('overwrite-tags',
-            help="Overwrite tags only."),
-        ]
+                     custom_help('verbose',
+                                 help='Show logs of pulled revisions.'),
+                     custom_help('directory',
+                                 help='Branch to pull into, '
+                                 'rather than the one containing the working directory.'),
+                     Option('local',
+                            help="Perform a local pull in a bound "
+                            "branch.  Local pulls are not applied to "
+                            "the master branch."
+                            ),
+                     Option('show-base',
+                            help="Show base revision text in conflicts."),
+                     Option('overwrite-tags',
+                            help="Overwrite tags only."),
+                     ]
     takes_args = ['location?']
     encoding_type = 'replace'
 
@@ -1190,7 +1210,7 @@
         if location is not None:
             try:
                 mergeable = bundle.read_mergeable_from_url(location,
-                    possible_transports=possible_transports)
+                                                           possible_transports=possible_transports)
             except errors.NotABundle:
                 mergeable = None
 
@@ -1198,12 +1218,13 @@
         if location is None:
             if stored_loc is None:
                 raise errors.BzrCommandError(gettext("No pull location known or"
-                                             " specified."))
+                                                     " specified."))
             else:
                 display_url = urlutils.unescape_for_display(stored_loc,
-                        self.outf.encoding)
+                                                            self.outf.encoding)
                 if not is_quiet():
-                    self.outf.write(gettext("Using saved parent location: %s\n") % display_url)
+                    self.outf.write(
+                        gettext("Using saved parent location: %s\n") % display_url)
                 location = stored_loc
 
         revision = _get_one_revision('pull', revision)
@@ -1217,11 +1238,11 @@
             branch_from = branch_to
         else:
             branch_from = Branch.open(location,
-                possible_transports=possible_transports)
+                                      possible_transports=possible_transports)
             self.add_cleanup(branch_from.lock_read().unlock)
             # Remembers if asked explicitly or no previous location is set
             if (remember
-                or (remember is None and branch_to.get_parent() is None)):
+                    or (remember is None and branch_to.get_parent() is None)):
                 # FIXME: This shouldn't be done before the pull
                 # succeeds... -- vila 2012-01-02
                 branch_to.set_parent(branch_from.base)
@@ -1284,44 +1305,44 @@
 
     _see_also = ['pull', 'update', 'working-trees']
     takes_options = ['remember', 'overwrite', 'verbose', 'revision',
-        Option('create-prefix',
-               help='Create the path leading up to the branch '
-                    'if it does not already exist.'),
-        custom_help('directory',
-            help='Branch to push from, '
-                 'rather than the one containing the working directory.'),
-        Option('use-existing-dir',
-               help='By default push will fail if the target'
-                    ' directory exists, but does not already'
-                    ' have a control directory.  This flag will'
-                    ' allow push to proceed.'),
-        Option('stacked',
-            help='Create a stacked branch that references the public location '
-                'of the parent branch.'),
-        Option('stacked-on',
-            help='Create a stacked branch that refers to another branch '
-                'for the commit history. Only the work not present in the '
-                'referenced branch is included in the branch created.',
-            type=text_type),
-        Option('strict',
-               help='Refuse to push if there are uncommitted changes in'
-               ' the working tree, --no-strict disables the check.'),
-        Option('no-tree',
-               help="Don't populate the working tree, even for protocols"
-               " that support it."),
-        Option('overwrite-tags',
-              help="Overwrite tags only."),
-        Option('lossy', help="Allow lossy push, i.e. dropping metadata "
-                             "that can't be represented in the target.")
-        ]
+                     Option('create-prefix',
+                            help='Create the path leading up to the branch '
+                            'if it does not already exist.'),
+                     custom_help('directory',
+                                 help='Branch to push from, '
+                                 'rather than the one containing the working directory.'),
+                     Option('use-existing-dir',
+                            help='By default push will fail if the target'
+                            ' directory exists, but does not already'
+                            ' have a control directory.  This flag will'
+                            ' allow push to proceed.'),
+                     Option('stacked',
+                            help='Create a stacked branch that references the public location '
+                            'of the parent branch.'),
+                     Option('stacked-on',
+                            help='Create a stacked branch that refers to another branch '
+                            'for the commit history. Only the work not present in the '
+                            'referenced branch is included in the branch created.',
+                            type=text_type),
+                     Option('strict',
+                            help='Refuse to push if there are uncommitted changes in'
+                            ' the working tree, --no-strict disables the check.'),
+                     Option('no-tree',
+                            help="Don't populate the working tree, even for protocols"
+                            " that support it."),
+                     Option('overwrite-tags',
+                            help="Overwrite tags only."),
+                     Option('lossy', help="Allow lossy push, i.e. dropping metadata "
+                            "that can't be represented in the target.")
+                     ]
     takes_args = ['location?']
     encoding_type = 'replace'
 
     def run(self, location=None, remember=None, overwrite=False,
-        create_prefix=False, verbose=False, revision=None,
-        use_existing_dir=False, directory=None, stacked_on=None,
-        stacked=False, strict=None, no_tree=False,
-        overwrite_tags=False, lossy=False):
+            create_prefix=False, verbose=False, revision=None,
+            use_existing_dir=False, directory=None, stacked_on=None,
+            stacked=False, strict=None, no_tree=False,
+            overwrite_tags=False, lossy=False):
         from .push import _show_push_branch
 
         if overwrite:
@@ -1375,21 +1396,21 @@
                         "No push location known or specified. To push to the "
                         "parent branch (at %s), use 'brz push :parent'." %
                         urlutils.unescape_for_display(parent_loc,
-                            self.outf.encoding)))
+                                                      self.outf.encoding)))
                 else:
                     raise errors.BzrCommandError(gettext(
                         "No push location known or specified."))
             else:
                 display_url = urlutils.unescape_for_display(stored_loc,
-                        self.outf.encoding)
+                                                            self.outf.encoding)
                 note(gettext("Using saved push location: %s") % display_url)
                 location = stored_loc
 
         _show_push_branch(br_from, revision_id, location, self.outf,
-            verbose=verbose, overwrite=overwrite, remember=remember,
-            stacked_on=stacked_on, create_prefix=create_prefix,
-            use_existing_dir=use_existing_dir, no_tree=no_tree,
-            lossy=lossy)
+                          verbose=verbose, overwrite=overwrite, remember=remember,
+                          stacked_on=stacked_on, create_prefix=create_prefix,
+                          use_existing_dir=use_existing_dir, no_tree=no_tree,
+                          lossy=lossy)
 
 
 class cmd_branch(Command):
@@ -1409,28 +1430,29 @@
     _see_also = ['checkout']
     takes_args = ['from_location', 'to_location?']
     takes_options = ['revision',
-        Option('hardlink', help='Hard-link working tree files where possible.'),
-        Option('files-from', type=text_type,
-               help="Get file contents from this tree."),
-        Option('no-tree',
-            help="Create a branch without a working-tree."),
-        Option('switch',
-            help="Switch the checkout in the current directory "
-                 "to the new branch."),
-        Option('stacked',
-            help='Create a stacked branch referring to the source branch. '
-                'The new branch will depend on the availability of the source '
-                'branch for all operations.'),
-        Option('standalone',
-               help='Do not use a shared repository, even if available.'),
-        Option('use-existing-dir',
-               help='By default branch will fail if the target'
-                    ' directory exists, but does not already'
-                    ' have a control directory.  This flag will'
-                    ' allow branch to proceed.'),
-        Option('bind',
-            help="Bind new branch to from location."),
-        ]
+                     Option(
+                         'hardlink', help='Hard-link working tree files where possible.'),
+                     Option('files-from', type=text_type,
+                            help="Get file contents from this tree."),
+                     Option('no-tree',
+                            help="Create a branch without a working-tree."),
+                     Option('switch',
+                            help="Switch the checkout in the current directory "
+                            "to the new branch."),
+                     Option('stacked',
+                            help='Create a stacked branch referring to the source branch. '
+                            'The new branch will depend on the availability of the source '
+                            'branch for all operations.'),
+                     Option('standalone',
+                            help='Do not use a shared repository, even if available.'),
+                     Option('use-existing-dir',
+                            help='By default branch will fail if the target'
+                            ' directory exists, but does not already'
+                            ' have a control directory.  This flag will'
+                            ' allow branch to proceed.'),
+                     Option('bind',
+                            help="Bind new branch to from location."),
+                     ]
 
     def run(self, from_location, to_location=None, revision=None,
             hardlink=False, stacked=False, standalone=False, no_tree=False,
@@ -1467,7 +1489,7 @@
             except errors.NotBranchError:
                 if not use_existing_dir:
                     raise errors.BzrCommandError(gettext('Target directory "%s" '
-                        'already exists.') % to_location)
+                                                         'already exists.') % to_location)
                 else:
                     to_dir = None
             else:
@@ -1513,13 +1535,14 @@
         # We therefore need a try/except here and not just 'if stacked:'
         try:
             note(gettext('Created new stacked branch referring to %s.') %
-                branch.get_stacked_on_url())
+                 branch.get_stacked_on_url())
         except (errors.NotStacked, _mod_branch.UnstackableBranchFormat,
             errors.UnstackableRepositoryFormat) as e:
             revno = branch.revno()
             if revno is not None:
-                note(ngettext('Branched %d revision.', 'Branched %d revisions.',
-                     branch.revno()) % revno)
+                note(ngettext('Branched %d revision.',
+                              'Branched %d revisions.',
+                              branch.revno()) % revno)
             else:
                 note(gettext('Created new branch.'))
         if bind:
@@ -1532,7 +1555,7 @@
             wt, _ = WorkingTree.open_containing('.')
             _mod_switch.switch(wt.controldir, branch)
             note(gettext('Switched to branch: %s'),
-                urlutils.unescape_for_display(branch.base, 'utf-8'))
+                 urlutils.unescape_for_display(branch.base, 'utf-8'))
 
 
 class cmd_branches(Command):
@@ -1544,9 +1567,9 @@
 
     takes_args = ['location?']
     takes_options = [
-                  Option('recursive', short_name='R',
-                         help='Recursively scan for branches rather than '
-                              'just looking in the specified location.')]
+        Option('recursive', short_name='R',
+               help='Recursively scan for branches rather than '
+               'just looking in the specified location.')]
 
     def run(self, location=".", recursive=False):
         if recursive:
@@ -1588,22 +1611,22 @@
 class cmd_checkout(Command):
     __doc__ = """Create a new checkout of an existing branch.
 
-    If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
-    the branch found in '.'. This is useful if you have removed the working tree
-    or if it was never created - i.e. if you pushed the branch to its current
-    location using SFTP.
+    If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree
+    for the branch found in '.'. This is useful if you have removed the working
+    tree or if it was never created - i.e. if you pushed the branch to its
+    current location using SFTP.
 
-    If the TO_LOCATION is omitted, the last component of the BRANCH_LOCATION will
-    be used.  In other words, "checkout ../foo/bar" will attempt to create ./bar.
-    If the BRANCH_LOCATION has no / or path separator embedded, the TO_LOCATION
-    is derived from the BRANCH_LOCATION by stripping a leading scheme or drive
-    identifier, if any. For example, "checkout lp:foo-bar" will attempt to
-    create ./foo-bar.
+    If the TO_LOCATION is omitted, the last component of the BRANCH_LOCATION
+    will be used.  In other words, "checkout ../foo/bar" will attempt to create
+    ./bar.  If the BRANCH_LOCATION has no / or path separator embedded, the
+    TO_LOCATION is derived from the BRANCH_LOCATION by stripping a leading
+    scheme or drive identifier, if any. For example, "checkout lp:foo-bar" will
+    attempt to create ./foo-bar.
 
     To retrieve the branch as of a particular revision, supply the --revision
-    parameter, as in "checkout foo/bar -r 5". Note that this will be immediately
-    out of date [so you cannot commit] but it may be useful (i.e. to examine old
-    code.)
+    parameter, as in "checkout foo/bar -r 5". Note that this will be
+    immediately out of date [so you cannot commit] but it may be useful (i.e.
+    to examine old code.)
     """
 
     _see_also = ['checkouts', 'branch', 'working-trees', 'remove-tree']
@@ -1648,8 +1671,7 @@
         # if the source and to_location are the same,
         # and there is no working tree,
         # then reconstitute a branch
-        if (osutils.abspath(to_location) ==
-            osutils.abspath(branch_location)):
+        if osutils.abspath(to_location) == osutils.abspath(branch_location):
             try:
                 source.controldir.open_workingtree()
             except errors.NoWorkingTree:
@@ -1692,11 +1714,11 @@
 
     This will perform a merge of the destination revision (the tip of the
     branch, or the specified revision) into the working tree, and then make
-    that revision the basis revision for the working tree.  
+    that revision the basis revision for the working tree.
 
     You can use this to visit an older revision, or to update a working tree
     that is out of date from its branch.
-    
+
     If there are any uncommitted changes in the tree, they will be carried
     across and remain as uncommitted changes after the update.  To discard
     these changes, use 'brz revert'.  The uncommitted changes may conflict
@@ -1713,7 +1735,7 @@
     out the old content of that file to a new location.
 
     The 'dir' argument, if given, must be the location of the root of a
-    working tree to update.  By default, the working tree that contains the 
+    working tree to update.  By default, the working tree that contains the
     current working directory is used.
     """
 
@@ -1768,7 +1790,7 @@
         if revision_id == _mod_revision.ensure_null(tree.last_revision()):
             revno = branch.revision_id_to_dotted_revno(revision_id)
             note(gettext("Tree is up to date at revision {0} of branch {1}"
-                        ).format('.'.join(map(str, revno)), branch_location))
+                         ).format('.'.join(map(str, revno)), branch_location))
             return 0
         view_info = _get_view_info_for_change_reporter(tree)
         change_reporter = delta._ChangeReporter(
@@ -1783,10 +1805,10 @@
                 show_base=show_base)
         except errors.NoSuchRevision as e:
             raise errors.BzrCommandError(gettext(
-                                  "branch has no revision %s\n"
-                                  "brz update --revision only works"
-                                  " for a revision in the branch history")
-                                  % (e.revision))
+                "branch has no revision %s\n"
+                "brz update --revision only works"
+                " for a revision in the branch history")
+                % (e.revision))
         revno = tree.branch.revision_id_to_dotted_revno(
             _mod_revision.ensure_null(tree.last_revision()))
         note(gettext('Updated to revision {0} of branch {1}').format(
@@ -1794,7 +1816,7 @@
         parent_ids = tree.get_parent_ids()
         if parent_ids[1:] and parent_ids[1:] != existing_pending_merges:
             note(gettext('Your local commits will now show as pending merges with '
-                 "'brz status', and can be committed with 'brz commit'."))
+                         "'brz status', and can be committed with 'brz commit'."))
         if conflicts != 0:
             return 1
         else:
@@ -1856,19 +1878,20 @@
     """
     takes_args = ['file*']
     takes_options = ['verbose',
-        Option('new', help='Only remove files that have never been committed.'),
-        RegistryOption.from_kwargs('file-deletion-strategy',
-            'The file deletion mode to be used.',
-            title='Deletion Strategy', value_switches=True, enum_switch=False,
-            safe='Backup changed files (default).',
-            keep='Delete from brz but leave the working copy.',
-            no_backup='Don\'t backup changed files.'),
-        ]
+                     Option(
+                         'new', help='Only remove files that have never been committed.'),
+                     RegistryOption.from_kwargs('file-deletion-strategy',
+                                                'The file deletion mode to be used.',
+                                                title='Deletion Strategy', value_switches=True, enum_switch=False,
+                                                safe='Backup changed files (default).',
+                                                keep='Delete from brz but leave the working copy.',
+                                                no_backup='Don\'t backup changed files.'),
+                     ]
     aliases = ['rm', 'del']
     encoding_type = 'replace'
 
     def run(self, file_list, verbose=False, new=False,
-        file_deletion_strategy='safe'):
+            file_deletion_strategy='safe'):
 
         tree, file_list = WorkingTree.open_containing_paths(file_list)
 
@@ -1880,7 +1903,7 @@
         # some such?
         if new:
             added = tree.changes_from(tree.basis_tree(),
-                specific_files=file_list).added
+                                      specific_files=file_list).added
             file_list = sorted([f[0] for f in added], reverse=True)
             if len(file_list) == 0:
                 raise errors.BzrCommandError(gettext('No matching files.'))
@@ -1895,8 +1918,8 @@
             file_list = sorted(missing, reverse=True)
             file_deletion_strategy = 'keep'
         tree.remove(file_list, verbose=verbose, to_file=self.outf,
-            keep_files=file_deletion_strategy=='keep',
-            force=(file_deletion_strategy=='no-backup'))
+                    keep_files=file_deletion_strategy == 'keep',
+                    force=(file_deletion_strategy == 'no-backup'))
 
 
 class cmd_file_id(Command):
@@ -1991,7 +2014,7 @@
         self.add_cleanup(branch.lock_read().unlock)
         graph = branch.repository.get_graph()
         history = list(graph.iter_lefthand_ancestry(branch.last_revision(),
-            [_mod_revision.NULL_REVISION]))
+                                                    [_mod_revision.NULL_REVISION]))
         for revid in reversed(history):
             self.outf.write(revid)
             self.outf.write('\n')
@@ -2019,7 +2042,7 @@
         self.add_cleanup(b.repository.lock_read().unlock)
         graph = b.repository.get_graph()
         revisions = [revid for revid, parents in
-            graph.iter_ancestry([last_revision])]
+                     graph.iter_ancestry([last_revision])]
         for revision_id in reversed(revisions):
             if _mod_revision.is_null(revision_id):
                 continue
@@ -2055,20 +2078,22 @@
         Option('create-prefix',
                help='Create the path leading up to the branch '
                     'if it does not already exist.'),
-         RegistryOption('format',
-                help='Specify a format for this branch. '
-                'See "help formats" for a full list.',
-                lazy_registry=('breezy.controldir', 'format_registry'),
-                converter=lambda name: controldir.format_registry.make_controldir(name),
-                value_switches=True,
-                title="Branch format",
-                ),
-         Option('append-revisions-only',
-                help='Never change revnos or the existing log.'
-                '  Append revisions to it only.'),
-         Option('no-tree',
-                'Create a branch without a working tree.')
-         ]
+        RegistryOption('format',
+                       help='Specify a format for this branch. '
+                       'See "help formats" for a full list.',
+                       lazy_registry=('breezy.controldir', 'format_registry'),
+                       converter=lambda name: controldir.format_registry.make_controldir(
+                            name),
+                       value_switches=True,
+                       title="Branch format",
+                       ),
+        Option('append-revisions-only',
+               help='Never change revnos or the existing log.'
+               '  Append revisions to it only.'),
+        Option('no-tree',
+               'Create a branch without a working tree.')
+        ]
+
     def run(self, location=None, format=None, append_revisions_only=False,
             create_prefix=False, no_tree=False):
         if format is None:
@@ -2088,14 +2113,15 @@
         except errors.NoSuchFile:
             if not create_prefix:
                 raise errors.BzrCommandError(gettext("Parent directory of %s"
-                    " does not exist."
-                    "\nYou may supply --create-prefix to create all"
-                    " leading parent directories.")
-                    % location)
+                                                     " does not exist."
+                                                     "\nYou may supply --create-prefix to create all"
+                                                     " leading parent directories.")
+                                             % location)
             to_transport.create_prefix()
 
         try:
-            a_controldir = controldir.ControlDir.open_from_transport(to_transport)
+            a_controldir = controldir.ControlDir.open_from_transport(
+                to_transport)
         except errors.NotBranchError:
             # really a NotBzrDir error...
             create_branch = controldir.ControlDir.create_branch_convenience
@@ -2111,8 +2137,8 @@
             from .transport.local import LocalTransport
             if a_controldir.has_branch():
                 if (isinstance(to_transport, LocalTransport)
-                    and not a_controldir.has_workingtree()):
-                        raise errors.BranchExistsWithoutWorkingTree(location)
+                        and not a_controldir.has_workingtree()):
+                    raise errors.BranchExistsWithoutWorkingTree(location)
                 raise errors.AlreadyBranchError(location)
             branch = a_controldir.create_branch()
             if not no_tree and not a_controldir.has_workingtree():
@@ -2122,7 +2148,7 @@
                 branch.set_append_revisions_only(True)
             except errors.UpgradeRequired:
                 raise errors.BzrCommandError(gettext('This branch format cannot be set'
-                    ' to append-revisions-only.  Try --default.'))
+                                                     ' to append-revisions-only.  Try --default.'))
         if not is_quiet():
             from .info import describe_layout, describe_format
             try:
@@ -2133,9 +2159,9 @@
             layout = describe_layout(repository, branch, tree).lower()
             format = describe_format(a_controldir, repository, branch, tree)
             self.outf.write(gettext("Created a {0} (format: {1})\n").format(
-                  layout, format))
+                layout, format))
             if repository.is_shared():
-                #XXX: maybe this can be refactored into transport.path_or_url()
+                # XXX: maybe this can be refactored into transport.path_or_url()
                 url = repository.controldir.root_transport.external_url()
                 try:
                     url = urlutils.local_path_from_url(url)
@@ -2149,12 +2175,12 @@
 
     New branches created under the repository directory will store their
     revisions in the repository, not in the branch directory.  For branches
-    with shared history, this reduces the amount of storage needed and 
+    with shared history, this reduces the amount of storage needed and
     speeds up the creation of new branches.
 
     If the --no-trees option is given then the branches in the repository
-    will not have working trees by default.  They will still exist as 
-    directories on disk, but they will not have separate copies of the 
+    will not have working trees by default.  They will still exist as
+    directories on disk, but they will not have separate copies of the
     files at a certain revision.  This can be useful for repositories that
     store branches which are interacted with through checkouts or remote
     branches, such as on a server.
@@ -2175,15 +2201,17 @@
     _see_also = ['init', 'branch', 'checkout', 'repositories']
     takes_args = ["location"]
     takes_options = [RegistryOption('format',
-                            help='Specify a format for this repository. See'
-                                 ' "brz help formats" for details.',
-                            lazy_registry=('breezy.controldir', 'format_registry'),
-                            converter=lambda name: controldir.format_registry.make_controldir(name),
-                            value_switches=True, title='Repository format'),
+                                    help='Specify a format for this repository. See'
+                                    ' "brz help formats" for details.',
+                                    lazy_registry=(
+                                        'breezy.controldir', 'format_registry'),
+                                    converter=lambda name: controldir.format_registry.make_controldir(
+                                        name),
+                                    value_switches=True, title='Repository format'),
                      Option('no-trees',
-                             help='Branches in the repository will default to'
-                                  ' not having a working tree.'),
-                    ]
+                            help='Branches in the repository will default to'
+                            ' not having a working tree.'),
+                     ]
     aliases = ["init-repo"]
 
     def run(self, location, format=None, no_trees=False):
@@ -2202,10 +2230,10 @@
 
         (repo, newdir, require_stacking, repository_policy) = (
             format.initialize_on_transport_ex(to_transport,
-            create_prefix=True, make_working_trees=not no_trees,
-            shared_repo=True, force_new_repo=True,
-            use_existing_dir=True,
-            repo_format_name=repo_format_name))
+                                              create_prefix=True, make_working_trees=not no_trees,
+                                              shared_repo=True, force_new_repo=True,
+                                              use_existing_dir=True,
+                                              repo_format_name=repo_format_name))
         if not is_quiet():
             from .info import show_bzrdir_info
             show_bzrdir_info(newdir, verbose=0, outfile=self.outf)
@@ -2226,8 +2254,8 @@
 
     Note that when using the -r argument with a range of revisions, the
     differences are computed between the two specified revisions.  That
-    is, the command does not show the changes introduced by the first 
-    revision in the range.  This differs from the interpretation of 
+    is, the command does not show the changes introduced by the first
+    revision in the range.  This differs from the interpretation of
     revision ranges used by "brz log" which includes the first revision
     in the range.
 
@@ -2259,7 +2287,7 @@
             brz diff -c2
 
         To see the changes introduced by revision X::
-        
+
             brz diff -cX
 
         Note that in the case of a merge, the -c option shows the changes
@@ -2307,28 +2335,28 @@
                help='Set prefixes added to old and new filenames, as '
                     'two values separated by a colon. (eg "old/:new/").'),
         Option('old',
-            help='Branch/tree to compare from.',
-            type=text_type,
-            ),
+               help='Branch/tree to compare from.',
+               type=text_type,
+               ),
         Option('new',
-            help='Branch/tree to compare to.',
-            type=text_type,
-            ),
+               help='Branch/tree to compare to.',
+               type=text_type,
+               ),
         'revision',
         'change',
         Option('using',
-            help='Use this command to compare files.',
-            type=text_type,
-            ),
+               help='Use this command to compare files.',
+               type=text_type,
+               ),
         RegistryOption('format',
-            short_name='F',
-            help='Diff format to use.',
-            lazy_registry=('breezy.diff', 'format_registry'),
-            title='Diff format'),
+                       short_name='F',
+                       help='Diff format to use.',
+                       lazy_registry=('breezy.diff', 'format_registry'),
+                       title='Diff format'),
         Option('context',
-            help='How many lines of context to show.',
-            type=int,
-            ),
+               help='How many lines of context to show.',
+               type=int,
+               ),
         ]
     aliases = ['di', 'dif']
     encoding_type = 'exact'
@@ -2338,7 +2366,7 @@
             prefix=None, old=None, new=None, using=None, format=None,
             context=None):
         from .diff import (get_trees_and_branches_to_diff_locked,
-            show_diff_trees)
+                           show_diff_trees)
 
         if prefix == u'0':
             # diff -p0 format
@@ -2356,7 +2384,7 @@
 
         if revision and len(revision) > 2:
             raise errors.BzrCommandError(gettext('brz diff --revision takes exactly'
-                                         ' one or two revision specifiers'))
+                                                 ' one or two revision specifiers'))
 
         if using is not None and format is not None:
             raise errors.BzrCommandError(gettext(
@@ -2609,7 +2637,7 @@
       line tools: you may prefer qlog or viz from qbzr or bzr-gtk, the
       bzr-explorer shell, or the Loggerhead web interface.  See the Bazaar
       Plugin Guide <http://doc.bazaar.canonical.com/plugins/en/> and
-      <http://wiki.bazaar.canonical.com/IDEIntegration>.  
+      <http://wiki.bazaar.canonical.com/IDEIntegration>.
 
       You may find it useful to add the aliases below to ``breezy.conf``::
 
@@ -2643,76 +2671,77 @@
     takes_args = ['file*']
     _see_also = ['log-formats', 'revisionspec']
     takes_options = [
-            Option('forward',
-                   help='Show from oldest to newest.'),
-            'timezone',
-            custom_help('verbose',
-                   help='Show files changed in each revision.'),
-            'show-ids',
-            'revision',
-            Option('change',
-                   type=breezy.option._parse_revision_str,
-                   short_name='c',
-                   help='Show just the specified revision.'
-                   ' See also "help revisionspec".'),
-            'log-format',
-            RegistryOption('authors',
-                'What names to list as authors - first, all or committer.',
-                title='Authors',
-                lazy_registry=('breezy.log', 'author_list_registry'),
-            ),
-            Option('levels',
-                   short_name='n',
-                   help='Number of levels to display - 0 for all, 1 for flat.',
-                   argname='N',
-                   type=_parse_levels),
-            Option('message',
-                   help='Show revisions whose message matches this '
-                        'regular expression.',
-                   type=text_type,
-                   hidden=True),
-            Option('limit',
-                   short_name='l',
-                   help='Limit the output to the first N revisions.',
-                   argname='N',
-                   type=_parse_limit),
-            Option('show-diff',
-                   short_name='p',
-                   help='Show changes made in each revision as a patch.'),
-            Option('include-merged',
-                   help='Show merged revisions like --levels 0 does.'),
-            Option('include-merges', hidden=True,
-                   help='Historical alias for --include-merged.'),
-            Option('omit-merges',
-                   help='Do not report commits with more than one parent.'),
-            Option('exclude-common-ancestry',
-                   help='Display only the revisions that are not part'
-                   ' of both ancestries (require -rX..Y).'
-                   ),
-            Option('signatures',
-                   help='Show digital signature validity.'),
-            ListOption('match',
-                short_name='m',
-                help='Show revisions whose properties match this '
-                'expression.',
-                type=text_type),
-            ListOption('match-message',
-                   help='Show revisions whose message matches this '
-                   'expression.',
-                type=text_type),
-            ListOption('match-committer',
+        Option('forward',
+               help='Show from oldest to newest.'),
+        'timezone',
+        custom_help('verbose',
+                    help='Show files changed in each revision.'),
+        'show-ids',
+        'revision',
+        Option('change',
+               type=breezy.option._parse_revision_str,
+               short_name='c',
+               help='Show just the specified revision.'
+               ' See also "help revisionspec".'),
+        'log-format',
+        RegistryOption('authors',
+                       'What names to list as authors - first, all or committer.',
+                       title='Authors',
+                       lazy_registry=(
+                           'breezy.log', 'author_list_registry'),
+                       ),
+        Option('levels',
+               short_name='n',
+               help='Number of levels to display - 0 for all, 1 for flat.',
+               argname='N',
+               type=_parse_levels),
+        Option('message',
+               help='Show revisions whose message matches this '
+               'regular expression.',
+               type=text_type,
+               hidden=True),
+        Option('limit',
+               short_name='l',
+               help='Limit the output to the first N revisions.',
+               argname='N',
+               type=_parse_limit),
+        Option('show-diff',
+               short_name='p',
+               help='Show changes made in each revision as a patch.'),
+        Option('include-merged',
+               help='Show merged revisions like --levels 0 does.'),
+        Option('include-merges', hidden=True,
+               help='Historical alias for --include-merged.'),
+        Option('omit-merges',
+               help='Do not report commits with more than one parent.'),
+        Option('exclude-common-ancestry',
+               help='Display only the revisions that are not part'
+               ' of both ancestries (require -rX..Y).'
+               ),
+        Option('signatures',
+               help='Show digital signature validity.'),
+        ListOption('match',
+                   short_name='m',
+                   help='Show revisions whose properties match this '
+                   'expression.',
+                   type=text_type),
+        ListOption('match-message',
+                   help='Show revisions whose message matches this '
+                   'expression.',
+                   type=text_type),
+        ListOption('match-committer',
                    help='Show revisions whose committer matches this '
                    'expression.',
-                type=text_type),
-            ListOption('match-author',
+                   type=text_type),
+        ListOption('match-author',
                    help='Show revisions whose authors match this '
                    'expression.',
-                type=text_type),
-            ListOption('match-bugs',
+                   type=text_type),
+        ListOption('match-bugs',
                    help='Show revisions whose bugs match this '
                    'expression.',
-                type=text_type)
-            ]
+                   type=text_type)
+        ]
     encoding_type = 'replace'
 
     @display_command
@@ -2747,7 +2776,7 @@
         if include_merged is None:
             include_merged = False
         if (exclude_common_ancestry
-            and (revision is None or len(revision) != 2)):
+                and (revision is None or len(revision) != 2)):
             raise errors.BzrCommandError(gettext(
                 '--exclude-common-ancestry requires -r with two revisions'))
         if include_merged:
@@ -2824,7 +2853,8 @@
         if log_format is None:
             log_format = log.log_formatter_registry.get_default(b)
         # Make a non-encoding output to include the diffs - bug 328007
-        unencoded_output = ui.ui_factory.make_output_stream(encoding_type='exact')
+        unencoded_output = ui.ui_factory.make_output_stream(
+            encoding_type='exact')
         lf = log_format(show_ids=show_ids, to_file=self.outf,
                         to_exact_file=unencoded_output,
                         show_timezone=timezone,
@@ -2847,7 +2877,7 @@
         # file that isn't a directory without showing a delta" case.
         partial_history = revision and b.repository._format.supports_chks
         match_using_deltas = (len(file_ids) != 1 or filter_by_dir
-            or delta_type or partial_history)
+                              or delta_type or partial_history)
 
         match_dict = {}
         if match:
@@ -2949,7 +2979,7 @@
         tree, relpath = WorkingTree.open_containing(filename)
         with tree.lock_read():
             touching_revs = log.find_touching_revisions(
-                    tree.branch.repository, tree.branch.last_revision(), tree, relpath)
+                tree.branch.repository, tree.branch.last_revision(), tree, relpath)
             for revno, revision_id, what in reversed(list(touching_revs)):
                 self.outf.write("%6d %s\n" % (revno, what))
 
@@ -2961,26 +2991,27 @@
     _see_also = ['status', 'cat']
     takes_args = ['path?']
     takes_options = [
-            'verbose',
-            'revision',
-            Option('recursive', short_name='R',
-                   help='Recurse into subdirectories.'),
-            Option('from-root',
-                   help='Print paths relative to the root of the branch.'),
-            Option('unknown', short_name='u',
-                help='Print unknown files.'),
-            Option('versioned', help='Print versioned files.',
-                   short_name='V'),
-            Option('ignored', short_name='i',
-                help='Print ignored files.'),
-            Option('kind', short_name='k',
-                   help=('List entries of a particular kind: file, '
-                         'directory, symlink, tree-reference.'),
-                   type=text_type),
-            'null',
-            'show-ids',
-            'directory',
-            ]
+        'verbose',
+        'revision',
+        Option('recursive', short_name='R',
+               help='Recurse into subdirectories.'),
+        Option('from-root',
+               help='Print paths relative to the root of the branch.'),
+        Option('unknown', short_name='u',
+               help='Print unknown files.'),
+        Option('versioned', help='Print versioned files.',
+               short_name='V'),
+        Option('ignored', short_name='i',
+               help='Print ignored files.'),
+        Option('kind', short_name='k',
+               help=('List entries of a particular kind: file, '
+                     'directory, symlink, tree-reference.'),
+               type=text_type),
+        'null',
+        'show-ids',
+        'directory',
+        ]
+
     @display_command
     def run(self, revision=None, verbose=False,
             recursive=False, from_root=False,
@@ -2991,17 +3022,18 @@
             raise errors.BzrCommandError(gettext('invalid kind specified'))
 
         if verbose and null:
-            raise errors.BzrCommandError(gettext('Cannot set both --verbose and --null'))
+            raise errors.BzrCommandError(
+                gettext('Cannot set both --verbose and --null'))
         all = not (unknown or versioned or ignored)
 
-        selection = {'I':ignored, '?':unknown, 'V':versioned}
+        selection = {'I': ignored, '?': unknown, 'V': versioned}
 
         if path is None:
             fs_path = '.'
         else:
             if from_root:
                 raise errors.BzrCommandError(gettext('cannot specify both --from-root'
-                                             ' and PATH'))
+                                                     ' and PATH'))
             fs_path = path
         tree, branch, relpath = \
             _open_directory_or_containing_tree_or_branch(fs_path, directory)
@@ -3027,7 +3059,7 @@
 
         self.add_cleanup(tree.lock_read().unlock)
         for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,
-            from_dir=relpath, recursive=recursive):
+                                                         from_dir=relpath, recursive=recursive):
             # Apply additional masking
             if not all and not selection[fc]:
                 continue
@@ -3093,7 +3125,7 @@
 
     If a .bzrignore file does not exist, the ignore command
     will create one and add the specified files or patterns to the newly
-    created file. The ignore command will also automatically add the 
+    created file. The ignore command will also automatically add the
     .bzrignore file to be versioned. Creating a .bzrignore file without
     the use of the ignore command will require an explicit add command.
 
@@ -3101,7 +3133,7 @@
     After adding, editing or deleting that file either indirectly by
     using this command or directly by using an editor, be sure to commit
     it.
-    
+
     Bazaar also supports a global ignore file ~/.bazaar/ignore. On Windows
     the global ignore file can be found in the application data directory as
     C:\\Documents and Settings\\<user>\\Application Data\\Bazaar\\2.0\\ignore.
@@ -3163,9 +3195,9 @@
     _see_also = ['status', 'ignored', 'patterns']
     takes_args = ['name_pattern*']
     takes_options = ['directory',
-        Option('default-rules',
-               help='Display the default ignore rules that brz uses.')
-        ]
+                     Option('default-rules',
+                            help='Display the default ignore rules that brz uses.')
+                     ]
 
     def run(self, name_pattern_list=None, default_rules=None,
             directory=u'.'):
@@ -3177,7 +3209,7 @@
             return
         if not name_pattern_list:
             raise errors.BzrCommandError(gettext("ignore requires at least one "
-                "NAME_PATTERN or --default-rules."))
+                                                 "NAME_PATTERN or --default-rules."))
         name_pattern_list = [globbing.normalize_pattern(p)
                              for p in name_pattern_list]
         bad_patterns = ''
@@ -3187,14 +3219,14 @@
                 bad_patterns_count += 1
                 bad_patterns += ('\n  %s' % p)
         if bad_patterns:
-            msg = (ngettext('Invalid ignore pattern found. %s', 
+            msg = (ngettext('Invalid ignore pattern found. %s',
                             'Invalid ignore patterns found. %s',
                             bad_patterns_count) % bad_patterns)
             ui.ui_factory.show_error(msg)
             raise lazy_regex.InvalidPattern('')
         for name_pattern in name_pattern_list:
             if (name_pattern[0] == '/' or
-                (len(name_pattern) > 1 and name_pattern[1] == ':')):
+                    (len(name_pattern) > 1 and name_pattern[1] == ':')):
                 raise errors.BzrCommandError(gettext(
                     "NAME_PATTERN should not be an absolute path"))
         tree, relpath = WorkingTree.open_containing(directory)
@@ -3210,9 +3242,9 @@
                     matches.append(filename)
         if len(matches) > 0:
             self.outf.write(gettext("Warning: the following files are version "
-                  "controlled and match your ignore pattern:\n%s"
-                  "\nThese files will continue to be version controlled"
-                  " unless you 'brz remove' them.\n") % ("\n".join(matches),))
+                                    "controlled and match your ignore pattern:\n%s"
+                                    "\nThese files will continue to be version controlled"
+                                    " unless you 'brz remove' them.\n") % ("\n".join(matches),))
 
 
 class cmd_ignored(Command):
@@ -3237,7 +3269,7 @@
         for path, file_class, kind, file_id, entry in tree.list_files():
             if file_class != 'I':
                 continue
-            ## XXX: Slightly inefficient since this was already calculated
+            # XXX: Slightly inefficient since this was already calculated
             pat = tree.is_ignored(path)
             self.outf.write('%-50s %s\n' % (path, pat))
 
@@ -3259,7 +3291,8 @@
         except ValueError:
             raise errors.BzrCommandError(gettext("not a valid revision-number: %r")
                                          % revno)
-        revid = WorkingTree.open_containing(directory)[0].branch.get_rev_id(revno)
+        revid = WorkingTree.open_containing(
+            directory)[0].branch.get_rev_id(revno)
         self.outf.write("%s\n" % revid.decode('utf-8'))
 
 
@@ -3295,26 +3328,26 @@
     encoding_type = 'exact'
     takes_args = ['dest', 'branch_or_subdir?']
     takes_options = ['directory',
-        Option('format',
-               help="Type of file to export to.",
-               type=text_type),
-        'revision',
-        Option('filters', help='Apply content filters to export the '
-                'convenient form.'),
-        Option('root',
-               type=text_type,
-               help="Name of the root directory inside the exported file."),
-        Option('per-file-timestamps',
-               help='Set modification time of files to that of the last '
-                    'revision in which it was changed.'),
-        Option('uncommitted',
-               help='Export the working tree contents rather than that of the '
-                    'last revision.'),
-        ]
+                     Option('format',
+                            help="Type of file to export to.",
+                            type=text_type),
+                     'revision',
+                     Option('filters', help='Apply content filters to export the '
+                            'convenient form.'),
+                     Option('root',
+                            type=text_type,
+                            help="Name of the root directory inside the exported file."),
+                     Option('per-file-timestamps',
+                            help='Set modification time of files to that of the last '
+                            'revision in which it was changed.'),
+                     Option('uncommitted',
+                            help='Export the working tree contents rather than that of the '
+                            'last revision.'),
+                     ]
 
     def run(self, dest, branch_or_subdir=None, revision=None, format=None,
-        root=None, filters=False, per_file_timestamps=False, uncommitted=False,
-        directory=u'.'):
+            root=None, filters=False, per_file_timestamps=False, uncommitted=False,
+            directory=u'.'):
         from .export import export, guess_format, get_root_name
 
         if branch_or_subdir is None:
@@ -3332,8 +3365,8 @@
             export_tree = tree
         else:
             export_tree = _get_one_revision_tree(
-                    'export', revision, branch=b,
-                    tree=tree)
+                'export', revision, branch=b,
+                tree=tree)
 
         if format is None:
             format = guess_format(dest)
@@ -3349,7 +3382,7 @@
         if filters:
             from breezy.filter_tree import ContentFilterTree
             export_tree = ContentFilterTree(
-                    export_tree, export_tree._content_filter_stack)
+                export_tree, export_tree._content_filter_stack)
 
         try:
             export(export_tree, dest, format, root, subdir,
@@ -3370,11 +3403,12 @@
 
     _see_also = ['ls']
     takes_options = ['directory',
-        Option('name-from-revision', help='The path name in the old tree.'),
-        Option('filters', help='Apply content filters to display the '
-                'convenience form.'),
-        'revision',
-        ]
+                     Option('name-from-revision',
+                            help='The path name in the old tree.'),
+                     Option('filters', help='Apply content filters to display the '
+                            'convenience form.'),
+                     'revision',
+                     ]
     takes_args = ['filename']
     encoding_type = 'exact'
 
@@ -3383,7 +3417,7 @@
             filters=False, directory=None):
         if revision is not None and len(revision) != 1:
             raise errors.BzrCommandError(gettext("brz cat --revision takes exactly"
-                                         " one revision specifier"))
+                                                 " one revision specifier"))
         tree, branch, relpath = \
             _open_directory_or_containing_tree_or_branch(filename, directory)
         self.add_cleanup(branch.lock_read().unlock)
@@ -3391,7 +3425,7 @@
                          name_from_revision, filters)
 
     def _run(self, tree, b, relpath, filename, revision, name_from_revision,
-        filtered):
+             filtered):
         import shutil
         if tree is None:
             tree = b.basis_tree()
@@ -3425,8 +3459,8 @@
         relpath = rev_tree.id2path(actual_file_id)
         if filtered:
             from .filter_tree import ContentFilterTree
-            filter_tree = ContentFilterTree(rev_tree,
-                rev_tree._content_filter_stack)
+            filter_tree = ContentFilterTree(
+                rev_tree, rev_tree._content_filter_stack)
             fileobj = filter_tree.get_file(relpath)
         else:
             fileobj = rev_tree.get_file(relpath)
@@ -3443,7 +3477,6 @@
         self.outf.write("%s\n" % osutils.local_time_offset())
 
 
-
 class cmd_commit(Command):
     __doc__ = """Commit changes into a new revision.
 
@@ -3539,11 +3572,11 @@
              Option('show-diff', short_name='p',
                     help='When no message is supplied, show the diff along'
                     ' with the status summary in the message editor.'),
-             Option('lossy', 
+             Option('lossy',
                     help='When committing to a foreign version control '
                     'system do not push data that can not be natively '
                     'represented.'),
-             ]
+        ]
     aliases = ['ci', 'checkin']
 
     def _iter_bug_urls(self, bugs, branch, status):
@@ -3643,7 +3676,7 @@
                 warning_msg = (
                     'The commit message is a file name: "%(f)s".\n'
                     '(use --file "%(f)s" to take commit message from that file)'
-                    % { 'f': message })
+                    % {'f': message})
                 ui.ui_factory.show_warning(warning_msg)
             if '\r' in message:
                 message = message.replace('\r\n', '\n')
@@ -3663,8 +3696,8 @@
                 # No message supplied: make one up.
                 # text is the status of the tree
                 text = make_commit_message_template_encoded(tree,
-                        selected_list, diff=show_diff,
-                        output_encoding=osutils.get_user_encoding())
+                                                            selected_list, diff=show_diff,
+                                                            output_encoding=osutils.get_user_encoding())
                 # start_message is the template generated from hooks
                 # XXX: Warning - looks like hooks return unicode,
                 # make_commit_message_template_encoded returns user encoding.
@@ -3672,20 +3705,21 @@
                 # avoid this.
                 my_message = set_commit_message(commit_obj)
                 if my_message is None:
-                    start_message = generate_commit_message_template(commit_obj)
+                    start_message = generate_commit_message_template(
+                        commit_obj)
                     if start_message is not None:
                         start_message = start_message.encode(
-                                osutils.get_user_encoding())
+                            osutils.get_user_encoding())
                     my_message = edit_commit_message_encoded(text,
-                        start_message=start_message)
+                                                             start_message=start_message)
                 if my_message is None:
                     raise errors.BzrCommandError(gettext("please specify a commit"
-                        " message with either --message or --file"))
+                                                         " message with either --message or --file"))
                 if my_message == "":
                     raise errors.BzrCommandError(gettext("Empty commit message specified."
-                            " Please specify a commit message with either"
-                            " --message or --file or leave a blank message"
-                            " with --message \"\"."))
+                                                         " Please specify a commit message with either"
+                                                         " --message or --file or leave a blank message"
+                                                         " with --message \"\"."))
             return my_message
 
         # The API permits a commit with a filter of [] to mean 'select nothing'
@@ -3703,20 +3737,20 @@
                         lossy=lossy)
         except PointlessCommit:
             raise errors.BzrCommandError(gettext("No changes to commit."
-                " Please 'brz add' the files you want to commit, or use"
-                " --unchanged to force an empty commit."))
+                                                 " Please 'brz add' the files you want to commit, or use"
+                                                 " --unchanged to force an empty commit."))
         except ConflictsInTree:
             raise errors.BzrCommandError(gettext('Conflicts detected in working '
-                'tree.  Use "brz conflicts" to list, "brz resolve FILE" to'
-                ' resolve.'))
+                                                 'tree.  Use "brz conflicts" to list, "brz resolve FILE" to'
+                                                 ' resolve.'))
         except StrictCommitFailed:
             raise errors.BzrCommandError(gettext("Commit refused because there are"
-                              " unknown files in the working tree."))
+                                                 " unknown files in the working tree."))
         except errors.BoundBranchOutOfDate as e:
             e.extra_help = (gettext("\n"
-                'To commit to master branch, run update and then commit.\n'
-                'You can also pass --local to commit to continue working '
-                'disconnected.'))
+                                    'To commit to master branch, run update and then commit.\n'
+                                    'You can also pass --local to commit to continue working '
+                                    'disconnected.'))
             raise
 
 
@@ -3827,15 +3861,16 @@
     takes_args = ['url?']
     takes_options = [
         RegistryOption('format',
-            help='Upgrade to a specific format.  See "brz help'
-                 ' formats" for details.',
-            lazy_registry=('breezy.controldir', 'format_registry'),
-            converter=lambda name: controldir.format_registry.make_controldir(name),
-            value_switches=True, title='Branch format'),
+                       help='Upgrade to a specific format.  See "brz help'
+                       ' formats" for details.',
+                       lazy_registry=('breezy.controldir', 'format_registry'),
+                       converter=lambda name: controldir.format_registry.make_controldir(
+                           name),
+                       value_switches=True, title='Branch format'),
         Option('clean',
-            help='Remove the backup.bzr directory if successful.'),
+               help='Remove the backup.bzr directory if successful.'),
         Option('dry-run',
-            help="Show what would be done, but don't actually do anything."),
+               help="Show what would be done, but don't actually do anything."),
     ]
 
     def run(self, url='.', format=None, clean=False, dry_run=False):
@@ -3861,13 +3896,13 @@
 
             brz whoami "Frank Chu <[e-mail]>"
     """
-    takes_options = [ 'directory',
-                      Option('email',
-                             help='Display email address only.'),
-                      Option('branch',
-                             help='Set identity for the current branch instead of '
-                                  'globally.'),
-                    ]
+    takes_options = ['directory',
+                     Option('email',
+                            help='Display email address only.'),
+                     Option('branch',
+                            help='Set identity for the current branch instead of '
+                            'globally.'),
+                     ]
     takes_args = ['name?']
     encoding_type = 'replace'
 
@@ -3892,12 +3927,12 @@
 
         if email:
             raise errors.BzrCommandError(gettext("--email can only be used to display existing "
-                                         "identity"))
+                                                 "identity"))
 
         # display a warning if an email address isn't included in the given name.
         try:
             _mod_config.extract_email_address(name)
-        except _mod_config.NoEmailInUsername as e:
+        except _mod_config.NoEmailInUsername:
             warning('"%s" does not seem to contain an email address.  '
                     'This is allowed, but not recommended.', name)
 
@@ -3977,7 +4012,7 @@
             if equal_pos == -1:
                 self.print_alias(name)
             else:
-                self.set_alias(name[:equal_pos], name[equal_pos+1:])
+                self.set_alias(name[:equal_pos], name[equal_pos + 1:])
 
     def remove_alias(self, alias_name):
         if alias_name is None:
@@ -4062,6 +4097,7 @@
     """
     # NB: this is used from the class without creating an instance, which is
     # why it does not have a self parameter.
+
     def get_transport_type(typestring):
         """Parse and return a transport specifier."""
         if typestring == "sftp":
@@ -4081,9 +4117,9 @@
     takes_args = ['testspecs*']
     takes_options = ['verbose',
                      Option('one',
-                             help='Stop when one test fails.',
-                             short_name='1',
-                             ),
+                            help='Stop when one test fails.',
+                            short_name='1',
+                            ),
                      Option('transport',
                             help='Use a different transport by default '
                                  'throughout the test suite.',
@@ -4103,10 +4139,11 @@
                      Option('list-only',
                             help='List the tests instead of running them.'),
                      RegistryOption('parallel',
-                        help="Run the test suite in parallel.",
-                        lazy_registry=('breezy.tests', 'parallel_registry'),
-                        value_switches=False,
-                        ),
+                                    help="Run the test suite in parallel.",
+                                    lazy_registry=(
+                                        'breezy.tests', 'parallel_registry'),
+                                    value_switches=False,
+                                    ),
                      Option('randomize', type=text_type, argname="SEED",
                             help='Randomize the order of tests using the given'
                                  ' seed or "now" for the current time.'),
@@ -4126,8 +4163,7 @@
                                 help='Turn on a selftest debug flag.'),
                      ListOption('starting-with', type=text_type, argname='TESTID',
                                 param_name='starting_with', short_name='s',
-                                help=
-                                'Load only the tests starting with TESTID.'),
+                                help='Load only the tests starting with TESTID.'),
                      Option('sync',
                             help="By default we disable fsync and fdatasync"
                                  " while running the test suite.")
@@ -4161,7 +4197,7 @@
             from . import tests
         except ImportError:
             raise errors.BzrCommandError("tests not available. Install the "
-                "breezy tests to run the breezy testsuite.")
+                                         "breezy tests to run the breezy testsuite.")
 
         if testspecs_list is not None:
             pattern = '|'.join(testspecs_list)
@@ -4181,7 +4217,7 @@
             # following code can be deleted when it's sufficiently deployed
             # -- vila/mgz 20100514
             if (sys.platform == "win32"
-                and getattr(sys.stdout, 'fileno', None) is not None):
+                    and getattr(sys.stdout, 'fileno', None) is not None):
                 import msvcrt
                 msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
         if subunit2:
@@ -4208,21 +4244,21 @@
         if not sync:
             self._disable_fsync()
         selftest_kwargs = {"verbose": verbose,
-                          "pattern": pattern,
-                          "stop_on_failure": one,
-                          "transport": transport,
-                          "test_suite_factory": test_suite_factory,
-                          "lsprof_timed": lsprof_timed,
-                          "lsprof_tests": lsprof_tests,
-                          "matching_tests_first": first,
-                          "list_only": list_only,
-                          "random_seed": randomize,
-                          "exclude_pattern": exclude_pattern,
-                          "strict": strict,
-                          "load_list": load_list,
-                          "debug_flags": debugflag,
-                          "starting_with": starting_with
-                          }
+                           "pattern": pattern,
+                           "stop_on_failure": one,
+                           "transport": transport,
+                           "test_suite_factory": test_suite_factory,
+                           "lsprof_timed": lsprof_timed,
+                           "lsprof_tests": lsprof_tests,
+                           "matching_tests_first": first,
+                           "list_only": list_only,
+                           "random_seed": randomize,
+                           "exclude_pattern": exclude_pattern,
+                           "strict": strict,
+                           "load_list": load_list,
+                           "debug_flags": debugflag,
+                           "starting_with": starting_with
+                           }
         selftest_kwargs.update(self.additional_selftest_args)
 
         # Make deprecation warnings visible, unless -Werror is set
@@ -4293,7 +4329,7 @@
         base_rev_id = graph.find_unique_lca(last1, last2)
 
         self.outf.write(gettext('merge base is revision %s\n') %
-                base_rev_id.decode('utf-8'))
+                        base_rev_id.decode('utf-8'))
 
 
 class cmd_merge(Command):
@@ -4394,16 +4430,16 @@
         Option('uncommitted', help='Apply uncommitted changes'
                ' from a working copy, instead of branch changes.'),
         Option('pull', help='If the destination is already'
-                ' completely merged into the source, pull from the'
-                ' source rather than merging.  When this happens,'
-                ' you do not need to commit the result.'),
+               ' completely merged into the source, pull from the'
+               ' source rather than merging.  When this happens,'
+               ' you do not need to commit the result.'),
         custom_help('directory',
-               help='Branch to merge into, '
+                    help='Branch to merge into, '
                     'rather than the one containing the working directory.'),
         Option('preview', help='Instead of merging, show a diff of the'
                ' merge.'),
         Option('interactive', help='Select changes interactively.',
-            short_name='i')
+               short_name='i')
     ]
 
     def run(self, location=None, revision=None, force=False,
@@ -4426,7 +4462,7 @@
         tree = WorkingTree.open_containing(directory)[0]
         if tree.branch.last_revision() == _mod_revision.NULL_REVISION:
             raise errors.BzrCommandError(gettext('Merging into empty branches not currently supported, '
-                                         'https://bugs.launchpad.net/bzr/+bug/308562'))
+                                                 'https://bugs.launchpad.net/bzr/+bug/308562'))
 
         # die as quickly as possible if there are uncommitted changes
         if not force:
@@ -4442,49 +4478,50 @@
         if location is not None:
             try:
                 mergeable = bundle.read_mergeable_from_url(location,
-                    possible_transports=possible_transports)
+                                                           possible_transports=possible_transports)
             except errors.NotABundle:
                 mergeable = None
             else:
                 if uncommitted:
                     raise errors.BzrCommandError(gettext('Cannot use --uncommitted'
-                        ' with bundles or merge directives.'))
+                                                         ' with bundles or merge directives.'))
 
                 if revision is not None:
                     raise errors.BzrCommandError(gettext(
                         'Cannot use -r with merge directives or bundles'))
                 merger, verified = _mod_merge.Merger.from_mergeable(tree,
-                   mergeable)
+                                                                    mergeable)
 
         if merger is None and uncommitted:
             if revision is not None and len(revision) > 0:
                 raise errors.BzrCommandError(gettext('Cannot use --uncommitted and'
-                    ' --revision at the same time.'))
+                                                     ' --revision at the same time.'))
             merger = self.get_merger_from_uncommitted(tree, location, None)
             allow_pending = False
 
         if merger is None:
             merger, allow_pending = self._get_merger_from_branch(tree,
-                location, revision, remember, possible_transports, None)
+                                                                 location, revision, remember, possible_transports, None)
 
         merger.merge_type = merge_type
         merger.reprocess = reprocess
         merger.show_base = show_base
         self.sanity_check_merger(merger)
         if (merger.base_rev_id == merger.other_rev_id and
-            merger.other_rev_id is not None):
+                merger.other_rev_id is not None):
             # check if location is a nonexistent file (and not a branch) to
             # disambiguate the 'Nothing to do'
             if merger.interesting_files:
                 if not merger.other_tree.has_filename(
-                    merger.interesting_files[0]):
+                        merger.interesting_files[0]):
                     note(gettext("merger: ") + str(merger))
                     raise errors.PathsDoNotExist([location])
             note(gettext('Nothing to do.'))
             return 0
         if pull and not preview:
             if merger.interesting_files is not None:
-                raise errors.BzrCommandError(gettext('Cannot pull individual files'))
+                raise errors.BzrCommandError(
+                    gettext('Cannot pull individual files'))
             if (merger.base_rev_id == tree.last_revision()):
                 result = tree.pull(merger.other_branch, False,
                                    merger.other_rev_id)
@@ -4549,9 +4586,9 @@
 
     def sanity_check_merger(self, merger):
         if (merger.show_base and
-            not merger.merge_type is _mod_merge.Merge3Merger):
+                merger.merge_type is not _mod_merge.Merge3Merger):
             raise errors.BzrCommandError(gettext("Show-base is not supported for this"
-                                         " merge type. %s") % merger.merge_type)
+                                                 " merge type. %s") % merger.merge_type)
         if merger.reprocess is None:
             if merger.show_base:
                 merger.reprocess = False
@@ -4560,11 +4597,11 @@
                 merger.reprocess = merger.merge_type.supports_reprocess
         if merger.reprocess and not merger.merge_type.supports_reprocess:
             raise errors.BzrCommandError(gettext("Conflict reduction is not supported"
-                                         " for merge type %s.") %
+                                                 " for merge type %s.") %
                                          merger.merge_type)
         if merger.reprocess and merger.show_base:
             raise errors.BzrCommandError(gettext("Cannot do conflict reduction and"
-                                         " show base."))
+                                                 " show base."))
 
         if (merger.merge_type.requires_file_merge_plan and
             (not getattr(merger.this_tree, 'plan_file_merge', None) or
@@ -4572,28 +4609,28 @@
              (merger.base_tree is not None and
                  not getattr(merger.base_tree, 'plan_file_merge', None)))):
             raise errors.BzrCommandError(
-                 gettext('Plan file merge unsupported: '
-                         'Merge type incompatible with tree formats.'))
+                gettext('Plan file merge unsupported: '
+                        'Merge type incompatible with tree formats.'))
 
     def _get_merger_from_branch(self, tree, location, revision, remember,
                                 possible_transports, pb):
         """Produce a merger from a location, assuming it refers to a branch."""
         # find the branch locations
         other_loc, user_location = self._select_branch_location(tree, location,
-            revision, -1)
+                                                                revision, -1)
         if revision is not None and len(revision) == 2:
             base_loc, _unused = self._select_branch_location(tree,
-                location, revision, 0)
+                                                             location, revision, 0)
         else:
             base_loc = other_loc
         # Open the branches
         other_branch, other_path = Branch.open_containing(other_loc,
-            possible_transports)
+                                                          possible_transports)
         if base_loc == other_loc:
             base_branch = other_branch
         else:
             base_branch, base_path = Branch.open_containing(base_loc,
-                possible_transports)
+                                                            possible_transports)
         # Find the revision ids
         other_revision_id = None
         base_revision_id = None
@@ -4611,15 +4648,15 @@
         # - user ask to remember or there is no previous location set to merge
         #   from and user didn't ask to *not* remember
         if (user_location is not None
-            and ((remember
-                  or (remember is None
-                      and tree.branch.get_submit_branch() is None)))):
+            and ((remember or
+              (remember is None and
+                   tree.branch.get_submit_branch() is None)))):
             tree.branch.set_submit_branch(other_branch.base)
         # Merge tags (but don't set them in the master branch yet, the user
         # might revert this merge).  Commit will propagate them.
         other_branch.tags.merge_to(tree.branch.tags, ignore_master=True)
         merger = _mod_merge.Merger.from_revision_ids(tree,
-            other_revision_id, base_revision_id, other_branch, base_branch)
+                                                     other_revision_id, base_revision_id, other_branch, base_branch)
         if other_path != '':
             allow_pending = False
             merger.interesting_files = [other_path]
@@ -4660,7 +4697,7 @@
             will be the user-entered location.
         """
         if (revision is not None and index is not None
-            and revision[index] is not None):
+                and revision[index] is not None):
             branch = revision[index].get_branch()
             if branch is not None:
                 return branch, branch
@@ -4682,10 +4719,11 @@
             stored_location_type = "parent"
         mutter("%s", stored_location)
         if stored_location is None:
-            raise errors.BzrCommandError(gettext("No location specified or remembered"))
+            raise errors.BzrCommandError(
+                gettext("No location specified or remembered"))
         display_url = urlutils.unescape_for_display(stored_location, 'utf-8')
         note(gettext("{0} remembered {1} location {2}").format(verb_string,
-                stored_location_type, display_url))
+                                                               stored_location_type, display_url))
         return stored_location
 
 
@@ -4713,11 +4751,11 @@
     """
     takes_args = ['file*']
     takes_options = [
-            'merge-type',
-            'reprocess',
-            Option('show-base',
-                   help="Show base revision text in conflicts."),
-            ]
+        'merge-type',
+        'reprocess',
+        Option('show-base',
+               help="Show base revision text in conflicts."),
+        ]
 
     def run(self, file_list=None, merge_type=None, show_base=False,
             reprocess=False):
@@ -4728,10 +4766,9 @@
         self.add_cleanup(tree.lock_write().unlock)
         parents = tree.get_parent_ids()
         if len(parents) != 2:
-            raise errors.BzrCommandError(gettext("Sorry, remerge only works after normal"
-                                         " merges.  Not cherrypicking or"
-                                         " multi-merges."))
-        repository = tree.branch.repository
+            raise errors.BzrCommandError(
+                gettext("Sorry, remerge only works after normal"
+                        " merges.  Not cherrypicking or multi-merges."))
         interesting_files = None
         new_conflicts = []
         conflicts = tree.conflicts()
@@ -4744,7 +4781,8 @@
                 if tree.kind(filename) != "directory":
                     continue
 
-                for path, ie in tree.iter_entries_by_dir(specific_files=[filename]):
+                for path, ie in tree.iter_entries_by_dir(
+                        specific_files=[filename]):
                     interesting_files.add(path)
             new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
         else:
@@ -4858,7 +4896,7 @@
     def _revert_tree_to_revision(tree, revision, file_list, no_backup):
         rev_tree = _get_one_revision_tree('revert', revision, tree=tree)
         tree.revert(file_list, rev_tree, not no_backup, None,
-            report_changes=True)
+                    report_changes=True)
 
 
 class cmd_assert_fail(Command):
@@ -4877,8 +4915,8 @@
 
     _see_also = ['topics']
     takes_options = [
-            Option('long', 'Show help on all commands.'),
-            ]
+        Option('long', 'Show help on all commands.'),
+        ]
     takes_args = ['topic?']
     aliases = ['?', '--help', '-?', '-h']
 
@@ -4955,12 +4993,12 @@
         'show-ids',
         'verbose',
         custom_help('revision',
-             help='Filter on other branch revisions (inclusive). '
-                'See "help revisionspec" for details.'),
+                    help='Filter on other branch revisions (inclusive). '
+                    'See "help revisionspec" for details.'),
         Option('my-revision',
-            type=_parse_revision_str,
-            help='Filter on local branch revisions (inclusive). '
-                'See "help revisionspec" for details.'),
+               type=_parse_revision_str,
+               help='Filter on local branch revisions (inclusive). '
+               'See "help revisionspec" for details.'),
         Option('include-merged',
                'Show all revisions in addition to the mainline ones.'),
         Option('include-merges', hidden=True,
@@ -5004,7 +5042,7 @@
             other_branch = parent
             if other_branch is None:
                 raise errors.BzrCommandError(gettext("No peer location known"
-                                             " or specified."))
+                                                     " or specified."))
             display_url = urlutils.unescape_for_display(parent,
                                                         self.outf.encoding)
             message(gettext("Using saved parent location: {0}\n").format(
@@ -5018,11 +5056,11 @@
 
         local_revid_range = _revision_range_to_revid_range(
             _get_revision_range(my_revision, local_branch,
-                self.name()))
+                                self.name()))
 
         remote_revid_range = _revision_range_to_revid_range(
             _get_revision_range(revision,
-                remote_branch, self.name()))
+                                remote_branch, self.name()))
 
         local_extra, remote_extra = find_unmerged(
             local_branch, remote_branch, restrict,
@@ -5041,16 +5079,16 @@
         status_code = 0
         if local_extra and not theirs_only:
             message(ngettext("You have %d extra revision:\n",
-                             "You have %d extra revisions:\n", 
+                             "You have %d extra revisions:\n",
                              len(local_extra)) %
-                len(local_extra))
+                    len(local_extra))
             rev_tag_dict = {}
             if local_branch.supports_tags():
                 rev_tag_dict = local_branch.tags.get_reverse_tag_dict()
             for revision in iter_log_revisions(local_extra,
-                                local_branch.repository,
-                                verbose,
-                                rev_tag_dict):
+                                               local_branch.repository,
+                                               verbose,
+                                               rev_tag_dict):
                 lf.log_revision(revision)
             printed_local = True
             status_code = 1
@@ -5063,13 +5101,13 @@
             message(ngettext("You are missing %d revision:\n",
                              "You are missing %d revisions:\n",
                              len(remote_extra)) %
-                len(remote_extra))
+                    len(remote_extra))
             if remote_branch.supports_tags():
                 rev_tag_dict = remote_branch.tags.get_reverse_tag_dict()
             for revision in iter_log_revisions(remote_extra,
-                                remote_branch.repository,
-                                verbose,
-                                rev_tag_dict):
+                                               remote_branch.repository,
+                                               verbose,
+                                               rev_tag_dict):
                 lf.log_revision(revision)
             status_code = 1
 
@@ -5115,7 +5153,8 @@
     _see_also = ['repositories']
     takes_args = ['branch_or_repo?']
     takes_options = [
-        Option('clean-obsolete-packs', 'Delete obsolete packs to save disk space.'),
+        Option('clean-obsolete-packs',
+               'Delete obsolete packs to save disk space.'),
         ]
 
     def run(self, branch_or_repo='.', clean_obsolete_packs=False):
@@ -5160,12 +5199,13 @@
 class cmd_testament(Command):
     __doc__ = """Show testament (signing-form) of a revision."""
     takes_options = [
-            'revision',
-            Option('long', help='Produce long-format testament.'),
-            Option('strict',
-                   help='Produce a strict-format testament.')]
+        'revision',
+        Option('long', help='Produce long-format testament.'),
+        Option('strict',
+               help='Produce a strict-format testament.')]
     takes_args = ['branch?']
     encoding_type = 'exact'
+
     @display_command
     def run(self, branch=u'.', revision=None, long=False, strict=False):
         from .testament import Testament, StrictTestament
@@ -5245,15 +5285,17 @@
     __doc__ = """Create a digital signature for an existing revision."""
     # TODO be able to replace existing ones.
 
-    hidden = True # is this right ?
+    hidden = True  # is this right ?
     takes_args = ['revision_id*']
     takes_options = ['directory', 'revision']
 
     def run(self, revision_id_list=None, revision=None, directory=u'.'):
         if revision_id_list is not None and revision is not None:
-            raise errors.BzrCommandError(gettext('You can only supply one of revision_id or --revision'))
+            raise errors.BzrCommandError(
+                gettext('You can only supply one of revision_id or --revision'))
         if revision_id_list is None and revision is None:
-            raise errors.BzrCommandError(gettext('You must supply either --revision or a revision_id'))
+            raise errors.BzrCommandError(
+                gettext('You must supply either --revision or a revision_id'))
         b = WorkingTree.open_containing(directory)[0].branch
         self.add_cleanup(b.lock_write().unlock)
         return self._run(b, revision_id_list, revision)
@@ -5266,7 +5308,7 @@
                 for revision_id in revision_id_list:
                     revision_id = cache_utf8.encode(revision_id)
                     b.repository.sign_revision(revision_id, gpg_strategy)
-            except:
+            except BaseException:
                 b.repository.abort_write_group()
                 raise
             else:
@@ -5277,7 +5319,7 @@
                 b.repository.start_write_group()
                 try:
                     b.repository.sign_revision(rev_id, gpg_strategy)
-                except:
+                except BaseException:
                     b.repository.abort_write_group()
                     raise
                 else:
@@ -5291,19 +5333,21 @@
                 if to_revid is None:
                     to_revno = b.revno()
                 if from_revno is None or to_revno is None:
-                    raise errors.BzrCommandError(gettext('Cannot sign a range of non-revision-history revisions'))
+                    raise errors.BzrCommandError(
+                        gettext('Cannot sign a range of non-revision-history revisions'))
                 b.repository.start_write_group()
                 try:
                     for revno in range(from_revno, to_revno + 1):
                         b.repository.sign_revision(b.get_rev_id(revno),
                                                    gpg_strategy)
-                except:
+                except BaseException:
                     b.repository.abort_write_group()
                     raise
                 else:
                     b.repository.commit_write_group()
             else:
-                raise errors.BzrCommandError(gettext('Please supply either one revision, or a range.'))
+                raise errors.BzrCommandError(
+                    gettext('Please supply either one revision, or a range.'))
 
 
 class cmd_bind(Command):
@@ -5328,8 +5372,9 @@
             try:
                 location = b.get_old_bound_location()
             except errors.UpgradeRequired:
-                raise errors.BzrCommandError(gettext('No location supplied.  '
-                    'This format does not remember old locations.'))
+                raise errors.BzrCommandError(
+                    gettext('No location supplied.  '
+                            'This format does not remember old locations.'))
             else:
                 if location is None:
                     if b.get_bound_location() is not None:
@@ -5343,8 +5388,9 @@
         try:
             b.bind(b_other)
         except errors.DivergedBranches:
-            raise errors.BzrCommandError(gettext('These branches have diverged.'
-                                         ' Try merging, and then bind again.'))
+            raise errors.BzrCommandError(
+                gettext('These branches have diverged.'
+                        ' Try merging, and then bind again.'))
         if b.get_config().has_explicit_nickname():
             b.nick = b_other.nick
 
@@ -5388,15 +5434,15 @@
     # information in shared branches as well.
     _see_also = ['commit']
     takes_options = ['verbose', 'revision',
-                    Option('dry-run', help='Don\'t actually make changes.'),
-                    Option('force', help='Say yes to all questions.'),
-                    Option('keep-tags',
-                           help='Keep tags that point to removed revisions.'),
-                    Option('local',
-                           help="Only remove the commits from the local branch"
-                                " when in a checkout."
-                           ),
-                    ]
+                     Option('dry-run', help='Don\'t actually make changes.'),
+                     Option('force', help='Say yes to all questions.'),
+                     Option('keep-tags',
+                            help='Keep tags that point to removed revisions.'),
+                     Option('local',
+                            help="Only remove the commits from the local "
+                            "branch when in a checkout."
+                            ),
+                     ]
     takes_args = ['location?']
     aliases = []
     encoding_type = 'replace'
@@ -5458,9 +5504,10 @@
 
         if dry_run:
             self.outf.write(gettext('Dry-run, pretending to remove'
-                            ' the above revisions.\n'))
+                                    ' the above revisions.\n'))
         else:
-            self.outf.write(gettext('The above revision(s) will be removed.\n'))
+            self.outf.write(
+                gettext('The above revision(s) will be removed.\n'))
 
         if not force:
             if not ui.ui_factory.confirm_action(
@@ -5474,8 +5521,10 @@
                last_rev_id, rev_id)
         uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
                  revno=revno, local=local, keep_tags=keep_tags)
-        self.outf.write(gettext('You can restore the old tip by running:\n'
-             '  brz pull . -r revid:%s\n') % last_rev_id.decode('utf-8'))
+        self.outf.write(
+            gettext('You can restore the old tip by running:\n'
+                    '  brz pull . -r revid:%s\n')
+            % last_rev_id.decode('utf-8'))
 
 
 class cmd_break_lock(Command):
@@ -5501,7 +5550,7 @@
         Option('config',
                help='LOCATION is the directory where the config lock is.'),
         Option('force',
-            help='Do not ask for confirmation before breaking the lock.'),
+               help='Do not ask for confirmation before breaking the lock.'),
         ]
 
     def run(self, location=None, config=False, force=False):
@@ -5509,8 +5558,8 @@
             location = u'.'
         if force:
             ui.ui_factory = ui.ConfirmationUserInterfacePolicy(ui.ui_factory,
-                None,
-                {'breezy.lockdir.break': True})
+                                                               None,
+                                                               {'breezy.lockdir.break': True})
         if config:
             conf = _mod_config.LockableConfig(file_name=location)
             conf.break_lock()
@@ -5545,18 +5594,20 @@
         Option('inet',
                help='Serve on stdin/out for use from inetd or sshd.'),
         RegistryOption('protocol',
-               help="Protocol to serve.",
-               lazy_registry=('breezy.transport', 'transport_server_registry'),
-               value_switches=True),
+                       help="Protocol to serve.",
+                       lazy_registry=('breezy.transport',
+                                      'transport_server_registry'),
+                       value_switches=True),
         Option('listen',
-               help='Listen for connections on nominated address.', type=text_type),
+               help='Listen for connections on nominated address.',
+               type=text_type),
         Option('port',
                help='Listen for connections on nominated port.  Passing 0 as '
                     'the port number will result in a dynamically allocated '
                     'port.  The default port depends on the protocol.',
                type=int),
         custom_help('directory',
-               help='Serve contents of this directory.'),
+                    help='Serve contents of this directory.'),
         Option('allow-writes',
                help='By default the server is a readonly server.  Supplying '
                     '--allow-writes enables write access to the contents of '
@@ -5565,7 +5616,7 @@
                     'external authentication is arranged supplying this '
                     'option leads to global uncontrolled write access to your '
                     'file system.'
-                ),
+               ),
         Option('client-timeout', type=float,
                help='Override the default idle client timeout (5min).'),
         ]
@@ -5601,8 +5652,8 @@
     _see_also = ['split']
     takes_args = ['tree']
     takes_options = [
-            Option('reference', help='Join by reference.', hidden=True),
-            ]
+        Option('reference', help='Join by reference.', hidden=True),
+        ]
 
     def run(self, tree, reference=False):
         from breezy.mutabletree import BadReferenceTarget
@@ -5622,13 +5673,13 @@
                 # XXX: Would be better to just raise a nicely printable
                 # exception from the real origin.  Also below.  mbp 20070306
                 raise errors.BzrCommandError(
-                       gettext("Cannot join {0}.  {1}").format(tree, e.reason))
+                    gettext("Cannot join {0}.  {1}").format(tree, e.reason))
         else:
             try:
                 containing_tree.subsume(sub_tree)
             except errors.BadSubsumeSource as e:
                 raise errors.BzrCommandError(
-                       gettext("Cannot join {0}.  {1}").format(tree, e.reason))
+                    gettext("Cannot join {0}.  {1}").format(tree, e.reason))
 
 
 class cmd_split(Command):
@@ -5681,7 +5732,8 @@
 
     takes_options = [
         'directory',
-        RegistryOption.from_kwargs('patch-type',
+        RegistryOption.from_kwargs(
+            'patch-type',
             'The type of patch to include in the directive.',
             title='Patch type',
             value_switches=True,
@@ -5691,9 +5743,10 @@
             plain='No patch, just directive.'),
         Option('sign', help='GPG-sign the directive.'), 'revision',
         Option('mail-to', type=text_type,
-            help='Instead of printing the directive, email to this address.'),
+               help='Instead of printing the directive, email to this '
+               'address.'),
         Option('message', type=text_type, short_name='m',
-            help='Message to use when committing this merge.')
+               help='Message to use when committing this merge.')
         ]
 
     encoding_type = 'exact'
@@ -5717,7 +5770,8 @@
         if submit_branch is None:
             submit_branch = branch.get_parent()
         if submit_branch is None:
-            raise errors.BzrCommandError(gettext('No submit branch specified or known'))
+            raise errors.BzrCommandError(
+                gettext('No submit branch specified or known'))
 
         stored_public_branch = branch.get_public_branch()
         if public_branch is None:
@@ -5726,13 +5780,14 @@
             # FIXME: Should be done only if we succeed ? -- vila 2012-01-03
             branch.set_public_branch(public_branch)
         if not include_bundle and public_branch is None:
-            raise errors.BzrCommandError(gettext('No public branch specified or'
-                                         ' known'))
+            raise errors.BzrCommandError(
+                gettext('No public branch specified or known'))
         base_revision_id = None
         if revision is not None:
             if len(revision) > 2:
-                raise errors.BzrCommandError(gettext('brz merge-directive takes '
-                    'at most two one revision identifiers'))
+                raise errors.BzrCommandError(
+                    gettext('brz merge-directive takes '
+                            'at most two one revision identifiers'))
             revision_id = revision[-1].as_revision_id(branch)
             if len(revision) == 2:
                 base_revision_id = revision[0].as_revision_id(branch)
@@ -5936,9 +5991,9 @@
             output = '-'
         from .send import send
         return send(submit_branch, revision, public_branch, remember,
-                         format, no_bundle, no_patch, output,
-                         kwargs.get('from', '.'), None, None, None,
-                         self.outf, strict=strict)
+                    format, no_bundle, no_patch, output,
+                    kwargs.get('from', '.'), None, None, None,
+                    self.outf, strict=strict)
 
 
 class cmd_tag(Command):
@@ -5957,7 +6012,7 @@
     To rename a tag (change the name but keep it on the same revsion), run ``brz
     tag new-name -r tag:old-name`` and then ``brz tag --delete oldname``.
 
-    If no tag name is specified it will be determined through the 
+    If no tag name is specified it will be determined through the
     'automatic_tag_name' hook. This can e.g. be used to automatically tag
     upstream releases by reading configure.ac. See ``brz help hooks`` for
     details.
@@ -5967,13 +6022,13 @@
     takes_args = ['tag_name?']
     takes_options = [
         Option('delete',
-            help='Delete this tag rather than placing it.',
-            ),
+               help='Delete this tag rather than placing it.',
+               ),
         custom_help('directory',
-            help='Branch in which to place the tag.'),
+                    help='Branch in which to place the tag.'),
         Option('force',
-            help='Replace existing tags.',
-            ),
+               help='Replace existing tags.',
+               ),
         'revision',
         ]
 
@@ -5987,7 +6042,8 @@
         self.add_cleanup(branch.lock_write().unlock)
         if delete:
             if tag_name is None:
-                raise errors.BzrCommandError(gettext("No tag specified to delete."))
+                raise errors.BzrCommandError(
+                    gettext("No tag specified to delete."))
             branch.tags.delete_tag(tag_name)
             note(gettext('Deleted tag %s.') % tag_name)
         else:
@@ -6029,11 +6085,11 @@
     _see_also = ['tag']
     takes_options = [
         custom_help('directory',
-            help='Branch whose tags should be displayed.'),
+                    help='Branch whose tags should be displayed.'),
         RegistryOption('sort',
-            'Sort tags by different criteria.', title='Sorting',
-            lazy_registry=('breezy.tag', 'tag_sort_methods')
-            ),
+                       'Sort tags by different criteria.', title='Sorting',
+                       lazy_registry=('breezy.tag', 'tag_sort_methods')
+                       ),
         'show-ids',
         'revision',
     ]
@@ -6092,8 +6148,8 @@
         tagged_revids = branch.tags.get_reverse_tag_dict()
         found = []
         for r in branch.iter_merge_sorted_revisions(
-            start_revision_id=revid2, stop_revision_id=revid1,
-            stop_rule='include'):
+                start_revision_id=revid2, stop_revision_id=revid1,
+                stop_rule='include'):
             revid_tags = tagged_revids.get(r[0], None)
             if revid_tags:
                 found.extend([(tag, r[0]) for tag in revid_tags])
@@ -6126,7 +6182,7 @@
             tree='Reconfigure to be an unbound branch with a working tree.',
             checkout='Reconfigure to be a bound branch with a working tree.',
             lightweight_checkout='Reconfigure to be a lightweight'
-                ' checkout (with no local history).',
+            ' checkout (with no local history).',
             ),
         RegistryOption.from_kwargs(
             'repository_type',
@@ -6134,7 +6190,7 @@
             help='Location fo the repository.',
             value_switches=True, enum_switch=False,
             standalone='Reconfigure to be a standalone branch '
-                '(i.e. stop using shared repository).',
+            '(i.e. stop using shared repository).',
             use_shared='Reconfigure to use a shared repository.',
             ),
         RegistryOption.from_kwargs(
@@ -6143,22 +6199,22 @@
             help='Whether new branches in the repository have trees.',
             value_switches=True, enum_switch=False,
             with_trees='Reconfigure repository to create '
-                'working trees on branches by default.',
+            'working trees on branches by default.',
             with_no_trees='Reconfigure repository to not create '
-                'working trees on branches by default.'
+            'working trees on branches by default.'
             ),
         Option('bind-to', help='Branch to bind checkout to.', type=text_type),
         Option('force',
-            help='Perform reconfiguration even if local changes'
-            ' will be lost.'),
+               help='Perform reconfiguration even if local changes'
+               ' will be lost.'),
         Option('stacked-on',
-            help='Reconfigure a branch to be stacked on another branch.',
-            type=text_type,
-            ),
+               help='Reconfigure a branch to be stacked on another branch.',
+               type=text_type,
+               ),
         Option('unstacked',
-            help='Reconfigure a branch to be unstacked.  This '
-                'may require copying substantial data into it.',
-            ),
+               help='Reconfigure a branch to be unstacked.  This '
+               'may require copying substantial data into it.',
+               ),
         ]
 
     def run(self, location=None, bind_to=None, force=False,
@@ -6166,7 +6222,8 @@
             stacked_on=None, unstacked=None):
         directory = controldir.ControlDir.open(location)
         if stacked_on and unstacked:
-            raise errors.BzrCommandError(gettext("Can't use both --stacked-on and --unstacked"))
+            raise errors.BzrCommandError(
+                gettext("Can't use both --stacked-on and --unstacked"))
         elif stacked_on is not None:
             reconfigure.ReconfigureStackedOn().apply(directory, stacked_on)
         elif unstacked:
@@ -6176,12 +6233,12 @@
         # to ban it.
         if (tree_type is None and
             repository_type is None and
-            repository_trees is None):
+                repository_trees is None):
             if stacked_on or unstacked:
                 return
             else:
                 raise errors.BzrCommandError(gettext('No target configuration '
-                    'specified'))
+                                                     'specified'))
         reconfiguration = None
         if tree_type == 'branch':
             reconfiguration = reconfigure.Reconfigure.to_branch(directory)
@@ -6240,15 +6297,15 @@
     takes_args = ['to_location?']
     takes_options = ['directory',
                      Option('force',
-                        help='Switch even if local commits will be lost.'),
+                            help='Switch even if local commits will be lost.'),
                      'revision',
                      Option('create-branch', short_name='b',
-                        help='Create the target branch from this one before'
-                             ' switching to it.'),
+                            help='Create the target branch from this one before'
+                            ' switching to it.'),
                      Option('store',
-                        help='Store and restore uncommitted changes in the'
-                             ' branch.'),
-                    ]
+                            help='Store and restore uncommitted changes in the'
+                            ' branch.'),
+                     ]
 
     def run(self, to_location=None, force=False, create_branch=False,
             revision=None, directory=u'.', store=False):
@@ -6257,11 +6314,11 @@
         revision = _get_one_revision('switch', revision)
         possible_transports = []
         control_dir = controldir.ControlDir.open_containing(tree_location,
-            possible_transports=possible_transports)[0]
+                                                            possible_transports=possible_transports)[0]
         if to_location is None:
             if revision is None:
                 raise errors.BzrCommandError(gettext('You must supply either a'
-                                             ' revision or a location'))
+                                                     ' revision or a location'))
             to_location = tree_location
         try:
             branch = control_dir.open_branch(
@@ -6274,20 +6331,23 @@
             if branch is None:
                 raise errors.BzrCommandError(
                     gettext('cannot create branch without source branch'))
-            to_location = lookup_new_sibling_branch(control_dir, to_location,
+            to_location = lookup_new_sibling_branch(
+                control_dir, to_location,
                  possible_transports=possible_transports)
             if revision is not None:
                 revision = revision.as_revision_id(branch)
-            to_branch = branch.controldir.sprout(to_location,
+            to_branch = branch.controldir.sprout(
+                to_location,
                  possible_transports=possible_transports,
                  revision_id=revision,
                  source_branch=branch).open_branch()
         else:
             try:
                 to_branch = Branch.open(to_location,
-                    possible_transports=possible_transports)
+                                        possible_transports=possible_transports)
             except errors.NotBranchError:
-                to_branch = open_sibling_branch(control_dir, to_location,
+                to_branch = open_sibling_branch(
+                    control_dir, to_location,
                     possible_transports=possible_transports)
             if revision is not None:
                 revision = revision.as_revision_id(to_branch)
@@ -6296,15 +6356,14 @@
                           store_uncommitted=store)
         except controldir.BranchReferenceLoop:
             raise errors.BzrCommandError(
-                    gettext('switching would create a branch reference loop. '
-                            'Use the "bzr up" command to switch to a '
-                            'different revision.'))
+                gettext('switching would create a branch reference loop. '
+                        'Use the "bzr up" command to switch to a '
+                        'different revision.'))
         if had_explicit_nick:
-            branch = control_dir.open_branch() #get the new branch!
+            branch = control_dir.open_branch()  # get the new branch!
             branch.nick = to_branch.nick
         note(gettext('Switched to branch: %s'),
-            urlutils.unescape_for_display(to_branch.base, 'utf-8'))
-
+             urlutils.unescape_for_display(to_branch.base, 'utf-8'))
 
 
 class cmd_view(Command):
@@ -6373,19 +6432,19 @@
     takes_args = ['file*']
     takes_options = [
         Option('all',
-            help='Apply list or delete action to all views.',
-            ),
+               help='Apply list or delete action to all views.',
+               ),
         Option('delete',
-            help='Delete the view.',
-            ),
+               help='Delete the view.',
+               ),
         Option('name',
-            help='Name of the view to define, list or delete.',
-            type=text_type,
-            ),
+               help='Name of the view to define, list or delete.',
+               type=text_type,
+               ),
         Option('switch',
-            help='Name of the view to switch to.',
-            type=text_type,
-            ),
+               help='Name of the view to switch to.',
+               type=text_type,
+               ),
         ]
 
     def run(self, file_list,
@@ -6395,7 +6454,7 @@
             switch=None,
             ):
         tree, file_list = WorkingTree.open_containing_paths(file_list,
-            apply_view=False)
+                                                            apply_view=False)
         current_view, view_dict = tree.views.get_view_info()
         if name is None:
             name = current_view
@@ -6410,7 +6469,8 @@
                 tree.views.set_view_info(None, {})
                 self.outf.write(gettext("Deleted all views.\n"))
             elif name is None:
-                raise errors.BzrCommandError(gettext("No current view to delete"))
+                raise errors.BzrCommandError(
+                    gettext("No current view to delete"))
             else:
                 tree.views.delete_view(name)
                 self.outf.write(gettext("Deleted '%s' view.\n") % name)
@@ -6423,13 +6483,16 @@
                     "Both --switch and --all specified"))
             elif switch == 'off':
                 if current_view is None:
-                    raise errors.BzrCommandError(gettext("No current view to disable"))
+                    raise errors.BzrCommandError(
+                        gettext("No current view to disable"))
                 tree.views.set_view_info(None, view_dict)
-                self.outf.write(gettext("Disabled '%s' view.\n") % (current_view))
+                self.outf.write(gettext("Disabled '%s' view.\n") %
+                                (current_view))
             else:
                 tree.views.set_view_info(switch, view_dict)
                 view_str = views.view_display_str(tree.views.lookup_view())
-                self.outf.write(gettext("Using '{0}' view: {1}\n").format(switch, view_str))
+                self.outf.write(
+                    gettext("Using '{0}' view: {1}\n").format(switch, view_str))
         elif all:
             if view_dict:
                 self.outf.write(gettext('Views defined:\n'))
@@ -6451,7 +6514,8 @@
                     "Cannot change the 'off' pseudo view"))
             tree.views.set_view(name, sorted(file_list))
             view_str = views.view_display_str(tree.views.lookup_view())
-            self.outf.write(gettext("Using '{0}' view: {1}\n").format(name, view_str))
+            self.outf.write(
+                gettext("Using '{0}' view: {1}\n").format(name, view_str))
         else:
             # list the files
             if name is None:
@@ -6459,7 +6523,8 @@
                 self.outf.write(gettext('No current view.\n'))
             else:
                 view_str = views.view_display_str(tree.views.lookup_view(name))
-                self.outf.write(gettext("'{0}' view is: {1}\n").format(name, view_str))
+                self.outf.write(
+                    gettext("'{0}' view is: {1}\n").format(name, view_str))
 
 
 class cmd_hooks(Command):
@@ -6485,7 +6550,7 @@
 class cmd_remove_branch(Command):
     __doc__ = """Remove a branch.
 
-    This will remove the branch from the specified location but 
+    This will remove the branch from the specified location but
     will keep any working tree or repository in place.
 
     :Examples:
@@ -6499,7 +6564,7 @@
     takes_args = ["location?"]
 
     takes_options = ['directory',
-        Option('force', help='Remove branch even if it is the active branch.')]
+                     Option('force', help='Remove branch even if it is the active branch.')]
 
     aliases = ["rmbranch"]
 
@@ -6511,7 +6576,7 @@
             except errors.NotBranchError:
                 active_branch = None
             if (active_branch is not None and
-                br.control_url == active_branch.control_url):
+                    br.control_url == active_branch.control_url):
                 raise errors.BzrCommandError(
                     gettext("Branch is active. Use --force to remove it."))
         br.controldir.destroy_branch(br.name)
@@ -6580,7 +6645,7 @@
             writer = breezy.option.diff_writer_registry.get()
         try:
             shelver = Shelver.from_args(writer(self.outf), revision, all,
-                file_list, message, destroy=destroy, directory=directory)
+                                        file_list, message, destroy=destroy, directory=directory)
             try:
                 shelver.run()
             finally:
@@ -6695,7 +6760,7 @@
         branchdir = '.'
         if path is not None:
             branchdir = path
-        tree, branch, relpath =(
+        tree, branch, relpath = (
             controldir.ControlDir.open_containing_tree_or_branch(branchdir))
         if path is not None:
             path = relpath
@@ -6727,13 +6792,13 @@
 
     hidden = True
     takes_options = [Option('plugin',
-                            help='Export help text from named command '\
+                            help='Export help text from named command '
                                  '(defaults to all built in commands).',
                             type=text_type),
                      Option('include-duplicates',
                             help='Output multiple copies of the same msgid '
                                  'string if it appears more than once.'),
-                            ]
+                     ]
 
     def run(self, plugin=None, include_duplicates=False):
         from .export_pot import export_pot
@@ -6807,16 +6872,16 @@
     # register lazy builtins from other modules; called at startup and should
     # be only called once.
     for (name, aliases, module_name) in [
-        ('cmd_bisect', [], 'breezy.bisect'),
-        ('cmd_bundle_info', [], 'breezy.bundle.commands'),
-        ('cmd_config', [], 'breezy.config'),
-        ('cmd_dump_btree', [], 'breezy.bzr.debug_commands'),
-        ('cmd_version_info', [], 'breezy.cmd_version_info'),
-        ('cmd_resolve', ['resolved'], 'breezy.conflicts'),
-        ('cmd_conflicts', [], 'breezy.conflicts'),
-        ('cmd_ping', [], 'breezy.bzr.smart.ping'),
-        ('cmd_sign_my_commits', [], 'breezy.commit_signature_commands'),
-        ('cmd_verify_signatures', [], 'breezy.commit_signature_commands'),
-        ('cmd_test_script', [], 'breezy.cmd_test_script'),
-        ]:
+            ('cmd_bisect', [], 'breezy.bisect'),
+            ('cmd_bundle_info', [], 'breezy.bundle.commands'),
+            ('cmd_config', [], 'breezy.config'),
+            ('cmd_dump_btree', [], 'breezy.bzr.debug_commands'),
+            ('cmd_version_info', [], 'breezy.cmd_version_info'),
+            ('cmd_resolve', ['resolved'], 'breezy.conflicts'),
+            ('cmd_conflicts', [], 'breezy.conflicts'),
+            ('cmd_ping', [], 'breezy.bzr.smart.ping'),
+            ('cmd_sign_my_commits', [], 'breezy.commit_signature_commands'),
+            ('cmd_verify_signatures', [], 'breezy.commit_signature_commands'),
+            ('cmd_test_script', [], 'breezy.cmd_test_script'),
+            ]:
         builtin_command_registry.register_lazy(name, aliases, module_name)

=== modified file 'breezy/bundle/__init__.py'
--- breezy/bundle/__init__.py	2017-05-22 00:56:52 +0000
+++ breezy/bundle/__init__.py	2018-11-16 18:34:24 +0000
@@ -41,7 +41,7 @@
         the target is not a mergeable type.
     """
     child_transport = _mod_transport.get_transport(url,
-        possible_transports=possible_transports)
+                                                   possible_transports=possible_transports)
     transport = child_transport.clone('..')
     filename = transport.relpath(child_transport.base)
     mergeable, transport = read_mergeable_from_transport(transport, filename,

=== modified file 'breezy/bundle/apply_bundle.py'
--- breezy/bundle/apply_bundle.py	2018-06-20 01:25:17 +0000
+++ breezy/bundle/apply_bundle.py	2018-11-16 18:34:24 +0000
@@ -39,12 +39,12 @@
             if repository.has_revision(revision.revision_id):
                 continue
             cset_tree = bundle_reader.revision_tree(repository,
-                                                       revision.revision_id)
+                                                    revision.revision_id)
             install_revision(repository, revision, cset_tree)
 
 
 def merge_bundle(reader, tree, check_clean, merge_type,
-                    reprocess, show_base, change_reporter=None):
+                 reprocess, show_base, change_reporter=None):
     """Merge a revision bundle into the current tree."""
     with ui.ui_factory.nested_progress_bar() as pb:
         pp = ProgressPhase("Merge phase", 6, pb)

=== modified file 'breezy/bundle/bundle_data.py'
--- breezy/bundle/bundle_data.py	2018-11-16 15:01:06 +0000
+++ breezy/bundle/bundle_data.py	2018-11-16 18:34:24 +0000
@@ -74,11 +74,11 @@
 
     def as_revision(self):
         rev = Revision(revision_id=self.revision_id,
-            committer=self.committer,
-            timestamp=float(self.timestamp),
-            timezone=int(self.timezone),
-            inventory_sha1=self.inventory_sha1,
-            message='\n'.join(self.message))
+                       committer=self.committer,
+                       timestamp=float(self.timestamp),
+                       timezone=int(self.timezone),
+                       inventory_sha1=self.inventory_sha1,
+                       message='\n'.join(self.message))
 
         if self.parent_ids:
             rev.parent_ids.extend(self.parent_ids)
@@ -93,7 +93,7 @@
                     value = ''
                 else:
                     key = str(property[:key_end])
-                    value = property[key_end+2:]
+                    value = property[key_end + 2:]
                 rev.properties[key] = value
 
         return rev
@@ -116,6 +116,7 @@
     """This contains the meta information. Stuff that allows you to
     recreate the revision or inventory XML.
     """
+
     def __init__(self, bundle_format=None):
         self.bundle_format = None
         self.committer = None
@@ -155,7 +156,7 @@
             if rev.timestamp is None:
                 if rev.date is not None:
                     rev.timestamp, rev.timezone = \
-                            unpack_highres_date(rev.date)
+                        unpack_highres_date(rev.date)
                 else:
                     rev.timestamp = self.timestamp
                     rev.timezone = self.timezone
@@ -210,7 +211,7 @@
         revision_info = self.get_revision_info(revision_id)
         inventory_revision_id = revision_id
         bundle_tree = BundleTree(repository.revision_tree(base),
-                                  inventory_revision_id)
+                                 inventory_revision_id)
         self._update_tree(bundle_tree, revision_id)
 
         inv = bundle_tree.inventory
@@ -226,19 +227,20 @@
         """
         rev_to_sha = {}
         inv_to_sha = {}
+
         def add_sha(d, revision_id, sha1):
             if revision_id is None:
                 if sha1 is not None:
                     raise BzrError('A Null revision should always'
-                        'have a null sha1 hash')
+                                   'have a null sha1 hash')
                 return
             if revision_id in d:
                 # This really should have been validated as part
                 # of _validate_revisions but lets do it again
                 if sha1 != d[revision_id]:
                     raise BzrError('** Revision %r referenced with 2 different'
-                            ' sha hashes %s != %s' % (revision_id,
-                                sha1, d[revision_id]))
+                                   ' sha hashes %s != %s' % (revision_id,
+                                                             sha1, d[revision_id]))
             else:
                 d[revision_id] = sha1
 
@@ -262,7 +264,7 @@
                                                                 revision_id)
                 if sha1 != local_sha1:
                     raise BzrError('sha1 mismatch. For revision id {%s}'
-                            'local: %s, bundle: %s' % (revision_id, local_sha1, sha1))
+                                   'local: %s, bundle: %s' % (revision_id, local_sha1, sha1))
                 else:
                     count += 1
             elif revision_id not in checked:
@@ -309,7 +311,7 @@
             raise TestamentMismatch(rev.revision_id, rev_info.sha1, sha1)
         if rev.revision_id in rev_to_sha1:
             raise BzrError('Revision {%s} given twice in the list'
-                    % (rev.revision_id))
+                           % (rev.revision_id))
         rev_to_sha1[rev.revision_id] = sha1
 
     def _update_tree(self, bundle_tree, revision_id):
@@ -352,7 +354,7 @@
             if encoding == 'base64':
                 patch = base64.b64decode(b''.join(lines))
             elif encoding is None:
-                patch =  b''.join(lines)
+                patch = b''.join(lines)
             else:
                 raise ValueError(encoding)
             bundle_tree.note_patch(path, patch)
@@ -361,7 +363,7 @@
             info = extra.split(' // ')
             if len(info) < 2:
                 raise BzrError('renamed action lines need both a from and to'
-                        ': %r' % extra)
+                               ': %r' % extra)
             old_path = info[0]
             if info[1].startswith('=> '):
                 new_path = info[1][3:]
@@ -380,7 +382,7 @@
                 # TODO: in the future we might allow file ids to be
                 # given for removed entries
                 raise BzrError('removed action lines should only have the path'
-                        ': %r' % extra)
+                               ': %r' % extra)
             path = info[0]
             bundle_tree.note_deletion(path)
 
@@ -388,14 +390,14 @@
             info = extra.split(' // ')
             if len(info) <= 1:
                 raise BzrError('add action lines require the path and file id'
-                        ': %r' % extra)
+                               ': %r' % extra)
             elif len(info) > 5:
                 raise BzrError('add action lines have fewer than 5 entries.'
-                        ': %r' % extra)
+                               ': %r' % extra)
             path = info[0]
             if not info[1].startswith('file-id:'):
                 raise BzrError('The file-id should follow the path for an add'
-                        ': %r' % extra)
+                               ': %r' % extra)
             # This will be Unicode because of how the stream is read. Turn it
             # back into a utf8 file_id
             file_id = cache_utf8.encode(info[1][8:])
@@ -413,7 +415,7 @@
             info = extra.split(' // ')
             if len(info) < 1:
                 raise BzrError('modified action lines have at least'
-                        'the path in them: %r' % extra)
+                               'the path in them: %r' % extra)
             path = info[0]
 
             last_modified, encoding = extra_info(info[1:], path)
@@ -422,31 +424,31 @@
                 do_patch(path, lines, encoding)
 
         valid_actions = {
-            'renamed':renamed,
-            'removed':removed,
-            'added':added,
-            'modified':modified
+            'renamed': renamed,
+            'removed': removed,
+            'added': added,
+            'modified': modified
         }
         for action_line, lines in \
-            self.get_revision_info(revision_id).tree_actions:
+                self.get_revision_info(revision_id).tree_actions:
             first = action_line.find(' ')
             if first == -1:
                 raise BzrError('Bogus action line'
-                        ' (no opening space): %r' % action_line)
-            second = action_line.find(' ', first+1)
+                               ' (no opening space): %r' % action_line)
+            second = action_line.find(' ', first + 1)
             if second == -1:
                 raise BzrError('Bogus action line'
-                        ' (missing second space): %r' % action_line)
+                               ' (missing second space): %r' % action_line)
             action = action_line[:first]
-            kind = action_line[first+1:second]
+            kind = action_line[first + 1:second]
             if kind not in ('file', 'directory', 'symlink'):
                 raise BzrError('Bogus action line'
-                        ' (invalid object kind %r): %r' % (kind, action_line))
-            extra = action_line[second+1:]
+                               ' (invalid object kind %r): %r' % (kind, action_line))
+            extra = action_line[second + 1:]
 
             if action not in valid_actions:
                 raise BzrError('Bogus action line'
-                        ' (unrecognized action): %r' % action_line)
+                               ' (unrecognized action): %r' % action_line)
             valid_actions[action](kind, extra, lines)
 
     def install_revisions(self, target_repo, stream_input=True):
@@ -470,15 +472,15 @@
 
     def __init__(self, base_tree, revision_id):
         self.base_tree = base_tree
-        self._renamed = {} # Mapping from old_path => new_path
-        self._renamed_r = {} # new_path => old_path
-        self._new_id = {} # new_path => new_id
-        self._new_id_r = {} # new_id => new_path
-        self._kinds = {} # new_path => kind
-        self._last_changed = {} # new_id => revision_id
-        self._executable = {} # new_id => executable value
+        self._renamed = {}  # Mapping from old_path => new_path
+        self._renamed_r = {}  # new_path => old_path
+        self._new_id = {}  # new_path => new_id
+        self._new_id_r = {}  # new_id => new_path
+        self._kinds = {}  # new_path => kind
+        self._last_changed = {}  # new_id => revision_id
+        self._executable = {}  # new_id => executable value
         self.patches = {}
-        self._targets = {} # new path => new symlink target
+        self._targets = {}  # new path => new symlink target
         self.deleted = []
         self.contents_by_id = True
         self.revision_id = revision_id
@@ -506,9 +508,9 @@
         if (file_id in self._last_changed
                 and self._last_changed[file_id] != revision_id):
             raise BzrError('Mismatched last-changed revision for file_id {%s}'
-                    ': %s != %s' % (file_id,
-                                    self._last_changed[file_id],
-                                    revision_id))
+                           ': %s != %s' % (file_id,
+                                           self._last_changed[file_id],
+                                           revision_id))
         self._last_changed[file_id] = revision_id
 
     def note_patch(self, new_path, patch):
@@ -545,8 +547,8 @@
                 old_path = pathjoin(old_dir, basename)
         else:
             old_path = new_path
-        #If the new path wasn't in renamed, the old one shouldn't be in
-        #renamed_r
+        # If the new path wasn't in renamed, the old one shouldn't be in
+        # renamed_r
         if old_path in self._renamed_r:
             return None
         return old_path
@@ -571,8 +573,8 @@
                 new_path = pathjoin(new_dir, basename)
         else:
             new_path = old_path
-        #If the old path wasn't in renamed, the new one shouldn't be in
-        #renamed_r
+        # If the old path wasn't in renamed, the new one shouldn't be in
+        # renamed_r
         if new_path in self._renamed:
             return None
         return new_path
@@ -627,7 +629,7 @@
         file_id = self.path2id(path)
         base_id = self.old_contents_id(file_id)
         if (base_id is not None and
-            base_id != self.base_tree.get_root_id()):
+                base_id != self.base_tree.get_root_id()):
             old_path = self.base_tree.id2path(base_id)
             patch_original = self.base_tree.get_file(old_path)
         else:
@@ -635,7 +637,7 @@
         file_patch = self.patches.get(path)
         if file_patch is None:
             if (patch_original is None and
-                self.kind(path) == 'directory'):
+                    self.kind(path) == 'directory'):
                 return BytesIO()
             if patch_original is None:
                 raise AssertionError("None: %s" % file_id)
@@ -794,4 +796,4 @@
     # string.splitlines(True) also splits on '\r', but the iter_patched code
     # only expects to iterate over '\n' style lines
     return IterableFile(iter_patched(original,
-                BytesIO(file_patch).readlines()))
+                                     BytesIO(file_patch).readlines()))

=== modified file 'breezy/bundle/commands.py'
--- breezy/bundle/commands.py	2018-07-17 21:20:55 +0000
+++ breezy/bundle/commands.py	2018-11-16 18:34:24 +0000
@@ -63,15 +63,16 @@
         else:
             if verbose:
                 raise errors.BzrCommandError(gettext(
-                            '--verbose requires a merge directive'))
+                    '--verbose requires a merge directive'))
         reader_method = getattr(bundle_info, 'get_bundle_reader', None)
         if reader_method is None:
-            raise errors.BzrCommandError(gettext('Bundle format not supported'))
+            raise errors.BzrCommandError(
+                gettext('Bundle format not supported'))
 
         by_kind = {}
         file_ids = set()
         for bytes, parents, repo_kind, revision_id, file_id\
-            in reader_method().iter_records():
+                in reader_method().iter_records():
             by_kind.setdefault(repo_kind, []).append(
                 (bytes, parents, repo_kind, revision_id, file_id))
             if file_id is not None:
@@ -93,9 +94,9 @@
 
         self.outf.write(gettext('Revisions\n'))
         self.outf.write((gettext('nicks: %s\n')
-            % ', '.join(sorted(nicks))).encode(term_encoding, 'replace'))
+                         % ', '.join(sorted(nicks))).encode(term_encoding, 'replace'))
         self.outf.write((gettext('committers: \n%s\n') %
-        '\n'.join(sorted(committers)).encode(term_encoding, 'replace')))
+                         '\n'.join(sorted(committers)).encode(term_encoding, 'replace')))
         if verbose:
             self.outf.write('\n')
             bundle_file.seek(0)

=== modified file 'breezy/bundle/serializer/__init__.py'
--- breezy/bundle/serializer/__init__.py	2018-07-15 18:45:17 +0000
+++ breezy/bundle/serializer/__init__.py	2018-11-16 18:34:24 +0000
@@ -49,6 +49,7 @@
 def _get_bundle_header(version):
     return b''.join([BUNDLE_HEADER, version.encode('ascii'), b'\n'])
 
+
 def _get_filename(f):
     return getattr(f, 'name', '<unknown>')
 
@@ -74,7 +75,7 @@
         if m:
             version = m.group('version')
             raise errors.BundleNotSupported(version,
-                'old format bundles not supported')
+                                            'old format bundles not supported')
 
     if version is None:
         raise errors.NotABundle('Did not find an opening header')
@@ -87,7 +88,7 @@
         serializer = serializer_registry.get(version)
     except KeyError:
         raise errors.BundleNotSupported(version,
-            'unknown bundle format')
+                                        'unknown bundle format')
 
     return serializer(version)
 
@@ -126,6 +127,7 @@
 
     Common functionality should be included here.
     """
+
     def __init__(self, version):
         self.version = version
 
@@ -158,8 +160,11 @@
     base64.encode(temp, to_file)
     to_file.write(b'\n')
 
-serializer_registry.register_lazy('0.8', 'breezy.bundle.serializer.v08', 'BundleSerializerV08')
-serializer_registry.register_lazy('0.9', 'breezy.bundle.serializer.v09', 'BundleSerializerV09')
+
+serializer_registry.register_lazy(
+    '0.8', 'breezy.bundle.serializer.v08', 'BundleSerializerV08')
+serializer_registry.register_lazy(
+    '0.9', 'breezy.bundle.serializer.v09', 'BundleSerializerV09')
 serializer_registry.register_lazy('4', 'breezy.bundle.serializer.v4',
-              'BundleSerializerV4')
+                                  'BundleSerializerV4')
 serializer_registry.default_key = '4'

=== modified file 'breezy/bundle/serializer/v08.py'
--- breezy/bundle/serializer/v08.py	2018-10-30 02:36:00 +0000
+++ breezy/bundle/serializer/v08.py	2018-11-16 18:34:24 +0000
@@ -73,7 +73,7 @@
 
     def write(self, to_file):
         """Write action as to a file"""
-        p_texts = [' '.join([self.name]+self.parameters)]
+        p_texts = [' '.join([self.name] + self.parameters)]
         for prop in self.properties:
             if len(prop) == 1:
                 p_texts.append(prop[0])
@@ -91,7 +91,7 @@
             text_line = text_line[available:]
             to_file.write(b'\n... ')
             available = 79 - len(b'... ')
-        to_file.write(text_line+b'\n')
+        to_file.write(text_line + b'\n')
 
 
 class BundleSerializerV08(BundleSerializer):
@@ -128,12 +128,12 @@
 
     def write_bundle(self, repository, revision_id, base_revision_id, out):
         """Helper function for translating write_bundle to write"""
-        forced_bases = {revision_id:base_revision_id}
+        forced_bases = {revision_id: base_revision_id}
         if base_revision_id is NULL_REVISION: