def encode_to_stream(self, value, out_stream: OutputStream):
user_context = decimal.getcontext()
decimal.setcontext(self.context)
value = value.quantize(self.scale_format)
bytes_value = str(value).encode("utf-8")
out_stream.write_bytes(bytes_value, len(bytes_value))
decimal.setcontext(user_context)
def _encode_to_stream(value: datetime.date, out_stream: OutputStream):
if value is None:
out_stream.write_int32(0xFFFFFFFF)
out_stream.write_int16(0xFFFF)
else:
out_stream.write_int32(value.year)
out_stream.write_int8(value.month)
out_stream.write_int8(value.day)
def encode_to_stream(self, value: List, out_stream: OutputStream):
for item in value:
self._field_coder.encode_to_stream(item, self._data_out_stream)
self._write_data_to_output_stream(out_stream)
# write end message
if self._separated_with_end_message:
out_stream.write_var_int64(1)
out_stream.write_byte(0x00)
class LengthPrefixBaseCoderImpl(ABC):
"""
LengthPrefixBaseCoder will be used in Operations and other coders will be the field coder of
LengthPrefixBaseCoder.
"""
def __init__(self, field_coder: 'FieldCoderImpl'):
self._field_coder = field_coder
self._data_out_stream = OutputStream()
def _write_data_to_output_stream(self, out_stream: OutputStream):
out_stream.write_var_int64(self._data_out_stream.size())
out_stream.write(self._data_out_stream.get())
self._data_out_stream.clear()
def encode_to_stream(self, value: Instant, out_stream: OutputStream):
if value is None:
out_stream.write_int64(self._null_seconds)
out_stream.write_int32(self._null_nanos)
else:
out_stream.write_int64(value.seconds)
out_stream.write_int32(value.nanos)
class BeamCoderImpl(StreamCoderImpl):
def __init__(self, value_coder):
self._value_coder = value_coder
self._data_output_stream = OutputStream()
def encode_to_stream(self, value, out_stream: create_OutputStream, nested):
self._value_coder.encode_to_stream(value, self._data_output_stream)
out_stream.write(self._data_output_stream.get())
self._data_output_stream.clear()
def decode_from_stream(self, in_stream: create_InputStream, nested):
data_input_stream = BeamInputStream(in_stream)
return self._value_coder.decode_from_stream(data_input_stream)
def __repr__(self):
return 'BeamCoderImpl[%s]' % self._value_coder
class FlinkCoderBeamWrapper(StreamCoderImpl):
"""
Bridge between Beam coder and Flink coder.
"""
def __init__(self, value_coder):
self._value_coder = value_coder
self._data_output_stream = OutputStream()
def encode_to_stream(self, value, out_stream: create_OutputStream, nested):
self._value_coder.encode_to_stream(value, self._data_output_stream)
out_stream.write(self._data_output_stream.get())
self._data_output_stream.clear()
def decode_from_stream(self, in_stream: create_InputStream, nested):
data_input_stream = BeamInputStream(in_stream)
return self._value_coder.decode_from_stream(data_input_stream)
def __repr__(self):
return 'FlinkCoderBeamWrapper[%s]' % self._value_coder
def write_mask(self, value, row_kind_value, out_stream: OutputStream):
field_pos = 0
null_byte_search_table = self.null_byte_search_table
remaining_bits_num = self._remaining_bits_num
# first byte contains the row kind bits
b = self.row_kind_search_table[row_kind_value]
for i in range(0, 8 - ROW_KIND_BIT_SIZE):
if field_pos + i < len(value) and value[field_pos + i] is None:
b |= null_byte_search_table[i + ROW_KIND_BIT_SIZE]
field_pos += 8 - ROW_KIND_BIT_SIZE
out_stream.write_byte(b)
for _ in range(1, self._leading_complete_bytes_num):
b = 0x00
for i in range(0, 8):
if value[field_pos + i] is None:
b |= null_byte_search_table[i]
field_pos += 8
out_stream.write_byte(b)
if self._leading_complete_bytes_num >= 1 and remaining_bits_num:
b = 0x00
for i in range(remaining_bits_num):
if value[field_pos + i] is None:
b |= null_byte_search_table[i]
out_stream.write_byte(b)
def encode_to_stream(self, value, out_stream: OutputStream):
out_stream.write_int32(len(value))
for elem in value:
if elem is None:
out_stream.write_byte(False)
else:
out_stream.write_byte(True)
self._elem_coder.encode_to_stream(elem, out_stream)
def encode_to_stream(self, value, out_stream: OutputStream):
milliseconds, nanoseconds = self.timestamp_to_internal(value)
if self.is_compact():
assert nanoseconds == 0
out_stream.write_int64(milliseconds)
else:
out_stream.write_int64(milliseconds)
out_stream.write_int32(nanoseconds)
def encode_to_stream(self, map_value, out_stream: OutputStream):
out_stream.write_int32(len(map_value))
for key in map_value:
self._key_coder.encode_to_stream(key, out_stream)
value = map_value[key]
if value is None:
out_stream.write_byte(True)
else:
out_stream.write_byte(False)
self._value_coder.encode_to_stream(map_value[key], out_stream)
def encode(self, value):
out = OutputStream()
self.encode_to_stream(value, out)
return out.get()
def encode_to_stream(self, value, out_stream: OutputStream):
out_stream.write_int32(len(value))
for elem in value:
self._elem_coder.encode_to_stream(elem, out_stream)
def encode_to_stream(self, value, out_stream: OutputStream):
out_stream.write_int32(self.time_to_internal(value))
def encode_to_stream(self, value, out_stream: OutputStream):
out_stream.write_int64(value.id)
def __init__(self, field_coder: 'FieldCoderImpl'):
self._field_coder = field_coder
self._data_out_stream = OutputStream()
def encode_to_stream(self, value, out_stream: OutputStream):
out_stream.write_double(value)
def encode_to_stream(self, value, out_stream: OutputStream):
out_stream.write_float(value)
def __init__(self, value_coder):
self._value_coder = value_coder
self._data_output_stream = OutputStream()
def encode_to_stream(self, value, out_stream: OutputStream):
out_stream.write_byte(0)
def _write_data_to_output_stream(self, out_stream: OutputStream):
out_stream.write_var_int64(self._data_out_stream.size())
out_stream.write(self._data_out_stream.get())
self._data_out_stream.clear()
def _encode_to_stream(value: datetime.time, out_stream: OutputStream):
if value is None:
out_stream.write_int8(0xFF)
out_stream.write_int16(0xFFFF)
out_stream.write_int32(0xFFFFFFFF)
else:
out_stream.write_int8(value.hour)
out_stream.write_int8(value.minute)
out_stream.write_int8(value.second)
out_stream.write_int32(value.microsecond * 1000)
def encode_to_stream(self, value, out_stream: OutputStream):
bytes_value = str(value).encode("utf-8")
out_stream.write_bytes(bytes_value, len(bytes_value))
