def check_and_setup_parameters(self):
        """Perform checks/setups on parameters.

        Here we check each parameter (and corresponding subparameters, if any)
        to see whether whether they expect...

        - expect incoming data from another node
        - have available data from widgets
        - lack input source

        In case one or more of them lack a source of data, we raise a
        LackOfInputError explaining the situation.
        """
        ### create a list to hold names of (sub)parameters
        ### lacking a data source
        lacking_data_source = []

        ### reference/alias relevant maps locally for quicker
        ### and easier access

        arg_map = self.argument_map
        var_kind_map = self.var_kind_map
        isl_flmap = self.input_socket_live_flmap

        ### iterate over the name of each parameter, performing
        ### checks and acting according to their results

        for param_name in self.signature_obj.parameters.keys():

            ## if parameter is of variable kind, check
            ## whether it has subparameters and their
            ## respective data sources (incoming data
            ## or data from a widget)

            if param_name in var_kind_map:
                
                ## retrieve kind
                kind = var_kind_map[param_name]

                ## retrieve a list of subparameters
                subparams = self.data['subparam_map'][param_name]

                ## if it has subparameters (list isn't
                ## empty), check whether we need to retrieve data
                ## from its widget or not

                if subparams:

                    for subparam_index in subparams:

                        # if respective input socket doesn't have a parent,
                        # store data from widget as the argument

                        input_socket = isl_flmap[param_name][subparam_index]

                        if not hasattr(input_socket, 'parent'):

                            # retrieve value from a widget

                            arg_map[param_name][subparam_index] = (
                                self.data
                                ['subparam_widget_map']
                                [param_name]
                                [subparam_index]
                                ['widget_kwargs']
                                ['value']
                            )

                ## otherwise, if it doesn't have any subparameters, we assign
                ## the default value for the parameter, according to
                ## its specific variable kind:
                ##
                ## - an empty tuple for a positional-variable parameter, or
                ## - an empty dict for a keyword-variable parameter

                else:
                    arg_map[param_name] = () if kind == "var_pos" else {}

            ## if the param name is not in the variable kind map,
            ## it means it is not a variable parameter,
            ## so we perform suitable checks

            else:

                ## if the parameter's input socket lacks a parent,
                ## try retrieving values from other sources

                input_socket = isl_flmap[param_name]

                if not hasattr(input_socket, 'parent'):

                    # try assigning the default value for the input,
                    # if it exists

                    try:
                        arg_map[param_name] = self.default_map[param_name]

                    except KeyError:
                        pass

                    # try assigning a value from an embedded widget
                    # if such value exists, (note that this is tried
                    # regardless of whether the previous try statement
                    # succeeds, because values set on widgets by users
                    # have precedence over the actual default values
                    # defined in the callables)

                    try:

                        arg_map[param_name] = (
                            self.data
                            ['param_widget_value_map']
                            [param_name]
                        )

                    except KeyError:
                        pass

                    # if, after the attempted assignments above, the input
                    # still isn't available, then it can only mean the
                    # node is inexecutable due to lack of input sources;
                    #
                    # we store its name on the 'lacking_data_source' list

                    if param_name not in arg_map:
                        lacking_data_source.append(param_name)

        ### if parameters lacking data sources were found,
        ### raise a LackOfInputError

        if lacking_data_source:
            raise LackOfInputError(self, lacking_data_source)
Perform checks/setups on parameters.

        Here we check each parameter (and corresponding subparameters, if any)
        to see whether whether they expect...

        - expect incoming data from another node
        - have available data from widgets
        - lack input source

        In case one or more of them lack a source of data, we raise a
        LackOfInputError explaining the situation.
        
nodezator/graphman/callablenode/execution.py