code: def create_function(self, tree):
      function_name = None
      or_replace = False
      if_not_exists = False
      input_definitions = []
      output_definitions = []
      impl_path = None
      function_type = None
      query = None
      metadata = []
  
      create_definitions_index = 0
      for child in tree.children:
          if isinstance(child, Tree):
              if child.data == "function_name":
                  function_name = self.visit(child)
              elif child.data == "or_replace":
                  or_replace = True
              elif child.data == "if_not_exists":
                  if_not_exists = True
              elif child.data == "create_definitions":
                  # There should be 2 createDefinition
                  # idx 0 describing function INPUT
                  # idx 1 describing function OUTPUT
                  if create_definitions_index == 0:
                      input_definitions = self.visit(child)
                      create_definitions_index += 1
                  elif create_definitions_index == 1:
                      output_definitions = self.visit(child)
              elif child.data == "function_type":
                  function_type = self.visit(child)
              elif child.data == "function_impl":
                  impl_path = self.visit(child).value
              elif child.data == "simple_select":
                  query = self.visit(child)
              elif child.data == "function_metadata":
                  # Each function metadata is a key value pair
                  key_value_pair = self.visit(child)
                  # value can be an integer or string
                  value = key_value_pair[1]
                  if isinstance(value, ConstantValueExpression):
                      value = value.value
                  # Removing .value from key_value_pair[0] since key is now an ID_LITERAL
                  # Adding lower() to ensure the key is in lowercase
                  metadata.append((key_value_pair[0].lower(), value)),
  
      return CreateFunctionStatement(
          function_name,
          or_replace,
          if_not_exists,
          impl_path,
          input_definitions,
          output_definitions,
          function_type,
          query,
          metadata,
      )
  
file_path: evadb/evadb/parser/lark_visitor/_functions.py
imports: from lark import Token, Tree
  from evadb.expression.abstract_expression import ExpressionType
  from evadb.expression.aggregation_expression import AggregationExpression
  from evadb.expression.constant_value_expression import ConstantValueExpression
  from evadb.expression.function_expression import FunctionExpression
  from evadb.expression.tuple_value_expression import TupleValueExpression
  from evadb.parser.create_function_statement import CreateFunctionStatement
label_desc: Use image node_id 3 for calling the Functions obj's underlying member method code with example usage: obj.create_function(tree) and returns: CreateFunctionStatement