code: def get_executed_params(execution_context, var_args):
      result_params = []
      param_dict = {}
      funcdef = execution_context.tree_node
      parent_context = execution_context.parent_context
  
      for param in funcdef.get_params():
          param_dict[param.name.value] = param
      unpacked_va = list(var_args.unpack(funcdef))
      var_arg_iterator = PushBackIterator(iter(unpacked_va))
  
      non_matching_keys = defaultdict(lambda: [])
      keys_used = {}
      keys_only = False
      had_multiple_value_error = False
      for param in funcdef.get_params():
          # The value and key can both be null. There, the defaults apply.
          # args / kwargs will just be empty arrays / dicts, respectively.
          # Wrong value count is just ignored. If you try to test cases that are
          # not allowed in Python, Jedi will maybe not show any completions.
          key, argument = next(var_arg_iterator, (None, None))
          while key is not None:
              keys_only = True
              try:
                  key_param = param_dict[key]
              except KeyError:
                  non_matching_keys[key] = argument
              else:
                  if key in keys_used:
                      had_multiple_value_error = True
                      m = (
                          "TypeError: %s() got multiple values for keyword argument '%s'."
                          % (funcdef.name, key)
                      )
                      for node in var_args.get_calling_nodes():
                          analysis.add(
                              parent_context,
                              "type-error-multiple-values",
                              node,
                              message=m,
                          )
                  else:
                      keys_used[key] = ExecutedParam(
                          execution_context, key_param, argument
                      )
              key, argument = next(var_arg_iterator, (None, None))
  
          try:
              result_params.append(keys_used[param.name.value])
              continue
          except KeyError:
              pass
  
          if param.star_count == 1:
              # *args param
              lazy_context_list = []
              if argument is not None:
                  lazy_context_list.append(argument)
                  for key, argument in var_arg_iterator:
                      # Iterate until a key argument is found.
                      if key:
                          var_arg_iterator.push_back((key, argument))
                          break
                      lazy_context_list.append(argument)
              seq = iterable.FakeSequence(
                  execution_context.evaluator,
                  "tuple",
                  lazy_context_list,
              )
              result_arg = LazyKnownContext(seq)
          elif param.star_count == 2:
              # **kwargs param
              dct = iterable.FakeDict(
                  execution_context.evaluator, dict(non_matching_keys)
              )
              result_arg = LazyKnownContext(dct)
              non_matching_keys = {}
          else:
              # normal param
              if argument is None:
                  # No value: Return an empty container
                  if param.default is None:
                      result_arg = LazyUnknownContext()
                      if not keys_only:
                          for node in var_args.get_calling_nodes():
                              m = _error_argument_count(
                                  funcdef, len(unpacked_va)
                              )
                              analysis.add(
                                  parent_context,
                                  "type-error-too-few-arguments",
                                  node,
                                  message=m,
                              )
                  else:
                      result_arg = LazyTreeContext(
                          parent_context, param.default
                      )
              else:
                  result_arg = argument
  
          result_params.append(
              ExecutedParam(execution_context, param, result_arg)
          )
          if not isinstance(result_arg, LazyUnknownContext):
              keys_used[param.name.value] = result_params[-1]
  
      if keys_only:
          # All arguments should be handed over to the next function. It's not
          # about the values inside, it's about the names. Jedi needs to now that
          # there's nothing to find for certain names.
          for k in set(param_dict) - set(keys_used):
              param = param_dict[k]
  
              if not (
                  non_matching_keys
                  or had_multiple_value_error
                  or param.star_count
                  or param.default
              ):
                  # add a warning only if there's not another one.
                  for node in var_args.get_calling_nodes():
                      m = _error_argument_count(
                          funcdef, len(unpacked_va)
                      )
                      analysis.add(
                          parent_context,
                          "type-error-too-few-arguments",
                          node,
                          message=m,
                      )
  
      for key, lazy_context in non_matching_keys.items():
          m = (
              "TypeError: %s() got an unexpected keyword argument '%s'."
              % (funcdef.name, key)
          )
          _add_argument_issue(
              parent_context,
              "type-error-keyword-argument",
              lazy_context,
              message=m,
          )
  
      remaining_arguments = list(var_arg_iterator)
      if remaining_arguments:
          m = _error_argument_count(funcdef, len(unpacked_va))
          # Just report an error for the first param that is not needed (like
          # cPython).
          first_key, lazy_context = remaining_arguments[0]
          if var_args.get_calling_nodes():
              # There might not be a valid calling node so check for that first.
              _add_argument_issue(
                  parent_context,
                  "type-error-too-many-arguments",
                  lazy_context,
                  message=m,
              )
      return result_params
  
file_path: catboost/contrib/python/jedi/py2/jedi/evaluate/param.py
imports: from collections import defaultdict
  from jedi.evaluate.utils import PushBackIterator
  from jedi.evaluate import analysis
  from jedi.evaluate.lazy_context import LazyKnownContext, LazyTreeContext, LazyUnknownContext
  from jedi.evaluate import docstrings
  from jedi.evaluate import pep0484
  from jedi.evaluate.context import iterable
label_desc: Use image node_id 2 for calling a global function with example usage: get_executed_params(execution_context, var_args) and returns: result_params