Stop listening to a job

        Parameters
        ----------
        id_ : str
            An ID to remove

        Returns
        --------
        str or None
            The ID removed or None if the ID was not removed
5228
def unlisten_to_node(self, id_):
        
        id_pubsub = _pubsub_key(id_)

        if id_pubsub in self._listening_to:
            del self._listening_to[id_pubsub]
            self.toredis.unsubscribe(id_pubsub)

            parent = json_decode(r_client.get(id_)).get('parent', None)
            if parent is not None:
                r_client.srem(_children_key(parent), id_)
            r_client.srem(self.group_children, id_)

            return id_
448797
def delete_job(job_id, connection=None):
    
    if connection is None:
        connection = r
    with connection.pipeline() as pipe:
        pipe.delete(job_key(job_id))
        pipe.zrem(REDIS_KEY, job_id)
        pipe.execute()
1028322
def delete(self, _id):
        
        mongo_response = yield self.collection.remove({"_id": ObjectId(_id)})

        raise Return(mongo_response)
1348721
def CancelJob(r, job_id, dry_run=False):
    

    return r.request("delete", "/2/jobs/%s" % job_id,
                             query={"dry-run": dry_run})
940064
def remove_notification_listener(self, notification_id):
    

    for v in self.notifications.values():
      toRemove = list(filter(lambda tup: tup[0] == notification_id, v))
      if len(toRemove) > 0:
        v.remove(toRemove[0])
        return True

    return False
1101380
def stop(cls, app_id):
        
        conn = Qubole.agent()
        return conn.put(cls.element_path(app_id) + "/stop")
262005
def _exclude_id(jar):
    
    return '{0}:{1}'.format(jar.org, jar.name) if jar.name else jar.org
1365919
def job_disable(self, job_id):
		
		job_id = normalize_job_id(job_id)
		with self._job_lock:
			job_desc = self._jobs[job_id]
			job_desc['enabled'] = False
1146129
def terminate(self, unique_id, configs=None):
    
    self._send_signal(unique_id, signal.SIGTERM, configs)
1016461
def remove_data_flow(self, data_flow_id, destroy=True):
        
        if data_flow_id not in self._data_flows:
            raise AttributeError("The data_flow_id %s does not exist" % str(data_flow_id))

        self._data_flows[data_flow_id].parent = None
        return self._data_flows.pop(data_flow_id)
73545
def removeID(self, idVal):
        
        for i in self:
            if i.id == idVal:
                self._collection.remove(i)
                return
        raise KeyError("A Record with the ID '{}' was not found in the RecordCollection: '{}'.".format(idVal, self))
138749
def request_job_cancel(self, job_id):
        
        msg = CancelMessage(job_id)
        self.messaging_backend.send(self.worker_mailbox, msg)
        self.storage_backend.mark_job_as_canceling(job_id)
622751
def delete_tag(context, id, tag_id):
    

    result = job.delete_tag(context, id=id, tag_id=tag_id)
    if result.status_code == 204:
        utils.print_json({'id': id, 'message': 'Tag removed.'})
    else:
        utils.format_output(result, context.format)
660201
def delete(ids, yes):
    
    failures = False

    for id in ids:
        data_source = get_data_object(id, use_data_config=True)

        if not data_source:
            failures = True
            continue

        data_name = normalize_data_name(data_source.name)
        suffix = data_name.split('/')[-1]
        if not suffix.isdigit():
            failures = True
            floyd_logger.error('%s is not a dataset, skipped.', id)
            if suffix == 'output':
                floyd_logger.error('To delete job output, please delete the job itself.')
            continue

        if not yes and not click.confirm("Delete Data: {}?".format(data_name),
                                         abort=False,
                                         default=False):
            floyd_logger.info("Data %s: Skipped", data_name)
            continue

        if not DataClient().delete(data_source.id):
            failures = True
        else:
            floyd_logger.info("Data %s: Deleted", data_name)

    if failures:
        sys.exit(1)
372062
def delete_source(self, id):
        
        # Set the index
        self.catalog.set_index('id')
        
        # Exclude the unwanted source
        self.catalog = self.catalog[self.catalog.id!=id]
        
        # Remove the records from the catalogs
        for cat_name in self.catalogs:
            new_cat = getattr(self, cat_name)[getattr(self, cat_name).source_id!=id]
            print('{} records removed from {} catalog'.format(int(len(getattr(self, cat_name))-len(new_cat)), cat_name))
            setattr(self, cat_name, new_cat)
825240
def disconnect(self, id): # pylint: disable=invalid-name,redefined-builtin
        
        return self.service.post(self.base+str(id)+'/disconnect/')
211904
def delete(self, id: int):
        
        assert isinstance(id, int)

        self.open_session()
        to_delete = self.get(id)
        self.session.delete(to_delete)
        self.save()