Remove the specified access point.

    You have to specify the device to remove the access point from, and the
    path of the access point.

    Please note that this does not set any global properties.
500871
def RemoveAccessPoint(self, dev_path, ap_path):
    '''
    '''

    dev_obj = dbusmock.get_object(dev_path)

    aps = dev_obj.Get(WIRELESS_DEVICE_IFACE, 'AccessPoints')
    aps.remove(ap_path)
    dev_obj.Set(WIRELESS_DEVICE_IFACE, 'AccessPoints', aps)

    dev_obj.access_points.remove(ap_path)

    dev_obj.EmitSignal(WIRELESS_DEVICE_IFACE, 'AccessPointRemoved', 'o', [ap_path])

    self.object_manager_emit_removed(ap_path)
    self.RemoveObject(ap_path)
540023
def remove(self):
        
        LOGGER.debug("IPAddress.remove")
        if self.id is None:
            return None
        else:
            params = {
                'id': self.id
            }
            args = {'http_operation': 'GET', 'operation_path': 'delete', 'parameters': params}
            response = IPAddressService.requester.call(args)
            if response.rc != 0:
                LOGGER.warning(
                    'IPAddress.remove - Problem while deleting IP Address' + self.ip_address +
                    '. Reason: ' + str(response.response_content) + '-' + str(response.error_message) +
                    " (" + str(response.rc) + ")"
                )
                return self
            else:
                return None
20695
def delete(self):
        
        if self in self._parent.vlan_interface:
            self._parent.data['vlanInterfaces'] = [
                v for v in self._parent.vlan_interface
                if v != self]
            self.update()
            for route in self._parent._engine.routing:
                if route.to_delete:
                    route.delete()
271272
def delete(self, endpoint, json=None, params=None, **kwargs):
        
        json = kwargs['data'] if 'data' in kwargs else json
        return self._make_request('delete', endpoint, data=json, params=params)
471700
function (identifier)  {
    var path;
    if (identifier) {
      path = this.constructPath(constants.DEVICES, identifier);
      return this.Core.DELETE(path);
    } else {
      return this.rejectRequest('Bad Request: A device identifier is required.');
    }
  }
296504
def remove(self, hostport):
        
        assert hostport, "hostport is required"
        peer = self._peers.pop(hostport, None)
        peer_in_heap = peer and peer.index != -1
        if peer_in_heap:
            self.peer_heap.remove_peer(peer)
        return peer
1231454
def _remove_trustee(self, device):
        '''
        '''

        trustee_name = get_device_info(device).name
        name_object_map = get_device_names_to_objects(self.devices)
        delete_func = self._get_delete_trustee_cmd

        for truster in self.domain:
            if trustee_name in self.domain[truster] and \
                    truster != trustee_name:
                truster_obj = name_object_map[truster]
                self._modify_trust(truster_obj, delete_func, trustee_name)
            self._populate_domain()

        for trustee in self.domain[trustee_name]:
            if trustee_name != trustee:
                self._modify_trust(device, delete_func, trustee)

        self.devices.remove(name_object_map[trustee_name])
960267
def delete(self):
        """"""
        if lib.EnvDeleteRouter(self._env, self._name.encode()) == 0:
            raise RuntimeError("Unable to delete router %s" % self._name)
250475
def remove_port_profile_to_delete(self, profile_name, device_id):
        """"""
        with self.session.begin(subtransactions=True):
            self.session.query(ucsm_model.PortProfileDelete).filter_by(
                profile_id=profile_name, device_id=device_id).delete()
584226
def _delete_iapp(self, iapp_name, deploying_device):
        '''
        '''

        iapp = deploying_device.tm.sys.application
        iapp_serv = iapp.services.service.load(
            name=iapp_name, partition=self.partition
        )
        iapp_serv.delete()
        iapp_tmpl = iapp.templates.template.load(
            name=iapp_name, partition=self.partition
        )
        iapp_tmpl.delete()
343671
def remove(self):
        

        xmlrpc = XMLRPCConnection()
        try:
            xmlrpc.connection.remove_vrf(
                {
                    'vrf': { 'id': self.id },
                    'auth': self._auth_opts.options
                })
        except xmlrpclib.Fault as xml_fault:
            raise _fault_to_exception(xml_fault)
        if self.id in _cache['VRF']:
            del(_cache['VRF'][self.id])
738798
def destroy(self):
        
        path = next(iter(self.linuxPaths))
        directory = _Directory(os.path.dirname(path))
        with directory as device:
            device.SNAP_DESTROY(name=str(os.path.basename(path)), )
954569
public function removeDevicesFromTopic($topicId = null, $deviceTokens = array())
    {
        if(!$topicId || empty($deviceTokens)){
            throw new \InvalidArgumentException("Please check arguments!");
        }

        return $this->client->removeTopicSubscription($topicId, $deviceTokens);
    }
334343
def delete(self):
        
        resp = self._client.delete(type(self).api_endpoint, model=self)

        if 'error' in resp:
            return False
        self.invalidate()
        return True
364943
def delete_address(kwargs=None, call=None):
    '''
    
    '''
    if call != 'function':
        raise SaltCloudSystemExit(
            'The delete_address function must be called with -f or --function.'
        )

    if not kwargs or 'name' not in kwargs:
        log.error(
            'A name must be specified when deleting an address.'
        )
        return False

    if not kwargs or 'region' not in kwargs:
        log.error(
            'A region must be specified when deleting an address.'
        )
        return False

    name = kwargs['name']
    ex_region = kwargs['region']

    conn = get_conn()

    __utils__['cloud.fire_event'](
        'event',
        'delete address',
        'salt/cloud/address/deleting',
        args={
            'name': name,
        },
        sock_dir=__opts__['sock_dir'],
        transport=__opts__['transport']
    )

    try:
        result = conn.ex_destroy_address(
            conn.ex_get_address(name, ex_region)
        )
    except ResourceNotFoundError as exc:
        log.error(
            'Address %s in region %s was not found. Exception was: %s',
            name, ex_region, exc, exc_info_on_loglevel=logging.DEBUG
        )
        return False

    __utils__['cloud.fire_event'](
        'event',
        'deleted address',
        'salt/cloud/address/deleted',
        args={
            'name': name,
        },
        sock_dir=__opts__['sock_dir'],
        transport=__opts__['transport']
    )

    log.info('Deleted GCE Address %s', name)

    return result
42735
def teardown(self):
        ''''''

        for device in self.devices:
            self._remove_trustee(device)
            self._populate_domain()
        self.domain = {}
1286611
public function delete()
    {
        Connection::sendCurlRequest(Connection::URL_DEVICES . '/' . $this->iden, 'DELETE', null, false,
            $this->apiKey);
    }