JsonhPy 2.2__tar.gz → 2.3__tar.gz

{jsonhpy-2.2 → jsonhpy-2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: JsonhPy
-Version: 2.2
+Version: 2.3
 Summary: JSON for Humans in Python.
 Author-email: Joyless <joyless.mod@gmail.com>
 License-Expression: MIT

{jsonhpy-2.2 → jsonhpy-2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "JsonhPy"
-version = "2.2"
+version = "2.3"
 authors = [
   { name="Joyless", email="joyless.mod@gmail.com" },
 ]

{jsonhpy-2.2 → jsonhpy-2.3}/src/JsonhPy/JsonhPy.py

@@ -1,3 +1,4 @@
+import math
 from enum import Enum
 from typing import Iterator, Iterable
 
@@ -223,7 +224,15 @@ class JsonhNumberParser:
             return exponent
 
         # Multiply mantissa by 10 ^ exponent
-        return JsonhResult.from_value(mantissa.value() * (10 ** exponent.value()))
+        try:
+            return JsonhResult.from_value(mantissa.value() * (10.0 ** exponent.value()))
+        except:
+            if mantissa.value() > 0:
+                return JsonhResult.from_value(math.inf)
+            elif mantissa.value() < 0:
+                return JsonhResult.from_value(-math.inf)
+            else:
+                return JsonhResult.from_value(0.0)
 
     @staticmethod
     def _parse_fractional_number(digits: str, base_digits: str) -> JsonhResult[float, str]:
@@ -238,29 +247,32 @@ class JsonhNumberParser:
 
         # Get parts of number
         whole_part: str = digits[:dot_index]
-        fractional_part: str = digits[(dot_index + 1):]
+        fraction_part: str = digits[(dot_index + 1):]
 
         # Parse parts of number
-        whole: JsonhResult[int, str] = JsonhNumberParser._parse_whole_number(whole_part, base_digits)
+        whole: JsonhResult[float, str] = JsonhNumberParser._parse_whole_number(whole_part, base_digits)
         if whole.is_error:
             return whole
-        fraction: JsonhResult[int, str] = JsonhNumberParser._parse_whole_number(fractional_part, base_digits)
-        if fraction.is_error:
-            return fraction
-
-        # Get fraction leading zeroes
-        fraction_leading_zeroes: str = ""
-        for index in range(0, len(fractional_part)):
-            if fractional_part[index] == '0':
-                fraction_leading_zeroes += '0'
-            else:
-                break
+
+        # Add each column of fraction digits
+        fraction: float = 0.0
+        for index in range(len(fraction_part) - 1, -1, -1):
+            # Get current digit
+            digit_char: str = fraction_part[index]
+            digit_int: int = base_digits.find(digit_char.lower())
+
+            # Ensure digit is valid
+            if digit_int < 0:
+                return JsonhResult.from_error(f"Invalid digit: '{digit_char}'")
+
+            # Add value of column
+            fraction = (fraction + digit_int) / len(base_digits)
 
         # Combine whole and fraction
-        return JsonhResult.from_value(float(str(whole.value()) + "." + fraction_leading_zeroes + str(fraction.value())))
+        return JsonhResult.from_value(whole.value() + fraction)
 
     @staticmethod
-    def _parse_whole_number(digits: str, base_digits: str) -> JsonhResult[int, str]:
+    def _parse_whole_number(digits: str, base_digits: str) -> JsonhResult[float, str]:
         """
         Converts a whole number (e.g. `12345`) from the given base (e.g. `01234567`) to a base-10 integer.
         """
@@ -274,7 +286,7 @@ class JsonhNumberParser:
             digits = digits[1:]
 
         # Add each column of digits
-        integer: int = 0
+        integer: float = 0.0
         for index in range(0, len(digits)):
             # Get current digit
             digit_char: str = digits[index]
@@ -284,12 +296,8 @@ class JsonhNumberParser:
             if digit_int < 0:
                 return JsonhResult.from_error(f"Invalid digit: '{digit_char}'")
 
-            # Get magnitude of current digit column
-            column_number: int = len(digits) - 1 - index
-            column_magnitude: int = len(base_digits) ** column_number
-
             # Add value of column
-            integer += digit_int * column_magnitude
+            integer = (integer * len(base_digits)) + digit_int
 
         # Apply sign
         if sign != 1:
@@ -1263,7 +1271,7 @@ class JsonhReader:
                 is_empty = False
             # Dot
             elif next == '.':
-                # Disallow dot preceding underscore
+                # Disallow dot following underscore
                 if len(number_builder.ref) >= 1 and number_builder.ref[-1] == '_':
                     return JsonhResult.from_error("`.` must not follow `_` in number")
 
@@ -1437,26 +1445,40 @@ class JsonhReader:
                 return
 
     def _read_hex_sequence(self, length: int) -> JsonhResult[int, str]:
-        hex_chars: str = ""
+        assert(length <= 8)
 
-        for index in range(0, length):
+        value: int = 0
+
+        for _ in range(0, length):
             next: str | None = self._read()
 
             # Hex digit
             if next != None and ((ord('0') <= ord(next) <= ord('9')) or (ord('A') <= ord(next) <= ord('F')) or (ord('a') <= ord(next) <= ord('f'))):
-                hex_chars += next
+                # Get hex digit
+                digit: int = ord(next)
+                # Convert hex digit to integer
+                integer: int = \
+                    digit - ord('A') + 10 if (digit >= ord('A') and digit <= ord('F')) else \
+                    digit - ord('a') + 10 if (digit >= ord('a') and digit <= ord('f')) else \
+                    digit - ord('0')
+                # Aggregate digit into value
+                value = (value * 16) + integer
             # Unexpected char
             else:
                 return JsonhResult.from_error("Incorrect number of hexadecimal digits in unicode escape sequence")
 
-        # Parse unicode character from hex digits
-        return JsonhResult.from_value(int(hex_chars, base=16))
+        # Return aggregated value
+        return JsonhResult.from_value(value)
 
-    def _read_escape_sequence(self) -> JsonhResult[str, str]:
+    def _read_escape_sequence(self, high_surrogate: int | None = None) -> JsonhResult[str, str]:
         escape_char: str | None = self._read()
         if escape_char == None:
             return JsonhResult.from_error("Expected escape sequence, got end of input")
 
+        # Ensure high surrogates are completed
+        if high_surrogate != None and escape_char not in ['u', 'x', 'U']:
+            return JsonhResult.from_error("Expected low surrogate after high surrogate")
+
         match escape_char:
             # Reverse solidus
             case '\\':
@@ -1490,13 +1512,13 @@ class JsonhReader:
                 return JsonhResult.from_value('\u001b')
             # Unicode hex sequence
             case 'u':
-                return self._read_hex_escape_sequence(4)
+                return self._read_hex_escape_sequence(4, high_surrogate)
             # Short unicode hex sequence
             case 'x':
-                return self._read_hex_escape_sequence(2)
+                return self._read_hex_escape_sequence(2, high_surrogate)
             # Long unicode hex sequence
             case 'U':
-                return self._read_hex_escape_sequence(8)
+                return self._read_hex_escape_sequence(8, high_surrogate)
             # Escaped newline
             case self._NEWLINE_CHARS:
                 # Join CR LF
@@ -1507,51 +1529,43 @@ class JsonhReader:
             case _:
                 return JsonhResult.from_value(escape_char)
 
-    def _read_hex_escape_sequence(self, length: int) -> JsonhResult[str, str]:
-        # This method is used to combine escaped UTF-16 surrogate pairs (e.g. "\uD83D\uDC7D" -> "👽")
-
-        # Read hex digits & convert to uint
+    def _read_hex_escape_sequence(self, length: int, high_surrogate: int | None) -> JsonhResult[str, str]:
         code_point: JsonhResult[int, str] = self._read_hex_sequence(length)
         if code_point.is_error:
             return JsonhResult.from_error(code_point.error())
 
-        # High surrogate
-        if (self._is_utf16_high_surrogate(code_point.value())):
-            original_position: int = self.index
-            # Escape sequence
-            if self._read_one('\\'):
-                next: str | None = self._read_any('u', 'x', 'U')
-                # Low surrogate escape sequence
-                if next:
-                    # Read hex sequence
-                    low_code_point: JsonhResult[int, str]
-                    match next:
-                        case 'u':
-                            low_code_point = self._read_hex_sequence(4)
-                        case 'x':
-                            low_code_point = self._read_hex_sequence(2)
-                        case 'U':
-                            low_code_point = self._read_hex_sequence(8)
-                    # Ensure hex sequence read successfully
-                    if low_code_point.is_error:
-                        return JsonhResult.from_error(low_code_point.error())
-                    # Combine high and low surrogates
-                    code_point.value_or_none = self._utf16_surrogates_to_code_point(code_point.value(), low_code_point.value())
-                # Other escape sequence
-                else:
-                    self.index = original_position
-
-        # Rune
-        return JsonhResult.from_value(chr(code_point.value()))
+        # Low surrogate
+        if high_surrogate != None:
+            combined: JsonhResult[int, str] = self._utf16_surrogates_to_code_point(high_surrogate, code_point.value())
+            if combined.is_error:
+                return JsonhResult.from_error(combined.error())
+            return JsonhResult.from_value(chr(combined.value()))
+        else:
+            # High surrogate followed by low surrogate
+            if self._is_utf16_high_surrogate(code_point.value()) and self._read_one('\\'):
+                return self._read_escape_sequence(code_point.value())
+            # Standalone character
+            else:
+                return JsonhResult.from_value(chr(code_point.value()))
 
     @staticmethod
-    def _utf16_surrogates_to_code_point(high_surrogate: int, low_surrogate: int) -> int:
-        return 0x10000 + (((high_surrogate - 0xD800) << 10) | (low_surrogate - 0xDC00))
+    def _utf16_surrogates_to_code_point(high_surrogate: int, low_surrogate: int) -> JsonhResult[int, str]:
+        if not JsonhReader._is_utf16_high_surrogate(high_surrogate):
+            return JsonhResult.from_error("High surrogate out of range")
+
+        if not JsonhReader._is_utf16_low_surrogate(low_surrogate):
+            return JsonhResult.from_error("Low surrogate out of range")
+
+        return JsonhResult.from_value(0x10000 + (((high_surrogate - 0xD800) << 10) | (low_surrogate - 0xDC00)))
 
     @staticmethod
     def _is_utf16_high_surrogate(code_point: int) -> bool:
         return code_point >= 0xD800 and code_point <= 0xDBFF
 
+    @staticmethod
+    def _is_utf16_low_surrogate(code_point: int) -> bool:
+        return code_point >= 0xDC00 and code_point <= 0xDFFF
+
     def _peek(self) -> str | None:
         if self.index >= len(self.string):
             return None

{jsonhpy-2.2 → jsonhpy-2.3}/src/JsonhPy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: JsonhPy
-Version: 2.2
+Version: 2.3
 Summary: JSON for Humans in Python.
 Author-email: Joyless <joyless.mod@gmail.com>
 License-Expression: MIT