Removed all logs that are assigned to a given rest api id.
343839
def remove_api_gateway_logs(self, project_name):
        
        for rest_api in self.get_rest_apis(project_name):
            for stage in self.apigateway_client.get_stages(restApiId=rest_api['id'])['item']:
                self.remove_log_group('API-Gateway-Execution-Logs_{}/{}'.format(rest_api['id'], stage['stageName']))
1316807
def remove(self, oid):
        
        uri = self._resources[oid].uri
        del self._resources[oid]
        del self._hmc.all_resources[uri]
437279
@RequirePOST
    public synchronized void doDoDelete(StaplerResponse rsp) throws IOException, ServletException {
        getConfigFile().delete();
        getParent().logRecorders.remove(name);
        // Disable logging for all our targets,
        // then reenable all other loggers in case any also log the same targets
        for (Target t : targets)
            t.disable();
        for (LogRecorder log : getParent().logRecorders.values())
            for (Target t : log.targets)
                t.enable();
        rsp.sendRedirect2("..");
    }
1018720
def remove(cls, id):
        

        api = Client.instance().api
        api.index(id).delete()
1023408
public void clearTenant(String tenantId) {
        String index = getIndex(tenantId);

        synchronized (knownIndices) {
            IndicesAdminClient indices = client.admin().indices();

            boolean indexExists = indices.prepareExists(index)
                    .execute()
                    .actionGet()
                    .isExists();

            if (indexExists) {
                indices.prepareDelete(index)
                        .execute()
                        .actionGet();
            }

            knownIndices.remove(index);
        }
    }
556759
private void cleanupLoggedOutToken(HttpServletRequest req, HttpServletResponse res) {
        AuthenticateApi aa = new AuthenticateApi(ssoCookieHelper, authenticationService);
        aa.simpleLogout(req, res);
    }
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()
842112
private void removeServiceListeners(String id) {
        final ServiceListener[] listeners = serviceListeners.remove(id);
        if (listeners != null)
            for (ServiceListener listener : listeners)
                if (listener != null) {
                    lock.readLock().lock();
                    try {
                        if (bundleContext != null)
                            bundleContext.removeServiceListener(listener);
                    } finally {
                        lock.readLock().unlock();
                    }
                }
    }
170063
def remove(self, ids, **kwargs):
        
        url = build_uri_with_ids('api/v3/interface/%s/', ids)

        return super(ApiInterfaceRequest, self).delete(self.prepare_url(url, kwargs))
205662
def remove_vip(self, vip_request_ids):
        
        uri = 'api/v3/vip-request/deploy/%s/' % vip_request_ids

        return super(ApiVipRequest, self).delete(uri)
863989
def purge_old_request_logs(delete_before_days=7):
    
    delete_before_date = timezone.now() - timedelta(days=delete_before_days)
    logs_deleted = RequestLog.objects.filter(
        created_on__lte=delete_before_date).delete()
    return logs_deleted
1178379
def clear(self):
        """"""

        r = self._h._http_resource(
            method='DELETE',
            resource=('user', 'keys'),
        )

        return r.ok
84405
def logging_remove_filter(filter_id, **kwargs):
    
    ctx = Context(**kwargs)
    ctx.execute_action('logging:remove_filter', **{
        'logging_service': ctx.repo.create_secure_service('logging'),
        'filter_id': filter_id,
    })
1287692
def remove_usage_rights_groups(self, group_id, file_ids, folder_ids=None):
        
        path = {}
        data = {}
        params = {}

        # REQUIRED - PATH - group_id
        """ID"""
        path["group_id"] = group_id

        # REQUIRED - file_ids
        """List of ids of files to remove associated usage rights from."""
        params["file_ids"] = file_ids

        # OPTIONAL - folder_ids
        """List of ids of folders. Usage rights will be removed from all files in these folders."""
        if folder_ids is not None:
            params["folder_ids"] = folder_ids

        self.logger.debug("DELETE /api/v1/groups/{group_id}/usage_rights with query params: {params} and form data: {data}".format(params=params, data=data, **path))
        return self.generic_request("DELETE", "/api/v1/groups/{group_id}/usage_rights".format(**path), data=data, params=params, no_data=True)
828182
protected void removeMsgFromLogHandler(String msgId, String handlerId) {
        Set<String> logHandlerIdSet = getOrCreateLogHandlerIdSet(msgId);
        logHandlerIdSet.remove(handlerId);
    }
722898
public static void removeAllThreadIdentityServices() {
        threadIdentityServices.clear();
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "All the ThreadIdentityService implementations were removed.");
        }
    }
968582
def clean(self):
        
        to_del = []
        for serv in self:
            if not serv.host:
                to_del.append(serv.uuid)
        for service_uuid in to_del:
            del self.items[service_uuid]