Remove all PTR records from the given address
        :type addresses: List[str]
        :param addresses: (List[str]) The IP Address to reset
        :return: (bool) True in case of success, False in case of failure
482951
def reset(self, addresses):
        
        request = self._call(SetEnqueueResetReverseDns.SetEnqueueResetReverseDns, IPs=addresses)
        response = request.commit()
        return response['Success']
329130
def __clear_bp(self, aProcess):
        
        lpAddress    = self.get_address()
        flNewProtect = aProcess.mquery(lpAddress).Protect
        flNewProtect = flNewProtect & (0xFFFFFFFF ^ win32.PAGE_GUARD)   # DWORD
        aProcess.mprotect(lpAddress, self.get_size(), flNewProtect)
1096779
def delete_obj_by_address(addr, id)
      @index.remove(id) if @index.is_open?
      header = FlatFileBlobHeader.read(@f, addr, id)
      header.clear_flags
      @space_list.add_space(addr, header.length) if @space_list.is_open?
    end
1276316
public AddressSelector reset() {
    if (selectionsIterator != null) {
      this.selections = strategy.selectConnections(leader, new ArrayList<>(servers));
      this.selectionsIterator = null;
    }
    return this;
  }
653157
def _delete_record(self, identifier=None, rtype=None, name=None, content=None):
        """"""
        to_delete_ids = list()
        if identifier:
            to_delete_ids.append(identifier)
        else:
            for record in self._list_records(rtype=rtype, name=name, content=content):
                to_delete_ids.append(record["id"])

        for to_delete_id in to_delete_ids:
            self._request_delete_dns_record_by_id(to_delete_id)
        return True
614450
def _find_address_range(addresses):
    
    it = iter(addresses)
    first = last = next(it)
    for ip in it:
        if ip._ip != last._ip + 1:
            yield first, last
            first = ip
        last = ip
    yield first, last
1204371
def remove_all_matching(self, address=None, name=None):
        
        if self.entries:
            if address and name:
                func = lambda entry: not entry.is_real_entry() or (entry.address != address and name not in entry.names)
            elif address:
                func = lambda entry: not entry.is_real_entry() or entry.address != address
            elif name:
                func = lambda entry: not entry.is_real_entry() or name not in entry.names
            else:
                raise ValueError('No address or name was specified for removal.')
            self.entries = list(filter(func, self.entries))
846391
def restrict(self, addr):
        

        # Remove the address from the set
        ip_addr = _parse_ip(addr)
        if ip_addr is None:
            LOG.warn("Cannot restrict address %r from proxy %s: "
                     "invalid address" % (addr, self.address))
        else:
            self.excluded.add(addr)
1061089
def update(self, address, updater, prune=False):
        '''
        
        '''

        node = self._get_or_create(address)

        node.data = updater(node.data)

        if prune:
            node.children.clear()
398576
def _RemoveForwardedIps(self, forwarded_ips, interface):
    
    for address in forwarded_ips:
      self.ip_forwarding_utils.RemoveForwardedIp(address, interface)
298489
private static void resetHostList(Listener listener, Deque<HostAddress> loopAddresses) {
    //if all servers have been connected without result
    //add back all servers
    List<HostAddress> servers = new ArrayList<>();
    servers.addAll(listener.getUrlParser().getHostAddresses());
    Collections.shuffle(servers);

    loopAddresses.clear();
    loopAddresses.addAll(servers);
  }
398040
def close(self):
        
        if self._closed:
            return
        try:
            with self.lock:
                if not self._closed:
                    self._closed = True
                    for address in list(self.connections):
                        self.remove(address)
        except TypeError as e:
            pass
312143
def deactivate(self, address):
        
        with self.lock:
            try:
                connections = self.connections[address]
            except KeyError: # already removed from the connection pool
                return
            for conn in list(connections):
                if not conn.in_use:
                    connections.remove(conn)
                    try:
                        conn.close()
                    except IOError:
                        pass
            if not connections:
                self.remove(address)
559678
def remove_address(self, fqdn, address):
        " "

        # Get a list of addresses.
        for record in self.list_address(fqdn):
            if record.address == address:
                record.delete()
                break
147747
private static void resetHostList(MastersSlavesListener listener,
      Deque<HostAddress> loopAddresses) {
    //if all servers have been connected without result
    //add back all servers
    List<HostAddress> servers = new ArrayList<>();
    servers.addAll(listener.getUrlParser().getHostAddresses());
    Collections.shuffle(servers);

    //remove current connected hosts to avoid reconnect them
    servers.removeAll(listener.connectedHosts());

    loopAddresses.clear();
    loopAddresses.addAll(servers);
  }
56422
def delNode(self, address):
        
        if address in self.nodes:
            del self.nodes[address]
        self.poly.delNode(address)
1144852
def remove_ipv6addr(self, ipv6addr):
        
        for addr in self.ipv6addrs:
            if ((isinstance(addr, dict) and addr['ipv6addr'] == ipv6addr) or
                (isinstance(addr, HostIPv4) and addr.ipv6addr == ipv6addr)):
                self.ipv6addrs.remove(addr)
                break