remove board.

    :param board_id: board id (e.g. 'diecimila')
    :rtype: None
2436
def remove_board(board_id):
    

    log.debug('remove %s', board_id)
    lines = boards_txt().lines()
    lines = filter(lambda x: not x.strip().startswith(board_id + '.'), lines)
    boards_txt().write_lines(lines)
350728
def delete_by_id(role_id, custom_headers:nil)
      response = delete_by_id_async(role_id, custom_headers:custom_headers).value!
      response.body unless response.nil?
    end
1141159
def delete(self, id):
        
        id = self.as_id(id)
        response = self.http.delete(
            '%s/%s' % (self.api_url, id),
            auth=self.auth)
        response.raise_for_status()
184909
def pop(self: BoardT) -> Move:
        
        move = self.move_stack.pop()
        self._stack.pop().restore(self)
        return move
825240
def disconnect(self, id): # pylint: disable=invalid-name,redefined-builtin
        
        return self.service.post(self.base+str(id)+'/disconnect/')
1317953
def delete(self, id):
        
        try:
            response = yield self.client.delete(id)

            if response.get("n") > 0:
                self.write({"message": "Deleted %s object: %s" % (self.object_name, id) })
                return

            self.raise_error(404, "Resource not found")

        except InvalidId as ex:
            self.raise_error(400, message="Your ID is malformed: %s" % id)
        except:
            self.raise_error()

        self.finish()
298701
def remove_visualization(self, visualization_id):
        
        for i, panel in enumerate(self.panels):
            if panel['id'] == visualization_id:
                del self.panels[i]
516477
def remove_output_data_port(self, data_port_id, force=False, destroy=True):
        
        if data_port_id in self._output_data_ports:
            if destroy:
                self.remove_data_flows_with_data_port_id(data_port_id)
            self._output_data_ports[data_port_id].parent = None
            return self._output_data_ports.pop(data_port_id)
        else:
            raise AttributeError("output data port with name %s does not exit", data_port_id)
783133
def delete(queue_id):
    '''
    

    '''

    ret = {'message': '',
           'result': True
           }

    if not queue_id:
        log.error('Require argument queue_id')

    if not queue_id == 'ALL':
        queue = show_queue()
        _message = None
        for item in queue:
            if item['queue_id'] == queue_id:
                _message = item

        if not _message:
            ret['message'] = 'No message in queue with ID {0}'.format(queue_id)
            ret['result'] = False
            return ret

    cmd = 'postsuper -d {0}'.format(queue_id)
    result = __salt__['cmd.run_all'](cmd)

    if result['retcode'] == 0:
        if queue_id == 'ALL':
            ret['message'] = 'Successfully removed all messages'
        else:
            ret['message'] = 'Successfully removed message with queue id {0}'.format(queue_id)
    else:
        if queue_id == 'ALL':
            ret['message'] = 'Unable to removed all messages'
        else:
            ret['message'] = 'Unable to remove message with queue id {0}: {1}'.format(queue_id, result['stderr'])
    return ret
1243177
def delete_firmware_image(self, image_id):
        
        api = self._get_api(update_service.DefaultApi)
        api.firmware_image_destroy(image_id=image_id)
        return
1287501
def delete(self, id):
        
        id = self.key_name(id)
        self.redis.delete(id)
430497
def del_interrupt_callback(self, gpio_id):
        
        debug("- removing interrupts on gpio %s" % gpio_id)
        gpio_id = _GPIO.channel_to_gpio(gpio_id)
        fileno = self._map_gpioid_to_fileno[gpio_id]

        # 1. Remove from epoll
        self._epoll.unregister(fileno)

        # 2. Cache the file
        f = self._map_fileno_to_file[fileno]

        # 3. Remove from maps
        del self._map_fileno_to_file[fileno]
        del self._map_fileno_to_gpioid[fileno]
        del self._map_fileno_to_options[fileno]
        del self._map_gpioid_to_fileno[gpio_id]
        del self._map_gpioid_to_callbacks[gpio_id]

        # 4. Close file last in case of IOError
        f.close()
1057824
def delete_bookmark(self, bookmark_id):
        
        url = self._generate_url('bookmarks/{0}'.format(bookmark_id))
        return self.delete(url)
904236
def delete(self, uid):
        
        try:
            record = resource_db[uid].copy()

        except KeyError:
            return self.response_factory.not_found(errors=['Resource with UID {} does not exist!'])

        del resource_db[uid]

        return self.response_factory.ok(data=record)
331773
def delete(self, id):
        
        self.conn.cursor().execute("DELETE FROM WeRoBot WHERE id=%s", (id, ))
        self.conn.commit()
49514
def deleteLabel(self, label_id):
        
        if label_id not in self._labels:
            return

        label = self._labels[label_id]
        label.delete()
        for node in self.all():
            node.labels.remove(label)
534241
def delete(self, id):
        
        url = self._url('%s' % (id))
        return self.client.delete(url)