code: def source_to_op(src, args, symbols, closure_vars):
      """Another level of wrapper
  
      Parameters
      ----------
      src : ast.node or str
          If an ast.node, then directly lower it.
          If a str, then parse it to ast and lower it.
  
      args : list of Tensors or Vars
          The argument lists to the function.
          It is NOT encouraged to write a function without arguments.
          It is NOT encouraged to write a function with side effect.
  
      symbols : list of str
          The symbol list of the global context of the function.
  
      closure_vars: dict
          A dict of external name reference captured by this function.
  
      Returns
      -------
      res : list of output tensors
          The result of output tensors of the formed OpNode.
      """
      parser = parse_python(src, args, symbols, closure_vars)
  
      input_tensors = []
  
      def get_input_tensors(arg):
          if isinstance(arg, Tensor):
              input_tensors.append(arg)
          elif isinstance(arg, Array):
              for i in arg:
                  get_input_tensors(i)
  
      for i in args:
          get_input_tensors(i)
      op = tvm.te._ffi_api.HybridOp(
          parser.func_name,
          "HybridOp",
          None,
          input_tensors,
          parser.outputs,
          parser.parsed_body,
      )
      res = [op.output(i) for i in range(len(parser.outputs))]
      return res[0] if len(res) == 1 else res
  
imports: import ast
  import operator
  import logging
  import sys
  import numbers
  from enum import Enum
  from tvm.ir import Array, Range
  import tvm.runtime
  import tvm.tir
  import tvm.te
  import tvm.te._ffi_api
  import tvm.arith
  from tvm.tir import expr
  from tvm.tir import stmt
  from tvm.te.tensor import Tensor, Operation
  from tvm.tir import all
  from tvm.tir import any
  from .utils import _internal_assert
  from .None import calls
  from .None import utils
  from .preprocessor import determine_variable_usage
label_desc: Use image node_id 6 for calling a global function with example usage: source_to_op(src, args, symbols, closure_vars) and returns: unknown