Reading empty files (odd use case) and reading files past the end of a file now raises an EOFError. Test suite adjusted to account for the the change

Author: GraylinKim

sc2reader/readers.py

@@ -180,7 +180,6 @@ def read(self, filecontents, replay):
             type, code = buffer.shift(3), buffer.read_byte()
 
             parser = PARSERS[type](code)
-            print parser
             if parser:
                 event = parser(buffer, frames, type, code, pid)
                 buffer.align()

sc2reader/utils.py

@@ -244,101 +244,106 @@ def shift(self, bits):
         If there is no loaded byte, or the loaded byte has been exhausted,
         then Buffer.shift(8) could technically be used to read a single
         byte-aligned byte.
-        """   
-        if bits == 0:
-            return 0
-        
-        elif bits <= (8-self.bit_shift):
-            #Grab a new byte if the currently loaded one is exhausted
-            if self.bit_shift == 0:
-                self.last_byte = ord(self.io.read(1))
+        """
+        try:
+            if bits == 0:
+                return 0
 
-            #Get the requested bits from the byte, and adjust state
-            ret = (self.last_byte >> self.bit_shift) & (2**bits-1)
-            self.bit_shift = (self.bit_shift + bits) % 8
-            return ret
-        
-        else:
-            msg = "Cannot shift off %s bits. Only %s bits remaining."
-            raise ValueError(msg % (bits, 8-self.bit_shift))
+            elif bits <= (8-self.bit_shift):
+                #Grab a new byte if the currently loaded one is exhausted
+                if self.bit_shift == 0:
+                    self.last_byte = ord(self.io.read(1))
+                
+                #Get the requested bits from the byte, and adjust state
+                ret = (self.last_byte >> self.bit_shift) & (2**bits-1)
+                self.bit_shift = (self.bit_shift + bits) % 8
+                return ret
+            
+            else:
+                msg = "Cannot shift off %s bits. Only %s bits remaining."
+                raise ValueError(msg % (bits, 8-self.bit_shift))
+        except TypeError:
+            raise EOFError("Cannot shift new byte. End of buffer reached")
 
     def read(self, bytes=0, bits=0):
-        bytes, bits = bytes+bits/8, bits%8,  
-        bit_count = bytes*8+bits
-        
-        #check special case of not having to do any work
-        if bit_count == 0: return []
-        
-        #check sepcial case of intra-byte read
-        if bit_count <= (8-self.bit_shift):
-            return [self.shift(bit_count)]
-        
-        #check special case of byte-aligned reads, performance booster
-        if self.bit_shift == 0:
-            base = [ord(self.io.read(1)) for byte in range(bytes)]
-            if bits != 0:
-                return base+[self.shift(bits)]
-            return base
-        
-        # Calculated shifts
-        old_bit_shift = self.bit_shift 
-        new_bit_shift = (self.bit_shift+bits) % 8
-        
-        # Masks
-        lo_mask = 2**old_bit_shift-1
-        lo_mask_inv = 0xFF - 2**(8-old_bit_shift)+1
-        hi_mask = 0xFF ^ lo_mask
-        hi_mask_inv = 0xFF ^ lo_mask_inv
-        
-        #last byte parameters
-        if new_bit_shift == 0: #this means we filled the last byte (8)
-            last_mask = 0xFF
-            adjustment = 8-old_bit_shift
-        else:
-            last_mask = 2**new_bit_shift-1
-            adjustment = new_bit_shift-old_bit_shift
-        
-        #Set up for the looping with a list, the bytes, and an initial part
-        raw_bytes = list()
-        prev, next = self.last_byte, ord(self.io.read(1))
-        first = prev & hi_mask
-        bit_count -= 8-old_bit_shift
-        
-        while bit_count > 0:
-        
-            if bit_count <= 8: #this is the last byte
-                #The bits in the last byte are included in order starting at
-                #the new_bit_shift boundary with extra bits bumped back a byte
-                #because we can have odd bit requests, the bit shift can change
-                last = (next & last_mask)
-
-                # we need to bring the first byte closer
-                # if the adjustment is lower than 0
-                if adjustment < 0:
-                    first = first >> abs(adjustment)
-                
-                raw_bytes.append(first | (last >> max(adjustment,0)))
-                if adjustment > 0:
-                    raw_bytes.append(last & (2**adjustment-1))
+        try:
+            bytes, bits = bytes+bits/8, bits%8
+            bit_count = bytes*8+bits
+            
+            #check special case of not having to do any work
+            if bit_count == 0: return []
+            
+            #check sepcial case of intra-byte read
+            if bit_count <= (8-self.bit_shift):
+                return [self.shift(bit_count)]
+            
+            #check special case of byte-aligned reads, performance booster
+            if self.bit_shift == 0:
+                base = [ord(self.io.read(1)) for byte in range(bytes)]
+                if bits != 0:
+                    return base+[self.shift(bits)]
+                return base
+            
+            # Calculated shifts
+            old_bit_shift = self.bit_shift 
+            new_bit_shift = (self.bit_shift+bits) % 8
+            
+            # Masks
+            lo_mask = 2**old_bit_shift-1
+            lo_mask_inv = 0xFF - 2**(8-old_bit_shift)+1
+            hi_mask = 0xFF ^ lo_mask
+            hi_mask_inv = 0xFF ^ lo_mask_inv
+            
+            #last byte parameters
+            if new_bit_shift == 0: #this means we filled the last byte (8)
+                last_mask = 0xFF
+                adjustment = 8-old_bit_shift
+            else:
+                last_mask = 2**new_bit_shift-1
+                adjustment = new_bit_shift-old_bit_shift
+            
+            #Set up for the looping with a list, the bytes, and an initial part
+            raw_bytes = list()
+            prev, next = self.last_byte, ord(self.io.read(1))
+            first = prev & hi_mask
+            bit_count -= 8-old_bit_shift
+            
+            while bit_count > 0:
+            
+                if bit_count <= 8: #this is the last byte
+                    #The bits in the last byte are included in order starting at
+                    #the new_bit_shift boundary with extra bits bumped back a byte
+                    #because we can have odd bit requests, the bit shift can change
+                    last = (next & last_mask)
+
+                    # we need to bring the first byte closer
+                    # if the adjustment is lower than 0
+                    if adjustment < 0:
+                        first = first >> abs(adjustment)
 
-                bit_count = 0
-                
-            if bit_count > 8: #We can do simple wrapping for middle bytes
-                second = (next & lo_mask_inv) >> (8-old_bit_shift)
-                raw_bytes.append(first | second)
-                
-                #To remain consistent, always shfit these bits into the hi_mask
-                first = (next & hi_mask_inv) << old_bit_shift
-                bit_count -= 8
-                
-                #Cycle down to the next byte
-                prev,next = next,ord(self.io.read(1))
-        
-        #Make sure to set our internals back together
-        self.last_byte = next
-        self.bit_shift = new_bit_shift
-        
-        return raw_bytes
+                    raw_bytes.append(first | (last >> max(adjustment,0)))
+                    if adjustment > 0:
+                        raw_bytes.append(last & (2**adjustment-1))
+                        
+                    bit_count = 0
+                    
+                if bit_count > 8: #We can do simple wrapping for middle bytes
+                    second = (next & lo_mask_inv) >> (8-old_bit_shift)
+                    raw_bytes.append(first | second)
+                    
+                    #To remain consistent, always shfit these bits into the hi_mask
+                    first = (next & hi_mask_inv) << old_bit_shift
+                    bit_count -= 8
+                    
+                    #Cycle down to the next byte
+                    prev,next = next,ord(self.io.read(1))
+            
+            self.last_byte = next
+            self.bit_shift = new_bit_shift
+            return raw_bytes
+            
+        except TypeError:
+            raise EOFError("Cannot read requested bits/bytes. End of buffer reached")
 
 
 class PersonDict(dict):

test_replays/test_all.py

@@ -15,7 +15,7 @@ def test_empty():
     # Todo: Are we happy with it raising a ValueError? Should it be rather ParseError or something else?
     # Maybe a "production" mode would be nice to have, so that it simply returns a status of the parse without
     # raising an exception.
-    with pytest.raises(ValueError):
+    with pytest.raises(EOFError):
         sc2reader.read("test_replays/corrupted/empty.SC2Replay")
 
 # Tests for build 17811 replays