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, 40 insertions, 40 deletions

diff --git a/git/refs/log.py b/git/refs/log.py
index 9a719ec0..d5d8d7d4 100644
--- a/git/refs/log.py
+++ b/git/refs/log.py
@@ -32,42 +32,42 @@ class RefLogEntry(tuple):
     _fmt = "%s %s %s <%s> %i %s\t%s\n"
     _re_hexsha_only = re.compile('^[0-9A-Fa-f]{40}$')
     __slots__ = tuple()
-    
+
     def __repr__(self):
         """Representation of ourselves in git reflog format"""
         act = self.actor
         time = self.time
         return self._fmt % (self.oldhexsha, self.newhexsha, act.name, act.email, 
                             time[0], altz_to_utctz_str(time[1]), self.message)
-    
+
     @property
     def oldhexsha(self):
         """The hexsha to the commit the ref pointed to before the change""" 
         return self[0]
-        
+
     @property
     def newhexsha(self):
         """The hexsha to the commit the ref now points to, after the change"""
         return self[1]
-        
+
     @property
     def actor(self):
         """Actor instance, providing access"""
         return self[2]
-        
+
     @property
     def time(self):
         """time as tuple:
-        
+
         * [0] = int(time)
         * [1] = int(timezone_offset) in time.altzone format """
         return self[3]
-        
+
     @property
     def message(self):
         """Message describing the operation that acted on the reference"""
         return self[4]
-    
+
     @classmethod
     def new(self, oldhexsha, newhexsha, actor, time, tz_offset, message):
         """:return: New instance of a RefLogEntry"""
@@ -75,7 +75,7 @@ class RefLogEntry(tuple):
             raise ValueError("Need actor instance, got %s" % actor)
         # END check types 
         return RefLogEntry((oldhexsha, newhexsha, actor, (time, tz_offset), message))
-        
+
     @classmethod
     def from_line(cls, line):
         """:return: New RefLogEntry instance from the given revlog line.
@@ -93,32 +93,32 @@ class RefLogEntry(tuple):
                 raise ValueError("Invalid hexsha: %s" % hexsha)
             # END if hexsha re doesn't match
         #END for each hexsha
-        
+
         email_end = info.find('>', 82)
         if email_end == -1:
             raise ValueError("Missing token: >")
         #END handle missing end brace
-        
+
         actor = Actor._from_string(info[82:email_end+1])
         time, tz_offset = parse_date(info[email_end+2:])
-        
+
         return RefLogEntry((oldhexsha, newhexsha, actor, (time, tz_offset), msg))
-        
+
 
 class RefLog(list, Serializable):
     """A reflog contains reflog entries, each of which defines a certain state
     of the head in question. Custom query methods allow to retrieve log entries 
     by date or by other criteria.
-    
+
     Reflog entries are orded, the first added entry is first in the list, the last
     entry, i.e. the last change of the head or reference, is last in the list."""
-    
+
     __slots__ = ('_path', )
-    
+
     def __new__(cls, filepath=None):
         inst = super(RefLog, cls).__new__(cls)
         return inst
-        
+
     def __init__(self, filepath=None):
         """Initialize this instance with an optional filepath, from which we will
         initialize our data. The path is also used to write changes back using 
@@ -127,7 +127,7 @@ class RefLog(list, Serializable):
         if filepath is not None:
             self._read_from_file()
         # END handle filepath
-    
+
     def _read_from_file(self):
         try:
             fmap = file_contents_ro_filepath(self._path, stream=True, allow_mmap=True)
@@ -135,15 +135,15 @@ class RefLog(list, Serializable):
             # it is possible and allowed that the file doesn't exist !
             return
         #END handle invalid log
-        
+
         try:
             self._deserialize(fmap)
         finally:
             fmap.close()
         #END handle closing of handle
-    
+
     #{ Interface
-    
+
     @classmethod
     def from_file(cls, filepath):
         """
@@ -152,7 +152,7 @@ class RefLog(list, Serializable):
         :param filepath: path to reflog 
         :raise ValueError: If the file could not be read or was corrupted in some way"""
         return cls(filepath)
-    
+
     @classmethod
     def path(cls, ref):
         """
@@ -161,7 +161,7 @@ class RefLog(list, Serializable):
             file though.
         :param ref: SymbolicReference instance"""
         return join(ref.repo.git_dir, "logs", to_native_path(ref.path))
-        
+
     @classmethod
     def iter_entries(cls, stream):
         """
@@ -179,16 +179,16 @@ class RefLog(list, Serializable):
                 return
             yield new_entry(line.strip())
         #END endless loop
-        
+
     @classmethod
     def entry_at(cls, filepath, index):
         """:return: RefLogEntry at the given index
         :param filepath: full path to the index file from which to read the entry
         :param index: python list compatible index, i.e. it may be negative to 
             specifiy an entry counted from the end of the list
-            
+
         :raise IndexError: If the entry didn't exist
-        
+
         .. note:: This method is faster as it only parses the entry at index, skipping
             all other lines. Nonetheless, the whole file has to be read if 
             the index is negative
@@ -204,20 +204,20 @@ class RefLog(list, Serializable):
                     break
                 #END abort on eof
             #END handle runup
-            
+
             if i != index or not line:
                 raise IndexError
             #END handle exception
-            
+
             return RefLogEntry.from_line(line.strip())
         #END handle index
-    
+
     def to_file(self, filepath):
         """Write the contents of the reflog instance to a file at the given filepath.
         :param filepath: path to file, parent directories are assumed to exist"""
         lfd = LockedFD(filepath)
         assure_directory_exists(filepath, is_file=True)
-        
+
         fp = lfd.open(write=True, stream=True)
         try:
             self._serialize(fp)
@@ -227,11 +227,11 @@ class RefLog(list, Serializable):
             lfd.rollback()
             raise
         #END handle change
-        
+
     @classmethod
     def append_entry(cls, config_reader, filepath, oldbinsha, newbinsha, message):
         """Append a new log entry to the revlog at filepath.
-        
+
         :param config_reader: configuration reader of the repository - used to obtain
             user information. May be None
         :param filepath: full path to the log file
@@ -248,10 +248,10 @@ class RefLog(list, Serializable):
         #END handle sha type
         assure_directory_exists(filepath, is_file=True)
         entry = RefLogEntry((bin_to_hex(oldbinsha), bin_to_hex(newbinsha), Actor.committer(config_reader), (int(time.time()), time.altzone), message))
-        
+
         lf = LockFile(filepath)
         lf._obtain_lock_or_raise()
-        
+
         fd = open(filepath, 'a')
         try:
             fd.write(repr(entry))
@@ -259,9 +259,9 @@ class RefLog(list, Serializable):
             fd.close()
             lf._release_lock()
         #END handle write operation
-        
+
         return entry
-        
+
     def write(self):
         """Write this instance's data to the file we are originating from
         :return: self"""
@@ -270,19 +270,19 @@ class RefLog(list, Serializable):
         #END assert path
         self.to_file(self._path)
         return self
-    
+
     #} END interface
-    
+
     #{ Serializable Interface
     def _serialize(self, stream):
         lm1 = len(self) - 1
         write = stream.write
-        
+
         # write all entries
         for e in self:
             write(repr(e))
         #END for each entry
-    
+
     def _deserialize(self, stream):
         self.extend(self.iter_entries(stream))
     #} END serializable interface