File size: 6,025 Bytes
f0f4f2b |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 |
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
import io
from abc import ABC, abstractmethod
from io import SEEK_CUR
from typing import (
Dict,
List,
Tuple,
Union,
cast,
)
from pyiceberg.avro import STRUCT_DOUBLE, STRUCT_FLOAT
from pyiceberg.io import InputStream
from pyiceberg.typedef import UTF8
class BinaryDecoder(ABC):
"""Decodes bytes into Python physical primitives."""
@abstractmethod
def tell(self) -> int:
"""Return the current position."""
@abstractmethod
def read(self, n: int) -> bytes:
"""Read n bytes."""
@abstractmethod
def skip(self, n: int) -> None:
"""Skip n bytes."""
def read_boolean(self) -> bool:
"""Read a value from the stream as a boolean.
A boolean is written as a single byte
whose value is either 0 (false) or 1 (true).
"""
return ord(self.read(1)) == 1
def read_int(self) -> int:
"""Read an int/long value.
int/long values are written using variable-length, zigzag coding.
"""
b = ord(self.read(1))
n = b & 0x7F
shift = 7
while (b & 0x80) != 0:
b = ord(self.read(1))
n |= (b & 0x7F) << shift
shift += 7
datum = (n >> 1) ^ -(n & 1)
return datum
def read_ints(self, n: int) -> Tuple[int, ...]:
"""Read a list of integers."""
return tuple(self.read_int() for _ in range(n))
def read_int_bytes_dict(self, n: int, dest: Dict[int, bytes]) -> None:
"""Read a dictionary of integers for keys and bytes for values into a destination dictionary."""
for _ in range(n):
k = self.read_int()
v = self.read_bytes()
dest[k] = v
def read_float(self) -> float:
"""Read a value from the stream as a float.
A float is written as 4 bytes.
The float is converted into a 32-bit integer using a method equivalent to
Java's floatToIntBits and then encoded in little-endian format.
"""
return float(cast(Tuple[float, ...], STRUCT_FLOAT.unpack(self.read(4)))[0])
def read_double(self) -> float:
"""Read a value from the stream as a double.
A double is written as 8 bytes.
The double is converted into a 64-bit integer using a method equivalent to
Java's doubleToLongBits and then encoded in little-endian format.
"""
return float(cast(Tuple[float, ...], STRUCT_DOUBLE.unpack(self.read(8)))[0])
def read_bytes(self) -> bytes:
"""Bytes are encoded as a long followed by that many bytes of data."""
num_bytes = self.read_int()
return self.read(num_bytes) if num_bytes > 0 else b""
def read_utf8(self) -> str:
"""Read an utf-8 encoded string from the stream.
A string is encoded as a long followed by
that many bytes of UTF-8 encoded character data.
"""
return self.read_bytes().decode(UTF8)
def skip_boolean(self) -> None:
self.skip(1)
def skip_int(self) -> None:
b = ord(self.read(1))
while (b & 0x80) != 0:
b = ord(self.read(1))
def skip_float(self) -> None:
self.skip(4)
def skip_double(self) -> None:
self.skip(8)
def skip_bytes(self) -> None:
self.skip(self.read_int())
def skip_utf8(self) -> None:
self.skip_bytes()
class StreamingBinaryDecoder(BinaryDecoder):
"""Decodes bytes into Python physical primitives."""
__slots__ = "_input_stream"
_input_stream: InputStream
def __init__(self, input_stream: Union[bytes, InputStream]) -> None:
"""Reader is a Python object on which we can call read, seek, and tell."""
if isinstance(input_stream, bytes):
# In the case of bytes, we wrap it into a BytesIO to make it a stream
self._input_stream = io.BytesIO(input_stream)
else:
self._input_stream = input_stream
def tell(self) -> int:
"""Return the current stream position."""
return self._input_stream.tell()
def read(self, n: int) -> bytes:
"""Read n bytes."""
if n < 0:
raise ValueError(f"Requested {n} bytes to read, expected positive integer.")
data: List[bytes] = []
n_remaining = n
while n_remaining > 0:
data_read = self._input_stream.read(n_remaining)
read_len = len(data_read)
if read_len == n:
# If we read everything, we return directly
# otherwise we'll continue to fetch the rest
return data_read
elif read_len <= 0:
raise EOFError(f"EOF: read {read_len} bytes")
data.append(data_read)
n_remaining -= read_len
return b"".join(data)
def skip(self, n: int) -> None:
self._input_stream.seek(n, SEEK_CUR)
def new_decoder(b: bytes) -> BinaryDecoder:
try:
from pyiceberg.avro.decoder_fast import CythonBinaryDecoder
return CythonBinaryDecoder(b)
except ModuleNotFoundError:
import warnings
warnings.warn("Falling back to pure Python Avro decoder, missing Cython implementation")
return StreamingBinaryDecoder(b)
|