Set the resource attributes from the kwargs.
        Only sets items in the `self.Meta.attributes` white list.

        Args:
            kwargs: Keyword arguements passed into the init of this class
514913
def set_attributes(self, **kwargs):
        
        for field, value in kwargs.items():
            if field in self.Meta.attributes:
                setattr(self, field, value)
302991
def set_defaults(self, **defaults):
        
        try:
            defaults_items = defaults.iteritems()
        except AttributeError:
            defaults_items = defaults.items()
        for key, val in defaults_items:
            if key not in self.args.keys():
                self.args[key] = val
500690
def update_kwargs(self, kwargs, count, offset):
        
        kwargs.update({self.count_key: count, self.offset_key: offset})
        return kwargs
162836
def kwargs(self):
        """"""
        # Subclasses must override this property if and only if they define
        # keyword-only arguments in their __init__ method
        if hasattr(self, '_has_kwargs') and self._has_kwargs:
            raise NotImplementedError(
                "Class %s does not provide a kwargs property"
                % str(self.__class__.__name__))
        return {}
920636
def _set_attr(self, **kwargs):
        
        for key, value in kwargs.items():
            if not isinstance(value, string_types):
                raise ValueError("Set Attr only accepts string values")
            check_call(_LIB.MXSymbolSetAttr(
                self.handle, c_str(key), c_str(str(value))))
1144701
def prepare_arguments(self, attributes):
        """"""
        kwargs = dict(attributes)
        # 1. Extension points
        kwargs = self.factory._adjust_kwargs(**kwargs)

        # 2. Remove hidden objects
        kwargs = {
            k: v for k, v in kwargs.items()
            if k not in self.exclude and k not in self.parameters and v is not declarations.SKIP
        }

        # 3. Rename fields
        for old_name, new_name in self.rename.items():
            if old_name in kwargs:
                kwargs[new_name] = kwargs.pop(old_name)

        # 4. Extract inline args
        args = tuple(
            kwargs.pop(arg_name)
            for arg_name in self.inline_args
        )

        return args, kwargs
485485
def args(self, *args, **kwargs):
        
        self._any_args = False
        self._arguments_rule.set_args(*args, **kwargs)
        return self
628245
def update(self, **kwargs):
        
        for attr, val in kwargs.items():
            if attr in (list(self.__class__.__attributes__) + \
                        list(associations.associations_for(self.__class__))):
                setattr(self, attr, val)
323743
def set_attr(self, **kwargs):
        
        for key, value in kwargs.items():
            if value is not None:
                if not isinstance(value, STRING_TYPES):
                    raise ValueError("Set Attr only accepts string values")
                value = c_str(str(value))
            _check_call(_LIB.XGBoosterSetAttr(
                self.handle, c_str(key), value))
635002
def set_options(self, **kwargs):
        
        p = Unskin(self.options)
        p.update(kwargs)
382421
def _attach_params(self, params, **kwargs):
        
        lst = params.to_list() if isinstance(params, ParameterSet) else params
        for param in lst:
            param._bundle = self

            for k, v in kwargs.items():
                # Here we'll set the attributes (_context, _qualifier, etc)
                if getattr(param, '_{}'.format(k)) is None:
                    setattr(param, '_{}'.format(k), v)
            self._params.append(param)

        self._check_copy_for()

        return
480629
def set_attributes(self, **attributes_dict):
        
        for attr_name, attr_value in attributes_dict.items():
            self.set_attr(attr_name, attr_value)
        return self
627100
def wrap_args_kwargs_to_initdict(init_args_kwargs_fn: InitArgsKwargsFnType,
                                 typename: str,
                                 check_result: bool = True) \
        -> InstanceToInitDictFnType:
    
    def wrapper(obj: Instance) -> InitDict:
        result = init_args_kwargs_fn(obj)
        if check_result:
            if (not isinstance(result, tuple) or
                    not len(result) == 2 or
                    not isinstance(result[0], list) or
                    not isinstance(result[1], dict)):
                raise ValueError(
                    "Class {} failed to provide an (args, kwargs) tuple and "
                    "provided instead: {}".format(typename, repr(result)))
        return args_kwargs_to_initdict(*result)

    return wrapper
206388
def _preprocess_params(cls, kwargs):
        
        # kwargs.pop('csrf_token', None)
        for attr, val in kwargs.items():
            if cls.is_the_primary_key(attr) and cls._prevent_primary_key_initialization_:
                del kwargs[attr]
                continue
            if val == "":
                # Making an assumption that there is no good usecase
                # for setting an empty string. This will help prevent
                # cases where empty string is sent because of client
                # not clearing form fields to null
                kwargs[attr] = None
                continue
            if attr in class_mapper(cls).relationships and attr not in cls._no_overwrite_:
                rel = class_mapper(cls).relationships[attr]
                if rel.uselist:
                    if isinstance(val, list):
                        if all(isinstance(v, dict) for v in val):
                            rel_cls = cls.mapped_rel_class(attr)
                            kwargs[attr] = rel_cls.update_or_new_all(
                                list_of_kwargs=val, keys=[rel_cls.primary_key_name()])
                    elif isinstance(val, dict):
                        rel_cls = cls.mapped_rel_class(attr)
                        mapping_col = rel.collection_class().keyfunc.name
                        list_of_kwargs = [merge(v, {mapping_col: k}) for k, v in val.items()]
                        kwargs[attr] = {getattr(obj, mapping_col): obj for obj in rel_cls.update_or_new_all(
                            list_of_kwargs=list_of_kwargs, keys=[rel_cls.primary_key_name()])}
                elif isinstance(val, dict):
                    rel_cls = cls.mapped_rel_class(attr)
                    kwargs[attr] = rel_cls.update_or_new(
                        **merge(val, {'keys': [rel_cls.primary_key_name()]}))
        return kwargs
453733
def set_attributes(self, attributes):
        
        # pylint: disable=no-member
        for attribute in attributes:
            if attribute.name in self.attributes:
                set_att_def_value(self.attributes[attribute.name], attribute.value, attribute.name, self.name)
                try:
                    set_att_def_value(self.attributes[attribute.name], attribute.value, attribute.name, self.name)
                except TypeError as terr:
                    six.print_("Error while trying to set value of attribute {0} to {1} in " \
                          "parameter {2}" \
                          "".format(attribute.name, attribute.value, self.name))
                    raise terr
            elif attribute.name in self.qualifiers:
                set_att_def_value(self.qualifiers[attribute.name], attribute.value, attribute.name, self.name)
                try:
                    set_att_def_value(self.qualifiers[attribute.name], attribute.value, attribute.name, self.name)
                except TypeError as terr:
                    six.print_("Error while trying to set value of qualifier {0} to " \
                               "{1} in parameter {2}".format(attribute.name,
                                                             attribute.value,
                                                             self.name))
                    raise terr
            else:
                raise UnknownAcdPropertyException(attribute.name,
                                                  attribute.value, self.name)
1095438
def _populate_alternate_kwargs(kwargs):
    

    resource_namespace = kwargs['namespace']
    resource_type = kwargs.get('child_type_{}'.format(kwargs['last_child_num'])) or kwargs['type']
    resource_name = kwargs.get('child_name_{}'.format(kwargs['last_child_num'])) or kwargs['name']

    _get_parents_from_parts(kwargs)
    kwargs['resource_namespace'] = resource_namespace
    kwargs['resource_type'] = resource_type
    kwargs['resource_name'] = resource_name
    return kwargs
654984
def setup_args(self, parser):
        

        # Add all the arguments to the argument parser
        for args, kwargs in self._arguments:
            parser.add_argument(*args, **kwargs)