Remove custom key binding for a key.

        :param key_name: Pymux key name, for instance "C-A".
436762
def remove_custom_binding(self, key_name, needs_prefix=False):
        
        k = (needs_prefix, key_name)

        if k in self.custom_bindings:
            self.custom_key_bindings.remove(self.custom_bindings[k].handler)
            del self.custom_bindings[k]
663186
def del_subkey(self,name):
        """"""
        self.sam |= KEY_WRITE
        subkey = self.get_subkey(name)
        subkey.clear()
        _winreg.DeleteKey(subkey.parent.hkey,subkey.name)
685636
function removeBinding(key, platform) {
        if (!key || ((platform !== null) && (platform !== undefined) && (platform !== brackets.platform))) {
            return;
        }

        var normalizedKey = normalizeKeyDescriptorString(key);

        if (!normalizedKey) {
            console.log("Failed to normalize " + key);
        } else if (_isKeyAssigned(normalizedKey)) {
            var binding = _keyMap[normalizedKey],
                command = CommandManager.get(binding.commandID),
                bindings = _commandMap[binding.commandID];

            // delete key binding record
            delete _keyMap[normalizedKey];

            if (bindings) {
                // delete mapping from command to key binding
                _commandMap[binding.commandID] = bindings.filter(function (b) {
                    return (b.key !== normalizedKey);
                });

                if (command) {
                    command.trigger("keyBindingRemoved", {key: normalizedKey, displayKey: binding.displayKey});
                }
            }
        }
    }
1213071
def pop(self, name):
        
        # check if present
        if name in self:
            # get case preserved name for variable
            new_name = self.var_case_name(name)
            # check if 1D or nD
            if new_name in self.keys():
                output = self[new_name]
                self.data.drop(new_name, inplace=True, axis=0)
            else:
                output = self.ho_data.pop(new_name)
                
            return output
        else:
            raise KeyError('Key not present in metadata variables')
464931
def get_subkey(self,name):
        
        subkey = Key(name,self)
        try:
            hkey = subkey.hkey
        except WindowsError:
            raise AttributeError("subkey '%s' does not exist" % (name,))
        return subkey
1329689
def delete_service_key(self, service_name, key_name):
        
        key = self.get_service_key(service_name, key_name)
        logging.info("Deleting service key %s for service %s" % (key, service_name))
        return self.api.delete(key['metadata']['url'])
1157490
def disable_key(key_id, region=None, key=None, keyid=None, profile=None):
    '''
    
    '''
    conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)

    r = {}
    try:
        key = conn.disable_key(key_id)
        r['result'] = True
    except boto.exception.BotoServerError as e:
        r['result'] = False
        r['error'] = __utils__['boto.get_error'](e)
    return r
1226034
def remove_config_type(name)
      unless config_type_registry.has_key?(name)
        raise NameError.new("#{name.inspect} is not a config_type on #{self}")
      end
      
      config_type = config_type_registry.delete(name)
      reset_config_types
      config_type
    end
864937
def unset(self, key):
        
        params = {
            'key': key
        }
        return self.client.delete(self._url(), params=params)
24910
public void clearKeyStoreFromMap(String keyStoreName) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
            Tr.debug(tc, "clearKeyStoreFromMap: " + keyStoreName);
        synchronized (keyStoreMap) {
            keyStoreMap.remove(keyStoreName);
        }
    }
15352
def remove_metadata_key(self, key, prefix=None):
        
        self.manager.remove_metadata_key(self, key, prefix=prefix)
1280064
def removeRemoteByName(self, name: str) -> int:
        
        remote = self.getRemote(name)
        rid = remote.uid
        self.removeRemote(remote)
        return rid
538799
public static void deleteKey(String keyName) throws RegistryException {
        checkError(invoke(Methods.REG_DELETE_KEY.get(), keyParts(keyName)));
    }
233094
def bind_key_name(self, function, object_name):
        """"""
        for funcname, name in self.name_map.items():
            if funcname == function:
                self.name_map[
                    funcname] = object_name
527562
def delete(self, block, name):
        
        self._kvs.delete(self._key(block, name))
617417
def delete(self, name):
    '''
    
    '''
    # TODO: confirm that this does not use the combo index and determine
    # performance implications.
    num_deleted = 0
    for interval,config in self._intervals.items():
      # TODO: use write preference settings if we have them
      num_deleted += self._client[interval].remove( {'name':name} )['n']
    return num_deleted
636734
public void remove(String nameOrKey) {
        Preconditions.checkNotNull(nameOrKey, "name or key for removal is null");
        values.remove(nameOrKey);
        children.remove(nameOrKey);
    }