JsonhPy 2.5__tar.gz → 2.7__tar.gz

{jsonhpy-2.5 → jsonhpy-2.7}/PKG-INFO

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

{jsonhpy-2.5 → jsonhpy-2.7}/pyproject.toml

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

{jsonhpy-2.5 → jsonhpy-2.7}/src/JsonhPy/JsonhPy.py

@@ -1,6 +1,6 @@
 import math
 from enum import Enum
-from typing import Iterator, Iterable
+from typing import Iterator, Iterable, cast
 import json
 
 class JsonhResult[T, E]:
@@ -8,28 +8,28 @@ class JsonhResult[T, E]:
     value_or_none: T | None
     error_or_none: E | None
 
-    def __init__(self, is_error: bool, value_or_none: T | None = None, error_or_none: E | None = None):
+    def __init__(self, is_error: bool, value_or_none: T | None = None, error_or_none: E | None = None) -> None:
         self.is_error = is_error
         self.value_or_none = value_or_none
         self.error_or_none = error_or_none
 
     @staticmethod
-    def from_value[T, E](value: T = None) -> "JsonhResult[T, E]":
-        return JsonhResult(False, value, None)
+    def from_value[_T, _E](value: _T = None) -> "JsonhResult[_T, _E]": # type: ignore
+        return JsonhResult[_T, _E](False, value, None)
 
     @staticmethod
-    def from_error[T, E](error: E = None) -> "JsonhResult[T, E]":
-        return JsonhResult(True, None, error)
+    def from_error[_T, _E](error: _E = None) -> "JsonhResult[_T, _E]": # type: ignore
+        return JsonhResult[_T, _E](True, None, error)
 
     def value(self) -> T:
         if self.is_error:
             raise RuntimeError(f"Result was error: {self.error_or_none}")
-        return self.value_or_none
+        return self.value_or_none # type: ignore
 
     def error(self) -> E:
         if not self.is_error:
             raise RuntimeError(f"Result was value: {self.value_or_none}")
-        return self.error_or_none
+        return self.error_or_none # type: ignore
 
     def __repr__(self) -> str:
         if self.is_error:
@@ -39,7 +39,7 @@ class JsonhResult[T, E]:
 class JsonhRef[T]:
     ref: T
 
-    def __init__(self, ref: T):
+    def __init__(self, ref: T) -> None:
         self.ref = ref
 
 class JsonhVersion(Enum):
@@ -135,10 +135,13 @@ class JsonTokenType(Enum):
     """
 
 class JsonhToken:
+    """
+    A single JSONH token.
+    """
     json_type: JsonTokenType
     value: str
 
-    def __init__(self, json_type: JsonTokenType, value: str = ""):
+    def __init__(self, json_type: JsonTokenType, value: str = "") -> None:
         self.json_type = json_type
         self.value = value
 
@@ -185,7 +188,7 @@ class JsonhNumberParser:
 
         # Apply sign
         if sign != 1:
-            number.value_or_none *= sign
+            number.value_or_none *= sign # type: ignore
         return number
 
     @staticmethod
@@ -306,7 +309,7 @@ class JsonhNumberParser:
         return JsonhResult.from_value(integer)
 
     @staticmethod
-    def _index_of_any(input: str, chars: Iterable[str]) -> float:
+    def _index_of_any(input: str, chars: Iterable[str]) -> int:
         for i in range(0, len(input)):
             char: str = input[i]
             if char in chars:
@@ -317,7 +320,7 @@ class JsonhReaderOptions:
     """
     Options for a JsonhReader.
     """
-    version: JsonhVersion.LATEST
+    version: JsonhVersion = JsonhVersion.LATEST
     """
     Specifies the major version of the JSONH specification to use.
     """
@@ -363,7 +366,7 @@ class JsonhReaderOptions:
     Only some tokens can be incomplete in this mode, so it should not be relied upon.
     """
 
-    def __init__(self, version: JsonhVersion = JsonhVersion.LATEST, parse_single_element: bool = False, max_depth: int = 64, incomplete_inputs: bool = False):
+    def __init__(self, version: JsonhVersion = JsonhVersion.LATEST, parse_single_element: bool = False, max_depth: int = 64, incomplete_inputs: bool = False) -> None:
         """
         Constructs options for a JsonhReader.
         """
@@ -385,11 +388,14 @@ class JsonhReaderOptions:
         return options_version.value >= given_version.value
 
 class JsonhReader:
+    """
+    A reader that reads JSONH tokens from a `str`.
+    """
     string: str
     """
     The string to read characters from.
     """
-    index: int
+    string_index: int
     """
     The index in the string.
     """
@@ -438,7 +444,7 @@ class JsonhReader:
         Constructs a reader that reads JSONH from a string.
         """
         self.string = string
-        self.index = 0
+        self.string_index = 0
         self.options = options
         self.char_counter = 0
         self.depth = 0
@@ -466,12 +472,12 @@ class JsonhReader:
                 return True
             # Array item
             if current_property_name == None:
-                current_array: list[object] = current_elements[-1]
+                current_array: list[object] = cast(list[object], current_elements[-1])
                 current_array.append(element)
                 return False
             # Object property
             else:
-                current_object: dict[str, object] = current_elements[-1]
+                current_object: dict[str, object] = cast(dict[str, object], current_elements[-1])
                 current_object[current_property_name] = element
                 current_property_name = None
                 return False
@@ -495,40 +501,40 @@ class JsonhReader:
                 match token_result.value().json_type:
                     # Null
                     case JsonTokenType.NULL:
-                        element: None = None
-                        if submit_element(element):
-                            return JsonhResult.from_value(element)
+                        element_null: None = None
+                        if submit_element(element_null):
+                            return JsonhResult.from_value(element_null)
                     # True
                     case JsonTokenType.TRUE:
-                        element: bool = True
-                        if submit_element(element):
-                            return JsonhResult.from_value(element)
+                        element_true: bool = True
+                        if submit_element(element_true):
+                            return JsonhResult.from_value(element_true)
                     # False
                     case JsonTokenType.FALSE:
-                        element: bool = False
-                        if submit_element(element):
-                            return JsonhResult.from_value(element)
+                        element_false: bool = False
+                        if submit_element(element_false):
+                            return JsonhResult.from_value(element_false)
                     # String
                     case JsonTokenType.STRING:
-                        element: bool = token_result.value().value
-                        if submit_element(element):
-                            return JsonhResult.from_value(element)
+                        element_string: str = token_result.value().value
+                        if submit_element(element_string):
+                            return JsonhResult.from_value(element_string)
                     # Number
                     case JsonTokenType.NUMBER:
-                        result: JsonhResult[float] = JsonhNumberParser.parse(token_result.value().value)
+                        result: JsonhResult[float, str] = JsonhNumberParser.parse(token_result.value().value)
                         if result.is_error:
                             return JsonhResult.from_error(result.error())
-                        element: float = result.value()
-                        if submit_element(element):
-                            return JsonhResult.from_value(element)
+                        element_number: float = result.value()
+                        if submit_element(element_number):
+                            return JsonhResult.from_value(element_number)
                     # Start Object
                     case JsonTokenType.START_OBJECT:
-                        element: dict[str, object] = {}
-                        start_element(element)
+                        element_object: dict[str, object] = {}
+                        start_element(element_object)
                     # Start Array
                     case JsonTokenType.START_ARRAY:
-                        element: list[object] = []
-                        start_element(element)
+                        element_array: list[object] = []
+                        start_element(element_array)
                     # End Object/Array
                     case JsonTokenType.END_OBJECT | JsonTokenType.END_ARRAY:
                         # Nested element
@@ -547,6 +553,9 @@ class JsonhReader:
                     case _:
                         return JsonhResult.from_error("Token type not implemented")
 
+            # End of input
+            return JsonhResult.from_error("Expected token, got end of input")
+
         next_element: JsonhResult[object, str] = parse_next_element()
 
         # Ensure exactly one element
@@ -571,21 +580,21 @@ class JsonhReader:
 
         def parse_next_element_as_json() -> JsonhResult[str, str]:
             current_depth: int = 0
-            isStartOfStructure: bool = True
+            is_start_of_structure: bool = True
             is_property_value: bool = False
 
             result_builder: str = ""
 
             for token_result in self.read_element():
                 # Check error
-                if (token_result.is_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):
+                    if (token.json_type not in [JsonTokenType.NONE, JsonTokenType.COMMENT]) and (current_depth > 0) and (not is_start_of_structure):
                         # Don't add trailing comma
                         if token.json_type not in [JsonTokenType.END_OBJECT, JsonTokenType.END_ARRAY]:
                             result_builder += ','
@@ -593,9 +602,9 @@ class JsonhReader:
                     # 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):
+                        if not (token.json_type in [JsonTokenType.END_OBJECT, JsonTokenType.END_ARRAY] and is_start_of_structure):
                             # Don't indent comment if not included
-                            if (not (token.json_type == JsonTokenType.COMMENT and (not include_comments))):
+                            if not (token.json_type == JsonTokenType.COMMENT and (not include_comments)):
                                 # Don't indent root elements
                                 if current_depth > 0:
                                     # Add newline before element
@@ -611,9 +620,9 @@ class JsonhReader:
                                         result_builder += indent
                 # Track start of structure to avoid adding leading comma
                 if token.json_type not in [JsonTokenType.NONE, JsonTokenType.COMMENT]:
-                    isStartOfStructure = False
+                    is_start_of_structure = False
                 if token.json_type in [JsonTokenType.START_OBJECT, JsonTokenType.START_ARRAY]:
-                    isStartOfStructure = True
+                    is_start_of_structure = True
 
                 match token.json_type:
                     # Null
@@ -638,8 +647,8 @@ class JsonhReader:
                             return JsonhResult.from_value(result_builder)
                     # Number
                     case JsonTokenType.NUMBER:
-                        result: JsonhResult[float] = JsonhNumberParser.parse(token_result.value().value)
-                        if (result.is_error):
+                        result: JsonhResult[float, str] = JsonhNumberParser.parse(token_result.value().value)
+                        if result.is_error:
                             return JsonhResult.from_error(result.error())
                         result_builder += str(result.value()).removesuffix(".0")
                         if current_depth == 0:
@@ -672,7 +681,7 @@ class JsonhReader:
                             result_builder += ' '
                     # Comment
                     case JsonTokenType.COMMENT:
-                        if (include_comments):
+                        if include_comments:
                             result_builder += "/*"
                             result_builder += token.value.replace("/*", "/ *").replace("*/", "* /")
                             result_builder += "*/"
@@ -745,7 +754,7 @@ class JsonhReader:
         # Peek char
         return self._peek() != None
 
-    def read_end_of_elements(self) -> Iterator[JsonhResult]:
+    def read_end_of_elements(self) -> Iterator[JsonhResult[JsonhToken, str]]:
         """
         Reads comments and whitespace and errors if the reader contains another element.
         """
@@ -840,6 +849,7 @@ class JsonhReader:
                     return
                 # Missing closing brace
                 yield JsonhResult.from_error("Expected `}` to end object, got end of input")
+                return
 
             # Closing brace
             if next == '}':
@@ -964,14 +974,12 @@ class JsonhReader:
         # Optional comma
         self._read_one(',')
 
-    def _read_property_name(self, string: str | None = None) -> Iterator[JsonhResult[JsonhToken, str]]:
+    def _read_property_name(self) -> Iterator[JsonhResult[JsonhToken, str]]:
         # String
-        if string == None:
-            string_token: JsonhResult[JsonhToken, str] = self._read_string()
-            if string_token.is_error:
-                yield string_token
-                return
-            string = string_token.value().value
+        string_token: JsonhResult[JsonhToken, str] = self._read_string()
+        if string_token.is_error:
+            yield string_token
+            return
         
         # Comments & whitespace
         for token in self._read_comments_and_whitespace():
@@ -986,7 +994,7 @@ class JsonhReader:
             return
 
         # End of property name
-        yield JsonhResult.from_value(JsonhToken(JsonTokenType.PROPERTY_NAME, string))
+        yield JsonhResult.from_value(JsonhToken(JsonTokenType.PROPERTY_NAME, string_token.value().value))
 
     def _read_array(self) -> Iterator[JsonhResult[JsonhToken, str]]:
         # Opening bracket
@@ -1071,7 +1079,7 @@ class JsonhReader:
             return self._read_quoteless_string("", is_verbatim)
 
         # Count multiple quotes
-        start_quote_counter = 1
+        start_quote_counter: int = 1
         while self._read_one(start_quote):
             start_quote_counter += 1
 
@@ -1086,24 +1094,24 @@ class JsonhReader:
         string_builder: str = ""
 
         while True:
-            next: str | None = self._read()
-            if next == None:
+            next2: str | None = self._read()
+            if next2 == None:
                 return JsonhResult.from_error("Expected end of string, got end of input")
 
             # Partial end quote was actually part of string
-            if next != start_quote:
+            if next2 != start_quote:
                 string_builder += start_quote * end_quote_counter
                 end_quote_counter = 0
 
             # End quote
-            if next == start_quote:
+            if next2 == start_quote:
                 end_quote_counter += 1
                 if end_quote_counter == start_quote_counter:
                     break
             # Escape sequence
-            elif next == '\\':
+            elif next2 == '\\':
                 if is_verbatim:
-                    string_builder += next
+                    string_builder += next2
                 else:
                     escape_sequence_result: JsonhResult[str, str] = self._read_escape_sequence()
                     if escape_sequence_result.is_error:
@@ -1111,7 +1119,7 @@ class JsonhReader:
                     string_builder += escape_sequence_result.value()
             # Literal character
             else:
-                string_builder += next
+                string_builder += next2
 
         # Condition: skip remaining steps unless started with multiple quotes
         if start_quote_counter > 1:
@@ -1120,19 +1128,19 @@ class JsonhReader:
             leading_whitespace_newline_counter: int = 0
             index: int = 0
             while index < len(string_builder):
-                next: str = string_builder[index]
+                next3: str = string_builder[index]
 
                 # Newline
-                if next in self._NEWLINE_CHARS:
+                if next3 in self._NEWLINE_CHARS:
                     # Join CR LF
-                    if next == '\r' and index + 1 < len(string_builder) and string_builder[index + 1] == '\n':
+                    if next3 == '\r' and index + 1 < len(string_builder) and string_builder[index + 1] == '\n':
                         index += 1
                     
                     has_leading_whitespace_newline = True
                     leading_whitespace_newline_counter = index + 1
                     break
                 # Non-whitespace
-                elif next not in self._WHITESPACE_CHARS:
+                elif next3 not in self._WHITESPACE_CHARS:
                     break
 
                 index += 1
@@ -1145,19 +1153,19 @@ class JsonhReader:
                 trailing_whitespace_counter: int = 0
                 index: int = 0
                 while index < len(string_builder):
-                    next: str = string_builder[index]
+                    next4: str = string_builder[index]
 
                     # Newline
-                    if next in self._NEWLINE_CHARS:
+                    if next4 in self._NEWLINE_CHARS:
                         has_trailing_newline_whitespace = True
                         last_newline_index = index
                         trailing_whitespace_counter = 0
 
                         # Join CR LF
-                        if next == '\r' and index + 1 < len(string_builder) and string_builder[index + 1] == '\n':
+                        if next4 == '\r' and index + 1 < len(string_builder) and string_builder[index + 1] == '\n':
                             index += 1
                     # Whitespace
-                    elif next in self._WHITESPACE_CHARS:
+                    elif next4 in self._WHITESPACE_CHARS:
                         trailing_whitespace_counter += 1
                     # Non-whitespace
                     else:
@@ -1181,14 +1189,14 @@ class JsonhReader:
                         line_leading_whitespace_counter: int = 0
                         index: int = 0
                         while index < len(string_builder):
-                            next: str = string_builder[index]
+                            next5: str = string_builder[index]
 
                             # Newline
-                            if next in self._NEWLINE_CHARS:
+                            if next5 in self._NEWLINE_CHARS:
                                 is_line_leading_whitespace = True
                                 line_leading_whitespace_counter = 0
                             # Whitespace
-                            elif next in self._WHITESPACE_CHARS:
+                            elif next5 in self._WHITESPACE_CHARS:
                                 if is_line_leading_whitespace:
                                     # Increment line-leading whitespace
                                     line_leading_whitespace_counter += 1
@@ -1232,7 +1240,7 @@ class JsonhReader:
                 if is_verbatim:
                     string_builder += next
                 else:
-                    escape_sequence_result: JsonhResult[str] = self._read_escape_sequence()
+                    escape_sequence_result: JsonhResult[str, str] = self._read_escape_sequence()
                     if escape_sequence_result.is_error:
                         return JsonhResult.from_error(escape_sequence_result.error())
                     string_builder += escape_sequence_result.value()
@@ -1338,9 +1346,9 @@ class JsonhReader:
                         has_leading_zero = False
 
         # Read main number
-        main_result: JsonhResult[None, None] = self._read_number_no_exponent(number_builder, base_digits, has_base_specifier, has_leading_zero)
+        main_result: JsonhResult[None, str] = self._read_number_no_exponent(number_builder, base_digits, has_base_specifier, has_leading_zero)
         if main_result.is_error:
-            number: JsonhResult[None, str] = JsonhResult.from_error(main_result.error())
+            number: JsonhResult[JsonhToken, str] = JsonhResult.from_error(main_result.error())
             partial_chars_read: str = number_builder.ref
             return number, partial_chars_read
 
@@ -1353,16 +1361,16 @@ class JsonhReader:
 
                 # Missing digit between base specifier and exponent (e.g. `0xe+`)
                 if has_base_specifier and len(number_builder.ref) == 4:
-                    number: JsonhResult[None, str] = JsonhResult.from_error("Missing digit between base specifier and exponent")
+                    number2: JsonhResult[JsonhToken, str] = JsonhResult.from_error("Missing digit between base specifier and exponent")
                     partial_chars_read: str = number_builder.ref
-                    return number, partial_chars_read
+                    return number2, partial_chars_read
 
                 # Read exponent number
-                exponent_result: JsonhResult[None, None] = self._read_number_no_exponent(number_builder, base_digits)
+                exponent_result: JsonhResult[None, str] = self._read_number_no_exponent(number_builder, base_digits)
                 if exponent_result.is_error:
-                    number: JsonhResult[None, str] = JsonhResult.from_error(exponent_result.error())
+                    number3: JsonhResult[JsonhToken, str] = JsonhResult.from_error(exponent_result.error())
                     partial_chars_read: str = number_builder.ref
-                    return number, partial_chars_read
+                    return number3, partial_chars_read
         # Exponent
         else:
             exponent_char: str | None = self._read_any('e', 'E')
@@ -1375,20 +1383,20 @@ class JsonhReader:
                     number_builder.ref += exponent_sign
 
                 # Read exponent number
-                exponent_result: JsonhResult[None, None] = self._read_number_no_exponent(number_builder, base_digits)
-                if exponent_result.is_error:
-                    number: JsonhResult[None, str] = JsonhResult.from_error(exponent_result.error())
+                exponent_result2: JsonhResult[None, str] = self._read_number_no_exponent(number_builder, base_digits)
+                if exponent_result2.is_error:
+                    number4: JsonhResult[JsonhToken, str] = JsonhResult.from_error(exponent_result2.error())
                     partial_chars_read: str = number_builder.ref
-                    return number, partial_chars_read
+                    return number4, partial_chars_read
 
         # End of number
-        number: JsonhResult[JsonhToken, str] = JsonhResult.from_value(JsonhToken(JsonTokenType.NUMBER, number_builder.ref))
+        number5: JsonhResult[JsonhToken, str] = JsonhResult.from_value(JsonhToken(JsonTokenType.NUMBER, number_builder.ref))
         partial_chars_read: str = ""
-        return number, partial_chars_read
+        return number5, partial_chars_read
 
-    def _read_number_no_exponent(self, number_builder: JsonhRef[str], base_digits: str, has_base_specifier: bool = False, has_leading_zero: bool = False) -> JsonhResult[None, None]:
+    def _read_number_no_exponent(self, number_builder: JsonhRef[str], base_digits: str, has_base_specifier: bool = False, has_leading_zero: bool = False) -> JsonhResult[None, str]:
         # Leading underscore
-        if (not has_base_specifier) and not (has_leading_zero) and self._peek() == '_':
+        if (not has_base_specifier) and (not has_leading_zero) and self._peek() == '_':
             return JsonhResult.from_error("Leading `_` in number")
 
         is_fraction: bool = False
@@ -1660,7 +1668,7 @@ class JsonhReader:
             case 'U':
                 return self._read_hex_escape_sequence(8, high_surrogate)
             # Escaped newline
-            case self._NEWLINE_CHARS:
+            case _ if escape_char in self._NEWLINE_CHARS:
                 # Join CR LF
                 if escape_char == 'r':
                     self._read_one('\n')
@@ -1707,16 +1715,16 @@ class JsonhReader:
         return code_point >= 0xDC00 and code_point <= 0xDFFF
 
     def _peek(self) -> str | None:
-        if self.index >= len(self.string):
+        if self.string_index >= len(self.string):
             return None
-        next: str = self.string[self.index]
+        next: str = self.string[self.string_index]
         return next
 
     def _read(self) -> str | None:
-        if self.index >= len(self.string):
+        if self.string_index >= len(self.string):
             return None
-        next: str = self.string[self.index]
-        self.index += 1
+        next: str = self.string[self.string_index]
+        self.string_index += 1
         self.char_counter += 1
         return next
 

{jsonhpy-2.5 → jsonhpy-2.7}/src/JsonhPy.egg-info/PKG-INFO

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