pyjsonfrag 0.0.1__py3-none-any.whl

examples/customers.json

@@ -0,0 +1,16 @@
+{
+  "customers": [
+    {
+      "id": 1,
+      "name": "Clark Henson",
+      "accountCount": 1,
+      "totalBalance": 5085.96
+    },
+    {
+      "id": 2,
+      "name": "Elnora Ericson",
+      "accountCount": 3,
+      "totalBalance": 3910.11
+    }
+  ]
+}

examples/parse_frag.py

@@ -0,0 +1,43 @@
+import pyjsonfrag
+
+class Customer(object):
+  def __init__(self, customerId = None, name = None, accountCount = None, totalBalance = None):
+    if customerId is not None:
+      self.customerId = int(customerId)
+    else:
+      self.customerId = None
+    self.name = name
+    if accountCount is not None:
+      self.accountCount = int(accountCount)
+    else:
+      self.accountCount = None
+    if totalBalance is not None:
+      self.totalBalance = float(totalBalance)
+    else:
+      self.totalBalance = None
+  def __repr__(s):
+    return ("Customer(%d,%s,%d,%.2f)" % (s.customerId,s.name,s.accountCount,s.totalBalance))
+
+cs = {}
+
+class MyHandler(pyjsonfrag.FragmentHandler):
+  def start_frag_dict(self, key):
+    if self.path_is([None, "customers", None]):
+      self.start_frag_collection()
+  def end_frag_dict(self, key, val):
+    if self.path_is([None, "customers", None]):
+      c = Customer(customerId=val["id"], name=val["name"],
+                   accountCount=val["accountCount"], totalBalance=val["totalBalance"])
+      cs[c.customerId] = c
+
+handler = MyHandler()
+stream = pyjsonfrag.JsonStream(handler)
+with open("customers.json", "r") as f:
+  while True:
+    buf = f.read(4096)
+    if buf == '':
+      stream.feed(buf, 0, len(buf), True)
+      break
+    else:
+      stream.feed(buf, 0, len(buf), False)
+print(cs)

examples/parse_stream.py

@@ -0,0 +1,59 @@
+import pyjsonfrag
+
+class Customer(object):
+  def __init__(self, customerId = None, name = None, accountCount = None, totalBalance = None):
+    if customerId is not None:
+      self.customerId = int(customerId)
+    else:
+      self.customerId = None
+    self.name = name
+    if accountCount is not None:
+      self.accountCount = int(accountCount)
+    else:
+      self.accountCount = None
+    if totalBalance is not None:
+      self.totalBalance = float(totalBalance)
+    else:
+      self.totalBalance = None
+  def __repr__(s):
+    return ("Customer(%d,%s,%d,%.2f)" % (s.customerId,s.name,s.accountCount,s.totalBalance))
+
+context = []
+cs = {}
+c = None
+
+class MyHandler(pyjsonfrag.JsonHandler):
+  def start_dict(stream, key):
+    global c
+    context.append(key)
+    if context == [None, "customers", None]:
+      c = Customer()
+  def start_array(stream, key):
+    context.append(key)
+  def end_dict(stream, key):
+    context.pop()
+  def end_array(stream, key):
+    context.pop()
+  def handle_string(stream, key, val):
+    if key == "name":
+      c.name = val
+  def handle_number(stream, key, num, is_integer):
+    if key == "id":
+      cs[int(num)] = c
+      c.customerId = int(num)
+    elif key == "accountCount":
+      c.accountCount = int(num)
+    elif key == "totalBalance":
+      c.totalBalance = num
+
+handler = MyHandler()
+stream = pyjsonfrag.JsonStream(handler)
+with open("customers.json", "r") as f:
+  while True:
+    buf = f.read(4096)
+    if buf == '':
+      stream.feed(buf, 0, len(buf), True)
+      break
+    else:
+      stream.feed(buf, 0, len(buf), False)
+print(cs)

examples/parse_tree.py

@@ -0,0 +1,4 @@
+import pyjsonfrag
+
+with open("customers.json", "r") as f:
+  print(pyjsonfrag.jsonstream_tree_parse(f.read()))

examples/pyjsonfrag/__init__.py

@@ -0,0 +1,765 @@
+import io
+
+JSONSTREAM_MODE_KEYSTRING = 1
+JSONSTREAM_MODE_KEYSTRING_ESCAPE = 2
+JSONSTREAM_MODE_KEYSTRING_UESCAPE = 3
+JSONSTREAM_MODE_STRING = 4
+JSONSTREAM_MODE_STRING_ESCAPE = 5
+JSONSTREAM_MODE_STRING_UESCAPE = 6
+JSONSTREAM_MODE_TRUE = 7
+JSONSTREAM_MODE_FALSE = 8
+JSONSTREAM_MODE_NULL = 9
+JSONSTREAM_MODE_FIRSTKEY = 10
+JSONSTREAM_MODE_KEY = 11
+JSONSTREAM_MODE_FIRSTVAL = 12
+JSONSTREAM_MODE_VAL = 13
+JSONSTREAM_MODE_COLON = 14
+JSONSTREAM_MODE_COMMA = 15
+JSONSTREAM_MODE_NUMBER = 16
+JSONSTREAM_MODE_ENDWS = 17
+
+class JsonHandler(object):
+  def handle_comment(self, comma_seen, val, is_multiline):
+    pass
+  def start_dict(self, key):
+    pass
+  def start_array(self, key):
+    pass
+  def end_dict(self, key):
+    pass
+  def end_array(self, key):
+    pass
+  def handle_number(self, key, num, is_integer):
+    pass
+  def handle_string(self, key, val):
+    pass
+  def handle_boolean(self, key, val):
+    pass
+  def handle_null(self, key):
+    pass
+
+class FragmentHandler(JsonHandler):
+  def __init__(self):
+    self.stack = []
+    self.fragstack = []
+    self.collect = False
+    self.val = None
+  def path_is(self, path):
+    return self.stack == path
+  def start_frag_collection(self):
+    self.collect = True
+  def handle_frag_comment(self, comma_seen, val, is_multiline):
+    pass
+  def handle_comment(self, comma_seen, val, is_multiline):
+    self.handle_frag_comment(comma_seen, val, is_multiline)
+  def start_frag_dict(self, key):
+    pass
+  def start_dict(self, key):
+    self.stack.append(key)
+    if not self.collect:
+      self.start_frag_dict(key)
+    if self.collect:
+      obj = {}
+      if self.fragstack:
+        if key is not None:
+          self.fragstack[-1][key] = obj
+        else:
+          self.fragstack[-1].append(obj)
+      self.fragstack.append(obj)
+  def start_frag_array(self, key):
+    pass
+  def start_array(self, key):
+    self.stack.append(key)
+    if not self.collect:
+      self.start_frag_array(key)
+    if self.collect:
+      obj = []
+      if self.fragstack:
+        if key is not None:
+          self.fragstack[-1][key] = obj
+        else:
+          self.fragstack[-1].append(obj)
+      self.fragstack.append(obj)
+  def end_frag_dict(self, key, val):
+    pass
+  def end_dict(self, key):
+    val = None
+    if self.fragstack:
+      val1 = self.fragstack.pop()
+      if not self.fragstack:
+        val = val1
+        self.collect = False
+    if not self.collect:
+      self.end_frag_dict(key, val)
+    self.stack.pop()
+  def end_frag_array(self, key, val):
+    pass
+  def end_array(self, key):
+    val = None
+    if self.fragstack:
+      val1 = self.fragstack.pop()
+      if not self.fragstack:
+        val = val1
+        self.collect = False
+    if not self.collect:
+      self.end_frag_array(key, val)
+    self.stack.pop()
+  def handle_frag_number(self, key, num, is_integer):
+    pass
+  def handle_frag_string(self, key, val):
+    pass
+  def handle_frag_boolean(self, key, val):
+    pass
+  def handle_frag_null(self, key):
+    pass
+  def handle_number(self, key, num, is_integer):
+    if is_integer:
+      num = int(num)
+    if self.collect and self.fragstack:
+      if key is not None:
+        self.fragstack[-1][key] = num
+      else:
+        self.fragstack[-1].append(num)
+    if self.collect:
+      return
+    self.handle_frag_number(key, num, is_integer)
+  def handle_string(self, key, val):
+    if self.collect and self.fragstack:
+      if key is not None:
+        self.fragstack[-1][key] = val
+      else:
+        self.fragstack[-1].append(val)
+    if self.collect:
+      return
+    self.handle_frag_string(key, val)
+  def handle_boolean(self, key, val):
+    if self.collect and self.fragstack:
+      if key is not None:
+        self.fragstack[-1][key] = val
+      else:
+        self.fragstack[-1].append(val)
+    if self.collect:
+      return
+    self.handle_frag_boolean(key, val)
+  def handle_null(self, key):
+    val = None
+    if self.collect and self.fragstack:
+      if key is not None:
+        self.fragstack[-1][key] = val
+      else:
+        self.fragstack[-1].append(val)
+    if self.collect:
+      return
+    self.handle_frag_null(key)
+
+class JsonStream(object):
+  def __init__(self, handler):
+    self.mode = JSONSTREAM_MODE_VAL
+    self.sz = 0
+    self.uescape = io.StringIO()
+    self.c_comment_seen = False
+    self.c_comment_seen_star = False
+    self.cpp_comment_seen = False
+    self.comment_seen_preliminary = False
+    self.comments = False
+    self.trailing_commas = False
+    self.keypresent = False
+    self.key = io.StringIO()
+    self.keystack = []
+    self.val = io.StringIO()
+    self.handler = handler
+    self.is_integer = False
+    self.comma_seen = False
+  def allow_comments(self):
+    self.comments = True
+  def allow_trailing_comma(self):
+    self.trailing_commas = True
+  def get_keystack(self): # for internal use only
+    if (self.keystack[-1] == None):
+      self.keypresent = False
+      self.keystack.pop()
+      return
+    self.keypresent = True
+    self.key = self.keystack[-1]
+    self.keystack.pop()
+  def put_keystack_1(self): # for internal use only
+    if not self.keypresent:
+      self.keystack.append(None)
+      self.keypresent = False
+      return
+    self.keystack.append(self.key)
+  def put_keystack_2(self): # for internal use only
+    self.keypresent = False
+  def get_key(self): # for internal use only
+    if not self.keypresent:
+      return None
+    return self.key.getvalue()
+  def strip_comment(self, buf, start, i, sz, eof): # for internal use only
+    i+=1
+    self.mode = JSONSTREAM_MODE_ENDWS
+    while i < sz:
+      if self.comments and (not self.comment_seen_preliminary) and (not self.cpp_comment_seen) and (not self.c_comment_seen) and buf[start+i] == '/':
+        self.comment_seen_preliminary = True
+        self.val = io.StringIO()
+        i+=1
+        continue
+      if self.comment_seen_preliminary:
+        if buf[start+i] == '*':
+          self.comment_seen_preliminary = False
+          self.c_comment_seen = True
+          self.c_comment_seen_star = False
+          self.val = io.StringIO()
+          i+=1
+          continue
+        if buf[start+i] != '/':
+          self.errloc = i
+          raise Exception("illegal comment")
+        self.comment_seen_preliminary = False
+        self.cpp_comment_seen = True
+        self.val = io.StringIO()
+        i+=1
+        continue
+      if self.c_comment_seen:
+        if buf[start+i] == '*':
+          self.c_comment_seen_star = True
+        elif self.c_comment_seen_star and buf[start+i] == '/':
+          self.c_comment_seen = False
+          self.c_comment_seen_star = False
+          if self.handler.handle_comment:
+            self.handler.handle_comment(self.comma_seen, self.val.getvalue(), True)
+        else:
+          if self.c_comment_seen_star:
+            self.val.write('*')
+          self.c_comment_seen_star = False
+          self.val.write(buf[start+i])
+        i+=1
+        continue
+      if self.cpp_comment_seen:
+        if buf[start+i] == '\n':
+          self.cpp_comment_seen = False
+          if self.handler.handle_comment:
+            self.handler.handle_comment(self.comma_seen, self.val.getvalue(), False)
+        else:
+          self.val.write(buf[start+i])
+        i+=1
+        continue
+      if buf[start+i] == ' ' or buf[start+i] == '\n' or buf[start+i] == '\r' or buf[start+i] == '\t':
+        i+=1
+        continue
+      self.errloc = i
+      raise Exception("Overflow")
+    if eof and (self.c_comment_seen or self.comment_seen_preliminary):
+      self.errloc = i
+      raise Exception("Unterminated beginning of comment")
+  def feed(self, buf, start, sz, eof):
+    if sz < 0 or start+sz > len(buf):
+      raise Exception("out of bounds")
+    if self.mode == JSONSTREAM_MODE_ENDWS:
+      self.strip_comment(buf, start, -1, sz, eof)
+      if eof:
+        return 0
+      return -1
+    i = 0
+    while i < sz:
+      if self.mode == JSONSTREAM_MODE_ENDWS:
+        i -= 1
+        self.strip_comment(buf, start, i, sz, eof)
+        if eof:
+          return 0
+        return -1
+      if self.mode == JSONSTREAM_MODE_KEYSTRING:
+        if buf[start+i] == '\\':
+          self.mode = JSONSTREAM_MODE_KEYSTRING_ESCAPE
+        elif buf[start+i] == '"':
+          self.keypresent = True
+          self.mode = JSONSTREAM_MODE_COLON
+        else:
+          self.key.write(buf[start+i])
+        i += 1
+        continue
+      elif self.mode == JSONSTREAM_MODE_STRING:
+        if buf[start+i] == '\\':
+          self.mode = JSONSTREAM_MODE_STRING_ESCAPE
+        elif buf[start+i] == '"':
+          self.mode = JSONSTREAM_MODE_COMMA
+          if not self.handler.handle_string:
+            if len(self.keystack) == 0:
+              self.strip_comment(buf, start, i, sz, eof)
+              if eof:
+                return 0
+              return -1
+            i += 1
+            continue
+          self.handler.handle_string(self.get_key(), self.val.getvalue())
+          if len(self.keystack) == 0:
+            self.strip_comment(buf, start, i, sz, eof)
+            if eof:
+              return 0
+            return -1
+        else:
+          self.val.write(buf[start+i])
+        i += 1
+        continue
+      elif self.mode == JSONSTREAM_MODE_KEYSTRING_ESCAPE:
+        if buf[start+i] == 'b':
+          self.key.write('\b')
+        elif buf[start+i] == 'f':
+          self.key.write('\f')
+        elif buf[start+i] == 'r':
+          self.key.write('\r')
+        elif buf[start+i] == 'n':
+          self.key.write('\n')
+        elif buf[start+i] == 't':
+          self.key.write('\t')
+        elif buf[start+i] == 'u':
+          self.mode = JSONSTREAM_MODE_KEYSTRING_UESCAPE
+          self.uescape = io.StringIO()
+        else:
+          self.errloc = i
+          raise Exception("Illegal sequence")
+        i += 1
+        continue
+      elif self.mode == JSONSTREAM_MODE_STRING_ESCAPE:
+        if buf[start+i] == 'b':
+          self.val.write('\b')
+        elif buf[start+i] == 'f':
+          self.val.write('\f')
+        elif buf[start+i] == 'r':
+          self.val.write('\r')
+        elif buf[start+i] == 'n':
+          self.val.write('\n')
+        elif buf[start+i] == 't':
+          self.val.write('\t')
+        elif buf[start+i] == 'u':
+          self.mode = JSONSTREAM_MODE_STRING_UESCAPE
+          self.uescape = io.StringIO()
+        else:
+          self.errloc = i
+          raise Exception("Illegal sequence")
+        i += 1
+        continue
+      elif self.mode == JSONSTREAM_MODE_STRING_UESCAPE and len(self.uescape.getvalue()) < 4:
+        if (buf[start+i] >= '0' and buf[start+i] <= '9') or (buf[start+i] >= 'A' and buf[start+i] <= 'F') or (buf[start+i] >= 'a' and buf[start+i] <= 'f'):
+          self.uescape.write(buf[start+i])
+          if len(self.uescape.getvalue()) == 4:
+            self.val.write(chr(int(self.uescape.getvalue(),16)))
+            self.mode = JSONSTREAM_MODE_STRING
+          i += 1
+          continue
+        raise Exception("Illegal unicode escape")
+      elif self.mode == JSONSTREAM_MODE_KEYSTRING_UESCAPE and len(self.uescape.getvalue()) < 4:
+        if (buf[start+i] >= '0' and buf[start+i] <= '9') or (buf[start+i] >= 'A' and buf[start+i] <= 'F') or (buf[start+i] >= 'a' and buf[start+i] <= 'f'):
+          self.uescape.write(buf[start+i])
+          if len(self.uescape.getvalue()) == 4:
+            self.key.write(chr(int(self.uescape.getvalue(),16)))
+            self.mode = JSONSTREAM_MODE_KEYSTRING
+          i += 1
+          continue
+        raise Exception("Illegal unicode escape")
+      if self.comments and (not self.comment_seen_preliminary) and (not self.cpp_comment_seen) and (not self.c_comment_seen) and buf[start+i] == '/' and (self.mode == JSONSTREAM_MODE_COLON or self.mode == JSONSTREAM_MODE_COMMA or self.mode == JSONSTREAM_MODE_FIRSTKEY or self.mode == JSONSTREAM_MODE_FIRSTVAL or self.mode == JSONSTREAM_MODE_KEY or self.mode == JSONSTREAM_MODE_VAL):
+        self.comment_seen_preliminary = True
+        self.val = io.StringIO()
+        i += 1
+        continue
+      if self.comment_seen_preliminary:
+        if buf[start+i] == '*':
+          self.comment_seen_preliminary = False
+          self.c_comment_seen = True
+          self.c_comment_seen_star = False
+          self.val = io.StringIO()
+          i += 1
+          continue
+        if buf[start+i] != '/':
+          self.errloc = i
+          raise Exception("illegal comment")
+        self.comment_seen_preliminary = False
+        self.cpp_comment_seen = True
+        self.val = io.StringIO()
+        i += 1
+        continue
+      if self.c_comment_seen:
+        if buf[start+i] == '*':
+          self.c_comment_seen_star = True
+        elif self.c_comment_seen_star and buf[start+i] == '/':
+          self.c_comment_seen = False
+          self.c_comment_seen_star = False
+          if self.handler.handle_comment:
+            self.handler.handle_comment(self.comma_seen, self.val.getvalue(), True)
+        else:
+          if self.c_comment_seen_star:
+            self.val.write('*')
+          self.c_comment_seen_star = False
+          self.val.write(buf[start+i])
+        i += 1
+        continue
+      if self.cpp_comment_seen:
+        if buf[start+i] == '\n':
+          self.cpp_comment_seen = False
+          if self.handler.handle_comment:
+            self.handler.handle_comment(self.comma_seen, self.val.getvalue(), False)
+        else:
+          self.val.write(buf[start+i])
+        i += 1
+        continue
+      if (buf[start+i] == ' ' or buf[start+i] == '\n' or buf[start+i] == '\r' or buf[start+i] == '\t') and (self.mode == JSONSTREAM_MODE_COLON or self.mode == JSONSTREAM_MODE_COMMA or self.mode == JSONSTREAM_MODE_FIRSTKEY or self.mode == JSONSTREAM_MODE_FIRSTVAL or self.mode == JSONSTREAM_MODE_KEY or self.mode == JSONSTREAM_MODE_VAL):
+        i += 1
+        continue
+      if self.mode == JSONSTREAM_MODE_COLON:
+        if buf[start+i] != ':':
+          self.errloc = i
+          raise Exception("invalid JSON")
+        self.mode = JSONSTREAM_MODE_VAL
+        i += 1
+        continue
+      if self.mode == JSONSTREAM_MODE_COMMA:
+        if buf[start+i] == ',':
+          self.comma_seen = True
+          if self.keypresent:
+            self.mode = JSONSTREAM_MODE_KEY
+            self.keypresent = False
+          else:
+            self.mode = JSONSTREAM_MODE_VAL
+          i += 1
+          continue
+      self.comma_seen = False
+      if (self.mode == JSONSTREAM_MODE_COMMA or self.mode == JSONSTREAM_MODE_FIRSTKEY or (self.trailing_commas and self.mode == JSONSTREAM_MODE_KEY)) and buf[start+i] == '}':
+        if self.mode == JSONSTREAM_MODE_COMMA:
+          if not self.keypresent:
+            self.errloc = i
+            raise Exception("invalid JSON")
+          # could be array or dict
+        self.mode = JSONSTREAM_MODE_COMMA
+        self.get_keystack()
+        if not self.handler.end_dict:
+          if len(self.keystack) == 0:
+            self.strip_comment(buf, start, i, sz, eof)
+            if eof:
+              return 0
+            return -1
+          i += 1
+          continue
+        self.handler.end_dict(self.get_key())
+        if len(self.keystack) == 0:
+          self.strip_comment(buf, start, i, sz, eof)
+          if eof:
+            return 0
+          return -1
+        i += 1
+        continue
+      if (self.mode == JSONSTREAM_MODE_COMMA or self.mode == JSONSTREAM_MODE_FIRSTVAL or (self.trailing_commas and self.mode == JSONSTREAM_MODE_VAL)) and buf[start+i] == ']':
+        if self.mode == JSONSTREAM_MODE_COMMA or self.mode == JSONSTREAM_MODE_VAL:
+          if self.keypresent or len(self.keystack) == 0:
+            self.errloc = i
+            raise Exception("invalid JSON")
+          # could be array or dict
+        self.mode = JSONSTREAM_MODE_COMMA
+        self.get_keystack()
+        if not self.handler.end_array:
+          if len(self.keystack) == 0:
+            self.strip_comment(buf, start, i, sz, eof)
+            if eof:
+              return 0
+            return -1
+          i += 1
+          continue
+        self.handler.end_array(self.get_key())
+        if len(self.keystack) == 0:
+          self.strip_comment(buf, start, i, sz, eof)
+          if eof:
+            return 0
+          return -1
+        i += 1
+        continue
+      if (self.mode == JSONSTREAM_MODE_FIRSTVAL or self.mode == JSONSTREAM_MODE_VAL) and buf[start+i] == '{':
+        self.put_keystack_1()
+        self.mode = JSONSTREAM_MODE_FIRSTKEY
+        if not self.handler.start_dict:
+          self.put_keystack_2()
+          i += 1
+          continue
+        self.handler.start_dict(self.get_key())
+        self.put_keystack_2()
+        i += 1
+        continue
+      if (self.mode == JSONSTREAM_MODE_FIRSTVAL or self.mode == JSONSTREAM_MODE_VAL) and buf[start+i] == '[':
+        self.put_keystack_1()
+        self.mode = JSONSTREAM_MODE_FIRSTVAL
+        if not self.handler.start_array:
+          self.put_keystack_2()
+          i += 1
+          continue
+        self.handler.start_array(self.get_key())
+        self.put_keystack_2()
+        i += 1
+        continue
+      if self.mode == JSONSTREAM_MODE_TRUE:
+        if buf[start+i] != "true"[self.sz]:
+          self.errloc = i
+          raise Exception("invalid JSON")
+        self.sz += 1
+        if self.sz < 4:
+          i += 1
+          continue
+        self.mode = JSONSTREAM_MODE_COMMA
+        if not self.handler.handle_boolean:
+          if len(self.keystack) == 0:
+            self.strip_comment(buf, start, i, sz, eof)
+            if eof:
+              return 0
+            return -1
+          i += 1
+          continue
+        self.handler.handle_boolean(self.get_key(), True)
+        if len(self.keystack) == 0:
+          self.strip_comment(buf, start, i, sz, eof)
+          if eof:
+            return 0
+          return -1
+        i += 1
+        continue
+      if self.mode == JSONSTREAM_MODE_FALSE:
+        if buf[start+i] != "false"[self.sz]:
+          self.errloc = i
+          raise Exception("invalid JSON")
+        self.sz += 1
+        if self.sz < 5:
+          i += 1
+          continue
+        self.mode = JSONSTREAM_MODE_COMMA
+        if not self.handler.handle_boolean:
+          if len(self.keystack) == 0:
+            self.strip_comment(buf, start, i, sz, eof)
+            if eof:
+              return 0
+            return -1
+          i += 1
+          continue
+        self.handler.handle_boolean(self.get_key(), False)
+        if len(self.keystack) == 0:
+          self.strip_comment(buf, start, i, sz, eof)
+          if eof:
+            return 0
+          return -1
+        i += 1
+        continue
+      if self.mode == JSONSTREAM_MODE_NULL:
+        if buf[start+i] != "null"[self.sz]:
+          self.errloc = i
+          raise Exception("invalid JSON")
+        self.sz += 1
+        if self.sz < 4:
+          i += 1
+          continue
+        self.mode = JSONSTREAM_MODE_COMMA
+        if not self.handler.handle_null:
+          if len(self.keystack) == 0:
+            self.strip_comment(buf, start, i, sz, eof)
+            if eof:
+              return 0
+            return -1
+          i += 1
+          continue
+        self.handler.handle_null(self.get_key())
+        if len(self.keystack) == 0:
+          self.strip_comment(buf, start, i, sz, eof)
+          if eof:
+            return 0
+          return -1
+        i += 1
+        continue
+      if (self.mode == JSONSTREAM_MODE_VAL or self.mode == JSONSTREAM_MODE_FIRSTVAL) and buf[start+i] == 'n':
+        self.mode = JSONSTREAM_MODE_NULL
+        self.sz = 1
+        i += 1
+        continue
+      if (self.mode == JSONSTREAM_MODE_VAL or self.mode == JSONSTREAM_MODE_FIRSTVAL) and buf[start+i] == 'f':
+        self.mode = JSONSTREAM_MODE_FALSE
+        self.sz = 1
+        i += 1
+        continue
+      if (self.mode == JSONSTREAM_MODE_VAL or self.mode == JSONSTREAM_MODE_FIRSTVAL) and buf[start+i] == 't':
+        self.mode = JSONSTREAM_MODE_TRUE
+        self.sz = 1
+        i += 1
+        continue
+      if (self.mode == JSONSTREAM_MODE_KEY or self.mode == JSONSTREAM_MODE_FIRSTKEY) and buf[start+i] == '"':
+        self.mode = JSONSTREAM_MODE_KEYSTRING
+        self.key = io.StringIO()
+        i += 1
+        continue
+      if (self.mode == JSONSTREAM_MODE_VAL or self.mode == JSONSTREAM_MODE_FIRSTVAL) and buf[start+i] == '"':
+        self.mode = JSONSTREAM_MODE_STRING
+        self.val = io.StringIO()
+        i += 1
+        continue
+      if (self.mode == JSONSTREAM_MODE_VAL or self.mode == JSONSTREAM_MODE_FIRSTVAL) and (buf[start+i] == '-' or (buf[start+i] >= '0' and buf[start+i] <= '9')):
+        self.mode = JSONSTREAM_MODE_NUMBER
+        self.is_integer = True
+        self.val = io.StringIO()
+      if self.mode == JSONSTREAM_MODE_NUMBER:
+        if self.val.getvalue() == "" and buf[start+i] == '-':
+          self.val.write(buf[start+i])
+          i += 1
+          continue
+        if (self.val.getvalue() == "" or self.val.getvalue() == "-") and buf[start+i] >= '0' and buf[start+i] <= '9':
+          self.val.write(buf[start+i])
+          i += 1
+          continue
+        if (self.val.getvalue() != "0" and self.val.getvalue() != "-0") and buf[start+i] >= '0' and buf[start+i] <= '9':
+          self.val.write(buf[start+i])
+          i += 1
+          continue
+        if buf[start+i] == '.' and ("." not in self.val.getvalue()) and ("E" not in self.val.getvalue()) and ("e" not in self.val.getvalue()):
+          self.is_integer = False
+          self.val.write(buf[start+i])
+          i += 1
+          continue
+        if (buf[start+i] == 'E' or buf[start+i] == 'e') and ("E" not in self.val.getvalue()) and ("e" not in self.val.getvalue()):
+          self.is_integer = False
+          self.val.write(buf[start+i])
+          i += 1
+          continue
+        if (buf[start+i] == '-' or buf[start+i] == '+') and len(self.val.getvalue()) and (self.val.getvalue()[-1] == 'E' or self.val.getvalue()[-1] == 'e'):
+          self.val.write(buf[start+i])
+          i += 1
+          continue
+        numval = float(self.val.getvalue())
+        self.mode = JSONSTREAM_MODE_COMMA
+        if not self.handler.handle_number:
+          if len(self.keystack) == 0:
+            self.strip_comment(buf, start, i-1, sz, eof)
+            if eof:
+              return 0
+            return -1
+          continue # without i += 1 on purpose
+        self.handler.handle_number(self.get_key(), numval, self.is_integer)
+        if len(self.keystack) == 0:
+          self.strip_comment(buf, start, i-1, sz, eof)
+          if eof:
+            return 0
+          return -1
+        continue # without i += 1 on purpose
+      self.errloc = i
+      raise Exception("invalid JSON")
+    if self.mode == JSONSTREAM_MODE_NUMBER and eof:
+      self.mode = JSONSTREAM_MODE_COMMA
+      if not self.handler.handle_number:
+        if len(self.keystack) == 0:
+          return 0
+        self.errloc = i
+        raise Exception("invalid JSON")
+      self.handler.handle_number(self.get_key(), float(self.val.getvalue()), self.is_integer)
+      if len(self.keystack) == 0:
+        return 0
+      self.errloc = i
+      raise Exception("invalid JSON")
+    if eof and (self.c_comment_seen or self.comment_seen_preliminary):
+      self.errloc = i
+      raise Exception("Unterminated beginning of comment")
+    if len(self.keystack) == 0 and eof and self.mode == JSONSTREAM_MODE_ENDWS:
+      return 0
+    if eof:
+      self.errloc = i
+      raise Exception("invalid JSON, parsing not finished at end")
+    return -1
+
+def jsonstream_tree_parse(buf, allow_comments=False, allow_trailing_comma=False):
+  class ElementContainer(object):
+    def __init__(self):
+      self.has_element = False
+      self.element = None
+  c = ElementContainer()
+  stack = []
+  class MyHandler(JsonHandler):
+    def start_dict(self, key):
+      obj = {}
+      if not c.has_element:
+        c.has_element = True
+        c.element = obj
+        stack.append(obj)
+        return
+      if key is not None:
+        stack[-1][key] = obj
+      else:
+        stack[-1].append(obj)
+      stack.append(obj)
+    def start_array(self, key):
+      obj = []
+      if not c.has_element:
+        c.has_element = True
+        c.element = obj
+        stack.append(obj)
+        return
+      if key is not None:
+        stack[-1][key] = obj
+      else:
+        stack[-1].append(obj)
+      stack.append(obj)
+    def end_dict(self, key):
+      stack.pop()
+    def end_array(self, key):
+      stack.pop()
+    def handle_number(self, key, num, is_integer):
+      if is_integer:
+        num = int(num)
+      if not c.has_element:
+        c.has_element = True
+        c.element = num
+        return
+      if key is not None:
+        stack[-1][key] = num
+      else:
+        stack[-1].append(num)
+      if not c.has_element:
+        c.has_element = True
+        c.element = num
+    def handle_string(self, key, val):
+      if not c.has_element:
+        c.has_element = True
+        c.element = val
+        return
+      if key is not None:
+        stack[-1][key] = val
+      else:
+        stack[-1].append(val)
+      if not c.has_element:
+        c.has_element = True
+        c.element = val
+    def handle_boolean(self, key, val):
+      if not c.has_element:
+        c.has_element = True
+        c.element = val
+        return
+      if key is not None:
+        stack[-1][key] = val
+      else:
+        stack[-1].append(val)
+    def handle_null(self, key):
+      val = None
+      if not c.has_element:
+        c.has_element = True
+        c.element = val
+        return
+      if key is not None:
+        stack[-1][key] = val
+      else:
+        stack[-1].append(val)
+  handler = MyHandler()
+  stream = JsonStream(handler)
+  if allow_comments:
+    stream.allow_comments()
+  if allow_trailing_comma:
+    stream.allow_trailing_comma()
+  stream.feed(buf, 0, len(buf), True)
+  if not c.has_element:
+    raise Exception("invalid JSON")
+  return c.element
+
+if __name__ == '__main__':
+  handler = JsonHandler()
+  buf = "//foo\n /* fof */ { //bar\n  \"foo\\u03a9\": [1 //baz\n, /*2,*/ 3 //quux\n], \"bar\": 4.0, \"baz\": {}, \"barf\": []   , \"quux\": [true, false, null,],  } // endcomment"
+  stream = JsonStream(handler)
+  stream.allow_comments()
+  stream.allow_trailing_comma()
+  print(stream.feed(buf, 0, len(buf), True))
+  print(jsonstream_tree_parse(buf, True, True))

pyjsonfrag-0.0.1.dist-info/METADATA

@@ -0,0 +1,230 @@
+Metadata-Version: 2.4
+Name: pyjsonfrag
+Version: 0.0.1
+Summary: Combined tree/event based JSON parser
+Project-URL: Homepage, https://github.com/jmtilli/pyjsonfrag
+Project-URL: Issues, https://github.com/jmtilli/pyjsonfrag/issues
+Author-email: Juha-Matti Tilli <juha-matti.tilli@iki.fi>
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# PyJsonFrag: a powerful combined tree-based and event-based parser for JSON
+
+Typically, JSON is parsed by a tree-based parser unlike XML that can be parsed by a tree-based parser or an event-based parser. Event-based parsers are fast and have a low memory footprint, but a drawback is that it is cumbersome to write the required event handlers. Tree-based parsers make the code easier to write, to understand and to maintain but have a large memory footprint as a drawback. Sometimes, JSON is used for huge files such as database dumps that would be preferably parsed by event-based parsing, or so it would appear at a glance, because a tree-based parser cannot hold the whole parse tree in memory at the same time, if the file is huge.
+
+## How to install: PyJsonFrag at PyPI
+
+PyJsonFrag is available at [PyPI](https://pypi.org/project/pyjsonfrag/).
+
+How to install:
+```
+python3 -m pip install pyjsonfrag
+```
+
+## Example application: customers in a major bank
+
+Let us consider an example application: a listing of a customers in a major bank that has 30 million customers. The test file is in the following format:
+
+```
+{
+  "customers": [
+    {
+      "id": 1,
+      "name": "Clark Henson",
+      "accountCount": 1,
+      "totalBalance": 5085.96
+    },
+    {
+      "id": 2,
+      "name": "Elnora Ericson",
+      "accountCount": 3,
+      "totalBalance": 3910.11
+    },
+    ...
+  ]
+}
+```
+
+The example format requires about 100 bytes per customer plus customer name length. If we assume an average customer name is 15 characters long, the required storage is about 115 bytes per customer. For 30 million customers, this is 3.5 gigabytes. In the example, the file is read to the following structure:
+
+```
+class Customer(object):
+    def __init__(self, customerId = None, name = None, accountCount = None, totalBalance = None):
+        if customerId is not None:
+            self.customerId = int(customerId)
+        else:
+            self.customerId = None
+        self.name = name
+        if accountCount is not None:
+            self.accountCount = int(accountCount)
+        else:
+            self.accountCount = None
+        if totalBalance is not None:
+            self.totalBalance = float(totalBalance)
+        else:
+            self.totalBalance = None
+```
+
+## Python jsonstream API
+
+For XML, there is Simple API for XML (SAX). However, for JSON the usual parse
+methods read the whole data into memory at once, not supporting event-driven
+parsing. Thus, we provide Python jsonstream API to provide the possibility
+for event-driven parsing. It is faster and less memory-hungry than the "read
+all at once" parsing methods, but it is cumbersome.
+
+A jsonstream-based parser is implemented here:
+
+```
+import pyjsonfrag
+
+class Customer(object):
+  def __init__(self, customerId = None, name = None, accountCount = None, totalBalance = None):
+    if customerId is not None:
+      self.customerId = int(customerId)
+    else:
+      self.customerId = None
+    self.name = name
+    if accountCount is not None:
+      self.accountCount = int(accountCount)
+    else:
+      self.accountCount = None
+    if totalBalance is not None:
+      self.totalBalance = float(totalBalance)
+    else:
+      self.totalBalance = None
+  def __repr__(s):
+    return ("Customer(%d,%s,%d,%.2f)" % (s.customerId,s.name,s.accountCount,s.totalBalance))
+
+context = []
+cs = {}
+c = None
+
+class MyHandler(pyjsonfrag.JsonHandler):
+  def start_dict(stream, key):
+    global c
+    context.append(key)
+    if context == [None, "customers", None]:
+      c = Customer()
+  def start_array(stream, key):
+    context.append(key)
+  def end_dict(stream, key):
+    context.pop()
+  def end_array(stream, key):
+    context.pop()
+  def handle_string(stream, key, val):
+    if key == "name":
+      c.name = val
+  def handle_number(stream, key, num, is_integer):
+    if key == "id":
+      cs[int(num)] = c
+      c.customerId = int(num)
+    elif key == "accountCount":
+      c.accountCount = int(num)
+    elif key == "totalBalance":
+      c.totalBalance = num
+
+handler = MyHandler()
+stream = pyjsonfrag.JsonStream(handler)
+with open("customers.json", "r") as f:
+  while True:
+    buf = f.read(4096)
+    if buf == '':
+      stream.feed(buf, 0, len(buf), True)
+      break
+    else:
+      stream.feed(buf, 0, len(buf), False)
+print(cs)
+```
+
+It can be seen that the parser is quite cumbersome and the code to construct a customer is scattered to two different places. Yet it is fast and has a low memory footprint.
+
+## Parser with the new library
+
+What if we could combine the benefits of the jsonstream-based approach with the benefits of the "read whole parse tree into memory" based approach? A parse tree fragment for a single customer dictionary is small enough to be kept in memory. This is what the new library is about. Here is the code to parse the customer file with the new library:
+
+```
+import pyjsonfrag
+
+class Customer(object):
+  def __init__(self, customerId = None, name = None, accountCount = None, totalBalance = None):
+    if customerId is not None:
+      self.customerId = int(customerId)
+    else:
+      self.customerId = None
+    self.name = name
+    if accountCount is not None:
+      self.accountCount = int(accountCount)
+    else:
+      self.accountCount = None
+    if totalBalance is not None:
+      self.totalBalance = float(totalBalance)
+    else:
+      self.totalBalance = None
+  def __repr__(s):
+    return ("Customer(%d,%s,%d,%.2f)" % (s.customerId,s.name,s.accountCount,s.totalBalance))
+
+cs = {}
+
+class MyHandler(pyjsonfrag.FragmentHandler):
+  def start_frag_dict(self, key):
+    if self.path_is([None, "customers", None]):
+      self.start_frag_collection()
+  def end_frag_dict(self, key, val):
+    if self.path_is([None, "customers", None]):
+      c = Customer(customerId=val["id"], name=val["name"],
+                   accountCount=val["accountCount"], totalBalance=val["totalBalance"])
+      cs[c.customerId] = c
+
+handler = MyHandler()
+stream = pyjsonfrag.JsonStream(handler)
+with open("customers.json", "r") as f:
+  while True:
+    buf = f.read(4096)
+    if buf == '':
+      stream.feed(buf, 0, len(buf), True)
+      break
+    else:
+      stream.feed(buf, 0, len(buf), False)
+print(cs)
+```
+
+Note how the code is significantly more simple than for the event-based approach. Performance is close to the event-based approach, and memory consumption is essentially the same as for the event-based approach.
+
+Of course, the new library supports getting the whole parse tree in memory:
+
+```
+import pyjsonfrag
+
+with open("customers.json", "r") as f:
+  print(pyjsonfrag.jsonstream_tree_parse(f.read()))
+```
+
+## License
+
+All of the material related to PyJsonFrag is licensed under the following MIT
+license:
+
+Copyright (C) 2026 Juha-Matti Tilli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyjsonfrag-0.0.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+examples/customers.json,sha256=pjKFcftqntyImW0W7UgNZ8deW_3F7v7pcNjftVCLvyE,252
+examples/parse_frag.py,sha256=ZNmHqOOMrRg0tY32sepaT27zKrXkBac9sl6JE0nLoqA,1324
+examples/parse_stream.py,sha256=07KUrvTQANoVZ9BxIxjspgrUwWfhIv9abDfpFfZ0Vew,1579
+examples/parse_tree.py,sha256=wBz4PbRFyOZEb2rOTTwzL8nAdt2HEoQwpDidp85MVsM,110
+examples/pyjsonfrag/__init__.py,sha256=dlwC7DG10gm9jj6_Pua8H0QKwJdyH_qScRsSrjIMBWg,26055
+pyjsonfrag-0.0.1.dist-info/METADATA,sha256=HMuO6PFU-7187hQBNM6LGhFDby89z4QiKnlULyBtwDs,8255
+pyjsonfrag-0.0.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pyjsonfrag-0.0.1.dist-info/licenses/LICENSE,sha256=znzHZMVYPnIJF9OxEwqUY2MrMf8NyFEaAWIVsmWvB_w,1060
+pyjsonfrag-0.0.1.dist-info/RECORD,,

pyjsonfrag-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

pyjsonfrag-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2026 Juha-Matti Tilli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.