Autopep8 fixes with maximum line length 120

1 files changed, 81 insertions, 78 deletions

diff --git a/git/refs/log.py b/git/refs/log.py
index 70f11b87..fbb3fcf8 100644
--- a/git/refs/log.py
+++ b/git/refs/log.py
@@ -1,21 +1,21 @@
 from git.util import (
-                        join_path,
-                        Actor,
-                        LockedFD,
-                        LockFile,
-                        assure_directory_exists,
-                        to_native_path,
-                        bin_to_hex,
-                        join,
-                        file_contents_ro_filepath
-                    )
+    join_path,
+    Actor,
+    LockedFD,
+    LockFile,
+    assure_directory_exists,
+    to_native_path,
+    bin_to_hex,
+    join,
+    file_contents_ro_filepath
+)
 
 from git.objects.util import (
-                                parse_date,
-                                Serializable, 
-                                utctz_to_altz,
-                                altz_to_utctz_str,
-                            )
+    parse_date,
+    Serializable,
+    utctz_to_altz,
+    altz_to_utctz_str,
+)
 
 import time
 import os
@@ -25,54 +25,55 @@ __all__ = ["RefLog", "RefLogEntry"]
 
 
 class RefLogEntry(tuple):
+
     """Named tuple allowing easy access to the revlog data fields"""
     _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, 
+        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""" 
+        """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"""
         if not isinstance(actor, Actor):
             raise ValueError("Need actor instance, got %s" % actor)
-        # END check types 
+        # 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.
@@ -82,40 +83,41 @@ class RefLogEntry(tuple):
             info, msg = line.split('\t', 2)
         except ValueError:
             raise ValueError("line is missing tab separator")
-        #END handle first plit
+        # END handle first plit
         oldhexsha = info[:40]
         newhexsha = info[41:81]
         for hexsha in (oldhexsha, newhexsha):
             if not cls._re_hexsha_only.match(hexsha):
                 raise ValueError("Invalid hexsha: %s" % hexsha)
             # END if hexsha re doesn't match
-        #END for each hexsha
-        
+        # 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:])
-        
+        # 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 
@@ -124,23 +126,23 @@ 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)
         except OSError:
             # it is possible and allowed that the file doesn't exist !
             return
-        #END handle invalid log
-        
+        # END handle invalid log
+
         try:
             self._deserialize(fmap)
         finally:
             fmap.close()
-        #END handle closing of handle
-    
+        # END handle closing of handle
+
     #{ Interface
-    
+
     @classmethod
     def from_file(cls, filepath):
         """
@@ -149,7 +151,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):
         """
@@ -158,7 +160,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):
         """
@@ -169,23 +171,23 @@ class RefLog(list, Serializable):
         new_entry = RefLogEntry.from_line
         if isinstance(stream, basestring):
             stream = file_contents_ro_filepath(stream)
-        #END handle stream type
+        # END handle stream type
         while True:
             line = stream.readline()
             if not line:
                 return
             yield new_entry(line.strip())
-        #END endless loop
-        
+        # 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
@@ -195,26 +197,26 @@ class RefLog(list, Serializable):
             return RefLogEntry.from_line(fp.readlines()[index].strip())
         else:
             # read until index is reached
-            for i in xrange(index+1):
+            for i in xrange(index + 1):
                 line = fp.readline()
                 if not line:
                     break
-                #END abort on eof
-            #END handle runup
-            
+                # END abort on eof
+            # END handle runup
+
             if i != index or not line:
                 raise IndexError
-            #END handle exception
-            
+            # END handle exception
+
             return RefLogEntry.from_line(line.strip())
-        #END handle index
-    
+        # 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)
@@ -223,12 +225,12 @@ class RefLog(list, Serializable):
             # on failure it rolls back automatically, but we make it clear
             lfd.rollback()
             raise
-        #END handle change
-        
+        # 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
@@ -242,44 +244,45 @@ class RefLog(list, Serializable):
             do not interfere with readers."""
         if len(oldbinsha) != 20 or len(newbinsha) != 20:
             raise ValueError("Shas need to be given in binary format")
-        #END handle sha type
+        # 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))
-        
+        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))
         finally:
             fd.close()
             lf._release_lock()
-        #END handle write operation
-        
+        # END handle write operation
+
         return entry
-        
+
     def write(self):
         """Write this instance's data to the file we are originating from
         :return: self"""
         if self._path is None:
             raise ValueError("Instance was not initialized with a path, use to_file(...) instead")
-        #END assert path
+        # 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
-    
+        # END for each entry
+
     def _deserialize(self, stream):
         self.extend(self.iter_entries(stream))
     #} END serializable interface