feat: integrate jsonpath extension package

Author: tomas-fp

jsonpath_rw/__init__.py

@@ -1,4 +1,5 @@
 from .jsonpath import *
 from .parser import parse
+from .lexer import lexer
 
-__version__ = '1.3.0'
+__version__ = '1.4.0'

jsonpath_rw/ext/__init__.py

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+from .parser import parse  # noqa

jsonpath_rw/ext/arithmetic.py

@@ -0,0 +1,72 @@
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+import operator
+from .. import JSONPath, DatumInContext
+
+
+OPERATOR_MAP = {
+    '+': operator.add,
+    '-': operator.sub,
+    '*': operator.mul,
+    '/': operator.truediv,
+}
+
+
+class Operation(JSONPath):
+    def __init__(self, left, op, right):
+        self.left = left
+        self.op = OPERATOR_MAP[op]
+        self.right = right
+
+    def find(self, datum):
+        result = []
+        if (isinstance(self.left, JSONPath)
+                and isinstance(self.right, JSONPath)):
+            left = self.left.find(datum)
+            right = self.right.find(datum)
+            if left and right and len(left) == len(right):
+                for l, r in zip(left, right):
+                    try:
+                        result.append(self.op(l.value, r.value))
+                    except TypeError:
+                        return []
+            else:
+                return []
+        elif isinstance(self.left, JSONPath):
+            left = self.left.find(datum)
+            for l in left:
+                try:
+                    result.append(self.op(l.value, self.right))
+                except TypeError:
+                    return []
+        elif isinstance(self.right, JSONPath):
+            right = self.right.find(datum)
+            for r in right:
+                try:
+                    result.append(self.op(self.left, r.value))
+                except TypeError:
+                    return []
+        else:
+            try:
+                result.append(self.op(self.left, self.right))
+            except TypeError:
+                return []
+        return [DatumInContext.wrap(r) for r in result]
+
+    def __repr__(self):
+        return '%s(%r%s%r)' % (self.__class__.__name__, self.left, self.op,
+                               self.right)
+
+    def __str__(self):
+        return '%s%s%s' % (self.left, self.op, self.right)

jsonpath_rw/ext/filter.py

@@ -0,0 +1,110 @@
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+import operator
+from six import moves
+
+from .. import JSONPath, DatumInContext, Index
+
+
+OPERATOR_MAP = {
+    '!=': operator.ne,
+    '==': operator.eq,
+    '=': operator.eq,
+    '<=': operator.le,
+    '<': operator.lt,
+    '>=': operator.ge,
+    '>': operator.gt,
+}
+
+
+class Filter(JSONPath):
+    """The JSONQuery filter"""
+
+    def __init__(self, expressions):
+        self.expressions = expressions
+
+    def find(self, datum):
+        if not self.expressions:
+            return datum
+
+        datum = DatumInContext.wrap(datum)
+        if not isinstance(datum.value, list):
+            return []
+
+        return [DatumInContext(datum.value[i], path=Index(i), context=datum)
+                for i in moves.range(0, len(datum.value))
+                if (len(self.expressions) ==
+                    len(list(filter(lambda x: x.find(datum.value[i]),
+                                    self.expressions))))]
+
+    def __repr__(self):
+        return '%s(%r)' % (self.__class__.__name__, self.expressions)
+
+    def __str__(self):
+        return '[?%s]' % self.expressions
+
+
+class Expression(JSONPath):
+    """The JSONQuery expression"""
+
+    def __init__(self, target, op, value):
+        self.target = target
+        self.op = op
+        self.value = value
+
+    def find(self, datum):
+        datum = self.target.find(DatumInContext.wrap(datum))
+
+        if not datum:
+            return []
+        if self.op is None:
+            return datum
+
+        found = []
+        for data in datum:
+            value = data.value
+            if isinstance(self.value, int):
+                try:
+                    value = int(value)
+                except ValueError:
+                    continue
+            elif isinstance(self.value, bool):
+                try:
+                    value = bool(value)
+                except ValueError:
+                    continue
+
+            if OPERATOR_MAP[self.op](value, self.value):
+                found.append(data)
+
+        return found
+
+    def __eq__(self, other):
+        return (isinstance(other, Filter) and
+                self.target == other.target and
+                self.op == other.op and
+                self.value == other.value)
+
+    def __repr__(self):
+        if self.op is None:
+            return '%s(%r)' % (self.__class__.__name__, self.target)
+        else:
+            return '%s(%r %s %r)' % (self.__class__.__name__,
+                                     self.target, self.op, self.value)
+
+    def __str__(self):
+        if self.op is None:
+            return '%s' % self.target
+        else:
+            return '%s %s %s' % (self.target, self.op, self.value)

jsonpath_rw/ext/iterable.py

@@ -0,0 +1,92 @@
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+import functools
+from .. import This, DatumInContext, JSONPath
+
+
+class SortedThis(This):
+    """The JSONPath referring to the sorted version of the current object.
+
+    Concrete syntax is '`sorted`' or [\\field,/field].
+    """
+    def __init__(self, expressions=None):
+        self.expressions = expressions
+
+    def _compare(self, left, right):
+        left = DatumInContext.wrap(left)
+        right = DatumInContext.wrap(right)
+
+        for expr in self.expressions:
+            field, reverse = expr
+            l_datum = field.find(left)
+            r_datum = field.find(right)
+            if (not l_datum or not r_datum or
+                    len(l_datum) > 1 or len(r_datum) > 1 or
+                    l_datum[0].value == r_datum[0].value):
+                # NOTE(sileht): should we do something if the expression
+                # match multiple fields, for now ignore them
+                continue
+            elif l_datum[0].value < r_datum[0].value:
+                return 1 if reverse else -1
+            else:
+                return -1 if reverse else 1
+        return 0
+
+    def find(self, datum):
+        """Return sorted value of This if list or dict."""
+        if isinstance(datum.value, dict) and self.expressions:
+            return datum
+
+        if isinstance(datum.value, dict) or isinstance(datum.value, list):
+            key = (functools.cmp_to_key(self._compare)
+                   if self.expressions else None)
+            return [DatumInContext.wrap(
+                [value for value in sorted(datum.value, key=key)])]
+        return datum
+
+    def __eq__(self, other):
+        return isinstance(other, Len)
+
+    def __repr__(self):
+        return '%s(%r)' % (self.__class__.__name__, self.expressions)
+
+    def __str__(self):
+        return '[?%s]' % self.expressions
+
+
+class Len(JSONPath):
+    """The JSONPath referring to the len of the current object.
+
+    Concrete syntax is '`len`'.
+    """
+
+    def find(self, datum):
+        datum = DatumInContext.wrap(datum)
+        try:
+            value = len(datum.value)
+        except TypeError:
+            return []
+        else:
+            return [DatumInContext(value,
+                                               context=None,
+                                               path=Len())]
+
+    def __eq__(self, other):
+        return isinstance(other, Len)
+
+    def __str__(self):
+        return '`len`'
+
+    def __repr__(self):
+        return 'Len()'