Removes an allocated node name

        :param name: allocated node name
519272
def remove_allocated_node_name(self, name):
        

        if name in self._allocated_node_names:
            self._allocated_node_names.remove(name)
926693
async def rename(self, name):
        """"""
        set_node_name = SetNodeName(pyvlx=self.pyvlx, node_id=self.node_id, name=name)
        await set_node_name.do_api_call()
        if not set_node_name.success:
            raise PyVLXException("Unable to rename node")
        self.name = name
438041
def delete(node_name):
    
    result = {}
    node = nago.core.get_node(node_name)
    if not node:
        result['status'] = 'error'
        result['message'] = "node not found."
    else:
        node.delete()
        result['status'] = 'success'
        result['message'] = 'node deleted.'
    return result
876301
def remove_from_cluster(self, name, *args):
        
        cluster = self.get_cluster(name=name)
        attrs_ = cluster['cluster']
        for a in args:
            del attrs_[a]
813357
def delete(name, force=False):
    '''
    
    '''
    ret = {}

    if name not in list_nictags():
        return True

    cmd = 'nictagadm delete {0}{1}'.format("-f " if force else "", name)
    res = __salt__['cmd.run_all'](cmd)

    if res['retcode'] == 0:
        return True
    else:
        return {'Error': 'failed to delete nictag.' if 'stderr' not in res and res['stderr'] == '' else res['stderr']}
824101
def remove_node(self, node):
        
        try:
            self._nodes.remove(node)
            del self._weights[node]
        except (KeyError, ValueError):
            pass
        self._hashring = dict()
        self._sorted_keys = []

        self._build_circle()
136951
public static void removeName(Node n) {
    checkState(n.isFunction() || n.isClass());
    Node originalName = n.getFirstChild();
    Node emptyName = n.isFunction() ? IR.name("") : IR.empty();
    n.replaceChild(originalName, emptyName.useSourceInfoFrom(originalName));
  }
328822
def delete(self, name):
        
        i, entry = next(((i, x) for i, x in enumerate(self._uploadCache) if x['name'] == name), (None, None))
        if entry is not None:
            logger.info("Deleting " + name)
            os.remove(str(entry['path']))
            del self._uploadCache[i]
            return entry
        else:
            logger.info("Unable to delete " + name + ", not found")
            return None
377976
def drop_curie(self, name):
        
        curies = self.o[LINKS_KEY][self.draft.curies_rel]
        if isinstance(curies, dict) and curies['name'] == name:
            del self.o[LINKS_KEY][self.draft.curies_rel]
            return

        for i, curie in enumerate(curies):
            if curie['name'] == name:
                del curies[i]
                break

            continue
1091119
def delete_network_subname(self, sub_name):
        
        try:
            body = {}
            net_list = self.neutronclient.list_networks(body=body)
            for net in net_list:
                if net.get('name').find(sub_name) != -1:
                    self.delete_network_all_subnets(net.get('net_id'))
        except Exception as exc:
            LOG.error("Failed to get network by subname %(name)s, "
                      "Exc %(exc)s",
                      {'name': sub_name, 'exc': str(exc)})
542357
def remove_node(self, node):
        

        if node in self._nodes:
            yield from node.delete()
            self._nodes.remove(node)
956184
async def remove(self, name: str) -> None:
        

        LOGGER.debug('NodePoolManager.remove >>> name: %s', name)

        try:
            await pool.delete_pool_ledger_config(name)
        except IndyError as x_indy:
            LOGGER.info('Abstaining from node pool removal; indy-sdk error code %s', x_indy.error_code)

        LOGGER.debug('NodePool.remove <<<')
371031
def delete_item(name)
      previous = items.size
      items.reject! { |item| item.name == name}
      previous != items.size
    end
647421
def remove_header(self, name):
        
        name_lower = name.lower()
        for index in range(len(self.headers) - 1, -1, -1):
            if self.headers[index][0].lower() == name_lower:
                del self.headers[index]
                return True

        return False
475156
def unregister(self, name):
        
        try:
            name = name.name
        except AttributeError:
            pass
        return self.pop(name,None)
24556
public void removeHeader( String name )
    {
        ListIterator<Header> it = headers.listIterator();
        while ( it.hasNext() ) {
            if ( it.next().getName().equals( name ) ) {
                it.remove();
            }
        }
    }
1077102
def unsetNsProp(self, ns, name):
        
        if ns is None: ns__o = None
        else: ns__o = ns._o
        ret = libxml2mod.xmlUnsetNsProp(self._o, ns__o, name)
        return ret