partialjson 1.0.0__tar.gz → 1.1.0__tar.gz

{partialjson-1.0.0 → partialjson-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: partialjson
-Version: 1.0.0
+Version: 1.1.0
 Summary: Parse incomplete or partial json
 Home-page: https://github.com/iw4p/partialjson
 Author: Nima Akbarzadeh
@@ -8,6 +8,8 @@ Author-email: iw4p@protonmail.com
 License: MIT
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Provides-Extra: json5
+Requires-Dist: json5; extra == "json5"
 Dynamic: author
 Dynamic: author-email
 Dynamic: description
@@ -15,6 +17,7 @@ Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: license
 Dynamic: license-file
+Dynamic: provides-extra
 Dynamic: summary
 
 # PartialJson
@@ -34,18 +37,18 @@ Dynamic: summary
 ## Example
 
 ```python
-from partialjson.json_parser import JSONParser
+from partialjson import JSONParser
 parser = JSONParser()
 
 incomplete_json = '{"name": "John Doe", "age": 30, "is_student": false, "courses": ["Math", "Science"'
 print(parser.parse(incomplete_json))
-# {'name': 'John', 'age': 30, 'is_student': False, 'courses': ['Math', 'Science']}
+# {'name': 'John Doe', 'age': 30, 'is_student': False, 'courses': ['Math', 'Science']}
 ```
 
-Problem with `\n`? strict mode is here
+Problem with `\n`? Use `strict=False`:
 
 ```python
-from partialjson.json_parser import JSONParser
+from partialjson import JSONParser
 parser = JSONParser(strict=False)
 
 incomplete_json = '{"name": "John\nDoe", "age": 30, "is_student": false, "courses": ["Math", "Science"'
@@ -53,6 +56,21 @@ print(parser.parse(incomplete_json))
 # {'name': 'John\nDoe', 'age': 30, 'is_student': False, 'courses': ['Math', 'Science']}
 ```
 
+### JSON5 support
+
+Use `create_json5_parser` or `JSONParser(json5_enabled=True)` for JSON5 (comments, unquoted keys, single quotes, etc.):
+
+```python
+from partialjson import create_json5_parser
+parser = create_json5_parser()
+
+incomplete_json5 = '{name: "Demo", version: 1.0, items: [1, 2, 3,]'
+print(parser.parse(incomplete_json5))
+# {'name': 'Demo', 'version': 1.0, 'items': [1, 2, 3]}
+```
+
+Install the optional `json5` dependency for full JSON5 support: `pip install partialjson[json5]`
+
 ### Installation
 
 ```sh

{partialjson-1.0.0 → partialjson-1.1.0}/README.md

@@ -15,18 +15,18 @@
 ## Example
 
 ```python
-from partialjson.json_parser import JSONParser
+from partialjson import JSONParser
 parser = JSONParser()
 
 incomplete_json = '{"name": "John Doe", "age": 30, "is_student": false, "courses": ["Math", "Science"'
 print(parser.parse(incomplete_json))
-# {'name': 'John', 'age': 30, 'is_student': False, 'courses': ['Math', 'Science']}
+# {'name': 'John Doe', 'age': 30, 'is_student': False, 'courses': ['Math', 'Science']}
 ```
 
-Problem with `\n`? strict mode is here
+Problem with `\n`? Use `strict=False`:
 
 ```python
-from partialjson.json_parser import JSONParser
+from partialjson import JSONParser
 parser = JSONParser(strict=False)
 
 incomplete_json = '{"name": "John\nDoe", "age": 30, "is_student": false, "courses": ["Math", "Science"'
@@ -34,6 +34,21 @@ print(parser.parse(incomplete_json))
 # {'name': 'John\nDoe', 'age': 30, 'is_student': False, 'courses': ['Math', 'Science']}
 ```
 
+### JSON5 support
+
+Use `create_json5_parser` or `JSONParser(json5_enabled=True)` for JSON5 (comments, unquoted keys, single quotes, etc.):
+
+```python
+from partialjson import create_json5_parser
+parser = create_json5_parser()
+
+incomplete_json5 = '{name: "Demo", version: 1.0, items: [1, 2, 3,]'
+print(parser.parse(incomplete_json5))
+# {'name': 'Demo', 'version': 1.0, 'items': [1, 2, 3]}
+```
+
+Install the optional `json5` dependency for full JSON5 support: `pip install partialjson[json5]`
+
 ### Installation
 
 ```sh

{partialjson-1.0.0 → partialjson-1.1.0}/partialjson/__init__.py

@@ -4,9 +4,10 @@ Partial Json.
 Parsing ChatGPT JSON stream response — Partial and incomplete JSON parser python library for OpenAI
 """
 
-from .json_parser import JSONParser
+from .json_parser import JSONParser, create_json_parser
+from .json5_parser import create_json5_parser
 
-__version__ = "1.0.0"
+__version__ = "1.1.0"
 __author__ = "Nima Akbarzadeh"
 __author_email__ = "iw4p@protonmail.com"
 __license__ = "MIT"
@@ -16,5 +17,7 @@ PYPI_SIMPLE_ENDPOINT: str = "https://pypi.org/project/partialjson"
 
 __all__ = [
     "JSONParser",
+    "create_json_parser",
+    "create_json5_parser",
     "PYPI_SIMPLE_ENDPOINT",
 ]

partialjson-1.1.0/partialjson/json5_parser.py

@@ -0,0 +1,346 @@
+"""JSON5 parser - extends JSON with comments, unquoted keys, single quotes, etc."""
+import json
+import re
+
+try:
+    import json5
+except ImportError:
+    json5 = None
+
+
+def create_json5_parser(strict=True, on_extra_token=None):
+    """Create a JSON5 parser."""
+    return _JSON5Parser(strict=strict, on_extra_token=on_extra_token)
+
+
+def _default_on_extra_token(text, data, reminding):
+    print("Parsed JSON with extra tokens:", {"text": text, "data": data, "reminding": reminding})
+
+
+_INCOMPLETE_ESCAPE_REGEX = re.compile(r"^\\(?:u[0-9a-fA-F]{0,3}|x[0-9a-fA-F]{0,1})?$")
+_JSON5_WHITESPACE = "\v\f\u00A0\u2028\u2029\uFEFF"
+
+
+class _JSON5Parser:
+    """JSON5 parser with comments, unquoted keys, single quotes, hex, Infinity, etc."""
+
+    def __init__(self, strict=True, on_extra_token=None):
+        self.strict = strict
+        self.on_extra_token = on_extra_token or _default_on_extra_token
+        self.last_parse_reminding = None
+        self._parsers = self._build_parsers()
+
+    def _build_parsers(self):
+        parsers = {
+            " ": self._parse_space,
+            "\r": self._parse_space,
+            "\n": self._parse_space,
+            "\t": self._parse_space,
+            "[": self._parse_array,
+            "{": self._parse_object,
+            '"': self._parse_string,
+            "'": self._parse_string,
+            "t": self._parse_true,
+            "f": self._parse_false,
+            "n": self._parse_null,
+            "/": self._parse_space,
+            "+": self._parse_number,
+            "I": self._parse_number,
+            "N": self._parse_n_literal,
+            "T": self._parse_true,
+            "F": self._parse_false,
+        }
+        for c in _JSON5_WHITESPACE:
+            parsers[c] = self._parse_space
+        for c in "0123456789.-":
+            parsers[c] = self._parse_number
+        return parsers
+
+    def parse(self, s):
+        if len(s) >= 1:
+            if json5:
+                try:
+                    return json5.loads(s)
+                except (json.JSONDecodeError, ValueError) as e:
+                    data, reminding = self.parse_any(s, e)
+                    self.last_parse_reminding = reminding
+                    if self.on_extra_token and reminding:
+                        self.on_extra_token(s, data, reminding)
+                    return data
+            data, reminding = self.parse_any(s, json.JSONDecodeError("", "", 0))
+            self.last_parse_reminding = reminding
+            if self.on_extra_token and reminding:
+                self.on_extra_token(s, data, reminding)
+            return data
+        return json.loads("{}")
+
+    def parse_any(self, s, e):
+        if not s:
+            raise e
+        while s and self._is_space_or_comment_start(s):
+            s = self._parse_space(s, e)
+        if not s:
+            return None, ""
+        parser = self._parsers.get(s[0])
+        if not parser:
+            raise e
+        return parser(s, e)
+
+    def _is_space_or_comment_start(self, s):
+        if not s:
+            return False
+        c = s[0]
+        if c.isspace() or c in _JSON5_WHITESPACE:
+            return True
+        if s.startswith("//") or s.startswith("/*"):
+            return True
+        return False
+
+    def _parse_space(self, s, e):
+        i = 0
+        while i < len(s):
+            if s[i].isspace() or s[i] in _JSON5_WHITESPACE:
+                i += 1
+            elif s[i : i + 2] == "//":
+                i += 2
+                while i < len(s) and s[i] not in "\n\r\u2028\u2029":
+                    i += 1
+            elif s[i : i + 2] == "/*":
+                i += 2
+                end = s.find("*/", i)
+                if end == -1:
+                    return ""
+                i = end + 2
+            else:
+                break
+        return s[i:]
+
+    def _parse_array(self, s, e):
+        s = s[1:]
+        acc = []
+        while True:
+            while s and self._is_space_or_comment_start(s):
+                s = self._parse_space(s, e)
+            if not s:
+                break
+            if s[0] == "]":
+                s = s[1:]
+                break
+            res, s = self.parse_any(s, e)
+            acc.append(res)
+            while s and self._is_space_or_comment_start(s):
+                s = self._parse_space(s, e)
+            if s and s.startswith(","):
+                s = s[1:]
+        return acc, s
+
+    def _parse_object(self, s, e):
+        s = s[1:]
+        acc = {}
+        while True:
+            while s and self._is_space_or_comment_start(s):
+                s = self._parse_space(s, e)
+            if not s:
+                break
+            if s[0] == "}":
+                s = s[1:]
+                break
+            if s[0] not in '"\'':
+                key, s = self._parse_identifier(s, e)
+                if not key:
+                    while s and self._is_space_or_comment_start(s):
+                        s = self._parse_space(s, e)
+                    if s and s[0] == "}":
+                        s = s[1:]
+                    break
+            else:
+                key, s = self.parse_any(s, e)
+            while s and self._is_space_or_comment_start(s):
+                s = self._parse_space(s, e)
+            if not s or s[0] == "}":
+                if key is not None:
+                    acc[key] = None
+                if s and s[0] == "}":
+                    s = s[1:]
+                break
+            if s[0] != ":":
+                if key is not None:
+                    acc[key] = None
+                break
+            s = s[1:]
+            while s and self._is_space_or_comment_start(s):
+                s = self._parse_space(s, e)
+            if not s or s[0] in ",}":
+                acc[key] = None
+                if s and s.startswith(","):
+                    s = s[1:]
+                elif s and s.startswith("}"):
+                    s = s[1:]
+                break
+            while s and self._is_space_or_comment_start(s):
+                s = self._parse_space(s, e)
+            if s and (
+                s[0] in self._parsers
+                or s[0] in "/+IN"
+                or s[0] in _JSON5_WHITESPACE
+            ):
+                value, s = self.parse_any(s, e)
+                acc[key] = value
+            else:
+                if key is not None:
+                    acc[key] = None
+                break
+            while s and self._is_space_or_comment_start(s):
+                s = self._parse_space(s, e)
+            if s and s.startswith(","):
+                s = s[1:]
+        return acc, s
+
+    def _parse_identifier(self, s, e):
+        i = 0
+        while i < len(s) and (s[i].isalnum() or s[i] in "_$"):
+            i += 1
+        return s[:i], s[i:]
+
+    def _parse_string(self, s, e):
+        quote = s[0]
+        end = 1
+        while end < len(s):
+            if s[end] == "\\":
+                end += 2
+                continue
+            if s[end] == quote:
+                break
+            end += 1
+
+        if end >= len(s):
+            content = s[1:]
+            if not self.strict:
+                return content, ""
+            if _INCOMPLETE_ESCAPE_REGEX.match(content):
+                return "", ""
+            try:
+                if quote == "'":
+                    return content, ""
+                return json.loads(f'"{content}"'), ""
+            except json.JSONDecodeError:
+                return "", ""
+
+        str_val = s[: end + 1]
+        remainder = s[end + 1 :]
+
+        if json5:
+            try:
+                return json5.loads(str_val), remainder
+            except Exception:
+                pass
+
+        decoded = str_val[1:-1]
+        decoded = re.sub(r"\\\n", "", decoded)
+        decoded = re.sub(r"\\\r\n", "", decoded)
+
+        def replace_hex(match):
+            return chr(int(match.group(1), 16))
+
+        decoded = re.sub(r"\\x([0-9a-fA-F]{2})", replace_hex, decoded)
+
+        if quote == "'":
+            decoded = decoded.replace('"', '\\"').replace("\\'", "'")
+            try:
+                return json.loads(f'"{decoded}"'), remainder
+            except Exception:
+                return decoded, remainder
+        if "\\x" in decoded or "\\\n" in str_val or "\\\r" in str_val:
+            return decoded, remainder
+        try:
+            return json.loads(str_val), remainder
+        except Exception:
+            return decoded, remainder
+
+    def _parse_number(self, s, e):
+        if s.startswith(("-0x", "-0X")):
+            i = 3
+            while i < len(s) and s[i] in "0123456789abcdefABCDEF":
+                i += 1
+            num_str = s[1:i]
+            remainder = s[i:]
+            if len(num_str) <= 2:
+                return s[:3], ""
+            return -int(num_str, 16), remainder
+        if s.startswith(("+0x", "+0X")):
+            i = 3
+            while i < len(s) and s[i] in "0123456789abcdefABCDEF":
+                i += 1
+            num_str = s[1:i]
+            remainder = s[i:]
+            if len(num_str) <= 2:
+                return s[:3], ""
+            return int(num_str, 16), remainder
+        if s.startswith(("0x", "0X")):
+            i = 2
+            while i < len(s) and s[i] in "0123456789abcdefABCDEF":
+                i += 1
+            num_str = s[:i]
+            remainder = s[i:]
+            if len(num_str) <= 2:
+                return num_str, ""
+            return int(num_str, 16), remainder
+
+        for literal, val in [("Infinity", float("inf")), ("NaN", float("nan"))]:
+            if s.startswith(literal):
+                return val, s[len(literal) :]
+            if s.startswith("+" + literal):
+                return val, s[len(literal) + 1 :]
+            if s.startswith("-" + literal):
+                return -val if literal == "Infinity" else val, s[len(literal) + 1 :]
+
+        if s.startswith(".") and len(s) > 1 and s[1].isdigit():
+            i = 1
+            while i < len(s) and s[i].isdigit():
+                i += 1
+            num_str = s[:i]
+            return float(num_str), s[i:]
+
+        if s.startswith("+"):
+            res, remainder = self._parse_number(s[1:], e)
+            return res, remainder
+
+        i = 0
+        while i < len(s) and s[i] in "0123456789.-":
+            i += 1
+        num_str = s[:i]
+        s = s[i:]
+        if not num_str or num_str == "-" or num_str == ".":
+            return num_str, ""
+        try:
+            if num_str.endswith("."):
+                num = int(num_str[:-1])
+            else:
+                num = (
+                    float(num_str)
+                    if "." in num_str or "e" in num_str or "E" in num_str
+                    else int(num_str)
+                )
+        except ValueError:
+            raise e
+        return num, s
+
+    def _parse_n_literal(self, s, e):
+        if s.lower().startswith("nan"):
+            return self._parse_number(s, e)
+        return self._parse_null(s, e)
+
+    def _parse_true(self, s, e):
+        if s.lower().startswith("true"):
+            return True, s[4:]
+        raise e
+
+    def _parse_false(self, s, e):
+        if s.lower().startswith("false"):
+            return False, s[5:]
+        raise e
+
+    def _parse_null(self, s, e):
+        if s.lower().startswith("null"):
+            return None, s[4:]
+        raise e

partialjson-1.1.0/partialjson/json_parser.py

@@ -0,0 +1,233 @@
+"""Pure JSON parser - no JSON5 extensions."""
+import json
+import re
+
+
+def create_json_parser(strict=True, on_extra_token=None):
+    """Create a JSON parser (no JSON5 extensions)."""
+    return _JSONParser(strict=strict, on_extra_token=on_extra_token)
+
+
+def _default_on_extra_token(text, data, reminding):
+    print("Parsed JSON with extra tokens:", {"text": text, "data": data, "reminding": reminding})
+
+
+_INCOMPLETE_ESCAPE_REGEX = re.compile(r"^\\(?:u[0-9a-fA-F]{0,3}|x[0-9a-fA-F]{0,1})?$")
+
+
+class _JSONParser:
+    """Internal JSON-only parser implementation."""
+
+    def __init__(self, strict=True, on_extra_token=None):
+        self.strict = strict
+        self.on_extra_token = on_extra_token or _default_on_extra_token
+        self.last_parse_reminding = None
+        self._parsers = self._build_parsers()
+
+    def _build_parsers(self):
+        parsers = {
+            " ": self._parse_space,
+            "\r": self._parse_space,
+            "\n": self._parse_space,
+            "\t": self._parse_space,
+            "[": self._parse_array,
+            "{": self._parse_object,
+            '"': self._parse_string,
+            "t": self._parse_true,
+            "f": self._parse_false,
+            "n": self._parse_null,
+        }
+        for c in "0123456789.-":
+            parsers[c] = self._parse_number
+        return parsers
+
+    def parse(self, s):
+        if len(s) >= 1:
+            try:
+                return json.loads(s)
+            except (json.JSONDecodeError, ValueError) as e:
+                data, reminding = self.parse_any(s, e)
+                self.last_parse_reminding = reminding
+                if self.on_extra_token and reminding:
+                    self.on_extra_token(s, data, reminding)
+                return data
+        return json.loads("{}")
+
+    def parse_any(self, s, e):
+        if not s:
+            raise e
+        while s and s[0].isspace():
+            s = self._parse_space(s, e)
+        if not s:
+            return None, ""
+        parser = self._parsers.get(s[0])
+        if not parser:
+            raise e
+        return parser(s, e)
+
+    def _parse_space(self, s, e):
+        i = 0
+        while i < len(s) and s[i].isspace():
+            i += 1
+        return s[i:]
+
+    def _parse_array(self, s, e):
+        s = s[1:]
+        acc = []
+        while True:
+            while s and s[0].isspace():
+                s = self._parse_space(s, e)
+            if not s:
+                break
+            if s[0] == "]":
+                s = s[1:]
+                break
+            res, s = self.parse_any(s, e)
+            acc.append(res)
+            while s and s[0].isspace():
+                s = self._parse_space(s, e)
+            if s and s.startswith(","):
+                s = s[1:]
+        return acc, s
+
+    def _parse_object(self, s, e):
+        s = s[1:]
+        acc = {}
+        while True:
+            while s and s[0].isspace():
+                s = self._parse_space(s, e)
+            if not s:
+                break
+            if s[0] == "}":
+                s = s[1:]
+                break
+            key, s = self.parse_any(s, e)
+            while s and s[0].isspace():
+                s = self._parse_space(s, e)
+            if not s or s[0] == "}":
+                if key is not None:
+                    acc[key] = None
+                if s and s[0] == "}":
+                    s = s[1:]
+                break
+            if s[0] != ":":
+                if key is not None:
+                    acc[key] = None
+                break
+            s = s[1:]
+            while s and s[0].isspace():
+                s = self._parse_space(s, e)
+            if not s or s[0] in ",}":
+                acc[key] = None
+                if s and s.startswith(","):
+                    s = s[1:]
+                elif s and s.startswith("}"):
+                    s = s[1:]
+                break
+            if s and s[0] in self._parsers:
+                value, s = self.parse_any(s, e)
+                acc[key] = value
+            else:
+                if key is not None:
+                    acc[key] = None
+                break
+            while s and s[0].isspace():
+                s = self._parse_space(s, e)
+            if s and s.startswith(","):
+                s = s[1:]
+        return acc, s
+
+    def _parse_string(self, s, e):
+        quote = s[0]
+        end = 1
+        while end < len(s):
+            if s[end] == "\\":
+                end += 2
+                continue
+            if s[end] == quote:
+                break
+            end += 1
+
+        if end >= len(s):
+            content = s[1:]
+            if not self.strict:
+                return content, ""
+            if _INCOMPLETE_ESCAPE_REGEX.match(content):
+                return "", ""
+            try:
+                return json.loads(f'"{content}"'), ""
+            except json.JSONDecodeError:
+                return "", ""
+
+        str_val = s[: end + 1]
+        remainder = s[end + 1 :]
+        if not self.strict:
+            return str_val[1:-1], remainder
+        return json.loads(str_val), remainder
+
+    def _parse_number(self, s, e):
+        i = 0
+        while i < len(s) and s[i] in "0123456789.-":
+            i += 1
+        num_str = s[:i]
+        s = s[i:]
+        if not num_str or num_str == "-" or num_str == ".":
+            return num_str, ""
+        try:
+            if num_str.endswith("."):
+                num = int(num_str[:-1])
+            else:
+                num = (
+                    float(num_str)
+                    if "." in num_str or "e" in num_str or "E" in num_str
+                    else int(num_str)
+                )
+        except ValueError:
+            raise e
+        return num, s
+
+    def _parse_true(self, s, e):
+        if s.startswith("t") or s.startswith("T"):
+            return True, s[4:]
+        raise e
+
+    def _parse_false(self, s, e):
+        if s.startswith("f") or s.startswith("F"):
+            return False, s[5:]
+        raise e
+
+    def _parse_null(self, s, e):
+        if s.startswith("n"):
+            return None, s[4:]
+        raise e
+
+
+# Backward compatibility
+class JSONParser:
+    """JSON parser. Use create_json_parser() or create_json5_parser() for new code."""
+
+    def __init__(self, strict=True, json5_enabled=False, on_extra_token=None):
+        if json5_enabled:
+            from .json5_parser import create_json5_parser
+
+            self._impl = create_json5_parser(strict=strict, on_extra_token=on_extra_token)
+        else:
+            self._impl = create_json_parser(strict=strict, on_extra_token=on_extra_token)
+
+    def parse(self, s):
+        return self._impl.parse(s)
+
+    def parse_any(self, s, e):
+        return self._impl.parse_any(s, e)
+
+    @property
+    def last_parse_reminding(self):
+        return getattr(self._impl, "last_parse_reminding", None)
+
+    @property
+    def on_extra_token(self):
+        return getattr(self._impl, "on_extra_token", None)
+
+    @on_extra_token.setter
+    def on_extra_token(self, value):
+        self._impl.on_extra_token = value

{partialjson-1.0.0 → partialjson-1.1.0}/partialjson.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: partialjson
-Version: 1.0.0
+Version: 1.1.0
 Summary: Parse incomplete or partial json
 Home-page: https://github.com/iw4p/partialjson
 Author: Nima Akbarzadeh
@@ -8,6 +8,8 @@ Author-email: iw4p@protonmail.com
 License: MIT
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Provides-Extra: json5
+Requires-Dist: json5; extra == "json5"
 Dynamic: author
 Dynamic: author-email
 Dynamic: description
@@ -15,6 +17,7 @@ Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: license
 Dynamic: license-file
+Dynamic: provides-extra
 Dynamic: summary
 
 # PartialJson
@@ -34,18 +37,18 @@ Dynamic: summary
 ## Example
 
 ```python
-from partialjson.json_parser import JSONParser
+from partialjson import JSONParser
 parser = JSONParser()
 
 incomplete_json = '{"name": "John Doe", "age": 30, "is_student": false, "courses": ["Math", "Science"'
 print(parser.parse(incomplete_json))
-# {'name': 'John', 'age': 30, 'is_student': False, 'courses': ['Math', 'Science']}
+# {'name': 'John Doe', 'age': 30, 'is_student': False, 'courses': ['Math', 'Science']}
 ```
 
-Problem with `\n`? strict mode is here
+Problem with `\n`? Use `strict=False`:
 
 ```python
-from partialjson.json_parser import JSONParser
+from partialjson import JSONParser
 parser = JSONParser(strict=False)
 
 incomplete_json = '{"name": "John\nDoe", "age": 30, "is_student": false, "courses": ["Math", "Science"'
@@ -53,6 +56,21 @@ print(parser.parse(incomplete_json))
 # {'name': 'John\nDoe', 'age': 30, 'is_student': False, 'courses': ['Math', 'Science']}
 ```
 
+### JSON5 support
+
+Use `create_json5_parser` or `JSONParser(json5_enabled=True)` for JSON5 (comments, unquoted keys, single quotes, etc.):
+
+```python
+from partialjson import create_json5_parser
+parser = create_json5_parser()
+
+incomplete_json5 = '{name: "Demo", version: 1.0, items: [1, 2, 3,]'
+print(parser.parse(incomplete_json5))
+# {'name': 'Demo', 'version': 1.0, 'items': [1, 2, 3]}
+```
+
+Install the optional `json5` dependency for full JSON5 support: `pip install partialjson[json5]`
+
 ### Installation
 
 ```sh

{partialjson-1.0.0 → partialjson-1.1.0}/partialjson.egg-info/SOURCES.txt

@@ -2,9 +2,12 @@ LICENSE
 README.md
 setup.py
 partialjson/__init__.py
+partialjson/json5_parser.py
 partialjson/json_parser.py
 partialjson.egg-info/PKG-INFO
 partialjson.egg-info/SOURCES.txt
 partialjson.egg-info/dependency_links.txt
+partialjson.egg-info/requires.txt
 partialjson.egg-info/top_level.txt
+tests/test_json5.py
 tests/test_parser.py

partialjson-1.1.0/partialjson.egg-info/requires.txt

@@ -0,0 +1,3 @@
+
+[json5]
+json5

{partialjson-1.0.0 → partialjson-1.1.0}/setup.py

@@ -31,4 +31,5 @@ setup(
     author_email=get_property("__author_email__"),
     license=get_property("__license__"),
     packages=["partialjson"],
+    extras_require={"json5": ["json5"]},
 )

partialjson-1.1.0/tests/test_json5.py

@@ -0,0 +1,57 @@
+import pytest
+import math
+from partialjson.json_parser import JSONParser
+
+def test_json5_comments():
+    parser = JSONParser(json5_enabled=True)
+    assert parser.parse("{// comment\n\"a\": 1}") == {"a": 1}
+    assert parser.parse("{/* multi-line\n comment */\"a\": 1}") == {"a": 1}
+    assert parser.parse("{/* incomplete comment") == {}
+
+def test_json5_unquoted_keys():
+    parser = JSONParser(json5_enabled=True)
+    assert parser.parse("{a: 1, b: 2}") == {"a": 1, "b": 2}
+    assert parser.parse("{_foo: \"bar\", $baz: 3}") == {"_foo": "bar", "$baz": 3}
+    assert parser.parse("{a: 1, ") == {"a": 1}
+
+def test_json5_single_quotes():
+    parser = JSONParser(json5_enabled=True)
+    assert parser.parse("'hello'") == "hello"
+    assert parser.parse("{'a': 'b'}") == {"a": "b"}
+    assert parser.parse("'it\\'s me'") == "it's me"
+
+def test_json5_multi_line_strings():
+    parser = JSONParser(json5_enabled=True)
+    assert parser.parse("'line1\\\nline2'") == "line1line2"
+    assert parser.parse("\"line1\\\r\nline2\"") == "line1line2"
+
+def test_json5_hex_numbers():
+    parser = JSONParser(json5_enabled=True)
+    assert parser.parse("0x1f") == 31
+    assert parser.parse("-0x10") == -16 # Note: JSON5 spec says hex can have optional sign
+    # Actually checking spec: "Hexadecimal numbers ... may be prefixed with an optional plus or minus sign"
+    assert parser.parse("0XFF") == 255
+
+def test_json5_special_numbers():
+    parser = JSONParser(json5_enabled=True)
+    assert parser.parse("Infinity") == float("inf")
+    assert parser.parse("-Infinity") == float("-inf")
+    assert math.isnan(parser.parse("NaN"))
+    assert parser.parse(".5") == 0.5
+    assert parser.parse("+42") == 42
+
+def test_json5_case_insensitive_literals():
+    parser = JSONParser(json5_enabled=True)
+    assert parser.parse("True") is True
+    assert parser.parse("FALSE") is False
+    assert parser.parse("Null") is None
+
+def test_json5_trailing_commas():
+    # Already supported but good to verify with JSON5 enabled
+    parser = JSONParser(json5_enabled=True)
+    assert parser.parse("[1, 2, 3,]") == [1, 2, 3]
+    assert parser.parse("{a: 1, b: 2,}") == {"a": 1, "b": 2}
+
+def test_json5_whitespace():
+    parser = JSONParser(json5_enabled=True)
+    assert parser.parse("{\v\"a\"\f: 1\u00A0}") == {"a": 1}

{partialjson-1.0.0 → partialjson-1.1.0}/tests/test_parser.py

@@ -84,8 +84,8 @@ def test_unicode_escape_complete():
     assert parser.parse('{"a":"\\u20AC"}') == {"a": "€"}
 
 
-def test_unicode_escape_incomplete_strict():
+def test_incomplete_string_without_closing_quote():
     parser = JSONParser(strict=True)
-    assert parser.parse('{"a":"\\u123"') == {"a": "\u1234"}
-    assert parser.parse('{"a":"\\u"') == {"a": ""}
-    assert parser.parse('{"a":"\\""') == {"a": ""}
+    # When string has no closing quote, incomplete escapes are handled
+    assert parser.parse('{"a":"\\u') == {"a": ""}
+    assert parser.parse('{"a":"\\') == {"a": ""}

partialjson-1.0.0/partialjson/json_parser.py

@@ -1,168 +0,0 @@
-import json
-import re
-
-
-class JSONParser:
-    def __init__(self, strict=True):
-        self.strict = strict
-        self.parsers = {
-            " ": self.parse_space,
-            "\r": self.parse_space,
-            "\n": self.parse_space,
-            "\t": self.parse_space,
-            "[": self.parse_array,
-            "{": self.parse_object,
-            '"': self.parse_string,
-            "t": self.parse_true,
-            "f": self.parse_false,
-            "n": self.parse_null,
-        }
-        for c in "0123456789.-":
-            self.parsers[c] = self.parse_number
-
-        self.last_parse_reminding = None
-        self.on_extra_token = self.default_on_extra_token
-
-    def default_on_extra_token(self, text, data, reminding):
-        print(
-            "Parsed JSON with extra tokens:",
-            {"text": text, "data": data, "reminding": reminding},
-        )
-
-    def parse(self, s):
-        if len(s) >= 1:
-            try:
-                return json.loads(s)
-            except json.JSONDecodeError as e:
-                data, reminding = self.parse_any(s, e)
-                self.last_parse_reminding = reminding
-                if self.on_extra_token and reminding:
-                    self.on_extra_token(s, data, reminding)
-                return data
-        else:
-            return json.loads("{}")
-
-    def parse_any(self, s, e):
-        if not s:
-            raise e
-        parser = self.parsers.get(s[0])
-        if not parser:
-            raise e
-        return parser(s, e)
-
-    def parse_space(self, s, e):
-        return self.parse_any(s.strip(), e)
-
-    def parse_array(self, s, e):
-        s = s[1:]  # skip starting '['
-        acc = []
-        s = s.strip()
-        while s:
-            if s[0] == "]":
-                s = s[1:]  # skip ending ']'
-                break
-            res, s = self.parse_any(s, e)
-            acc.append(res)
-            s = s.strip()
-            if s.startswith(","):
-                s = s[1:]
-                s = s.strip()
-        return acc, s
-
-    def parse_object(self, s, e):
-        s = s[1:]  # skip starting '{'
-        acc = {}
-        s = s.strip()
-        while s:
-            if s[0] == "}":
-                s = s[1:]  # skip ending '}'
-                break
-            key, s = self.parse_any(s, e)
-            s = s.strip()
-
-            if not s or s[0] == "}":
-                acc[key] = None
-                break
-
-            if s[0] != ":":
-                raise e  # or handle this scenario as per your requirement
-
-            s = s[1:]  # skip ':'
-            s = s.strip()
-
-            if not s or s[0] in ",}":
-                acc[key] = None
-                if s.startswith(","):
-                    s = s[1:]
-                break
-
-            value, s = self.parse_any(s, e)
-            acc[key] = value
-            s = s.strip()
-            if s.startswith(","):
-                s = s[1:]
-                s = s.strip()
-        return acc, s
-
-    def parse_string(self, s, e):
-        incomplete_escape_regex = re.compile(r"^\\(?:u[0-9a-fA-F]{0,3})?$")
-        end = s.find('"', 1)
-        while end != -1 and s[end - 1] == "\\":  # Handle escaped quotes
-            end = s.find('"', end + 1)
-        if end == -1:
-            # Incomplete string: handle it based on strict mode
-            if not self.strict:
-                # Check for incomplete escape sequences
-                if incomplete_escape_regex.match(s[1:]):
-                    return s[1:], ""
-                return s[1:], ""
-            else:
-                # Handle incomplete escape sequences
-                if incomplete_escape_regex.match(s[1:]):
-                    return "", ""
-                # Attempt to parse the string without incomplete escape sequences
-                try:
-                    return json.loads(f'"{s[1:]}"'), ""
-                except json.JSONDecodeError:
-                    return "", ""
-        str_val = s[: end + 1]
-        s = s[end + 1 :]
-        if not self.strict:
-            return str_val[1:-1], s  # Remove surrounding quotes for strict mode
-        return json.loads(str_val), s
-
-    def parse_number(self, s, e):
-        i = 0
-        while i < len(s) and s[i] in "0123456789.-":
-            i += 1
-        num_str = s[:i]
-        s = s[i:]
-        if not num_str or num_str == "-" or num_str == ".":
-            return num_str, ""
-        try:
-            if num_str.endswith("."):
-                num = int(num_str[:-1])
-            else:
-                num = (
-                    float(num_str)
-                    if "." in num_str or "e" in num_str or "E" in num_str
-                    else int(num_str)
-                )
-        except ValueError:
-            raise e
-        return num, s
-
-    def parse_true(self, s, e):
-        if s.startswith("t") or s.startswith("T"):
-            return True, s[4:]
-        raise e
-
-    def parse_false(self, s, e):
-        if s.startswith("f") or s.startswith("F"):
-            return False, s[5:]
-        raise e
-
-    def parse_null(self, s, e):
-        if s.startswith("n"):
-            return None, s[4:]
-        raise e