omlish 0.0.0.dev45__py3-none-any.whl → 0.0.0.dev47__py3-none-any.whl

omlish/specs/jmespath/visitor.py

@@ -0,0 +1,344 @@
+import numbers
+import operator
+import typing as ta
+
+from . import functions
+
+
+def _equals(x, y):
+    if _is_special_number_case(x, y):
+        return False
+    else:
+        return x == y
+
+
+def _is_special_number_case(x, y):
+    # We need to special case comparing 0 or 1 to True/False.  While normally comparing any integer other than 0/1 to
+    # True/False will always return False.  However 0/1 have this:
+    # >>> 0 == True
+    # False
+    # >>> 0 == False
+    # True
+    # >>> 1 == True
+    # True
+    # >>> 1 == False
+    # False
+    #
+    # Also need to consider that:
+    # >>> 0 in [True, False]
+    # True
+    if _is_actual_number(x) and x in (0, 1):
+        return isinstance(y, bool)
+
+    elif _is_actual_number(y) and y in (0, 1):
+        return isinstance(x, bool)
+
+    else:
+        return None
+
+
+def _is_comparable(x):
+    # The spec doesn't officially support string types yet, but enough people are relying on this behavior that it's
+    # been added back.  This should eventually become part of the official spec.
+    return _is_actual_number(x) or isinstance(x, str)
+
+
+def _is_actual_number(x):
+    # We need to handle python's quirkiness with booleans, specifically:
+    #
+    # >>> isinstance(False, int)
+    # True
+    # >>> isinstance(True, int)
+    # True
+    if isinstance(x, bool):
+        return False
+    return isinstance(x, numbers.Number)
+
+
+class Options:
+    """Options to control how a Jmespath function is evaluated."""
+
+    def __init__(self, dict_cls=None, custom_functions=None):
+        #: The class to use when creating a dict.  The interpreter may create dictionaries during the evaluation of a
+        #  Jmespath expression.  For example, a multi-select hash will create a dictionary.  By default we use a dict()
+        #  type. You can set this value to change what dict type is used. The most common reason you would change this
+        #  is if you want to set a collections.OrderedDict so that you can have predictable key ordering.
+        self.dict_cls = dict_cls
+        self.custom_functions = custom_functions
+
+
+class _Expression:
+    def __init__(self, expression, interpreter):
+        self.expression = expression
+        self.interpreter = interpreter
+
+    def visit(self, node, *args, **kwargs):
+        return self.interpreter.visit(node, *args, **kwargs)
+
+
+class Visitor:
+    def __init__(self):
+        self._method_cache = {}
+
+    def visit(self, node, *args, **kwargs):
+        node_type = node['type']
+        method = self._method_cache.get(node_type)
+        if method is None:
+            method = getattr(self, f'visit_{node["type"]}', self.default_visit)
+            self._method_cache[node_type] = method
+        return method(node, *args, **kwargs)  # type: ignore
+
+    def default_visit(self, node, *args, **kwargs):
+        raise NotImplementedError('default_visit')
+
+
+class TreeInterpreter(Visitor):
+    COMPARATOR_FUNC: ta.Mapping[str, ta.Callable] = {
+        'eq': _equals,
+        'ne': lambda x, y: not _equals(x, y),
+        'lt': operator.lt,
+        'gt': operator.gt,
+        'lte': operator.le,
+        'gte': operator.ge,
+    }
+
+    _EQUALITY_OPS: ta.Sequence[str] = ['eq', 'ne']
+
+    MAP_TYPE = dict
+
+    def __init__(self, options=None):
+        super().__init__()
+
+        self._dict_cls = self.MAP_TYPE
+
+        if options is None:
+            options = Options()
+        self._options = options
+
+        if options.dict_cls is not None:
+            self._dict_cls = self._options.dict_cls
+
+        if options.custom_functions is not None:
+            self._functions = self._options.custom_functions
+        else:
+            self._functions = functions.Functions()
+
+    def default_visit(self, node, *args, **kwargs):
+        raise NotImplementedError(node['type'])
+
+    def visit_subexpression(self, node, value):
+        result = value
+        for child in node['children']:
+            result = self.visit(child, result)
+        return result
+
+    def visit_field(self, node, value):
+        try:
+            return value.get(node['value'])
+        except AttributeError:
+            return None
+
+    def visit_comparator(self, node, value):
+        # Common case: comparator is == or !=
+        comparator_func = self.COMPARATOR_FUNC[node['value']]
+        if node['value'] in self._EQUALITY_OPS:
+            return comparator_func(
+                self.visit(node['children'][0], value),
+                self.visit(node['children'][1], value),
+            )
+
+        else:
+            # Ordering operators are only valid for numbers. Evaluating any other type with a comparison operator will
+            # yield a None value.
+            left = self.visit(node['children'][0], value)
+            right = self.visit(node['children'][1], value)
+            # num_types = (int, float)
+            if not (_is_comparable(left) and _is_comparable(right)):
+                return None
+            return comparator_func(left, right)
+
+    def visit_current(self, node, value):
+        return value
+
+    def visit_expref(self, node, value):
+        return _Expression(node['children'][0], self)
+
+    def visit_function_expression(self, node, value):
+        resolved_args = []
+        for child in node['children']:
+            current = self.visit(child, value)
+            resolved_args.append(current)
+
+        return self._functions.call_function(node['value'], resolved_args)
+
+    def visit_filter_projection(self, node, value):
+        base = self.visit(node['children'][0], value)
+        if not isinstance(base, list):
+            return None
+
+        comparator_node = node['children'][2]
+        collected = []
+        for element in base:
+            if self._is_true(self.visit(comparator_node, element)):
+                current = self.visit(node['children'][1], element)
+                if current is not None:
+                    collected.append(current)
+
+        return collected
+
+    def visit_flatten(self, node, value):
+        base = self.visit(node['children'][0], value)
+        if not isinstance(base, list):
+            # Can't flatten the object if it's not a list.
+            return None
+
+        merged_list = []
+        for element in base:
+            if isinstance(element, list):
+                merged_list.extend(element)
+            else:
+                merged_list.append(element)
+
+        return merged_list
+
+    def visit_identity(self, node, value):
+        return value
+
+    def visit_index(self, node, value):
+        # Even though we can index strings, we don't want to support that.
+        if not isinstance(value, list):
+            return None
+
+        try:
+            return value[node['value']]
+        except IndexError:
+            return None
+
+    def visit_index_expression(self, node, value):
+        result = value
+        for child in node['children']:
+            result = self.visit(child, result)
+
+        return result
+
+    def visit_slice(self, node, value):
+        if not isinstance(value, list):
+            return None
+        s = slice(*node['children'])
+        return value[s]
+
+    def visit_key_val_pair(self, node, value):
+        return self.visit(node['children'][0], value)
+
+    def visit_literal(self, node, value):
+        return node['value']
+
+    def visit_multi_select_dict(self, node, value):
+        if value is None:
+            return None
+
+        collected = self._dict_cls()
+        for child in node['children']:
+            collected[child['value']] = self.visit(child, value)
+
+        return collected
+
+    def visit_multi_select_list(self, node, value):
+        if value is None:
+            return None
+
+        collected = []
+        for child in node['children']:
+            collected.append(self.visit(child, value))
+
+        return collected
+
+    def visit_or_expression(self, node, value):
+        matched = self.visit(node['children'][0], value)
+
+        if self._is_false(matched):
+            matched = self.visit(node['children'][1], value)
+
+        return matched
+
+    def visit_and_expression(self, node, value):
+        matched = self.visit(node['children'][0], value)
+
+        if self._is_false(matched):
+            return matched
+
+        return self.visit(node['children'][1], value)
+
+    def visit_not_expression(self, node, value):
+        original_result = self.visit(node['children'][0], value)
+
+        if _is_actual_number(original_result) and original_result == 0:
+            # Special case for 0, !0 should be false, not true. 0 is not a special cased integer in jmespath.
+            return False
+
+        return not original_result
+
+    def visit_pipe(self, node, value):
+        result = value
+        for child in node['children']:
+            result = self.visit(child, result)
+        return result
+
+    def visit_projection(self, node, value):
+        base = self.visit(node['children'][0], value)
+        if not isinstance(base, list):
+            return None
+
+        collected = []
+        for element in base:
+            current = self.visit(node['children'][1], element)
+            if current is not None:
+                collected.append(current)
+
+        return collected
+
+    def visit_value_projection(self, node, value):
+        base = self.visit(node['children'][0], value)
+        try:
+            base = base.values()
+        except AttributeError:
+            return None
+
+        collected = []
+        for element in base:
+            current = self.visit(node['children'][1], element)
+            if current is not None:
+                collected.append(current)
+
+        return collected
+
+    def _is_false(self, value):
+        # This looks weird, but we're explicitly using equality checks because the truth/false values are different
+        # between python and jmespath.
+        return (value == '' or value == [] or value == {} or value is None or value is False)  # noqa
+
+    def _is_true(self, value):
+        return not self._is_false(value)
+
+
+class GraphvizVisitor(Visitor):
+    def __init__(self):
+        super().__init__()
+        self._lines = []
+        self._count = 1
+
+    def visit(self, node, *args, **kwargs):
+        self._lines.append('digraph AST {')
+        current = f"{node['type']}{self._count}"
+        self._count += 1
+        self._visit(node, current)
+        self._lines.append('}')
+        return '\n'.join(self._lines)
+
+    def _visit(self, node, current):
+        self._lines.append('%s [label="%s(%s)"]' % (current, node['type'], node.get('value', '')))  # noqa
+        for child in node.get('children', []):
+            child_name = f"{child['type']}{self._count}"
+            self._count += 1
+            self._lines.append(f'  {current} -> {child_name}')
+            self._visit(child, child_name)

{omlish-0.0.0.dev45.dist-info → omlish-0.0.0.dev47.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev45
+Version: 0.0.0.dev47
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev45.dist-info → omlish-0.0.0.dev47.dist-info}/RECORD

@@ -1,5 +1,5 @@
-omlish/.manifests.json,sha256=FPSgLg_3QDVzKlNOuqV3dMqhja2KG_TUfKdGmHE8Eg4,803
-omlish/__about__.py,sha256=ksJohON1-moGxasw7d_K1YOOVRTb4318HQNolEuZ3zo,2919
+omlish/.manifests.json,sha256=sAddTbCUKdX0UYA4PeZ_z9JKF0vyzEpFYWq1tAAl9bw,1091
+omlish/__about__.py,sha256=_RRLEqykT0ujsHiOho919ore-XgZvArOXLbbLo2v0oo,2919
 omlish/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/argparse.py,sha256=Vr70_85EVLJLgEkRtwOr264tMRtqtlN7ncFfXRUk5aM,6914
 omlish/c3.py,sha256=4vogWgwPb8TbNS2KkZxpoWbwjj7MuHG2lQG-hdtkvjI,8062
@@ -262,7 +262,17 @@ omlish/secrets/openssl.py,sha256=wxA_wIlxtuOUy71ABxAJgavh-UI_taOfm-A0dVlmSwM,621
 omlish/secrets/passwords.py,sha256=3r-vEK6Gp6aq4L5Csnd06QnrjO9xfzHJP-g_7I9W_ao,4101
 omlish/secrets/secrets.py,sha256=ClD7t_mkmWkseVk4ahLzYLuLXeTxiwwPiidYm42vLh4,6871
 omlish/secrets/subprocesses.py,sha256=EcnKlHHtnUMHGrBWXDfu8tv28wlgZx4P4GOiuPW9Vo8,1105
-omlish/specs/__init__.py,sha256=R5X62_Iur9gg_gWLWJCgjSK_zec76g15agYPLNgwfGc,99
+omlish/specs/__init__.py,sha256=Xl4fT1o1MlcEIAjMt5EifgMuO4UBSa9Suj5NE9eMX1A,87
+omlish/specs/jmespath/LICENSE,sha256=IH-ZZlZkS8XMkf_ubNVD1aYHQ2l_wd0tmHtXrCcYpRU,1113
+omlish/specs/jmespath/__init__.py,sha256=JFNIeqDvkuZQ036_SVD_uQiPLIThOmkLApdS_0GAtNk,281
+omlish/specs/jmespath/__main__.py,sha256=pZ4PnDWEtvTSpVOsNswkE9esg6Wu1i1b3P2aLvwBnKc,186
+omlish/specs/jmespath/ast.py,sha256=mclYjkd1b7-xYTLhzJ5QRRrYMKvDqRtnAj-xZhAHj1Q,2138
+omlish/specs/jmespath/cli.py,sha256=ORM5tEeHr9pUtRfAHImfB0ObQQ8VOTR4X48U4-kNoOM,1633
+omlish/specs/jmespath/exceptions.py,sha256=5cCVkGFh524Rj42JVWu7PznqK1odXK9h9sCwCpx-5nY,3697
+omlish/specs/jmespath/functions.py,sha256=VxGkGHRyUvo3UCP-BS0NMUirpB7fbxUD-rBmWGiUdf4,12273
+omlish/specs/jmespath/lexer.py,sha256=6ug4Mw1PtxYP6FUo41f6Pcdh7rWWrkasztK6uJ4B3Xw,9735
+omlish/specs/jmespath/parser.py,sha256=qSpTkjmR9MSdKShVjUqSPI9eV6WoB1t8DkKTdxFZfQE,19308
+omlish/specs/jmespath/visitor.py,sha256=u0poV2BkJmYJzFqjA2Hb86K8LXKWiic4ICKM-FffC2o,10672
 omlish/specs/jsonrpc/__init__.py,sha256=E0EogYSKmbj1D-V57tBgPDTyVuD8HosHqVg0Vh1CVwM,416
 omlish/specs/jsonrpc/errors.py,sha256=-Zgmlo6bV6J8w5f8h9axQgLquIFBHDgIwcpufEH5NsE,707
 omlish/specs/jsonrpc/marshal.py,sha256=iXZNR7n0vfL_yiPFFYN-ZyGlzknNXExs2qC1HFChGPU,1913
@@ -328,9 +338,9 @@ omlish/text/delimit.py,sha256=ubPXcXQmtbOVrUsNh5gH1mDq5H-n1y2R4cPL5_DQf68,4928
 omlish/text/glyphsplit.py,sha256=Ug-dPRO7x-OrNNr8g1y6DotSZ2KH0S-VcOmUobwa4B0,3296
 omlish/text/indent.py,sha256=6Jj6TFY9unaPa4xPzrnZemJ-fHsV53IamP93XGjSUHs,1274
 omlish/text/parts.py,sha256=7vPF1aTZdvLVYJ4EwBZVzRSy8XB3YqPd7JwEnNGGAOo,6495
-omlish-0.0.0.dev45.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omlish-0.0.0.dev45.dist-info/METADATA,sha256=Wgmc5z7G_7Nqo7dCn6hUlxya_-xb7yRNAy9kFr16xC0,3817
-omlish-0.0.0.dev45.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-omlish-0.0.0.dev45.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
-omlish-0.0.0.dev45.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
-omlish-0.0.0.dev45.dist-info/RECORD,,
+omlish-0.0.0.dev47.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omlish-0.0.0.dev47.dist-info/METADATA,sha256=fBgDiQQnKFFc4L2qA3Dc_rh2d2mKKmKT7U3UeeiBPwA,3817
+omlish-0.0.0.dev47.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+omlish-0.0.0.dev47.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
+omlish-0.0.0.dev47.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
+omlish-0.0.0.dev47.dist-info/RECORD,,