:param account: a zobjects.Account
        :param attrs  : a dictionary of attributes to set ({key:value,...})
330511
def modify_account(self, account, attrs):
        
        attrs = [{'n': k, '_content': v} for k, v in attrs.items()]
        self.request('ModifyAccount', {
            'id': self._get_or_fetch_id(account, self.get_account),
            'a': attrs
        })
542445
def _attr_data_(self, slots):
        
        self.__attr_data = type(
            ''.join([type(self).__name__, 'Data']),
            (),
            {
                '__module__': type(self).__module__,
                '__slots__': tuple(set(slots))
            }
        )()
961719
def set(self, attr_dict):
    
    for key in attr_dict:
      if key == self._id_attribute:
        setattr(self, self._id_attribute, attr_dict[key])
      else:
        setattr(self, u"_" + key, attr_dict[key])
    return self
1177040
def attributes(instance)
      definitions.values.each_with_object({}) do |item, obj|
        key = item.target
        val = instance.send(:instance_variable_get, item.ivar)
        obj[key] = val unless null == val
      end
    end
452502
def attributes=(attributes = {})
      attributes.each do |name, value|
        begin
          send("#{name}=", value)
        rescue NoMethodError => e
          puts "Unable to assign #{name}. No such method."
        end
      end
    end
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)
295705
def _attrs_to_tuple(obj, attrs):
    
    return tuple(getattr(obj, a.name) for a in attrs)
669970
def assign(self, attrs):
        
        for k, v in attrs.items():
            setattr(self, k, v)
395223
def set_attrs!(attrs)
      attrs.each do |name, value|
        ivar = :"@#{name.to_s.sub(/\?$/, '_q_')}"
        instance_variable_set(ivar, value)
      end
    end
617242
def model_setattr():
    

    def model_setattr(value, context, **_params):
        setattr(context["model"], context["key"], value)
        return _attr()

    return model_setattr
671945
def assign_all_attributes(attrs, track_changes = false)
      # Assign each attribute using setters
      attrs.each_pair do |key, value|
        key = key.to_sym

        # Track the change, since assign_all_attributes runs with no_change_tracking
        old_val = @attributes[key]
        attribute_will_change!(key, old_val) if track_changes && old_val != value

        if self.respond_to?(:"#{key}=")
          # If a method without an underscore is defined, call that.
          send(:"#{key}=", value)
        else
          # Otherwise, use the _ version
          set(key, value)
        end
      end

      # Make an id if there isn't one yet
      if @attributes[:id].nil? && persistor.try(:auto_generate_id)
        @attributes[:id] = generate_id
      end
    end
811752
def attributes=(attributes = {})
      attributes.each_pair { |k, v|
        respond_to?(name = "#{k}=") and send(name, v) or self[k] = v
      }
    end
177425
def set_attr_value(self, key, attr, value):
        
        idx = self._keys[key]
        self._attrs[attr][idx].set(value)
446922
def assign_provider_attrs(user, auth_hash)
      attrs = auth_hash['info'].slice(*user.attribute_names)
      user.assign_attributes(attrs)
    end
726466
def set_attributes(self, **attributes):
        

        auto_set = IxeObject.get_auto_set()
        IxeObject.set_auto_set(False)
        for name, value in attributes.items():
            setattr(self, name, value)
        if auto_set:
            self.ix_set()
        IxeObject.set_auto_set(auto_set)
609404
def values(self):
        
        if not hasattr(self, VALUES_ATTR_NAME):
            setattr(self, VALUES_ATTR_NAME, {})
        return getattr(self, VALUES_ATTR_NAME)
997540
def populate_obj(obj, attrs):
    
    for k, v in attrs.iteritems():
        setattr(obj, k, v)