Delete the current :class:`InstanceResource`
328562
def delete(self):
        
        self.requester.delete(
            '/{endpoint}/{id}', endpoint=self.endpoint,
            id=self.id
        )
        return self
382027
def DeleteInstance(r, instance, dry_run=False):
    

    return r.request("delete", "/2/instances/%s" % instance,
                     query={"dry-run": dry_run})
241267
def DeleteInstance(self, si, logger, session, vcenter_data_model, vm_uuid, vm_name):
        
        # find vm
        vm = self.pv_service.find_by_uuid(si, vm_uuid)
        if vm is not None:
            # destroy vm
            result = self.pv_service.destroy_vm(vm=vm, logger=logger)
        else:
            resource___format = "Could not find the VM {0},will remove the resource.".format(vm_name)
            logger.info(resource___format)
            result = resource___format

        return result
1088810
public void removeInstance( String applicationName, String instancePath ) {
		this.logger.finer( String.format( "Removing instance \"%s\" from application \"%s\"...",
				instancePath, applicationName ) );

		WebResource path = this.resource
				.path( UrlConstants.APP )
				.path( applicationName )
				.path( "instances" )
				.queryParam( "instance-path", instancePath );

		this.wsClient.createBuilder( path ).delete();
		this.logger.finer( String.format( "Instance \"%s\" has been removed from application \"%s\"",
				instancePath, applicationName ) );
	}
363686
def delete_subresource(self, subresource):
        
        subresources = getattr(self, subresource.parent_key, {})
        del subresources[subresource.id]
        yield self._save()
246654
def delete(self):
        
        if self.instance is None:
            raise CQLEngineException("DML Query instance attribute is None")

        ds = DeleteStatement(self.column_family_name, timestamp=self._timestamp, conditionals=self._conditional, if_exists=self._if_exists)
        for name, col in self.model._primary_keys.items():
            val = getattr(self.instance, name)
            if val is None and not col.partition_key:
                continue
            ds.add_where(col, EqualsOperator(), val)
        self._execute(ds)
268464
@Override
    public <Instance> void removeInstance(Instance instance) {
        DatastoreType datastoreType = getDatastoreType(instance);
        DatastoreId id = getDatastoreId(datastoreType);
        cache.remove(id);
    }
346353
def delete(self):
        
        if self.resource_uri is None:
            raise ValueError("{0} object cannot be deleted because resource_uri attribute cannot be None".format(self._meta.resource_name))

        self._meta.api.http_resource("DELETE", self.resource_uri)
1167272
def remove_handlers_bound_to_instance(self, obj):
        
        for handler in self.handlers:
            if handler.im_self == obj:
                self -= handler
599983
def _teardown(self):
        '''
        
        '''
        if not self._was_object_method:
            setattr(self._instance, self._attr, self._obj)
        else:
            delattr(self._instance, self._attr)
38591
public void wipeInMemorySettings() {
    this.waitUntilInitialized();

    syncLock.lock();
    try {
      this.instanceChangeStreamListener.stop();
      if (instancesColl.find().first() == null) {
        throw new IllegalStateException("expected to find instance configuration");
      }
      this.syncConfig = new InstanceSynchronizationConfig(configDb);
      this.instanceChangeStreamListener = new InstanceChangeStreamListenerImpl(
          syncConfig,
          service,
          networkMonitor,
          authMonitor
      );
      this.isConfigured = false;
      this.stop();
    } finally {
      syncLock.unlock();
    }
  }
963546
async def delete(self, request, resource=None, **kwargs):
        
        if resource:
            resources = [resource]
        else:
            data = await self.parse(request)
            if data:
                resources = list(self.collection.where(self.meta.model_pk << data))

        if not resources:
            raise RESTNotFound(reason='Resource not found')

        for resource in resources:
            resource.delete_instance()
962286
def delete(self, context):
	
		
		
		encoded_name = urllib.parse.quote_plus(self.__name)
		status_code, msg = self.__endpoint.delete(
			"/resources/custom-resource/{}".format(encoded_name)
		)
		self.__available = False
15219
public function sasDeleteInstance()
	{
		$clazz = $this->getCurrentClass();
		$instance = $this->getCurrentInstance();

		$this->setData('label', $instance->getLabel());

		$this->setData('uri', tao_helpers_Uri::encode($instance->getUri()));
		$this->setData('classUri', tao_helpers_Uri::encode($clazz->getUri()));
		$this->setView('sas/delete.tpl', 'tao');
	}
1054418
def delete(self, *args, **kwargs):
        
        return self.session.delete(*args, **self.get_kwargs(**kwargs))
714349
def clear_global(self):
        
        vname = self.varname
        logger.debug(f'global clearning {vname}')
        if vname in globals():
            logger.debug('removing global instance var: {}'.format(vname))
            del globals()[vname]
384568
def remove(t)
      raise ArgumentError.new('Expecting an ActionPool::Thread object') unless t.is_a?(ActionPool::Thread)
      del = @threads.include?(t)
      @threads.delete(t) if del
      fill_pool
      t.stop
      del
    end