code: def is_expression_interesting(node: ast.expr, value: Any) -> bool:
      """
      Determines if an expression is potentially interesting, at least in my opinion.
      Returns False for the following expressions whose value is generally obvious:
          - Literals (e.g. 123, 'abc', [1, 2, 3], {'a': (), 'b': ([1, 2], [3])})
          - Variables or attributes whose name is equal to the value's __name__.
              For example, a function `def foo(): ...` is not interesting when referred to
              as `foo` as it usually would, but `bar` can be interesting if `bar is foo`.
              Similarly the method `self.foo` is not interesting.
          - Builtins (e.g. `len`) referred to by their usual name.
  
      This is a low level API, typically you will use `interesting_expressions_grouped`.
  
      :param node: an AST expression
      :param value: the value of the node
      :return: a boolean: True if the expression is interesting, False otherwise
      """
  
      with suppress(ValueError):
          ast.literal_eval(node)
          return False
  
      # TODO exclude inner modules, e.g. numpy.random.__name__ == 'numpy.random' != 'random'
      # TODO exclude common module abbreviations, e.g. numpy as np, pandas as pd
      if has_ast_name(value, node):
          return False
  
      if (
          isinstance(node, ast.Name)
          and getattr(builtins, node.id, object()) is value
      ):
          return False
  
      return True
  
imports: import ast
  import builtins
  import operator
  from collections import ChainMap, OrderedDict, deque
  from contextlib import suppress
  from types import FrameType
  from typing import Any, Tuple, Iterable, List, Mapping, Dict, Union, Set
  from pure_eval.my_getattr_static import getattr_static
  from pure_eval.utils import CannotEval, has_ast_name, copy_ast_without_context, is_standard_types, of_standard_types, is_any, of_type, ensure_dict
label_desc: Use image node_id 1 for calling a global function with example usage: is_expression_interesting(node, value) and returns: True, False, False, False