code: def _parse_sparkml_single_operator(topology, operator, all_inputs):
      """
      This function handles the parsing of all Spark-ML operators.
  
      Args:
          topology: The ``onnxconverter_common.topology.Topology`` where the model will be added
          model: A Spark-ML operator
          all_inputs: A list of `onnxconverter_common.topology.Variable`s
      """
      import inspect
  
      if isinstance(operator, str):
          raise RuntimeError(
              "Parameter operator must be an object not a "
              "string '{0}'.".format(operator)
          )
  
      alias = get_sparkml_api_operator_name(type(operator))
      this_operator = topology.declare_logical_operator(alias, operator)
  
      if hasattr(operator, "getInputCol") and callable(
          operator.getInputCol
      ):
          this_operator.inputs = [
              i
              for i in all_inputs
              if i.raw_name == operator.getInputCol()
          ]
      elif hasattr(operator, "getInputCols") and callable(
          operator.getInputCols
      ):
          temp = {
              i.raw_name: i
              for i in all_inputs
              if i.raw_name in operator.getInputCols()
          }
          this_operator.inputs = [
              temp[i] for i in operator.getInputCols()
          ]
      elif operator.hasParam("featuresCol"):
          col_name = [
              param[1]
              for param in operator.extractParamMap().items()
              if param[0].name == "featuresCol"
          ][0]
          this_operator.inputs = [
              i for i in all_inputs if i.raw_name == col_name
          ]
      else:
          print(operator.getParam("featuresCol"))
          raise RuntimeError(
              "Unable to determine inputs for the Spark-ML operator: {}".format(
                  type(operator)
              )
          )
  
      if hasattr(operator, "getOutputCol") and callable(
          operator.getOutputCol
      ):
          variable = topology.declare_logical_variable(
              operator.getOutputCol()
          )
          this_operator.outputs.append(variable)
      elif hasattr(operator, "getOutputCols") and callable(
          operator.getOutputCols
      ):
          for output_col in operator.getOutputCols():
              variable = topology.declare_logical_variable(output_col)
              this_operator.outputs.append(variable)
      else:
          variable = topology.declare_logical_variable("variable")
          this_operator.outputs.append(variable)
  
      return this_operator.outputs, all_inputs + this_operator.outputs
  
imports: from collections import OrderedDict
  from copy import deepcopy
  import pprint
  from uuid import uuid4
  import numpy
  from onnxconverter_common.optimizer import LinkedNode, _topological_sort
  from sklearn import pipeline
  from sklearn.compose import ColumnTransformer
  from sklearn.ensemble import BaggingClassifier, BaggingRegressor
  from sklearn.model_selection import GridSearchCV, RandomizedSearchCV
  from sklearn.multioutput import MultiOutputRegressor, RegressorChain
  from sklearn.preprocessing import OneHotEncoder
  from .containers import CommonSklearnModelContainer, CommonONNXModelContainer, CommonSparkMLModelContainer
  from ._topology import Topology
  from ._utils import sklearn_installed, sparkml_installed
  from .operator_converters import constants
  from .supported import get_sklearn_api_operator_name, get_onnxml_api_operator_name, get_sparkml_api_operator_name
label_desc: Use image node_id 22 for calling a global function with example usage: _parse_sparkml_single_operator(topology, operator, all_inputs) and returns: this_operator,  unknown