pep8 linting (whitespaces)

W191 indentation contains tabs
E221 multiple spaces before operator
E222 multiple spaces after operator
E225 missing whitespace around operator
E271 multiple spaces after keyword
W292 no newline at end of file
W293 blank line contains whitespace
W391 blank line at end of file

1 files changed, 37 insertions, 37 deletions

diff --git a/git/objects/submodule/root.py b/git/objects/submodule/root.py
index d9764b36..fb0a65c3 100644
--- a/git/objects/submodule/root.py
+++ b/git/objects/submodule/root.py
@@ -14,7 +14,7 @@ class RootUpdateProgress(UpdateProgress):
     """Utility class which adds more opcodes to the UpdateProgress"""
     REMOVE, PATHCHANGE, BRANCHCHANGE, URLCHANGE = [1 << x for x in range(UpdateProgress._num_op_codes, UpdateProgress._num_op_codes+4)]
     _num_op_codes = UpdateProgress._num_op_codes+4
-    
+
     __slots__ = tuple()
 
 BEGIN = RootUpdateProgress.BEGIN
@@ -27,11 +27,11 @@ PATHCHANGE = RootUpdateProgress.PATHCHANGE
 class RootModule(Submodule):
     """A (virtual) Root of all submodules in the given repository. It can be used
     to more easily traverse all submodules of the master repository"""
-    
+
     __slots__ = tuple()
-    
+
     k_root_name = '__ROOT__'
-    
+
     def __init__(self, repo):
         # repo, binsha, mode=None, path=None, name = None, parent_commit=None, url=None, ref=None)
         super(RootModule, self).__init__(
@@ -44,14 +44,14 @@ class RootModule(Submodule):
                                         url = '',
                                         branch_path = git.Head.to_full_path(self.k_head_default)
                                         )
-        
-    
+
+
     def _clear_cache(self):
         """May not do anything"""
         pass
-    
+
     #{ Interface 
-    
+
     def update(self, previous_commit=None, recursive=True, force_remove=False, init=True, 
                     to_latest_revision=False, progress=None, dry_run=False):
         """Update the submodules of this repository to the current HEAD commit.
@@ -60,7 +60,7 @@ class RootModule(Submodule):
         checked out. This works if the submodules ID does not change.
         Additionally it will detect addition and removal of submodules, which will be handled
         gracefully.
-        
+
         :param previous_commit: If set to a commit'ish, the commit we should use 
             as the previous commit the HEAD pointed to before it was set to the commit it points to now. 
             If None, it defaults to HEAD@{1} otherwise
@@ -79,17 +79,17 @@ class RootModule(Submodule):
         if self.repo.bare:
             raise InvalidGitRepositoryError("Cannot update submodules in bare repositories")
         # END handle bare
-        
+
         if progress is None:
             progress = RootUpdateProgress()
         #END assure progress is set
-        
+
         prefix = ''
         if dry_run:
             prefix = 'DRY-RUN: '
-        
+
         repo = self.repo
-        
+
         # SETUP BASE COMMIT
         ###################
         cur_commit = repo.head.commit
@@ -106,13 +106,13 @@ class RootModule(Submodule):
         else:
             previous_commit = repo.commit(previous_commit)   # obtain commit object 
         # END handle previous commit
-        
-        
+
+
         psms = self.list_items(repo, parent_commit=previous_commit)
         sms = self.list_items(repo)
         spsms = set(psms)
         ssms = set(sms)
-        
+
         # HANDLE REMOVALS
         ###################
         rrsm = (spsms - ssms)
@@ -122,7 +122,7 @@ class RootModule(Submodule):
             if i == 0:
                 op |= BEGIN
             #END handle begin
-            
+
             # fake it into thinking its at the current commit to allow deletion
             # of previous module. Trigger the cache to be updated before that
             progress.update(op, i, len_rrsm, prefix+"Removing submodule %r at %s" % (rsm.name, rsm.abspath))
@@ -130,13 +130,13 @@ class RootModule(Submodule):
             if not dry_run:
                 rsm.remove(configuration=False, module=True, force=force_remove)
             #END handle dry-run
-            
+
             if i == len_rrsm-1:
                 op |= END
             #END handle end
             progress.update(op, i, len_rrsm, prefix+"Done removing submodule %r" % rsm.name)
         # END for each removed submodule
-        
+
         # HANDLE PATH RENAMES
         #####################
         # url changes + branch changes
@@ -145,7 +145,7 @@ class RootModule(Submodule):
         for i, csm in enumerate(csms):
             psm = psms[csm.name]
             sm = sms[csm.name]
-            
+
             #PATH CHANGES
             ##############
             if sm.path != psm.path and psm.module_exists():
@@ -156,7 +156,7 @@ class RootModule(Submodule):
                 #END handle dry_run
                 progress.update(END|PATHCHANGE, i, len_csms, prefix+"Done moving repository of submodule %r" % sm.name)
             # END handle path changes
-            
+
             if sm.module_exists():
                 # HANDLE URL CHANGE
                 ###################
@@ -167,22 +167,22 @@ class RootModule(Submodule):
                     nn = '__new_origin__'
                     smm = sm.module()
                     rmts = smm.remotes
-                    
+
                     # don't do anything if we already have the url we search in place
                     if len([r for r in rmts if r.url == sm.url]) == 0:
                         progress.update(BEGIN|URLCHANGE, i, len_csms, prefix+"Changing url of submodule %r from %s to %s" % (sm.name, psm.url, sm.url))
-                        
+
                         if not dry_run:
                             assert nn not in [r.name for r in rmts]
                             smr = smm.create_remote(nn, sm.url)
                             smr.fetch(progress=progress)
-                            
+
                             # If we have a tracking branch, it should be available
                             # in the new remote as well.
                             if len([r for r in smr.refs if r.remote_head == sm.branch_name]) == 0:
                                 raise ValueError("Submodule branch named %r was not available in new submodule remote at %r" % (sm.branch_name, sm.url))
                             # END head is not detached
-                            
+
                             # now delete the changed one
                             rmt_for_deletion = None
                             for remote in rmts:
@@ -191,7 +191,7 @@ class RootModule(Submodule):
                                     break
                                 # END if urls match
                             # END for each remote
-                            
+
                             # if we didn't find a matching remote, but have exactly one, 
                             # we can safely use this one
                             if rmt_for_deletion is None:
@@ -206,7 +206,7 @@ class RootModule(Submodule):
                                     raise InvalidGitRepositoryError("Couldn't find original remote-repo at url %r" % psm.url)
                                 #END handle one single remote
                             # END handle check we found a remote
-                            
+
                             orig_name = rmt_for_deletion.name
                             smm.delete_remote(rmt_for_deletion)
                             # NOTE: Currently we leave tags from the deleted remotes
@@ -215,10 +215,10 @@ class RootModule(Submodule):
                             # another project ). At some point, one might want to clean
                             # it up, but the danger is high to remove stuff the user
                             # has added explicitly
-                            
+
                             # rename the new remote back to what it was
                             smr.rename(orig_name)
-                            
+
                             # early on, we verified that the our current tracking branch
                             # exists in the remote. Now we have to assure that the 
                             # sha we point to is still contained in the new remote
@@ -232,7 +232,7 @@ class RootModule(Submodule):
                                     break
                                 # END traverse all commits in search for sha
                             # END for each commit
-                            
+
                             if not found:
                                 # adjust our internal binsha to use the one of the remote
                                 # this way, it will be checked out in the next step
@@ -241,13 +241,13 @@ class RootModule(Submodule):
                                 print >> sys.stderr, "WARNING: Current sha %s was not contained in the tracking branch at the new remote, setting it the the remote's tracking branch" % sm.hexsha
                                 sm.binsha = rref.commit.binsha
                             #END reset binsha
-                            
+
                             #NOTE: All checkout is performed by the base implementation of update
                         #END handle dry_run
                         progress.update(END|URLCHANGE, i, len_csms, prefix+"Done adjusting url of submodule %r" % (sm.name))
                     # END skip remote handling if new url already exists in module
                 # END handle url
-                
+
                 # HANDLE PATH CHANGES
                 #####################
                 if sm.branch_path != psm.branch_path:
@@ -263,7 +263,7 @@ class RootModule(Submodule):
                             # ... or reuse the existing one
                             tbr = git.Head(smm, sm.branch_path)
                         #END assure tracking branch exists
-                        
+
                         tbr.set_tracking_branch(find_first_remote_branch(smmr, sm.branch_name))
                         # figure out whether the previous tracking branch contains
                         # new commits compared to the other one, if not we can 
@@ -278,22 +278,22 @@ class RootModule(Submodule):
                             # current remotes, this just means we can't handle it
                             pass
                         # END exception handling
-                        
+
                         #NOTE: All checkout is done in the base implementation of update
                     #END handle dry_run
-                    
+
                     progress.update(END|BRANCHCHANGE, i, len_csms, prefix+"Done changing branch of submodule %r" % sm.name)
                 #END handle branch
             #END handle 
         # END for each common submodule 
-        
+
         # FINALLY UPDATE ALL ACTUAL SUBMODULES
         ######################################
         for sm in sms:
             # update the submodule using the default method
             sm.update(recursive=False, init=init, to_latest_revision=to_latest_revision, 
                         progress=progress, dry_run=dry_run)
-            
+
             # update recursively depth first - question is which inconsitent 
             # state will be better in case it fails somewhere. Defective branch
             # or defective depth. The RootSubmodule type will never process itself,