jsonata-python 0.6.0__py3-none-any.whl → 0.6.2__py3-none-any.whl

jsonata/cli/__main__.py

@@ -32,9 +32,9 @@ from jsonata import functions, jexception, jsonata, timebox
 def get_options(argv: Optional[list[str]] = None) -> argparse.ArgumentParser:
     """Parses command-line arguments.
     """
-    parser = argparse.ArgumentParser(prog="jsonata.cli", description="Pure Python JSONata CLI")
+    parser = argparse.ArgumentParser(prog="jsonata", description="Pure Python JSONata CLI")
     parser.add_argument(
-        "-v", "--version", action='version', version='%(prog)s 0.6.0')
+        "-v", "--version", action='version', version='%(prog)s 0.6.2')
 
     parser.add_argument(
         "-e", "--expression", metavar="<file>",

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/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")
 
     #
     #
@@ -2105,7 +2098,8 @@ class Functions:
                 dt = datetime.datetime.strptime(timestamp, "%Y")
             else:
                 dt = datetime.datetime.fromisoformat(timestamp)
-            dt = dt.replace(tzinfo=datetime.timezone.utc)
+            if dt.tzinfo is None:
+                dt = dt.replace(tzinfo=datetime.timezone.utc)
             return int(dt.timestamp() * 1000)
             # try:
             #     size = len(timestamp)

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/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)
@@ -519,7 +519,7 @@ class Jsonata:
             if index < 0:
                 # count in from end of array
                 index = len(input) + index
-            item = input[index] if index < len(input) else None
+            item = input[index] if 0 <= index < len(input) else None
             if item is not None:
                 if isinstance(item, list):
                     results = item
@@ -684,9 +684,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)
 
@@ -800,9 +797,9 @@ class Jsonata:
 
         result = None
         if op == "=":
-            result = lhs == rhs  # isDeepEqual(lhs, rhs);
+            result = utils.Utils.is_deep_equal(lhs, rhs)
         elif op == "!=":
-            result = lhs != rhs  # !isDeepEqual(lhs, rhs);
+            result = not utils.Utils.is_deep_equal(lhs, rhs)
         return result
 
     #
@@ -1475,7 +1472,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 +1493,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

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/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/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/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
@@ -90,6 +86,28 @@ class Utils:
         sequence.sequence = True
         return sequence
 
+    @staticmethod
+    def is_deep_equal(lhs: Optional[Any], rhs: Optional[Any]) -> bool:
+        if isinstance(lhs, list) and isinstance(rhs, list):
+            if len(lhs) != len(rhs):
+                return False
+            for ii, _ in enumerate(lhs):
+                if not Utils.is_deep_equal(lhs[ii], rhs[ii]):
+                    return False
+            return True
+        elif isinstance(lhs, dict) and isinstance(rhs, dict):
+            if lhs.keys() != rhs.keys():
+                return False
+            for key in lhs.keys():
+                if not Utils.is_deep_equal(lhs[key], rhs[key]):
+                    return False
+            return True
+        if lhs == rhs:
+            if isinstance(lhs, bool) != isinstance(rhs, bool):
+                return False
+            return True
+        return False
+
     class JList(list):
         sequence: bool
         outer_wrapper: bool

{jsonata_python-0.6.0.dist-info → jsonata_python-0.6.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jsonata-python
-Version: 0.6.0
+Version: 0.6.2
 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
@@ -235,7 +235,7 @@ The JSONata documentation can be found [here](https://jsonata.org).
 ## Installation
 
 ```
-pip install jsonata-python
+pipx install jsonata-python
 ```
 
 ## Getting Started
@@ -256,8 +256,8 @@ A very simple start:
 The CLI provides the same functionality as the [Dashjoin JSONata CLI](https://github.com/dashjoin/jsonata-cli).
 
 ```
-% python3 -m jsonata.cli
-usage: jsonata.cli [-h] [-v] [-e <file>] [-i <arg>] [-ic <arg>] [-f {auto,json,string}] [-o <arg>] [-oc <arg>] [-time] [-c] [-b <json-string>]
+% jsonata -h
+usage: jsonata [-h] [-v] [-e <file>] [-i <arg>] [-ic <arg>] [-f {auto,json,string}] [-o <arg>] [-oc <arg>] [-time] [-c] [-b <json-string>]
                    [-bf <file>] [-it]
                    [expr]
 
@@ -293,19 +293,19 @@ options:
 ### Examples
 
 ```
-% echo '{"a":"hello", "b":" world"}' | python3 -m jsonata.cli '(a & b)'
+% echo '{"a":"hello", "b":" world"}' | jsonata '(a & b)'
 hello world
 
-% echo '{"a":"hello", "b":" world"}' | python3 -m jsonata.cli -o helloworld.json $
+% echo '{"a":"hello", "b":" world"}' | jsonata -o helloworld.json $
 # helloworld.json written
 
-% ls | python3 -m jsonata.cli $
+% ls | jsonata $
 helloworld.json
 
-% ps -o pid="",%cpu="",%mem="" | python3 -m jsonata.cli '$.$split(/\n/).$trim().[ $split(/\s+/)[$length()>0].$number() ]' -c
+% ps -o pid="",%cpu="",%mem="" | jsonata '$.$split(/\n/).$trim().[ $split(/\s+/)[$length()>0].$number() ]' -c
 [[4105,0,0],[4646,0,0],[4666,0,0],[33696,0,0]...]
 
-% curl -s https://raw.githubusercontent.com/jsonata-js/jsonata/master/test/test-suite/datasets/dataset1.json | python3 -m jsonata.cli '{"Name": FirstName & " " & Surname, "Cities": **.City, "Emails": Email[type="home"].address}'
+% curl -s https://raw.githubusercontent.com/jsonata-js/jsonata/master/test/test-suite/datasets/dataset1.json | jsonata '{"Name": FirstName & " " & Surname, "Cities": **.City, "Emails": Email[type="home"].address}'
 {
   "Name": "Fred Smith",
   "Cities": [
@@ -318,7 +318,7 @@ helloworld.json
   ]
 }
 
-% python3 -m jsonata.cli -i helloworld.json -it
+% jsonata -i helloworld.json -it
 Enter an expression to have it evaluated.
 JSONata> (a & b)
 hello world

jsonata_python-0.6.2.dist-info/RECORD

@@ -0,0 +1,18 @@
+jsonata/__init__.py,sha256=4r8USHj4SoBy_TD8dLxt9HJIgpLfXApFrZBipi4rgr0,388
+jsonata/constants.py,sha256=WtdH_l_s5KD-SiOJ4GR2az7WpVgKB2HguXUnyfy4tvs,3017
+jsonata/datetimeutils.py,sha256=lCTGih5Qn4HZlqG2qcCniREaOt_2Dvxai5rpFq-hKj4,48609
+jsonata/functions.py,sha256=VoVVyK-9SS6CrseChFJkERqUxm7mPzcoIeALegwVztI,75709
+jsonata/jexception.py,sha256=AjyPmFyE7FecV--FLYHfcZFu-SkG1XKAEdvUQ1Ojuqo,12956
+jsonata/jsonata.py,sha256=mKoqLdVED7nQyCjNqxgPr5_IBV5nzLKdonXDVy0SXyk,84652
+jsonata/parser.py,sha256=VfWmD79PA_zp7uXUjbVY1E9CEwA60EG1EV2vEKue__M,55444
+jsonata/signature.py,sha256=6iQIgFSCH9Wv7Zhuu5U8PT-LVTtxY_qL8QMsGn5wGH4,20221
+jsonata/timebox.py,sha256=bnevNR_ONvKUiIZCJZEWsRiR0gCWTGOwn5RCY7dKqYc,2861
+jsonata/tokenizer.py,sha256=M5vEaYrMEr6UQwakDLz7dAAIXeJ7ZBPlqw9gYWTbcZM,12550
+jsonata/utils.py,sha256=kn2qjrp7et2NPT3T6XtF9g6Y5lIHWEHgA42hHXQz8rs,5834
+jsonata/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jsonata/cli/__main__.py,sha256=XfgdzMQEvKd3xkgTpvUndn5ifgVi0j4fYrn2Oejzu1E,7121
+jsonata_python-0.6.2.dist-info/METADATA,sha256=9U-6dc9p-wUZaptm0-59-RUQsAT3kRgHUDGnIwKNSyo,17338
+jsonata_python-0.6.2.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+jsonata_python-0.6.2.dist-info/entry_points.txt,sha256=a-W2yyT3IPhcC1q12BhKPcWnjNi3NXTZ3ZxoI9_UK88,54
+jsonata_python-0.6.2.dist-info/licenses/LICENSE,sha256=y16Ofl9KOYjhBjwULGDcLfdWBfTEZRXnduOspt-XbhQ,11325
+jsonata_python-0.6.2.dist-info/RECORD,,

{jsonata_python-0.6.0.dist-info → jsonata_python-0.6.2.dist-info}/WHEEL

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

jsonata_python-0.6.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+jsonata = jsonata.cli.__main__:main

jsonata_python-0.6.0.dist-info/RECORD

@@ -1,17 +0,0 @@
-jsonata/__init__.py,sha256=4r8USHj4SoBy_TD8dLxt9HJIgpLfXApFrZBipi4rgr0,388
-jsonata/constants.py,sha256=WtdH_l_s5KD-SiOJ4GR2az7WpVgKB2HguXUnyfy4tvs,3017
-jsonata/datetimeutils.py,sha256=IzU6y-vwyhwobHyw9rsImBye-RfWDV7K8Vk0Xs-yiG0,48567
-jsonata/functions.py,sha256=2vip5OJt8VMprF1vOnvr3iCQQlLGbfOItQ3MwDXzCTM,75691
-jsonata/jexception.py,sha256=6Jz7WMsIiNlQ7-1Hq8RKiE2HxcHq2PDekw0qsSe3lqo,12885
-jsonata/jsonata.py,sha256=jZIxVrNcZI3aBvE0PURZ4-cxpaK9JiJVH5Q_cllCXS0,84247
-jsonata/parser.py,sha256=dzZ6PeM5l3scTHq4DzCXt4FSRO49yzYEk7XqspCcHNU,55359
-jsonata/signature.py,sha256=j7eNKUuGx_9vCt5Qv8BPM7iV5vH26U0Kx8zrkDcctME,20194
-jsonata/timebox.py,sha256=bnevNR_ONvKUiIZCJZEWsRiR0gCWTGOwn5RCY7dKqYc,2861
-jsonata/tokenizer.py,sha256=6noGxO1L_n2V-Uva5oV044Xx0p08Gm7-XXSfLEG4rR0,12429
-jsonata/utils.py,sha256=U13I49Ie3hEn3PKGR4361TPengDAkbyHmwipDFZJlXo,5192
-jsonata/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jsonata/cli/__main__.py,sha256=xfwJE5nkt6tYH__Zk1PQ_R0idkmQq1XcAKRFt3-bTEo,7125
-jsonata_python-0.6.0.dist-info/METADATA,sha256=m_Srw48y9PCRzQYzqZz6TJM7mU73pWddDhw9FXEGLOo,17442
-jsonata_python-0.6.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-jsonata_python-0.6.0.dist-info/licenses/LICENSE,sha256=y16Ofl9KOYjhBjwULGDcLfdWBfTEZRXnduOspt-XbhQ,11325
-jsonata_python-0.6.0.dist-info/RECORD,,