code: def update_kwargs(kwargs, *updates):
      
      for update in updates:
          if not update:
              continue
          for key, val in six.iteritems(update):
              u_item = resolve_value(val)
              if u_item is None:
                  continue
              if key in ('command' or 'entrypoint'):
                  kwargs[key] = u_item
              elif isinstance(u_item, (tuple, list)):
                  kw_item = kwargs.get(key)
                  u_list = map(resolve_value, u_item)
                  if isinstance(kw_item, list):
                      merge_list(kw_item, u_list)
                  elif isinstance(kw_item, tuple):
                      new_list = list(kw_item)
                      merge_list(new_list, u_list)
                      kwargs[key] = new_list
                  else:
                      kwargs[key] = list(u_list)
              elif isinstance(u_item, dict):
                  kw_item = kwargs.get(key)
                  u_dict = {u_k: resolve_value(u_v) for u_k, u_v in six.iteritems(u_item)}
                  if isinstance(kw_item, dict):
                      kw_item.update(u_dict)
                  else:
                      kwargs[key] = u_dict
              else:
                  kwargs[key] = u_item
docs: Utility function for merging multiple keyword arguments, depending on their type:
  
      * Non-existent keys are added.
      * Existing lists or tuples are extended, but not duplicating entries.
        The keywords ``command`` and ``entrypoint`` are however simply overwritten.
      * Nested dictionaries are updated, overriding previous key-value assignments.
      * Other items are simply overwritten (just like in a regular dictionary update) unless the updating value is
        ``None``.
  
      Lists/tuples and dictionaries are (shallow-)copied before adding and late resolving values are looked up.
      This function does not recurse.
  
      :param kwargs: Base keyword arguments. This is modified in-place.
      :type kwargs: dict
      :param updates: Dictionaries to update ``kwargs`` with.
      :type updates: dict