JsonhPy 2.2__tar.gz → 2.4__tar.gz

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

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

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

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

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

@@ -1,5 +1,7 @@
+import math
 from enum import Enum
 from typing import Iterator, Iterable
+import json
 
 class JsonhResult[T, E]:
     is_error: bool
@@ -223,7 +225,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 +248,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 +287,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 +297,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:
@@ -549,6 +558,132 @@ class JsonhReader:
 
         return next_element
 
+    def parse_json(self, include_comments: bool = False, indent: str | None = None) -> JsonhResult[str, str]:
+        """
+        Parses a single element as JSON from the reader.
+
+        If `include_comments` is true, comments are included (`/*` and `*/` are escaped as `/ *` and `* /`).
+
+        If `indent` is not null, the output is pretty-printed with the given indentation.
+
+        The result is not safe to embed in HTML.
+        """
+
+        current_depth: int = 0
+        isStartOfStructure: bool = True
+        is_property_value: bool = False
+
+        resultBuilder: str = ""
+
+        for token_result in self.read_element():
+            # Check error
+            if (token_result.is_error):
+                return JsonhResult.from_error(token_result.error())
+            token: JsonhToken = token_result.value()
+
+            # Add comments and indents
+            if not is_property_value:
+                # Add comma before property/item
+                if (token.json_type not in [JsonTokenType.NONE, JsonTokenType.COMMENT]) and (current_depth > 0) and (not isStartOfStructure):
+                    # Don't add trailing comma
+                    if token.json_type not in [JsonTokenType.END_OBJECT, JsonTokenType.END_ARRAY]:
+                        resultBuilder += ','
+
+                # Apply indentation
+                if indent != None:
+                    # Don't indent inside empty structures
+                    if not (token.json_type in [JsonTokenType.END_OBJECT, JsonTokenType.END_ARRAY] and isStartOfStructure):
+                        # Don't indent comment if not included
+                        if (not (token.json_type == JsonTokenType.COMMENT and (not include_comments))):
+                            # Don't indent root elements
+                            if current_depth > 0:
+                                # Add newline before element
+                                resultBuilder += '\n'
+
+                                # Get current indent count
+                                indent_count: int = current_depth
+                                if token.json_type in [JsonTokenType.END_OBJECT, JsonTokenType.END_ARRAY]:
+                                    indent_count -= 1
+
+                                # Add indent
+                                for _ in range(0, indent_count):
+                                    resultBuilder += indent
+            # Track start of structure to avoid adding leading comma
+            if token.json_type not in [JsonTokenType.NONE, JsonTokenType.COMMENT]:
+                isStartOfStructure = False
+            if token.json_type in [JsonTokenType.START_OBJECT, JsonTokenType.START_ARRAY]:
+                isStartOfStructure = True
+
+            match token.json_type:
+                # Null
+                case JsonTokenType.NONE:
+                    resultBuilder += "null"
+                    if current_depth == 0:
+                        return JsonhResult.from_value(resultBuilder)
+                # True
+                case JsonTokenType.TRUE:
+                    resultBuilder += "true"
+                    if current_depth == 0:
+                        return JsonhResult.from_value(resultBuilder)
+                # False
+                case JsonTokenType.FALSE:
+                    resultBuilder += "false"
+                    if current_depth == 0:
+                        return JsonhResult.from_value(resultBuilder)
+                # String
+                case JsonTokenType.STRING:
+                    resultBuilder += json.dumps(token.value, ensure_ascii=False)
+                    if current_depth == 0:
+                        return JsonhResult.from_value(resultBuilder)
+                # Number
+                case JsonTokenType.NUMBER:
+                    result: JsonhResult[float] = JsonhNumberParser.parse(token_result.value().value)
+                    if (result.is_error):
+                        return JsonhResult.from_error(result.error())
+                    resultBuilder += str(result.value())
+                    if current_depth == 0:
+                        return JsonhResult.from_value(resultBuilder)
+                # Start Object
+                case JsonTokenType.START_OBJECT:
+                    resultBuilder += '{'
+                    current_depth += 1
+                # Start Array
+                case JsonTokenType.START_ARRAY:
+                    resultBuilder += '['
+                    current_depth += 1
+                # End Object
+                case JsonTokenType.END_OBJECT:
+                    resultBuilder += '}'
+                    current_depth -= 1
+                    if current_depth == 0:
+                        return JsonhResult.from_value(resultBuilder)
+                # End Array
+                case JsonTokenType.END_ARRAY:
+                    resultBuilder += ']'
+                    current_depth -= 1
+                    if current_depth == 0:
+                        return JsonhResult.from_value(resultBuilder)
+                # Property Name
+                case JsonTokenType.PROPERTY_NAME:
+                    resultBuilder += json.dumps(token.value, ensure_ascii=False)
+                    resultBuilder += ':'
+                    if indent != None:
+                        resultBuilder += ' '
+                # Comment
+                case JsonTokenType.COMMENT:
+                    if (include_comments):
+                        resultBuilder += "/*"
+                        resultBuilder += token.value.replace("/*", "/ *").replace("*/", "* /")
+                        resultBuilder += "*/"
+                # Not implemented
+                case _:
+                    return JsonhResult.from_error("Token type not implemented")
+
+            is_property_value = token.json_type == JsonTokenType.PROPERTY_NAME
+
+        # End of input
+        return JsonhResult.from_error("Expected token, got end of input")
+
     def find_property_value(self, property_name: str) -> bool:
         """
         Tries to find the given property name in the reader.
@@ -1263,7 +1398,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 +1572,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 +1639,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 +1656,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.4}/src/JsonhPy.egg-info/PKG-INFO

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