jsonata-python 0.6.1__tar.gz → 0.6.3__tar.gz

{jsonata_python-0.6.1 → jsonata_python-0.6.3}/.github/workflows/test.yml

@@ -9,16 +9,16 @@ jobs:
   test:
     strategy:
       matrix:
-        python: ['3.9', '3.10', '3.11', '3.12', '3.13']
+        python: ['3.10', '3.11', '3.12', '3.13', '3.14']
         platform: [ubuntu-latest, macos-latest, windows-latest]
     runs-on: ${{ matrix.platform }}
     steps:
     - name: Checkout
-      uses: actions/checkout@v3
+      uses: actions/checkout@v6
       with:
         submodules: recursive
     - name: Set up Python ${{ matrix.python }}
-      uses: actions/setup-python@v3
+      uses: actions/setup-python@v6
       with:
         python-version: ${{ matrix.python }}
     - name: Install test dependencies

{jsonata_python-0.6.1 → jsonata_python-0.6.3}/.gitignore

@@ -17,3 +17,5 @@ venv/
 .idea
 .venv
 tests/gen
+
+.claude

{jsonata_python-0.6.1 → jsonata_python-0.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jsonata-python
-Version: 0.6.1
+Version: 0.6.3
 Summary: Pure Python implementation of JSONata
 Project-URL: Homepage, https://github.com/rayokota/jsonata-python
 Project-URL: Bug Reports, https://github.com/rayokota/jsonata-python/issues
@@ -212,7 +212,7 @@ Keywords: json,jsonata
 Classifier: Development Status :: 4 - Beta
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 
 # jsonata-python

{jsonata_python-0.6.1 → jsonata_python-0.6.3}/noxfile.py

@@ -37,7 +37,7 @@ def build_and_check_dists(session):
     session.run("python", "-m", "twine", "check", "dist/*")
 
 
-@nox.session(python=["3.9", "3.10", "3.11", "3.12", "3.13"])
+@nox.session(python=["3.10", "3.11", "3.12", "3.13", "3.14"])
 def tests(session):
     session.install("pytest")
     session.install("pytest-asyncio")

{jsonata_python-0.6.1 → jsonata_python-0.6.3}/pyproject.toml

@@ -7,10 +7,10 @@ jsonata = "jsonata.cli.__main__:main"
 
 [project]
 name = "jsonata-python"
-version = "0.6.1"
+version = "0.6.3"
 description = "Pure Python implementation of JSONata"
 readme = "README.md"
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 license = {file = "LICENSE"}
 keywords = ["jsonata", "json"]
 authors = [

{jsonata_python-0.6.1 → jsonata_python-0.6.3}/src/jsonata/cli/__main__.py

@@ -34,7 +34,7 @@ def get_options(argv: Optional[list[str]] = None) -> argparse.ArgumentParser:
     """
     parser = argparse.ArgumentParser(prog="jsonata", description="Pure Python JSONata CLI")
     parser.add_argument(
-        "-v", "--version", action='version', version='%(prog)s 0.6.1')
+        "-v", "--version", action='version', version='%(prog)s 0.6.3')
 
     parser.add_argument(
         "-e", "--expression", metavar="<file>",

{jsonata_python-0.6.1 → jsonata_python-0.6.3}/src/jsonata/datetimeutils.py

@@ -524,7 +524,7 @@ class DateTimeUtils:
         while pos < len(picture):
             if picture[pos] == '[':
                 # check it's not a doubled [[
-                if picture[pos + 1] == '[':
+                if pos + 1 < len(picture) and picture[pos + 1] == '[':
                     # literal [
                     format.add_literal(picture, start, pos)
                     format.parts.append(DateTimeUtils.SpecPart("literal", value="["))
@@ -637,14 +637,14 @@ class DateTimeUtils:
 
         offset_millis = (60 * offset_hours + offset_minutes) * 60 * 1000
         date_time = datetime.datetime.fromtimestamp((millis + offset_millis) / 1000.0, datetime.timezone.utc)
-        result = ""
+        parts = []
         for part in format_spec.parts:
             if part.type == "literal":
-                result += part.value
+                parts.append(part.value)
             else:
-                result += DateTimeUtils._format_component(date_time, part, offset_hours, offset_minutes)
+                parts.append(DateTimeUtils._format_component(date_time, part, offset_hours, offset_minutes))
 
-        return result
+        return ''.join(parts)
 
     @staticmethod
     def _format_component(date: datetime.datetime, marker_spec: SpecPart, offset_hours: int,

{jsonata_python-0.6.1 → jsonata_python-0.6.3}/src/jsonata/functions.py

@@ -474,11 +474,7 @@ class Functions:
         pads = size - str_len
         if pads <= 0:
             return string
-        padding = ""
-        i = 0
-        while i < pads + 1:
-            padding += pad_str
-            i += 1
+        padding = pad_str * (pads // len(pad_str) + 1)
         return Functions.substr(padding, 0, pads) + string
 
     # Source: Jsonata4Java PadFunction
@@ -501,11 +497,7 @@ class Functions:
         pads = size - str_len
         if pads <= 0:
             return string
-        padding = ""
-        i = 0
-        while i < pads + 1:
-            padding += pad_str
-            i += 1
+        padding = pad_str * (pads // len(pad_str) + 1)
         return string + Functions.substr(padding, 0, pads)
 
     @dataclass
@@ -767,23 +759,23 @@ class Functions:
             raise jexception.JException("Fourth argument of replace function must evaluate to a positive number", 0)
 
         def string_replacer(match):
-            result = ''
+            parts = []
             position = 0
             repl = str(replacement)
             while position < len(repl):
                 index = repl.find('$', position)
                 if index == -1:
-                    result += repl[position:]
+                    parts.append(repl[position:])
                     break
-                result += repl[position:index]
+                parts.append(repl[position:index])
                 position = index + 1
                 if position < len(repl):
                     dollar_val = repl[position]
                     if dollar_val == '$':
-                        result += '$'
+                        parts.append('$')
                         position += 1
                     elif dollar_val == '0':
-                        result += match.group(0)
+                        parts.append(match.group(0))
                         position += 1
                     else:
                         max_digits = len(str(len(match.groups())))
@@ -791,15 +783,15 @@ class Functions:
                         if group_num.isdigit():
                             group_index = int(group_num)
                             if 0 < group_index <= len(match.groups()):
-                                result += match.group(group_index) or ''
+                                parts.append(match.group(group_index) or '')
                                 position += len(group_num)
                             else:
-                                result += '$'
+                                parts.append('$')
                         else:
-                            result += '$'
+                            parts.append('$')
                 else:
-                    result += '$'
-            return result
+                    parts.append('$')
+            return ''.join(parts)
 
         if callable(replacement):
             replacer = lambda m: replacement(m.groupdict())
@@ -810,23 +802,23 @@ class Functions:
 
         if isinstance(pattern, str):
             # Use string methods for literal string patterns
-            result = ''
+            parts = []
             position = 0
             count = 0
             while True:
                 if limit is not None and count >= limit:
-                    result += string[position:]
+                    parts.append(string[position:])
                     break
                 index = string.find(pattern, position)
                 if index == -1:
-                    result += string[position:]
+                    parts.append(string[position:])
                     break
-                result += string[position:index]
+                parts.append(string[position:index])
                 match = re.match(re.escape(pattern), string[index:])
-                result += replacer(match)
+                parts.append(replacer(match))
                 position = index + len(pattern)
                 count += 1
-            return result
+            return ''.join(parts)
         else:
             # Use regex for pattern objects
             if limit is None:
@@ -1844,7 +1836,8 @@ class Functions:
     #     
     @staticmethod
     def error(message: Optional[str]) -> NoReturn:
-        raise jexception.JException("D3137", -1, message if message is not None else "$error() function evaluated")
+        raise jexception.JException("D3137", -1,
+                                    message if message is not None else "$error() function evaluated")
 
     #
     #
@@ -1859,8 +1852,8 @@ class Functions:
             raise jexception.JException("T0410", -1)
 
         if not condition:
-            raise jexception.JException("D3141", -1, "$assert() statement failed")
-            #                message: message || "$assert() statement failed"
+            raise jexception.JException("D3141", -1,
+                                        message if message is not None else "$assert() statement failed")
 
     #
     #

{jsonata_python-0.6.1 → jsonata_python-0.6.3}/src/jsonata/jexception.py

@@ -105,6 +105,9 @@ class JException(RuntimeError):
 
         formatted = message
 
+        if formatted == "{{{message}}}":
+            return str(arg1)
+
         # Replace any {{var}} with format "{}"
         formatted = re.sub("\\{\\{\\w+\\}\\}", "{}", formatted)
 

{jsonata_python-0.6.1 → jsonata_python-0.6.3}/src/jsonata/jsonata.py

@@ -469,7 +469,7 @@ class Jsonata:
         result.tuple_stream = True
         step_env = environment
         if tuple_bindings is None:
-            tuple_bindings = [{"@": item} for item in input if item is not None]
+            tuple_bindings = [{"@": item} for item in input]
 
         for tuple_binding in tuple_bindings:
             step_env = self.create_frame_from_tuple(environment, tuple_binding)
@@ -512,15 +512,21 @@ class Jsonata:
         results = utils.Utils.create_sequence()
         if isinstance(input, utils.Utils.JList) and input.tuple_stream:
             results.tuple_stream = True
-        if not (isinstance(input, list)):
+        if input is None:
+            # undefined input yields undefined output; skip filtering entirely
+            input = utils.Utils.create_sequence()
+        elif not (isinstance(input, list)):
             input = utils.Utils.create_sequence(input)
         if predicate.type == "number":
             index = int(predicate.value)  # round it down - was Math.floor
             if index < 0:
                 # count in from end of array
                 index = len(input) + index
-            item = input[index] if index < len(input) else None
-            if item is not None:
+            if 0 <= index < len(input):
+                item = input[index]
+                # Preserve JSON null at this index (vs. out-of-bounds, which is undefined)
+                if item is None:
+                    item = utils.Utils.NULL_VALUE
                 if isinstance(item, list):
                     results = item
                 else:
@@ -684,9 +690,6 @@ class Jsonata:
                 if isinstance(value, list):
                     value = self.flatten(value, None)
                     results = functions.Functions.append(results, value)
-                elif isinstance(value, dict):
-                    # Call recursively do decompose the map
-                    results.extend(self.evaluate_wildcard(expr, value))
                 else:
                     results.append(value)
 
@@ -1475,7 +1478,14 @@ class Jsonata:
             elif isinstance(proc, Jsonata.JLambda):
                 result = proc.call(input, validated_args)
             elif isinstance(proc, re.Pattern):
-                result = [s for s in validated_args if proc.search(s) is not None]
+                _res = []
+                for s in validated_args:
+                    if isinstance(s, str):
+                        _res.append(Jsonata._regex_closure(proc.finditer(s)))
+                if len(_res) == 1:
+                    result = _res[0]
+                else:
+                    result = _res
             else:
                 print("Proc not found " + str(proc))
                 raise jexception.JException("T1006", 0)
@@ -1489,6 +1499,19 @@ class Jsonata:
             raise err
         return result
 
+    @staticmethod
+    def _regex_closure(iterator):
+        m = next(iterator, None)
+        if m is None:
+            return None
+        return {
+            "match": m.group(),
+            "start": m.start(),
+            "end": m.end(),
+            "groups": [m.group()],
+            "next": Jsonata.JLambda(lambda: Jsonata._regex_closure(iterator))
+        }
+
     #
     # Evaluate lambda against input data
     # @param {Object} expr - JSONata expression
@@ -1898,6 +1921,7 @@ class Jsonata:
 
         self.input = None
         self.validate_input = True
+        self.output_convert_nulls = True
 
         # Note: now and millis are implemented in Functions
         #  environment.bind("now", defineFunction(function(picture, timezone) {
@@ -1934,6 +1958,24 @@ class Jsonata:
     def set_validate_input(self, validate_input: bool) -> None:
         self.validate_input = validate_input
 
+    #
+    # Checks whether output NULL_VALUE conversion is enabled
+    #
+    def is_output_convert_nulls(self) -> bool:
+        return self.output_convert_nulls
+
+    #
+    # Enable or disable output NULL_VALUE conversion. Enabled by default, which
+    # returns both "JSONata null" and "JSONata undefined" as Python None.
+    #
+    # When disabled, output values may contain Utils.NULL_VALUE indicating
+    # "JSONata null" while Python None indicates "JSONata undefined".
+    # Manually calling Utils.convert_nulls(result) on a raw result will yield
+    # the converted result.
+    #
+    def set_output_convert_nulls(self, output_convert_nulls: bool) -> None:
+        self.output_convert_nulls = output_convert_nulls
+
     def evaluate(self, input: Optional[Any], bindings: Optional[Frame] = None) -> Optional[Any]:
         # throw if the expression compiled with syntax errors
         if self.errors is not None:
@@ -1970,7 +2012,8 @@ class Jsonata:
             #  if (typeof callback === "function") {
             #      callback(null, it)
             #  }
-            it = utils.Utils.convert_nulls(it)
+            if self.output_convert_nulls:
+                it = utils.Utils.convert_nulls(it)
             return it
         except Exception as err:
             # insert error message into structure

{jsonata_python-0.6.1 → jsonata_python-0.6.3}/src/jsonata/parser.py

@@ -1047,7 +1047,8 @@ class Parser:
                 rest = self.process_ast(expr.rhs)
                 if (rest.type == "function" and rest.procedure.type == "path" and len(
                         rest.procedure.steps) == 1 and rest.procedure.steps[0].type == "name" and
-                        result.steps[-1].type == "function"):
+                        result.steps[-1].type == "function" and
+                        isinstance(rest.procedure.steps[0].value, Parser.Symbol)):
                     # next function in chain of functions - will override a thenable
                     result.steps[-1].next_function = rest.procedure.steps[0].value
                 if rest.type == "path":

{jsonata_python-0.6.1 → jsonata_python-0.6.3}/src/jsonata/signature.py

@@ -308,6 +308,7 @@ class Signature:
                             arg = args[arg_index] if arg_index < len(args) else None
                             validated_args.append(arg)
                             arg_index += 1
+                index += 1
             return validated_args
         self.throw_validation_error(args, supplied_sig, self.function_name)
 

{jsonata_python-0.6.1 → jsonata_python-0.6.3}/src/jsonata/tokenizer.py

@@ -32,6 +32,8 @@ from typing import Any, Optional
 
 from jsonata import jexception, utils
 
+_NUMBER_PATTERN = re.compile(r"^-?(0|([1-9][0-9]*))(\.[0-9]+)?([Ee][-+]?[0-9]+)?")
+
 
 class Tokenizer:
     operators = {
@@ -135,7 +137,10 @@ class Tokenizer:
                 if pattern == "":
                     raise jexception.JException("S0301", self.position)
                 self.position += 1
-                current_char = self.path[self.position]
+                if self.position < self.length:
+                    current_char = self.path[self.position]
+                else:
+                    current_char = None
                 # flags
                 start = self.position
                 while current_char == 'i' or current_char == 'm':
@@ -264,8 +269,7 @@ class Tokenizer:
                 self.position += 1
             raise jexception.JException("S0101", self.position)
         # test for numbers
-        numregex = re.compile("^-?(0|([1-9][0-9]*))(\\.[0-9]+)?([Ee][-+]?[0-9]+)?")
-        match_ = numregex.search(self.path[self.position:])
+        match_ = _NUMBER_PATTERN.search(self.path[self.position:])
         if match_ is not None:
             num = float(match_.group(0))
             if not math.isnan(num) and math.isfinite(num):

{jsonata_python-0.6.1 → jsonata_python-0.6.3}/src/jsonata/utils.py

@@ -74,11 +74,7 @@ class Utils:
     @staticmethod
     def create_sequence(el: Optional[Any] = NONE) -> list:
         if el is not Utils.NONE:
-            if isinstance(el, list) and len(el) == 1:
-                sequence = Utils.JList(el)
-            else:
-                # This case does NOT exist in Javascript! Why?
-                sequence = Utils.JList([el])
+            sequence = Utils.JList([el])
         else:
             sequence = Utils.JList()
         sequence.sequence = True
@@ -106,9 +102,10 @@ class Utils:
                 if not Utils.is_deep_equal(lhs[key], rhs[key]):
                     return False
             return True
-        if lhs == rhs and type(lhs) == type(rhs):
+        if lhs == rhs:
+            if isinstance(lhs, bool) != isinstance(rhs, bool):
+                return False
             return True
-
         return False
 
     class JList(list):

jsonata_python-0.6.3/tests/array_test.py

@@ -0,0 +1,40 @@
+import jsonata
+import pytest
+
+
+class TestArray:
+
+    def test_negative_index(self):
+        expr = jsonata.Jsonata("item[-1]")
+        assert expr.evaluate({"item": []}) is None
+        expr = jsonata.Jsonata("$[-1]")
+        assert expr.evaluate([]) is None
+
+    def test_array(self):
+        assert jsonata.Jsonata("$.[{ }] ~> $reduce($append)").evaluate([True, True]) == [{}, {}]
+
+    def test_wildcard(self):
+        expr = jsonata.Jsonata("*")
+        assert expr.evaluate([{"x": 1}]) == {"x": 1}
+
+    def test_index(self):
+        expr = jsonata.Jsonata("($x:=['a','b']; $x#$i.$i)")
+        assert expr.evaluate(1) == [0, 1]
+        assert expr.evaluate(None) == [0, 1]
+
+    def test_wildcard_filter(self):
+        value1 = {"value": {"Name": "Cell1", "Product": "Product1"}}
+        value2 = {"value": {"Name": "Cell2", "Product": "Product2"}}
+        data = [value1, value2]
+
+        expression = jsonata.Jsonata("*[value.Product = 'Product1']")
+        assert expression.evaluate(data) == value1
+
+        expression2 = jsonata.Jsonata("**[value.Product = 'Product1']")
+        assert expression2.evaluate(data) == value1
+
+    def test_assert_custom_message(self):
+        expr = jsonata.Jsonata("$assert(false, 'custom error')")
+        with pytest.raises(jsonata.JException) as exc_info:
+            expr.evaluate(None)
+        assert "custom error" in str(exc_info.value)

{jsonata_python-0.6.1 → jsonata_python-0.6.3}/tests/jsonata_test.py

@@ -3,6 +3,23 @@ import jsonata
 import math
 import pathlib
 import traceback
+import uuid
+
+
+# Sentinel representing a JSONata undefined result (distinct from JSONata null,
+# which surfaces as Python None after Utils.convert_nulls).
+UNDEFINED = "__UNDEFINED__" + uuid.uuid4().hex
+
+
+def evaluate_jsonata(expr, data, bindings):
+    """Evaluate `expr`, returning UNDEFINED for an undefined result (to
+    distinguish it from JSONata null, which becomes Python None)."""
+    j = jsonata.Jsonata(expr)
+    j.set_output_convert_nulls(False)
+    result = j.evaluate(data, bindings)
+    if result is None:
+        result = UNDEFINED
+    return jsonata.Utils.convert_nulls(result)
 
 
 class TestJsonata:
@@ -27,20 +44,15 @@ class TestJsonata:
                 for k, v in bindings.items():
                     binding_frame.bind(k, v)
 
-            jsonata_expr = jsonata.Jsonata(expr)
             if binding_frame is not None:
                 binding_frame.set_runtime_bounds(500000 if TestJsonata.debug else 10000, 303)
-            result = jsonata_expr.evaluate(data, binding_frame)
-            if code is not None:
-                success = False
 
-            if expected is not None and expected != result:
-                # if ((""+expected).equals(""+result))
-                #     System.out.println("Value equals failed, stringified equals = true. Result = "+result)
-                # else
+            result = evaluate_jsonata(expr, data, binding_frame)
+
+            if code is not None:
                 success = False
 
-            if expected is None and result is not None:
+            if expected != result:
                 success = False
 
             if TestJsonata.debug and success:
@@ -119,22 +131,6 @@ class TestJsonata:
             success &= self.run_test_case(name, test_case)
         return success
 
-    def replace_nulls(self, o):
-        if isinstance(o, list):
-            index = 0
-            for i in o:
-                if i is None:
-                    o[index] = jsonata.Utils.NULL_VALUE
-                else:
-                    self.replace_nulls(i)
-                index += 1
-        if isinstance(o, dict):
-            for k, v in o.items():
-                if v is None:
-                    o[k] = jsonata.Utils.NULL_VALUE
-                else:
-                    self.replace_nulls(v)
-
     testOverrides = None
 
     @staticmethod
@@ -174,20 +170,21 @@ class TestJsonata:
         bindings = test_def.get("bindings")
         result = test_def.get("result")
 
-        # if (result == null)
-        #   if (testDef.containsKey("result"))
-        #     result = Jsonata.NULL_VALUE
-
-        # replaceNulls(result)
+        # Check if test is expected to return undefined result
+        if str(test_def.get("undefinedResult")).lower() == "true":
+            result = UNDEFINED
 
         code = test_def.get("code")
 
         if isinstance(test_def.get("error"), dict):
             code = test_def.get("error").get("code")
 
-        # System.out.println(""+bindings)
-
         data = test_def.get("data")
+        # Explicit `"data": null` means JSONata null input (not undefined), so
+        # feed it as NULL_VALUE since Python None would be read as undefined.
+        if "data" in test_def and data is None:
+            data = jsonata.Utils.NULL_VALUE
+
         if data is None and dataset is not None:
             data = self.read_json("jsonata/test/test-suite/datasets/" + dataset + ".json")