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, 23 insertions, 24 deletions

diff --git a/git/objects/base.py b/git/objects/base.py
index 03b22863..9e73e2f3 100644
--- a/git/objects/base.py
+++ b/git/objects/base.py
@@ -12,7 +12,7 @@ from gitdb.util import (
                         )
 
 import gitdb.typ as dbtyp
-    
+
 _assertion_msg_format = "Created object %r whose python type %r disagrees with the acutal git object type %r"
 
 __all__ = ("Object", "IndexObject")
@@ -21,17 +21,17 @@ class Object(LazyMixin):
     """Implements an Object which may be Blobs, Trees, Commits and Tags"""
     NULL_HEX_SHA = '0'*40
     NULL_BIN_SHA = '\0'*20
-    
+
     TYPES = (dbtyp.str_blob_type, dbtyp.str_tree_type, dbtyp.str_commit_type, dbtyp.str_tag_type)
     __slots__ = ("repo", "binsha", "size" )
     type = None         # to be set by subclass
-    
+
     def __init__(self, repo, binsha):
         """Initialize an object by identifying it by its binary sha. 
         All keyword arguments will be set on demand if None.
-        
+
         :param repo: repository this object is located in
-            
+
         :param binsha: 20 byte SHA1"""
         super(Object,self).__init__()
         self.repo = repo
@@ -44,13 +44,13 @@ class Object(LazyMixin):
         :return: New Object instance of a type appropriate to the object type behind 
             id. The id of the newly created object will be a binsha even though 
             the input id may have been a Reference or Rev-Spec
-            
+
         :param id: reference, rev-spec, or hexsha
-            
+
         :note: This cannot be a __new__ method as it would always call __init__
             with the input id which is not necessarily a binsha."""
         return repo.rev_parse(str(id))
-        
+
     @classmethod
     def new_from_sha(cls, repo, sha1):
         """
@@ -65,36 +65,36 @@ class Object(LazyMixin):
         inst = get_object_type_by_name(oinfo.type)(repo, oinfo.binsha)
         inst.size = oinfo.size
         return inst 
-    
+
     def _set_cache_(self, attr):
         """Retrieve object information"""
-        if attr  == "size":
+        if attr == "size":
             oinfo = self.repo.odb.info(self.binsha)
             self.size = oinfo.size
             # assert oinfo.type == self.type, _assertion_msg_format % (self.binsha, oinfo.type, self.type)
         else:
             super(Object,self)._set_cache_(attr)
-        
+
     def __eq__(self, other):
         """:return: True if the objects have the same SHA1"""
         if not hasattr(other, 'binsha'):
             return False
         return self.binsha == other.binsha
-        
+
     def __ne__(self, other):
         """:return: True if the objects do not have the same SHA1 """
         if not hasattr(other, 'binsha'):
             return True
         return self.binsha != other.binsha
-        
+
     def __hash__(self):
         """:return: Hash of our id allowing objects to be used in dicts and sets"""
         return hash(self.binsha)
-        
+
     def __str__(self):
         """:return: string of our SHA1 as understood by all git commands"""
         return bin_to_hex(self.binsha)
-        
+
     def __repr__(self):
         """:return: string with pythonic representation of our object"""
         return '<git.%s "%s">' % (self.__class__.__name__, self.hexsha)
@@ -117,16 +117,16 @@ class Object(LazyMixin):
         istream = self.repo.odb.stream(self.binsha)
         stream_copy(istream, ostream)
         return self
-        
+
 
 class IndexObject(Object):
     """Base for all objects that can be part of the index file , namely Tree, Blob and
     SubModule objects"""
     __slots__ = ("path", "mode")
-    
+
     # for compatability with iterable lists
     _id_attribute_ = 'path'
-    
+
     def __init__(self, repo, binsha, mode=None, path=None):
         """Initialize a newly instanced IndexObject
         :param repo: is the Repo we are located in
@@ -144,13 +144,13 @@ class IndexObject(Object):
             self.mode = mode
         if path is not None:
             self.path = path
-    
+
     def __hash__(self):
         """:return:
             Hash of our path as index items are uniquely identifyable by path, not 
             by their data !"""
         return hash(self.path)
-    
+
     def _set_cache_(self, attr):
         if attr in IndexObject.__slots__:
             # they cannot be retrieved lateron ( not without searching for them )
@@ -158,19 +158,18 @@ class IndexObject(Object):
         else:
             super(IndexObject, self)._set_cache_(attr)
         # END hanlde slot attribute
-    
+
     @property
     def name(self):
         """:return: Name portion of the path, effectively being the basename"""
         return basename(self.path)
-        
+
     @property
     def abspath(self):
         """
         :return:
             Absolute path to this index object in the file system ( as opposed to the 
             .path field which is a path relative to the git repository ).
-            
+
             The returned path will be native to the system and contains '\' on windows. """
         return join_path_native(self.repo.working_tree_dir, self.path)
-