Unlink a device from an All-Link group.

        Not supported by i1 devices.
185832
def enter_unlinking_mode(self, group):
        
        msg = StandardSend(self._address,
                           COMMAND_ENTER_UNLINKING_MODE_0X0A_NONE,
                           cmd2=group)
        self._send_msg(msg)
1232302
def kpl_off(self, address, group):
        """"""
        addr = Address(address)
        device = self.plm.devices[addr.id]
        device.states[group].off()
801648
def unlink(self, definition, doc1, doc2) :
        ""
        links = self.database[definition].fetchByExample( {"_from": doc1._id,"_to" : doc2._id}, batchSize = 100)
        for l in links :
            self.deleteEdge(l)
605020
def remove(self):
        
        for cgroup in self.paths:
            remove_cgroup(cgroup)

        del self.paths
        del self.per_subsystem
1196537
def unjoin(self):
        
        self.debug("()")
        if self._joined.is_set():
            packet = APPUnjoinMessage(device_id=Id.NOT_SET)
            self._send_packet(self._server_ip, self._server_port, packet)
            self._joined.clear()
            self.info("Left the audience")
1313562
def _unmount_devicemapper(self, cid):
        
        mountpoint = self.mountpoint
        Mount.unmount_path(mountpoint)

        cinfo = self.client.inspect_container(cid)
        dev_name = cinfo['GraphDriver']['Data']['DeviceName']

        Mount.remove_thin_device(dev_name)
        self._cleanup_container(cinfo)
679819
public final boolean unlink()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "unlink", _positionString());

        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "cursor count = " + _cursorCount);

        boolean unlinked = false;
        LinkedList parent = _parent;
        if (null != parent)
        {
            synchronized(parent)
            {
                if (LinkState.LINKED == _state)
                {
                    _state = LinkState.LOGICALLY_UNLINKED;
                    _tryUnlink();
                    unlinked = true;
                }
                else
                {
                    if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "unlink while " + _state);
                }
            }
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "unlink", new Object[] { Boolean.valueOf(unlinked), _positionString()});
        return unlinked;
    }
208508
public boolean unlink(Object source, String attributeName, Object target)
    {
        return linkOrUnlink(false, source, attributeName, false);
    }
573261
def teardown(self):
        ''''''

        self.device_group.teardown()
        self.trust_domain.teardown()
        self.cluster = None
1134717
def unlink(self, key, *keys):
        """"""
        return wait_convert(self.execute(b'UNLINK', key, *keys), int)
1188556
def unmap_by_address(self, absolute_address):
        

        desc = self._address_to_region_id[absolute_address]
        del self._address_to_region_id[absolute_address]
        del self._region_id_to_address[desc.region_id]
110185
def disconnect(self):
        """"""
        # TODO Close the APs. When this is attempted, we get an undocumented 0x1d error. Doesn't
        #      seem to be necessary, anyway.
        self._memory_interfaces = {}
        
        self._link.enter_idle()
        self._is_connected = False
607599
def remove_from_group(self, devices):
        """"""
        ids = {d.id for d in self.devices_in_group()}
        ids.difference_update(self._device_ids(devices))
        self._set_group(ids)
113726
public static DeviceGroupDeleteResult deviceGroupDelete(String accessToken,
                                                            DeviceGroupDelete deviceGroupDelete) {
        return deviceGroupDelete(accessToken,
                JsonUtil.toJSONString(deviceGroupDelete));
    }
1113529
def disassociate_hosting_device_with_config_agent(
            self, client, config_agent_id, hosting_device_id):
        """"""
        return client.delete((ConfigAgentHandlingHostingDevice.resource_path +
                              CFG_AGENT_HOSTING_DEVICES + "/%s") % (
            config_agent_id, hosting_device_id))
431718
def unlink(self):
        
        s_line_obj = self.env['sale.order.line']
        for line in self:
            if line.service_line_id:
                sale_unlink_obj = s_line_obj.browse([line.service_line_id.id])
                sale_unlink_obj.unlink()
        return super(HotelServiceLine, self).unlink()
932223
def remove_thin_device(name, force=False):
        
        cmd = ['dmsetup', 'remove', '--retry', name]
        r = util.subp(cmd)
        if not force:
            if r.return_code != 0:
                raise MountError('Could not remove thin device:\n%s' %
                                 r.stderr.decode(sys.getdefaultencoding()).split("\n")[0])