Delete a set of image regions.

 @param project_id The project id.
 @param region_ids Regions to delete. Limited to 64.
 @param custom_headers [Hash{String => String}] A hash of custom headers that
 will be added to the HTTP request.
9526
def delete_image_regions(project_id, region_ids, custom_headers:nil)
      response = delete_image_regions_async(project_id, region_ids, custom_headers:custom_headers).value!
      nil
    end
497334
public function add_regions($regions, $custom = true) {
        foreach ($regions as $region) {
            $this->add_region($region, $custom);
        }
    }
759540
def delete(self, ids):
        
        url = build_uri_with_ids('api/v3/ipv4/%s/', ids)

        return super(ApiIPv4, self).delete(url)
645821
def delete_key_pair(region, pair_name)
      kp = client(region).describe_key_pairs(:key_names => [pair_name]).key_pairs.first
      unless kp.nil?
        @logger.debug("aws-sdk: delete key pair in region: #{region}")
        client(region).delete_key_pair(:key_name => pair_name)
      end
    rescue Aws::EC2::Errors::InvalidKeyPairNotFound
      nil
    end
200802
public void setRegions(java.util.Collection<String> regions) {
        if (regions == null) {
            this.regions = null;
            return;
        }

        this.regions = new java.util.ArrayList<String>(regions);
    }
915674
void deleteProjectDirsIfNecessary(final long newProjectSizeInBytes) {
    final long projectCacheMaxSizeInByte =
        (long) (this.projectCacheDir.getTotalSpace() * this.percentageOfDisk);

    final long start = System.currentTimeMillis();
    final List<ProjectDirectoryMetadata> allProjects = loadAllProjects();
    log.info("Loading {} project dirs metadata completed in {} sec(s)",
        allProjects.size(), (System.currentTimeMillis() - start) / 1000);

    final long currentSpaceInBytes = getProjectDirsTotalSizeInBytes(allProjects);
    if (currentSpaceInBytes + newProjectSizeInBytes >= projectCacheMaxSizeInByte) {
      log.info(
          "Project cache usage[{} MB] >= cache limit[{} MB], start cleaning up project dirs",
          (currentSpaceInBytes + newProjectSizeInBytes) / (1024 * 1024),
          projectCacheMaxSizeInByte / (1024 * 1024));

      final long freeCacheSpaceInBytes = projectCacheMaxSizeInByte - currentSpaceInBytes;

      deleteLeastRecentlyUsedProjects(newProjectSizeInBytes - freeCacheSpaceInBytes, allProjects);
    }
  }
559025
def destroy
      @project = Project.find params[:project_id]
      @api = @project.apis.find(params[:id])
      @api.destroy
  
      respond_to do |format|
        format.html { redirect_to project_apis_path }
        format.json { head :no_content }
      end
    end
1259577
function(buckets) {
    var bucketRegionCache = this.bucketRegionCache;
    if (!buckets) {
      buckets = Object.keys(bucketRegionCache);
    } else if (typeof buckets === 'string') {
      buckets = [buckets];
    }
    for (var i = 0; i < buckets.length; i++) {
      delete bucketRegionCache[buckets[i]];
    }
    return bucketRegionCache;
   }
1372867
public function delete($id, $project_id = null)
    {
        $id = (int) $id;
        if ($id <= 0) {
            throw new Exception('Invalid param id');
        }
        $project_id = (int) $project_id;
        $action = "$this->action/$id";
        if ($project_id) {
            $action = "projects/$project_id/$action";
        }
        return $this->rest->delete($action);
    }
1213097
def project_remove_tags(object_id, input_params={}, always_retry=True, **kwargs):
    
    return DXHTTPRequest('/%s/removeTags' % object_id, input_params, always_retry=always_retry, **kwargs)
981506
public ProjectTopicName deleteTopic(String topicId) throws Exception {
    // [START pubsub_delete_topic]
    try (TopicAdminClient topicAdminClient = TopicAdminClient.create()) {
      ProjectTopicName topicName = ProjectTopicName.of(projectId, topicId);
      topicAdminClient.deleteTopic(topicName);
      return topicName;
    }
    // [END pubsub_delete_topic]
  }
909641
def delete_project(project_id,**kwargs):
    
    user_id = kwargs.get('user_id')
    #check_perm(user_id, 'delete_project')
    project = _get_project(project_id)
    project.check_write_permission(user_id)
    db.DBSession.delete(project)
    db.DBSession.flush()

    return 'OK'
1128789
def delete(self, ids):
        
        url = build_uri_with_ids('api/v3/object-group-perm/%s/', ids)
        return super(ApiObjectGroupPermission, self).delete(url)
386100
def deleteprojectmember(self, project_id, user_id):
        
        request = requests.delete(
            '{0}/{1}/members/{2}'.format(self.projects_url, project_id, user_id),
            headers=self.headers, verify=self.verify_ssl, auth=self.auth, timeout=self.timeout)

        if request.status_code == 200:
            return True
1127770
protected static function deleteCountryByIdAsyncWithHttpInfo($country_id) 
    {
        $returnType = '';  
        $request = self::deleteCountryByIdRequest($country_id); 

        return self::getHttpClient()
            ->sendAsync($request, self::createHttpClientOption())
            ->then(
                function ($response) use ($returnType) {
                    return [null, $response->getStatusCode(), $response->getHeaders()];
                },
                function ($exception) {
                    $response = $exception->getResponse();
                    $statusCode = $response->getStatusCode();
                    throw new ApiException(
                        sprintf(
                            '[%d] Error connecting to the API (%s)',
                            $statusCode,
                            $exception->getRequest()->getUri()
                        ),
                        $statusCode,
                        $response->getHeaders(),
                        $response->getBody()
                    );
                }
            );
    }
1128998
@RequestMapping(value = "projects/{projectId}/{type}/{id}", method = RequestMethod.DELETE)
    public Ack deleteProjectPermission(@PathVariable ID projectId, @PathVariable PermissionTargetType type, @PathVariable int id) {
        return accountService.deleteProjectPermission(projectId, type, id);
    }
252525
def delete_events(self, event_collection, params):
        

        url = "{0}/{1}/projects/{2}/events/{3}".format(self.base_url,
                                                       self.api_version,
                                                       self.project_id,
                                                       event_collection)
        headers = utilities.headers(self.master_key)
        response = self.fulfill(HTTPMethods.DELETE, url, params=params, headers=headers, timeout=self.post_timeout)

        self._error_handling(response)
        return True