Purge the stream

        :param stream_id: The stream identifier
        :param remove_definition: Whether to remove the stream definition as well
        :param sandbox: The sandbox for this stream
        :return: None
161943
def purge_stream(self, stream_id, remove_definition=False, sandbox=None):
        
        super(AssetsChannel, self).purge_stream(
            stream_id=stream_id, remove_definition=remove_definition, sandbox=sandbox)
74833
def delete_watch(self, id, params=None):
        
        if id in SKIP_IN_PATH:
            raise ValueError("Empty value passed for a required argument 'id'.")
        return self.transport.perform_request(
            "DELETE", _make_path("_watcher", "watch", id), params=params
        )
1086151
def delete(identifier):
    ''''''
    log.info('Deleting source "%s"', identifier)
    actions.delete_source(identifier)
    log.info('Deleted source "%s"', identifier)
563553
public void deleteStream(String domain, String app, String stream) {
        DeleteStreamRequest request = new DeleteStreamRequest()
                .withDomain(domain)
                .withApp(app)
                .withStream(stream);
        deleteStream(request);
    }
546300
def remove_container(self, container_id, force=False):
        
        logger.info("removing container '%s' from filesystem", container_id)
        logger.debug("container_id = '%s'", container_id)
        self.d.remove_container(container_id, force=force)
723169
def remove(self, connection):
        
        cid = id(connection)
        if cid not in self.connections:
            raise ConnectionNotFoundError(self.id, cid)
        self.connection_handle(connection).close()
        with self._lock:
            del self.connections[cid]
        LOGGER.debug('Pool %s removed connection %s', self.id, cid)
606154
def remove_session_id(self, sid):
        
        for uid in self.get('sid2uid', sid):
            self.remove('uid2sid', uid, sid)
        self.delete('sid2uid', sid)

        for sub in self.get('sid2sub', sid):
            self.remove('sub2sid', sub, sid)
        self.delete('sid2sub', sid)
297223
public boolean removeStream(Stream stream) {
        final boolean removed = streams.remove(stream);

        if (removed) {
            indexSets.clear();
            for (Stream s : streams) {
                indexSets.add(s.getIndexSet());
            }
            sizeCounter.dec(8);
            if (LOG.isTraceEnabled()) {
                LOG.trace("[Message size update][{}] stream removed: {}", getId(), sizeCounter.getCount());
            }
        }

        return removed;
    }
1323279
protected void removeHlsStreamingHostFromSpaceProps(String spaceId) {
        // Update bucket tags to remove streaming host
        Map<String, String> spaceProps = s3Provider.getSpaceProperties(spaceId);
        if (spaceProps.containsKey(HLS_STREAMING_HOST_PROP) || spaceProps.containsKey(HLS_STREAMING_TYPE_PROP)) {
            spaceProps.remove(HLS_STREAMING_HOST_PROP);
            spaceProps.remove(HLS_STREAMING_TYPE_PROP);
            unwrappedS3Provider.setNewSpaceProperties(spaceId, spaceProps);
        }
    }
177632
def delete_subscription(self, subscription_id):
        
        return self.client._delete(self.url + 'subscriptions/{}'.format(subscription_id), headers=self.get_headers())
1032071
def remove(self, pools):
        

        data = dict()
        data["pools"] = pools

        uri = "api/pools/v2/"

        return self.delete(uri, data)
140465
def delete(self, id, seq, line): # pylint: disable=invalid-name,redefined-builtin
        
        return self.service.delete_id(self._base(id, seq), line)
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)
710613
def purge_all(self, remove_definitions=False):
        
        for stream_id in list(self.streams.keys()):
            self.purge_stream(stream_id, remove_definition=remove_definitions)
163058
def delete(self, id):
        
        resp = self.client.accounts.delete(id)
        self.display(resp)
1290374
def del_stream(self, bucket, label):
        
        bucket = self._require_bucket(bucket)
        key = self._require_key(bucket, label)
        key.delete()
534241
def delete(self, id):
        
        url = self._url('%s' % (id))
        return self.client.delete(url)