mercurial: comparison mercurial/utils/cborutil.py

equal deleted inserted replaced

-:2372284d9457
+:687b865b95ad
 yield BREAK
 def streamencodeint(v):
 if v >= 18446744073709551616 or v < -18446744073709551616:
-raise ValueError('big integers not supported')
+raise ValueError(b'big integers not supported')
 if v >= 0:
 yield encodelength(MAJOR_TYPE_UINT, v)
 else:
 yield encodelength(MAJOR_TYPE_NEGINT, abs(v) - 1)
 continue
 fn = STREAM_ENCODERS[ty]
 break
 if not fn:
-raise ValueError('do not know how to encode %s' % type(v))
+raise ValueError(b'do not know how to encode %s' % type(v))
 return fn(v)
 class CBORDecodeError(Exception):
 def _elementtointeger(b, i):
 return ord(b[i])
 STRUCT_BIG_UBYTE = struct.Struct(r'>B')
-STRUCT_BIG_USHORT = struct.Struct('>H')
+STRUCT_BIG_USHORT = struct.Struct(b'>H')
-STRUCT_BIG_ULONG = struct.Struct('>L')
+STRUCT_BIG_ULONG = struct.Struct(b'>L')
-STRUCT_BIG_ULONGLONG = struct.Struct('>Q')
+STRUCT_BIG_ULONGLONG = struct.Struct(b'>Q')
 SPECIAL_NONE = 0
 SPECIAL_START_INDEFINITE_BYTESTRING = 1
 SPECIAL_START_ARRAY = 2
 SPECIAL_START_MAP = 3
 # It is an indefinite length bytestring.
 else:
 return True, None, 1, SPECIAL_START_INDEFINITE_BYTESTRING
 elif majortype == MAJOR_TYPE_STRING:
-raise CBORDecodeError('string major type not supported')
+raise CBORDecodeError(b'string major type not supported')
 elif majortype == MAJOR_TYPE_ARRAY:
 # Beginning of arrays are treated as uints in order to decode their
 # length. We don't allow indefinite length arrays.
 complete, size, readcount = decodeuint(subtype, b, offset)
 if not complete:
 return False, None, readcount2, SPECIAL_NONE
 if special != SPECIAL_START_ARRAY:
 raise CBORDecodeError(
-'expected array after finite set ' 'semantic tag'
+b'expected array after finite set ' b'semantic tag'
 )
 return True, size, readcount + readcount2 + 1, SPECIAL_START_SET
 else:
-raise CBORDecodeError('semantic tag %d not allowed' % tagvalue)
+raise CBORDecodeError(b'semantic tag %d not allowed' % tagvalue)
 elif majortype == MAJOR_TYPE_SPECIAL:
 # Only specific values for the information field are allowed.
 if subtype == SUBTYPE_FALSE:
 return True, False, 1, SPECIAL_NONE
 return True, None, 1, SPECIAL_NONE
 elif subtype == SUBTYPE_INDEFINITE:
 return True, None, 1, SPECIAL_INDEFINITE_BREAK
 # If value is 24, subtype is in next byte.
 else:
-raise CBORDecodeError('special type %d not allowed' % subtype)
+raise CBORDecodeError(b'special type %d not allowed' % subtype)
 else:
 assert False
 def decodeuint(subtype, b, offset=0, allowindefinite=False):
 # Indefinite length specifier.
 elif subtype == 31:
 if allowindefinite:
 return True, None, 0
 else:
-raise CBORDecodeError('indefinite length uint not allowed here')
+raise CBORDecodeError(b'indefinite length uint not allowed here')
 elif subtype >= 28:
 raise CBORDecodeError(
-'unsupported subtype on integer type: %d' % subtype
+b'unsupported subtype on integer type: %d' % subtype
 )
 if subtype == 24:
 s = STRUCT_BIG_UBYTE
 elif subtype == 25:
 elif subtype == 26:
 s = STRUCT_BIG_ULONG
 elif subtype == 27:
 s = STRUCT_BIG_ULONGLONG
 else:
-raise CBORDecodeError('bounds condition checking violation')
+raise CBORDecodeError(b'bounds condition checking violation')
 if len(b) - offset >= s.size:
 return True, s.unpack_from(b, offset)[0], s.size
 else:
 return False, None, len(b) - offset - s.size
 if special == SPECIAL_NONE:
 self._decodedvalues.append(value)
 elif special == SPECIAL_START_ARRAY:
 self._collectionstack.append(
-{'remaining': value, 'v': [],}
+{b'remaining': value, b'v': [],}
 )
 self._state = self._STATE_WANT_ARRAY_VALUE
 elif special == SPECIAL_START_MAP:
 self._collectionstack.append(
-{'remaining': value, 'v': {},}
+{b'remaining': value, b'v': {},}
 )
 self._state = self._STATE_WANT_MAP_KEY
 elif special == SPECIAL_START_SET:
 self._collectionstack.append(
-{'remaining': value, 'v': set(),}
+{b'remaining': value, b'v': set(),}
 )
 self._state = self._STATE_WANT_SET_VALUE
 elif special == SPECIAL_START_INDEFINITE_BYTESTRING:
 self._state = self._STATE_WANT_BYTESTRING_CHUNK_FIRST
 else:
 raise CBORDecodeError(
-'unhandled special state: %d' % special
+b'unhandled special state: %d' % special
 )
 # This value becomes an element of the current array.
 elif self._state == self._STATE_WANT_ARRAY_VALUE:
 # Simple values get appended.
 if special == SPECIAL_NONE:
 c = self._collectionstack[-1]
-c['v'].append(value)
+c[b'v'].append(value)
-c['remaining'] -= 1
+c[b'remaining'] -= 1
 # self._state doesn't need changed.
 # An array nested within an array.
 elif special == SPECIAL_START_ARRAY:
 lastc = self._collectionstack[-1]
 newvalue = []
-lastc['v'].append(newvalue)
+lastc[b'v'].append(newvalue)
-lastc['remaining'] -= 1
+lastc[b'remaining'] -= 1
 self._collectionstack.append(
-{'remaining': value, 'v': newvalue,}
+{b'remaining': value, b'v': newvalue,}
 )
 # self._state doesn't need changed.
 # A map nested within an array.
 elif special == SPECIAL_START_MAP:
 lastc = self._collectionstack[-1]
 newvalue = {}
-lastc['v'].append(newvalue)
+lastc[b'v'].append(newvalue)
-lastc['remaining'] -= 1
+lastc[b'remaining'] -= 1
 self._collectionstack.append(
-{'remaining': value, 'v': newvalue}
+{b'remaining': value, b'v': newvalue}
 )
 self._state = self._STATE_WANT_MAP_KEY
 elif special == SPECIAL_START_SET:
 lastc = self._collectionstack[-1]
 newvalue = set()
-lastc['v'].append(newvalue)
+lastc[b'v'].append(newvalue)
-lastc['remaining'] -= 1
+lastc[b'remaining'] -= 1
 self._collectionstack.append(
-{'remaining': value, 'v': newvalue,}
+{b'remaining': value, b'v': newvalue,}
 )
 self._state = self._STATE_WANT_SET_VALUE
 elif special == SPECIAL_START_INDEFINITE_BYTESTRING:
 raise CBORDecodeError(
-'indefinite length bytestrings '
+b'indefinite length bytestrings '
-'not allowed as array values'
+b'not allowed as array values'
 )
 else:
 raise CBORDecodeError(
-'unhandled special item when '
+b'unhandled special item when '
-'expecting array value: %d' % special
+b'expecting array value: %d' % special
 )
 # This value becomes the key of the current map instance.
 elif self._state == self._STATE_WANT_MAP_KEY:
 if special == SPECIAL_NONE:
 self._currentmapkey = value
 self._state = self._STATE_WANT_MAP_VALUE
 elif special == SPECIAL_START_INDEFINITE_BYTESTRING:
 raise CBORDecodeError(
-'indefinite length bytestrings '
+b'indefinite length bytestrings '
-'not allowed as map keys'
+b'not allowed as map keys'
 )
 elif special in (
 SPECIAL_START_ARRAY,
 SPECIAL_START_MAP,
 SPECIAL_START_SET,
 ):
 raise CBORDecodeError(
-'collections not supported as map ' 'keys'
+b'collections not supported as map ' b'keys'
 )
 # We do not allow special values to be used as map keys.
 else:
 raise CBORDecodeError(
-'unhandled special item when '
+b'unhandled special item when '
-'expecting map key: %d' % special
+b'expecting map key: %d' % special
 )
 # This value becomes the value of the current map key.
 elif self._state == self._STATE_WANT_MAP_VALUE:
 # Simple values simply get inserted into the map.
 if special == SPECIAL_NONE:
 lastc = self._collectionstack[-1]
-lastc['v'][self._currentmapkey] = value
+lastc[b'v'][self._currentmapkey] = value
-lastc['remaining'] -= 1
+lastc[b'remaining'] -= 1
 self._state = self._STATE_WANT_MAP_KEY
 # A new array is used as the map value.
 elif special == SPECIAL_START_ARRAY:
 lastc = self._collectionstack[-1]
 newvalue = []
-lastc['v'][self._currentmapkey] = newvalue
+lastc[b'v'][self._currentmapkey] = newvalue
-lastc['remaining'] -= 1
+lastc[b'remaining'] -= 1
 self._collectionstack.append(
-{'remaining': value, 'v': newvalue,}
+{b'remaining': value, b'v': newvalue,}
 )
 self._state = self._STATE_WANT_ARRAY_VALUE
 # A new map is used as the map value.
 elif special == SPECIAL_START_MAP:
 lastc = self._collectionstack[-1]
 newvalue = {}
-lastc['v'][self._currentmapkey] = newvalue
+lastc[b'v'][self._currentmapkey] = newvalue
-lastc['remaining'] -= 1
+lastc[b'remaining'] -= 1
 self._collectionstack.append(
-{'remaining': value, 'v': newvalue,}
+{b'remaining': value, b'v': newvalue,}
 )
 self._state = self._STATE_WANT_MAP_KEY
 # A new set is used as the map value.
 elif special == SPECIAL_START_SET:
 lastc = self._collectionstack[-1]
 newvalue = set()
-lastc['v'][self._currentmapkey] = newvalue
+lastc[b'v'][self._currentmapkey] = newvalue
-lastc['remaining'] -= 1
+lastc[b'remaining'] -= 1
 self._collectionstack.append(
-{'remaining': value, 'v': newvalue,}
+{b'remaining': value, b'v': newvalue,}
 )
 self._state = self._STATE_WANT_SET_VALUE
 elif special == SPECIAL_START_INDEFINITE_BYTESTRING:
 raise CBORDecodeError(
-'indefinite length bytestrings not '
+b'indefinite length bytestrings not '
-'allowed as map values'
+b'allowed as map values'
 )
 else:
 raise CBORDecodeError(
-'unhandled special item when '
+b'unhandled special item when '
-'expecting map value: %d' % special
+b'expecting map value: %d' % special
 )
 self._currentmapkey = None
 # This value is added to the current set.
 elif self._state == self._STATE_WANT_SET_VALUE:
 if special == SPECIAL_NONE:
 lastc = self._collectionstack[-1]
-lastc['v'].add(value)
+lastc[b'v'].add(value)
-lastc['remaining'] -= 1
+lastc[b'remaining'] -= 1
 elif special == SPECIAL_START_INDEFINITE_BYTESTRING:
 raise CBORDecodeError(
-'indefinite length bytestrings not '
+b'indefinite length bytestrings not '
-'allowed as set values'
+b'allowed as set values'
 )
 elif special in (
 SPECIAL_START_ARRAY,
 SPECIAL_START_MAP,
 SPECIAL_START_SET,
 ):
 raise CBORDecodeError(
-'collections not allowed as set ' 'values'
+b'collections not allowed as set ' b'values'
 )
 # We don't allow non-trivial types to exist as set values.
 else:
 raise CBORDecodeError(
-'unhandled special item when '
+b'unhandled special item when '
-'expecting set value: %d' % special
+b'expecting set value: %d' % special
 )
 # This value represents the first chunk in an indefinite length
 # bytestring.
 elif self._state == self._STATE_WANT_BYTESTRING_CHUNK_FIRST:
 assert not self._collectionstack
 self._state = self._STATE_NONE
 else:
 raise CBORDecodeError(
-'unexpected special value when '
+b'unexpected special value when '
-'expecting bytestring chunk: %d' % special
+b'expecting bytestring chunk: %d' % special
 )
 # This value represents the non-initial chunk in an indefinite
 # length bytestring.
 elif self._state == self._STATE_WANT_BYTESTRING_CHUNK_SUBSEQUENT:
 assert not self._collectionstack
 self._state = self._STATE_NONE
 else:
 raise CBORDecodeError(
-'unexpected special value when '
+b'unexpected special value when '
-'expecting bytestring chunk: %d' % special
+b'expecting bytestring chunk: %d' % special
 )
 else:
 raise CBORDecodeError(
-'unhandled decoder state: %d' % self._state
+b'unhandled decoder state: %d' % self._state
 )
 # We could have just added the final value in a collection. End
 # all complete collections at the top of the stack.
 while True:
 break
 # Or we are expecting more items for this collection.
 lastc = self._collectionstack[-1]
-if lastc['remaining']:
+if lastc[b'remaining']:
 break
 # The collection at the top of the stack is complete.
 # Discard it, as it isn't needed for future items.
 if self._collectionstack:
 self._state = {
 list: self._STATE_WANT_ARRAY_VALUE,
 dict: self._STATE_WANT_MAP_KEY,
 set: self._STATE_WANT_SET_VALUE,
-}[type(self._collectionstack[-1]['v'])]
+}[type(self._collectionstack[-1][b'v'])]
 # If this is the root collection, emit it.
 else:
-self._decodedvalues.append(lastc['v'])
+self._decodedvalues.append(lastc[b'v'])
 self._state = self._STATE_NONE
 return (
 bool(self._decodedvalues),
 offset - initialoffset,
 decoder = sansiodecoder()
 havevalues, readcount, wantbytes = decoder.decode(b)
 if readcount != len(b):
-raise CBORDecodeError('input data not fully consumed')
+raise CBORDecodeError(b'input data not fully consumed')
 if decoder.inprogress:
-raise CBORDecodeError('input data not complete')
+raise CBORDecodeError(b'input data not complete')
 return decoder.getavailable()

changeset 43077	687b865b95ad
parent 43076	2372284d9457
child 43106	d783f945a701