jsonata-python 0.4.0__tar.gz → 0.5.0__tar.gz

{jsonata_python-0.4.0 → jsonata_python-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: jsonata-python
-Version: 0.4.0
+Version: 0.5.0
 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

{jsonata_python-0.4.0 → jsonata_python-0.5.0}/jsonata/docs/overview.md

@@ -26,9 +26,10 @@ The following are known implementations of JSONata in addition to the primary im
 |Go|https://github.com/blues/jsonata-go|Native implementation|1.5.4|
 |Go|https://github.com/yxuco/gojsonata|Native implementation| |
 |Java|https://github.com/IBM/JSONata4Java|Native implementation| |
-|Java|https://github.com/dashjoin/jsonata-java|Native port of reference|2.0.3|
+|Java|https://github.com/dashjoin/jsonata-java|Native port of reference|2.0.5|
 |.NET|https://github.com/mikhail-barg/jsonata.net.native|Native implementation|1.8.5|
 |Python|https://github.com/qlyoung/pyjsonata|API bindings based on C bindings|1.8.3|
+|Python|https://github.com/rayokota/jsonata-python|Native port of reference|2.0.5|
 |Rust|https://github.com/johanventer/jsonata-rust|Implementation work in progress| |
 |Rust|https://github.com/Stedi/jsonata-rs|Actively-developed fork of jsonata-rust| |
 

{jsonata_python-0.4.0 → jsonata_python-0.5.0}/jsonata/docs/processing.md

@@ -50,7 +50,7 @@ Stage | Syntax | Action
  __Filter__ | seq`[`expr`]` | Filter results from previous stage by applying predicate expression between brackets to each item.
  __Sort__ | seq`^(`expr`)` | Sorts (re-orders) the input sequence according to the criteria in parentheses.
  __Index__ | seq`#`$var | Binds a named variable to the current context position (zero offset) in the sequence.
- __Join__ | seq`@`$var | Binds a named variable to the current current context item in the sequence.  Can only be used directly following a map stage.
+ __Join__ | seq`@`$var | Binds a named variable to the current context item in the sequence.  Can only be used directly following a map stage.
 __Reduce__ | seq`{` expr`:`expr`,` expr`:`expr ...`}` | Group and aggregate the input sequence to a single result object as defined by the name/value expressions.  Can only appear as the final stage in a path expression.
 
 In the above table:

{jsonata_python-0.4.0 → jsonata_python-0.5.0}/jsonata/docs/programming.md

@@ -200,7 +200,7 @@ Note that it is actually possible to write a recursive function using purely ano
 
 ### Tail call optimization (Tail recursion)
 
-A recursive function adds a new frame to the call stack each time it invokes itself.  This can eventually lead to stack exhaustion if the function recuses beyond a certain limit.  Consider the classic recursive implementation of the factorial function
+A recursive function adds a new frame to the call stack each time it invokes itself.  This can eventually lead to stack exhaustion if the function recurses beyond a certain limit.  Consider the classic recursive implementation of the factorial function
 
 ```
 (

{jsonata_python-0.4.0 → jsonata_python-0.5.0}/jsonata/jsonata.d.ts

@@ -11,7 +11,26 @@ declare namespace jsonata {
   }
 
   interface ExprNode {
-    type: string;
+    type:
+        | "binary"
+        | "unary"
+        | "function"
+        | "partial"
+        | "lambda"
+        | "condition"
+        | "transform"
+        | "block"
+        | "name"
+        | "parent"
+        | "string"
+        | "number"
+        | "value"
+        | "wildcard"
+        | "descendant"
+        | "variable"
+        | "regexp"
+        | "operator"
+        | "error";
     value?: any;
     position?: number;
     arguments?: ExprNode[];
@@ -20,7 +39,7 @@ declare namespace jsonata {
     steps?: ExprNode[];
     expressions?: ExprNode[];
     stages?: ExprNode[];
-    lhs?: ExprNode[];
+    lhs?: ExprNode | ExprNode[];
     rhs?: ExprNode;
   }
 

{jsonata_python-0.4.0 → jsonata_python-0.5.0}/jsonata/src/parser.js

@@ -1194,6 +1194,7 @@ const parser = (() => {
                             result = {type: 'apply', value: expr.value, position: expr.position};
                             result.lhs = processAST(expr.lhs);
                             result.rhs = processAST(expr.rhs);
+                            result.keepArray = result.lhs.keepArray || result.rhs.keepArray;
                             break;
                         default:
                             result = {type: expr.type, value: expr.value, position: expr.position};

jsonata_python-0.5.0/jsonata/test/test-suite/groups/hof-map/case0010.json

@@ -0,0 +1,6 @@
+{
+    "expr": "( $square := function($x){$x*$x}; $map([1], $square)[] )",
+    "data": null,
+    "bindings": {},
+    "result": [1]
+}

jsonata_python-0.5.0/jsonata/test/test-suite/groups/hof-map/case0011.json

@@ -0,0 +1,6 @@
+{
+    "expr": "( $data := [1]; $square := function($x){$x*$x}; $data ~> $map($square)[] )",
+    "data": null,
+    "bindings": {},
+    "result": [1]
+}

{jsonata_python-0.4.0 → jsonata_python-0.5.0}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "jsonata-python"
-version = "0.4.0"
+version = "0.5.0"
 description = "Pure Python implementation of JSONata"
 readme = "README.md"
 requires-python = ">=3.9"

{jsonata_python-0.4.0 → jsonata_python-0.5.0}/src/jsonata/cli/__main__.py

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

{jsonata_python-0.4.0 → jsonata_python-0.5.0}/src/jsonata/functions.py

@@ -1570,8 +1570,11 @@ class Functions:
         from jsonata import jsonata
         if isinstance(func, jsonata.Jsonata.JFunction):
             return func.signature.get_min_number_of_args()
+        elif isinstance(func, jsonata.Jsonata.JLambda):
+            from inspect import signature
+
+            return len(signature(func.function).parameters)
         else:
-            # Lambda
             return len(func.arguments)
 
     #

{jsonata_python-0.4.0 → jsonata_python-0.5.0}/src/jsonata/parser.py

@@ -1180,6 +1180,7 @@ class Parser:
                 result.position = expr.position
                 result.lhs = self.process_ast(expr.lhs)
                 result.rhs = self.process_ast(expr.rhs)
+                result.keep_array = result.lhs.keep_array or result.rhs.keep_array
             else:
                 result = Parser.Infix(self, None)
                 result.type = expr.type

{jsonata_python-0.4.0 → jsonata_python-0.5.0}/src/jsonata/signature.py

@@ -307,6 +307,7 @@ class Signature:
                             validated_args.append(arg)
                             arg_index += 1
                         else:
+                            arg = args[arg_index] if arg_index < len(args) else None
                             validated_args.append(arg)
                             arg_index += 1
             return validated_args

{jsonata_python-0.4.0 → jsonata_python-0.5.0}/tests/custom_function_test.py

@@ -22,3 +22,12 @@ class TestCustomFunction:
         expression = jsonata.Jsonata("$abc(a,b,c)")
         expression.register_lambda("abc", lambda x, y, z: str(x) + str(y) + str(z))
         assert expression.evaluate({"a": "a", "b": "b", "c": "c"}) == "abc"
+
+    def test_map_with_lambda(self):
+        expression = jsonata.Jsonata("$map([1, 2, 3], $square)")
+        expression.register_lambda("square", lambda x: x * x)
+        assert expression.evaluate(None) == [1, 4, 9]
+
+    def test_map_with_function(self):
+        expression = jsonata.Jsonata("$map([1, 2, 3], function($v) { $v * $v })")
+        assert expression.evaluate(None) == [1, 4, 9]