DeleteProcessById.
        [Preview API] Removes a process of a specific ID.
        :param str process_type_id:
11989
def delete_process_by_id(self, process_type_id):
        
        route_values = {}
        if process_type_id is not None:
            route_values['processTypeId'] = self._serialize.url('process_type_id', process_type_id, 'str')
        self._send(http_method='DELETE',
                   location_id='02cc6a73-5cfb-427d-8c8e-b49fb086e8af',
                   version='5.0-preview.2',
                   route_values=route_values)
1358977
def remove_pid_file(process_name):
    
    pid_filename = get_pid_filename(process_name)
    try:
        os.remove(pid_filename)
        print('Removed pid file at: {0}'.format(pid_filename), file=sys.stdout)
    except Exception as e:
        print('Unable to remove pid file at: {0}, because of: {1}'.format(pid_filename, e),
              file=sys.stderr)
19942
def delete_event(self, id, **data):
        
        
        return self.delete("/events/{0}/".format(id), data=data)
137433
def delete_processing_block(processing_block_id):
    """"""
    scheduling_block_id = processing_block_id.split(':')[0]
    config = get_scheduling_block(scheduling_block_id)
    processing_blocks = config.get('processing_blocks')
    processing_block = list(filter(
        lambda x: x.get('id') == processing_block_id, processing_blocks))[0]
    config['processing_blocks'].remove(processing_block)
    DB.set('scheduling_block/{}'.format(config['id']), json.dumps(config))

    # Add a event to the scheduling block event list to notify
    # of a new scheduling block being added to the db.
    DB.rpush('processing_block_events',
             json.dumps(dict(type="deleted", id=processing_block_id)))
1343687
def get_process_by_its_id(self, process_type_id, expand=None):
        
        route_values = {}
        if process_type_id is not None:
            route_values['processTypeId'] = self._serialize.url('process_type_id', process_type_id, 'str')
        query_parameters = {}
        if expand is not None:
            query_parameters['$expand'] = self._serialize.query('expand', expand, 'str')
        response = self._send(http_method='GET',
                              location_id='02cc6a73-5cfb-427d-8c8e-b49fb086e8af',
                              version='5.0-preview.2',
                              route_values=route_values,
                              query_parameters=query_parameters)
        return self._deserialize('ProcessInfo', response)
432910
private void onCleanExit(final String processId) {
    this.onResourceStatus(
        ResourceStatusEventImpl.newBuilder()
            .setIdentifier(processId)
            .setState(State.DONE)
            .setExitCode(0)
            .build()
    );
  }
28608
def get_process(self, dwProcessId):
        
        self.__initialize_snapshot()
        if dwProcessId not in self.__processDict:
            msg = "Unknown process ID %d" % dwProcessId
            raise KeyError(msg)
        return self.__processDict[dwProcessId]
1292064
def list(self, id=None):
        
        args = {'pid': id}
        self._process_chk.check(args)
        return self._client.json('process.list', args)
848861
private int processId(final java.lang.Process process) {
    int processId = 0;
    try {
      final Field f = process.getClass().getDeclaredField("pid");
      f.setAccessible(true);

      processId = f.getInt(process);
    } catch (final Throwable e) {
      e.printStackTrace();
    }

    return processId;
  }
970481
def detach_framebuffer(self, screen_id, id_p):
        
        if not isinstance(screen_id, baseinteger):
            raise TypeError("screen_id can only be an instance of type baseinteger")
        if not isinstance(id_p, basestring):
            raise TypeError("id_p can only be an instance of type basestring")
        self._call("detachFramebuffer",
                     in_p=[screen_id, id_p])
631917
def remove(id_):
    
    with LOCK:
        thread = REGISTRY.pop(id_, None)
        if thread is not None:
            thread.cancel()

    return thread
617700
def workflow_remove_stage(object_id, input_params={}, always_retry=True, **kwargs):
    
    return DXHTTPRequest('/%s/removeStage' % object_id, input_params, always_retry=always_retry, **kwargs)
345214
def remove_type_from_resource( type_id, resource_type, resource_id,**kwargs):
    
    node_id = resource_id if resource_type == 'NODE' else None
    link_id = resource_id if resource_type == 'LINK' else None
    group_id = resource_id if resource_type == 'GROUP' else None

    resourcetype = db.DBSession.query(ResourceType).filter(
                                        ResourceType.type_id==type_id,
                                        ResourceType.ref_key==resource_type,
                                        ResourceType.node_id == node_id,
    ResourceType.link_id == link_id,
    ResourceType.group_id == group_id).one()

    db.DBSession.delete(resourcetype)
    db.DBSession.flush()

    return 'OK'
1082375
def deprovision(self, instance_id: str, details: DeprovisionDetails, async_allowed: bool) -> DeprovisionServiceSpec:
        
        
        # Find the instance
        instance = self._backend.find(instance_id)
        if not instance.isProvisioned():
            # the instance does not exist
            raise ErrInstanceDoesNotExist()
        
        return self._backend.delete(instance)
594628
def delete(self, obj, id):
        
        self.url = '{}{}/{}'.format(self.base_url, obj, id)
        self.method = 'DELETE'
        self.resp = requests.delete(url=self.url,
                                    auth=self.auth,
                                    headers=self.headers, cert=self.ca_cert)
        return self.__process_resp__(obj)
46192
def removeforkrelation(self, project_id):
        
        request = requests.delete(
            '{0}/{1}/fork'.format(self.projects_url, project_id),
            headers=self.headers, verify=self.verify_ssl,
            auth=self.auth, timeout=self.timeout)

        if request.status_code == 200:
            return True
        else:
            return False
468342
def remove_description_by_type(self, type_p):
        
        if not isinstance(type_p, VirtualSystemDescriptionType):
            raise TypeError("type_p can only be an instance of type VirtualSystemDescriptionType")
        self._call("removeDescriptionByType",
                     in_p=[type_p])