Delete a devcie from database

        :param argin: device name
        :type: tango.DevString
        :return:
        :rtype: tango.DevVoid
333170
def DbDeleteDevice(self, argin):
        
        self._log.debug("In DbDeleteDevice()")

        ret, dev_name, dfm = check_device_name(argin)
        if not ret:
            self.warn_stream("DataBase::db_delete_device(): device name " + argin + " incorrect ")
            th_exc(DB_IncorrectDeviceName,
                   "failed to delete device, device name incorrect",
                   "DataBase::DeleteDevice()")
        self.db.delete_device(dev_name)
1322072
def delete(gandi, resource):
    

    result = gandi.dnssec.delete(resource)
    gandi.echo('Delete successful.')

    return result
318987
def DbDeleteDeviceAlias(self, argin):
        
        self._log.debug("In DbDeleteDeviceAlias()")
        self.db.delete_device_alias(argin)
1150808
async def del_aldb(self, addr, mem_addr: int):
        """"""
        dev_addr = Address(addr)
        device = self.plm.devices[dev_addr.id]
        if device:
            _LOGGING.debug('calling device del_aldb')
            device.del_aldb(mem_addr)
            await asyncio.sleep(1, loop=self.loop)
            while device.aldb.status == ALDBStatus.LOADING:
                await asyncio.sleep(1, loop=self.loop)
            self.print_device_aldb(addr)
1106988
public void delete_device_attribute_property(Database database, String deviceName, String attname, String propname)
            throws DevFailed {
        String[] array = new String[1];
        array[0] = propname;
        delete_device_attribute_property(database, deviceName, attname, array);
    }
643503
public void delete_device_attribute_property(Database database, String deviceName, DbAttribute[] attribute)
            throws DevFailed {
        for (DbAttribute att : attribute)
            delete_device_attribute_property(database, deviceName,
                    att.name, att.get_property_list());
    }

    //
	/* (non-Javadoc)
	 * @see fr.esrf.TangoApi.IDatabaseDAO#delete_device_attribute_property(java.lang.String, java.lang.String, java.lang.String[])
	 */
    //
    public void delete_device_attribute_property(Database database, String deviceName, String attname, String[] propnames)
            throws DevFailed {
        if (propnames.length==0)
            return;

        if (!database.isAccess_checked()) checkAccess(database);

        //	Build a String array before command
        String[] array = new String[2 + propnames.length];
        array[0] = deviceName;
        array[1] = attname;
        System.arraycopy(propnames, 0, array, 2, propnames.length);

        DeviceData argIn = new DeviceData();
        argIn.insert(array);
        command_inout(database, "DbDeleteDeviceAttributeProperty", argIn);
    }
934775
def _delete_device(device):
    '''
    
    '''
    log.trace('Deleting device with type %s', type(device))
    device_spec = vim.vm.device.VirtualDeviceSpec()
    device_spec.operation = vim.vm.device.VirtualDeviceSpec.Operation.remove
    device_spec.device = device
    return device_spec
727007
def delete_device(self, device_id):
        
        api = self._get_api(device_directory.DefaultApi)
        return api.device_destroy(id=device_id)
1150645
def delete_fw_device(self, tenant_id, fw_id, data):
        
        drvr_dict, mgmt_ip = self.sched_obj.get_fw_dev_map(fw_id)
        ret = drvr_dict.get('drvr_obj').delete_fw(tenant_id, data)
        # FW DB gets deleted, so no need to remove the MGMT IP
        if ret:
            self.sched_obj.deallocate_fw_dev(fw_id)
        return ret
1169728
def delete(self,removed):
        
        if isinstance(removed,dict):
            # remove a single record
            removed = [removed]
        else:
            # convert iterable into a list (to be able to sort it)
            removed = [ r for r in removed ]
        if not removed:
            return 0
        _ids = [ r['__id__'] for r in removed ]
        _ids.sort()
        sql = "DELETE FROM %s WHERE __id__ IN (%s)" %(self.name,
            ",".join([str(_id) for _id in _ids]))
        self.cursor.execute(sql)
        return len(removed)
2410
public void delete_device_property(String name, String propname) throws DevFailed {
		databaseDAO.delete_device_property(this, name, propname);
	}
658646
def remove(self, uuid, project=None):
        
        uuid = uuid.split('@')[0]
        with self._lock:
            run(['task', 'rc.verbose=nothing', 'rc.data.location={self._data_location}'.format(**locals()), 'rc.confirmation=no', uuid, 'delete'])
893258
public void deleteDevicePipe(Database database, String deviceName, String pipeName) throws DevFailed {
        String[]    array = new String[] { deviceName, pipeName };
        DeviceData  argIn = new DeviceData();
        argIn.insert(array);
        database.command_inout("DbDeleteDevicePipe", argIn);
    }
366305
public DeviceData command_inout(final Connection connection, final String command,
	    	final DeviceData argin) throws DevFailed {
		Any received = null;
		
		build_connection(connection);

		// Check if taco device
		if (connection.url.protocol == TACO) {
	    	return connection.taco_device.command_inout(command, argin);
		}
		//System.out.println(connection.devname + ".command_inout("+command + ") -----------> " +
		//		((connection.access==TangoConst.ACCESS_READ)? "Read" : "Write"));

		//
		// Manage Access control
		//
		if (connection.access == TangoConst.ACCESS_READ) {
	    	final Database db = ApiUtil.get_db_obj(connection.url.host, connection.url.strPort);
	    	if (!db.isCommandAllowed(connection.get_class_name(), command)) {
				// Check if not allowed or PB with access device
				if (db.access_devfailed != null) {
		    		throw db.access_devfailed;
				}
                //  Special case for first connection on database
                if (firstTime && connection instanceof Database) {
                    firstTime = false;
                    return command_inout(connection, command, argin);
                }
				// ping the device to throw exception
				// if failed (for reconnection)
				ping(connection);

				System.out.println(connection.devname + "." + command
					+ "  -> TangoApi_READ_ONLY_MODE");
            	throwNotAuthorizedException(connection.devname + ".command_inout(" + command + ")",
                    	"Connection.command_inout()");
	    	}
		}
		// Else tango call
		boolean done = false;
		// try 2 times for reconnection if requested
		final int retries = connection.transparent_reconnection ? 2 : 1;
		for (int i=0 ; i<retries && !done ; i++) {
	    	try {
				if (connection.device_5 != null) {
		    		received = connection.device_5.command_inout_4(command, argin.extractAny(),
			    		connection.dev_src, DevLockManager.getInstance().getClntIdent());
                } else if (connection.device_4 != null) {
		    		received = connection.device_4.command_inout_4(command, argin.extractAny(),
			    		connection.dev_src, DevLockManager.getInstance().getClntIdent());
                } else if (connection.device_2 != null) {
                    received = connection.device_2.command_inout_2(command, argin.extractAny(),
                        connection.dev_src);
                } else {
                    received = connection.device.command_inout(command, argin.extractAny());
                }
                done = true;
            }
			catch (final DevFailed e) {
            	final String reason = "TangoApi_CANNOT_EXECUTE_COMMAND";
            	final String desc = "Cannot execute command " + command + " on "
                	+ connection.devname;
            	final String origin = "Connection.command_inout()";

            	// Check if (from database) DeviceNotDefined exception
            	// then add witch database in the existing DevFailed.
            	if (e.errors[0].reason.equals("DB_DeviceNotDefined")) {
                	String d = e.errors[0].desc;
                	final int idx = d.lastIndexOf("!");
                	if (idx > 0) {
                    	d = d.substring(0, idx);
                	}
                	d += "  " + connection.url.host + ":" + connection.url.port + " !";
                	e.errors[0].desc = d;
            	}
            	Except.throw_connection_failed(e, reason, desc, origin);
        	} catch (final Exception e) {
					manageExceptionReconnection(connection, retries, i, e,
						 this.getClass() + ".command_inout");
	    	}
		}
		return new DeviceData(received);
    }
1072265
def delete(self):
        
        target = DeviceTarget(self.device_id)
        return self._fssapi.delete_file(target, self.path)[self.device_id]
740979
def delete(ids, force):
    """"""
    records_deprecation_warning()

    from .api import Record
    for id_ in ids:
        record = Record.get_record(id_, with_deleted=force)
        record.delete(force=force)
    db.session.commit()
235396
def delete(self, n=1, interval=0, pre_dl=None, post_dl=None):
        
        self.delay(pre_dl)
        self.k.tap_key(self.k.delete_key, n, interval)
        self.delay(post_dl)