| ######################## BEGIN LICENSE BLOCK ######################## |
| # |
| # Contributor(s): |
| # Jason Zavaglia |
| # |
| # This library is free software; you can redistribute it and/or |
| # modify it under the terms of the GNU Lesser General Public |
| # License as published by the Free Software Foundation; either |
| # version 2.1 of the License, or (at your option) any later version. |
| # |
| # This library is distributed in the hope that it will be useful, |
| # but WITHOUT ANY WARRANTY; without even the implied warranty of |
| # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| # Lesser General Public License for more details. |
| # |
| # You should have received a copy of the GNU Lesser General Public |
| # License along with this library; if not, write to the Free Software |
| # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA |
| # 02110-1301 USA |
| ######################### END LICENSE BLOCK ######################### |
| from typing import List, Union |
| |
| from .charsetprober import CharSetProber |
| from .enums import ProbingState |
| |
| |
| class UTF1632Prober(CharSetProber): |
| """ |
| This class simply looks for occurrences of zero bytes, and infers |
| whether the file is UTF16 or UTF32 (low-endian or big-endian) |
| For instance, files looking like ( \0 \0 \0 [nonzero] )+ |
| have a good probability to be UTF32BE. Files looking like ( \0 [nonzero] )+ |
| may be guessed to be UTF16BE, and inversely for little-endian varieties. |
| """ |
| |
| # how many logical characters to scan before feeling confident of prediction |
| MIN_CHARS_FOR_DETECTION = 20 |
| # a fixed constant ratio of expected zeros or non-zeros in modulo-position. |
| EXPECTED_RATIO = 0.94 |
| |
| def __init__(self) -> None: |
| super().__init__() |
| self.position = 0 |
| self.zeros_at_mod = [0] * 4 |
| self.nonzeros_at_mod = [0] * 4 |
| self._state = ProbingState.DETECTING |
| self.quad = [0, 0, 0, 0] |
| self.invalid_utf16be = False |
| self.invalid_utf16le = False |
| self.invalid_utf32be = False |
| self.invalid_utf32le = False |
| self.first_half_surrogate_pair_detected_16be = False |
| self.first_half_surrogate_pair_detected_16le = False |
| self.reset() |
| |
| def reset(self) -> None: |
| super().reset() |
| self.position = 0 |
| self.zeros_at_mod = [0] * 4 |
| self.nonzeros_at_mod = [0] * 4 |
| self._state = ProbingState.DETECTING |
| self.invalid_utf16be = False |
| self.invalid_utf16le = False |
| self.invalid_utf32be = False |
| self.invalid_utf32le = False |
| self.first_half_surrogate_pair_detected_16be = False |
| self.first_half_surrogate_pair_detected_16le = False |
| self.quad = [0, 0, 0, 0] |
| |
| @property |
| def charset_name(self) -> str: |
| if self.is_likely_utf32be(): |
| return "utf-32be" |
| if self.is_likely_utf32le(): |
| return "utf-32le" |
| if self.is_likely_utf16be(): |
| return "utf-16be" |
| if self.is_likely_utf16le(): |
| return "utf-16le" |
| # default to something valid |
| return "utf-16" |
| |
| @property |
| def language(self) -> str: |
| return "" |
| |
| def approx_32bit_chars(self) -> float: |
| return max(1.0, self.position / 4.0) |
| |
| def approx_16bit_chars(self) -> float: |
| return max(1.0, self.position / 2.0) |
| |
| def is_likely_utf32be(self) -> bool: |
| approx_chars = self.approx_32bit_chars() |
| return approx_chars >= self.MIN_CHARS_FOR_DETECTION and ( |
| self.zeros_at_mod[0] / approx_chars > self.EXPECTED_RATIO |
| and self.zeros_at_mod[1] / approx_chars > self.EXPECTED_RATIO |
| and self.zeros_at_mod[2] / approx_chars > self.EXPECTED_RATIO |
| and self.nonzeros_at_mod[3] / approx_chars > self.EXPECTED_RATIO |
| and not self.invalid_utf32be |
| ) |
| |
| def is_likely_utf32le(self) -> bool: |
| approx_chars = self.approx_32bit_chars() |
| return approx_chars >= self.MIN_CHARS_FOR_DETECTION and ( |
| self.nonzeros_at_mod[0] / approx_chars > self.EXPECTED_RATIO |
| and self.zeros_at_mod[1] / approx_chars > self.EXPECTED_RATIO |
| and self.zeros_at_mod[2] / approx_chars > self.EXPECTED_RATIO |
| and self.zeros_at_mod[3] / approx_chars > self.EXPECTED_RATIO |
| and not self.invalid_utf32le |
| ) |
| |
| def is_likely_utf16be(self) -> bool: |
| approx_chars = self.approx_16bit_chars() |
| return approx_chars >= self.MIN_CHARS_FOR_DETECTION and ( |
| (self.nonzeros_at_mod[1] + self.nonzeros_at_mod[3]) / approx_chars |
| > self.EXPECTED_RATIO |
| and (self.zeros_at_mod[0] + self.zeros_at_mod[2]) / approx_chars |
| > self.EXPECTED_RATIO |
| and not self.invalid_utf16be |
| ) |
| |
| def is_likely_utf16le(self) -> bool: |
| approx_chars = self.approx_16bit_chars() |
| return approx_chars >= self.MIN_CHARS_FOR_DETECTION and ( |
| (self.nonzeros_at_mod[0] + self.nonzeros_at_mod[2]) / approx_chars |
| > self.EXPECTED_RATIO |
| and (self.zeros_at_mod[1] + self.zeros_at_mod[3]) / approx_chars |
| > self.EXPECTED_RATIO |
| and not self.invalid_utf16le |
| ) |
| |
| def validate_utf32_characters(self, quad: List[int]) -> None: |
| """ |
| Validate if the quad of bytes is valid UTF-32. |
| |
| UTF-32 is valid in the range 0x00000000 - 0x0010FFFF |
| excluding 0x0000D800 - 0x0000DFFF |
| |
| https://en.wikipedia.org/wiki/UTF-32 |
| """ |
| if ( |
| quad[0] != 0 |
| or quad[1] > 0x10 |
| or (quad[0] == 0 and quad[1] == 0 and 0xD8 <= quad[2] <= 0xDF) |
| ): |
| self.invalid_utf32be = True |
| if ( |
| quad[3] != 0 |
| or quad[2] > 0x10 |
| or (quad[3] == 0 and quad[2] == 0 and 0xD8 <= quad[1] <= 0xDF) |
| ): |
| self.invalid_utf32le = True |
| |
| def validate_utf16_characters(self, pair: List[int]) -> None: |
| """ |
| Validate if the pair of bytes is valid UTF-16. |
| |
| UTF-16 is valid in the range 0x0000 - 0xFFFF excluding 0xD800 - 0xFFFF |
| with an exception for surrogate pairs, which must be in the range |
| 0xD800-0xDBFF followed by 0xDC00-0xDFFF |
| |
| https://en.wikipedia.org/wiki/UTF-16 |
| """ |
| if not self.first_half_surrogate_pair_detected_16be: |
| if 0xD8 <= pair[0] <= 0xDB: |
| self.first_half_surrogate_pair_detected_16be = True |
| elif 0xDC <= pair[0] <= 0xDF: |
| self.invalid_utf16be = True |
| else: |
| if 0xDC <= pair[0] <= 0xDF: |
| self.first_half_surrogate_pair_detected_16be = False |
| else: |
| self.invalid_utf16be = True |
| |
| if not self.first_half_surrogate_pair_detected_16le: |
| if 0xD8 <= pair[1] <= 0xDB: |
| self.first_half_surrogate_pair_detected_16le = True |
| elif 0xDC <= pair[1] <= 0xDF: |
| self.invalid_utf16le = True |
| else: |
| if 0xDC <= pair[1] <= 0xDF: |
| self.first_half_surrogate_pair_detected_16le = False |
| else: |
| self.invalid_utf16le = True |
| |
| def feed(self, byte_str: Union[bytes, bytearray]) -> ProbingState: |
| for c in byte_str: |
| mod4 = self.position % 4 |
| self.quad[mod4] = c |
| if mod4 == 3: |
| self.validate_utf32_characters(self.quad) |
| self.validate_utf16_characters(self.quad[0:2]) |
| self.validate_utf16_characters(self.quad[2:4]) |
| if c == 0: |
| self.zeros_at_mod[mod4] += 1 |
| else: |
| self.nonzeros_at_mod[mod4] += 1 |
| self.position += 1 |
| return self.state |
| |
| @property |
| def state(self) -> ProbingState: |
| if self._state in {ProbingState.NOT_ME, ProbingState.FOUND_IT}: |
| # terminal, decided states |
| return self._state |
| if self.get_confidence() > 0.80: |
| self._state = ProbingState.FOUND_IT |
| elif self.position > 4 * 1024: |
| # if we get to 4kb into the file, and we can't conclude it's UTF, |
| # let's give up |
| self._state = ProbingState.NOT_ME |
| return self._state |
| |
| def get_confidence(self) -> float: |
| return ( |
| 0.85 |
| if ( |
| self.is_likely_utf16le() |
| or self.is_likely_utf16be() |
| or self.is_likely_utf32le() |
| or self.is_likely_utf32be() |
| ) |
| else 0.00 |
| ) |
