Remove an attribute from the node.

        Use only if is_mapping() returns True.

        Args:
            attribute: The name of the attribute to remove.
198774
def remove_attribute(self, attribute: str) -> None:
        
        attr_index = self.__attr_index(attribute)
        if attr_index is not None:
            self.yaml_node.value.pop(attr_index)
356578
def remove(self, child):
        
        if isinstance(child, Element):
            return child.detach()
        if isinstance(child, Attribute):
            self.attributes.remove(child)
        return None
863369
def _remove_attributes(attrs, remove_list):
    
    new_attrs = {}
    for attr in attrs.keys():
        if attr not in remove_list:
            new_attrs[attr] = attrs[attr]
    return new_attrs
1340963
public Attribute removeAttributeByLocalName(CharSequence name) {
		for (Iterator<Attribute> it = event.attributes.iterator(); it.hasNext(); ) {
			Attribute attr = it.next();
			if (attr.localName.equals(name)) {
				it.remove();
				return attr;
			}
		}
		return null;
	}
1300113
@Override
    public void removeAttribute(String name) {
        final boolean bTrace = TraceComponent.isAnyTracingEnabled();
        if (bTrace && tc.isDebugEnabled()) {
            Tr.debug(tc, "removeAttribute: " + name);
        }
        if (isInvalid()) {
            throw new IllegalStateException("Session is invalid");
        }
        Object attr = this.attributes.remove(name);
        if (null == attr) {
            if (bTrace && tc.isDebugEnabled()) {
                Tr.debug(tc, "Attribute not found");
            }
            return;
        }
        HttpSessionBindingEvent event = null;
        if (attr instanceof HttpSessionBindingListener) {
            // this value wants to know when it's removed
            if (bTrace && tc.isDebugEnabled()) {
                Tr.debug(tc, "Notifying value; " + attr);
            }
            event = new HttpSessionBindingEvent(this, name, attr);
            ((HttpSessionBindingListener) attr).valueUnbound(event);
        }
        // List<HttpSessionAttributeListener> listeners = this.myConfig.getSessionAttributeListeners();
        // if (null != listeners) {
        // // notify any session-attribute listeners that were registered
        // // in the module configuration
        // if (null == event) {
        // event = new HttpSessionBindingEvent(this, name, attr);
        // }
        // for (HttpSessionAttributeListener listener : listeners) {
        // if (bTrace && tc.isDebugEnabled()) {
        // Tr.debug(tc, "Notifying listener: " + listener);
        // }
        // listener.attributeRemoved(event);
        // }
        // }
    }
1362930
function (node, name) {
    node.removeAttribute(name);
    if (process.env.NODE_ENV !== 'production') {
      ReactInstrumentation.debugTool.onHostOperation({
        instanceID: ReactDOMComponentTree.getInstanceFromNode(node)._debugID,
        type: 'remove attribute',
        payload: name
      });
    }
  }
463798
public boolean removeAttribute(String attribute, boolean removeFromACModel, boolean notifyListeners) {
                if (!super.removeObject(attribute, false)) {
                        return false;
                }

                if (acModel != null && removeFromACModel && acModel.getContext() != this) {
                        acModel.getContext().removeObject(attribute);
                }

                // Remove data usage of removed attributes
                for (String activity : activities) {
                        removeDataUsageFor(activity, attribute);
                }
                if (notifyListeners) {
                        contextListenerSupport.notifyObjectRemoved(attribute);
                }
                return true;
        }
292868
def reset_attribute!(name)
      value = attribute_was(name)
      if value
        @attributes[name] = value
        modifications.delete(name)
      end
    end
1124010
public NameOpValue removeParam(String attribute) {
        if (_relations == null || attribute == null) return null;

        Iterator iter = _relations.iterator();
        NameOpValue nv;
	String canonAttrib = canonicalize(attribute);
        String tmpCanonAttrib = null;
        while(iter.hasNext()) {
            nv = (NameOpValue)iter.next();
            tmpCanonAttrib = canonicalize(nv.getAttribute());
            if (tmpCanonAttrib.equalsIgnoreCase(canonAttrib)) {
		iter.remove();
                return nv;
            }
        }
        return null;
    }
1353839
public void removeAttribute(String arg0) {
        //321485
    	if (_attributes==null)
    		return;
        if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled()&&logger.isLoggable (Level.FINE)) {  //306998.15
            logger.logp(Level.FINE, CLASS_NAME,"removeAttribute", " name --> " + arg0);
        }
        Object oldValue=_attributes.remove(arg0);
    }
100459
def clean_attribute(value)
        if value.kind_of?(Hash)
          value.delete_if { |key, value| clean_attribute(value) }.empty?
        elsif value.kind_of?(Array)
          value.delete_if { |value| clean_attribute(value) }.empty?
        else
          value.to_s.strip.empty?
        end
      end
75388
def delete_attributes(self, attrs):
        
        assert(isinstance(attrs, list)), "Argument must be a list of names of keys to delete."
        self._manager.domain.delete_attributes(self.id, attrs)
        self.reload()
        return self
1127584
def remove_callback(self, name, callback):
        

        if self.is_callback_property(name):
            prop = getattr(type(self), name)
            try:
                prop.remove_callback(self, callback)
            except ValueError:  # pragma: nocover
                pass  # Be forgiving if callback was already removed before
        else:
            raise TypeError("attribute '{0}' is not a callback property".format(name))
1105917
function (node, name) {
    node.removeAttribute(name);
    {
      ReactInstrumentation.debugTool.onHostOperation({
        instanceID: ReactDOMComponentTree_1.getInstanceFromNode(node)._debugID,
        type: 'remove attribute',
        payload: name
      });
    }
  }
74533
public void removeAttribute(String attributeName) {
        synchronized (_iSession) {
            if (!_iSession.isValid())
                throw new IllegalStateException();
            Object object = _iSession.removeAttribute(attributeName);
        }
    }
138463
public function removeAttribute(Attribute $attribute)
    {
        foreach ($this->attributes as $key => $attributeElement) {
            if ($attributeElement === $attribute) {
                unset($this->attributes[$key]);
                break;
            }
        }

        return $this;
    }
392553
function removeAttribute(element, name) {
    element = getComponentNode(element) || element;
    let oldValue = element.getAttribute(name);
    element.removeAttribute(name);
    return update(element, name, oldValue, null);
}