mercurial-scm/hg: comparison mercurial/utils/cborutil.py

equal deleted inserted replaced

-:5e09c6b5b795
+:8a2091a2f974
 yield BREAK
 def streamencodeint(v: int) -> Iterator[bytes]:
 if v >= 18446744073709551616 or v < -18446744073709551616:
-raise ValueError(b'big integers not supported')
+raise ValueError('big integers not supported')
 if v >= 0:
 yield encodelength(MAJOR_TYPE_UINT, v)
 else:
 yield encodelength(MAJOR_TYPE_NEGINT, abs(v) - 1)
 # It is an indefinite length bytestring.
 else:
 return True, None, 1, SPECIAL_START_INDEFINITE_BYTESTRING
 elif majortype == MAJOR_TYPE_STRING:
-raise CBORDecodeError(b'string major type not supported')
+raise CBORDecodeError('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(
-b'expected array after finite set semantic tag'
+'expected array after finite set semantic tag'
 )
 return True, size, readcount + readcount2 + 1, SPECIAL_START_SET
 else:
-raise CBORDecodeError(b'semantic tag %d not allowed' % tagvalue)
+raise CBORDecodeError('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(b'special type %d not allowed' % subtype)
+raise CBORDecodeError('special type %d not allowed' % subtype)
 else:
 assert False
 def decodeuint(
 # Indefinite length specifier.
 elif subtype == 31:
 if allowindefinite:
 return True, None, 0
 else:
-raise CBORDecodeError(b'indefinite length uint not allowed here')
+raise CBORDecodeError('indefinite length uint not allowed here')
 elif subtype >= 28:
 raise CBORDecodeError(
-b'unsupported subtype on integer type: %d' % subtype
+'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(b'bounds condition checking violation')
+raise CBORDecodeError('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
 elif special == SPECIAL_START_INDEFINITE_BYTESTRING:
 self._state = self._STATE_WANT_BYTESTRING_CHUNK_FIRST
 else:
 raise CBORDecodeError(
-b'unhandled special state: %d' % special
+'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.
 self._state = self._STATE_WANT_SET_VALUE
 elif special == SPECIAL_START_INDEFINITE_BYTESTRING:
 raise CBORDecodeError(
-b'indefinite length bytestrings '
+'indefinite length bytestrings '
-b'not allowed as array values'
+'not allowed as array values'
 )
 else:
 raise CBORDecodeError(
-b'unhandled special item when '
+'unhandled special item when '
-b'expecting array value: %d' % special
+'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(
-b'indefinite length bytestrings '
+'indefinite length bytestrings '
-b'not allowed as map keys'
+'not allowed as map keys'
 )
 elif special in (
 SPECIAL_START_ARRAY,
 SPECIAL_START_MAP,
 SPECIAL_START_SET,
 ):
 raise CBORDecodeError(
-b'collections not supported as map keys'
+'collections not supported as map keys'
 )
 # We do not allow special values to be used as map keys.
 else:
 raise CBORDecodeError(
-b'unhandled special item when '
+'unhandled special item when '
-b'expecting map key: %d' % special
+'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.
 self._state = self._STATE_WANT_SET_VALUE
 elif special == SPECIAL_START_INDEFINITE_BYTESTRING:
 raise CBORDecodeError(
-b'indefinite length bytestrings not '
+'indefinite length bytestrings not '
-b'allowed as map values'
+'allowed as map values'
 )
 else:
 raise CBORDecodeError(
-b'unhandled special item when '
+'unhandled special item when '
-b'expecting map value: %d' % special
+'expecting map value: %d' % special
 )
 self._currentmapkey = None
 # This value is added to the current set.
 lastc[b'v'].add(value)
 lastc[b'remaining'] -= 1
 elif special == SPECIAL_START_INDEFINITE_BYTESTRING:
 raise CBORDecodeError(
-b'indefinite length bytestrings not '
+'indefinite length bytestrings not '
-b'allowed as set values'
+'allowed as set values'
 )
 elif special in (
 SPECIAL_START_ARRAY,
 SPECIAL_START_MAP,
 SPECIAL_START_SET,
 ):
 raise CBORDecodeError(
-b'collections not allowed as set values'
+'collections not allowed as set values'
 )
 # We don't allow non-trivial types to exist as set values.
 else:
 raise CBORDecodeError(
-b'unhandled special item when '
+'unhandled special item when '
-b'expecting set value: %d' % special
+'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(
-b'unexpected special value when '
+'unexpected special value when '
-b'expecting bytestring chunk: %d' % special
+'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(
-b'unexpected special value when '
+'unexpected special value when '
-b'expecting bytestring chunk: %d' % special
+'expecting bytestring chunk: %d' % special
 )
 else:
 raise CBORDecodeError(
-b'unhandled decoder state: %d' % self._state
+'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:
 decoder = sansiodecoder()
 havevalues, readcount, wantbytes = decoder.decode(b)
 if readcount != len(b):
-raise CBORDecodeError(b'input data not fully consumed')
+raise CBORDecodeError('input data not fully consumed')
 if decoder.inprogress:
-raise CBORDecodeError(b'input data not complete')
+raise CBORDecodeError('input data not complete')
 return decoder.getavailable()

changeset 52694	8a2091a2f974
parent 52693	5e09c6b5b795