First steps of ConceptLexer. Need to update DefaultParser before continuing

core/builtin_helpers.py

@@ -1,3 +1,8 @@
+import ast
+import core.ast.nodes
+from core.ast.nodes import CallNodeConcept, GenericNodeConcept
+from core.ast.visitors import UnreferencedNamesVisitor
+
 from core.builtin_concepts import BuiltinConcepts
 
 
@@ -81,3 +86,107 @@ def expect_one(context, return_values):
         False,
         sheerka.new(BuiltinConcepts.TOO_MANY_ERRORS, obj=return_values),
         parents=return_values)
+
+
+def get_names(sheerka, concept_node):
+    """
+    Finds all the names referenced by the concept_node
+    :param sheerka:
+    :param concept_node:
+    :return:
+    """
+    unreferenced_names_visitor = UnreferencedNamesVisitor(sheerka)
+    unreferenced_names_visitor.visit(concept_node)
+    return list(unreferenced_names_visitor.names)
+
+
+def extract_predicates(sheerka, expression, variables_to_include, variables_to_exclude):
+    """
+    from expression, tries to find all the predicates referencing a variable, and the variable only
+    for example
+    exp : isinstance(a, int) and isinstance(b, str)
+    will return 'isinstance(a, int)' if variable_name == 'a'
+    :param sheerka:
+    :param expression:
+    :param variables_to_include:
+    :param variables_to_exclude:
+    :return: list of predicates
+    """
+
+    if len(variables_to_include) == 0:
+        return []
+
+    def _get_predicates(_nodes):
+        _predicates = []
+        for _node in _nodes:
+            python_node = ast.Expression(body=core.ast.nodes.concept_to_python(_node))
+            python_node = ast.fix_missing_locations(python_node)
+            _predicates.append(python_node)
+        return _predicates
+
+    if isinstance(expression, str):
+        node = ast.parse(expression, mode="eval")
+    else:
+        return NotImplementedError()
+
+    concept_node = core.ast.nodes.python_to_concept(node)
+    main_op = concept_node.get_prop("body")
+
+    return _get_predicates(_extract_predicates(sheerka, main_op, variables_to_include, variables_to_exclude))
+
+
+def _extract_predicates(sheerka, node, variables_to_include, variables_to_exclude):
+    predicates = []
+
+    def _matches(_names, to_include, to_exclude):
+        _res = None
+        for n in _names:
+            if n in to_include and _res is None:
+                _res = True
+            if n in to_exclude:
+                _res = False
+        return _res
+
+    if node.node_type == "Compare":
+        if node.get_prop("left").node_type == "Name":
+            """Simple case of one comparison"""
+            comparison_name = sheerka.value(node.get_prop("left"))
+            if comparison_name in variables_to_include and comparison_name not in variables_to_exclude:
+                predicates.append(node)
+        else:
+            """The left part is an expression"""
+            res = _extract_predicates(sheerka, node.get_prop("left"), variables_to_include, variables_to_exclude)
+            if len(res) > 0:
+                predicates.append(node)
+    elif node.node_type == "Call":
+        """Simple case predicate"""
+        call_node = node if isinstance(node, CallNodeConcept) else CallNodeConcept().update_from(node)
+        args = list(call_node.get_args_names(sheerka))
+        if _matches(args, variables_to_include, variables_to_exclude):
+            predicates.append(node)
+    elif node.node_type == "UnaryOp" and node.get_prop("op").node_type == "Not":
+        """Simple case of negation"""
+        res = _extract_predicates(sheerka, node.get_prop("operand"), variables_to_include, variables_to_exclude)
+        if len(res) > 0:
+            predicates.append(node)
+    elif node.node_type == "BinOp":
+        names = get_names(sheerka, node)
+        if _matches(names, variables_to_include, variables_to_exclude):
+            predicates.append(node)
+    elif node.node_type == "BoolOp":
+        all_op = True
+        temp_res = []
+        for op in node.get_prop("values"):
+            res = _extract_predicates(sheerka, op, variables_to_include, variables_to_exclude)
+            if len(res) == 0:
+                all_op = False
+            else:
+                temp_res.extend(res)
+
+        if all_op:
+            predicates.append(node)
+        else:
+            for res in temp_res:
+                predicates.append(res)
+
+    return predicates