Deletes the specified policy from the scaling group.
181539
def delete_policy(self, scaling_group, policy):
        
        return self._manager.delete_policy(scaling_group=scaling_group,
                policy=policy)
1305435
public void delete() {
        URL url = STORAGE_POLICY_ASSIGNMENT_WITH_ID_URL_TEMPLATE.build(this.getAPI().getBaseURL(), this.getID());
        BoxAPIRequest request = new BoxAPIRequest(this.getAPI(), url, HttpMethod.DELETE);

        request.send();
    }
268839
@Override
	public void removeByGroupId(long groupId) {
		for (CPInstance cpInstance : findByGroupId(groupId, QueryUtil.ALL_POS,
				QueryUtil.ALL_POS, null)) {
			remove(cpInstance);
		}
	}
880230
public function clearPolicy()
    {
        foreach (['p', 'g'] as $sec) {
            if (!isset($this->model[$sec])) {
                return;
            }
            foreach ($this->model[$sec] as $key => $ast) {
                $this->model[$sec][$key]->policy = [];
            }
        }
    }
159557
def delete_dscp_marking_rule(self, rule, policy):
        """"""
        return self.delete(self.qos_dscp_marking_rule_path %
                           (policy, rule))
399392
def Delete(self):
		
		r = clc.v2.API.Call('DELETE','antiAffinityPolicies/%s/%s' % (self.alias,self.id),{},session=self.session)
545296
public void deleteGroup(String key, IPerson deleter) {

        if (!canDeleteGroup(deleter, key)) {
            throw new RuntimeAuthorizationException(
                    deleter, IPermission.DELETE_GROUP_ACTIVITY, key);
        }

        log.info("Deleting group with key " + key);

        // find the current version of this group entity
        IEntityGroup group = GroupService.findGroup(key);

        // remove this group from the membership list of any current parent
        // groups
        for (IEntityGroup parent : group.getParentGroups()) {
            parent.removeChild(group);
            parent.updateMembers();
        }

        // delete the group
        group.delete();
    }
862359
protected void deleteCollection() throws PolicyIndexException {

        // get root collection management service
        Collection rootCol;
        try {
            rootCol = DatabaseManager.getCollection(m_databaseURI + ROOT_COLLECTION_PATH ,m_user, m_password);
            CollectionManagementService mgtService = (CollectionManagementService) rootCol.getService("CollectionManagementService", "1.0");

            // delete the collection
            mgtService.removeCollection(m_collectionName);

            log.debug("Policy collection deleted");
        } catch (XMLDBException e) {
            throw new PolicyIndexException("Error deleting collection " + e.getMessage(), e);
        }
    }
652075
def delete(options = {})
      options = options.merge(
        policy_arn: @arn,
        version_id: @version_id
      )
      resp = @client.delete_policy_version(options)
      resp.data
    end
822438
def deleteSettings(self, groupName=None):
        
        groupName = groupName if groupName else self.settingsGroupName
        settings = QtCore.QSettings()
        logger.info("Deleting {} from: {}".format(groupName, settings.fileName()))
        removeSettingsGroup(groupName)
678012
@Override
	public void removeByGroupId(long groupId) {
		for (CPDefinitionSpecificationOptionValue cpDefinitionSpecificationOptionValue : findByGroupId(
				groupId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
			remove(cpDefinitionSpecificationOptionValue);
		}
	}
814653
def delete_policy_version(policy_name, version_id,
                  region=None, key=None, keyid=None, profile=None):
    '''
    
    '''
    conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)

    policy_arn = _get_policy_arn(policy_name, region, key, keyid, profile)
    if not policy_version_exists(policy_arn, version_id, region, key, keyid, profile):
        return True
    try:
        conn.delete_policy_version(policy_arn, version_id)
        log.info('Deleted IAM policy %s version %s.', policy_name, version_id)
    except boto.exception.BotoServerError as e:
        aws = __utils__['boto.get_error'](e)
        log.debug(aws)
        log.error('Failed to delete IAM policy %s version %s: %s',
                  policy_name, version_id, aws.get('message'))
        return False
    return True
998949
def delete(options = {})
      options = options.merge(
        auto_scaling_group_name: @group_name,
        topic_arn: @topic_arn
      )
      resp = @client.delete_notification_configuration(options)
      resp.data
    end
770345
private void removeFromPermissionsCache(IAuthorizationPrincipal[] principals)
            throws AuthorizationException {
        for (int i = 0; i < principals.length; i++) {
            cacheRemove(principals[i]);
        }
    }
503056
def fw_policy_delete(self, data, fw_name=None):
        
        LOG.debug("FW Policy Debug")
        self._fw_policy_delete(fw_name, data)
1215226
@Override
	public void removeByGroupId(long groupId) {
		for (CPDefinitionOptionRel cpDefinitionOptionRel : findByGroupId(
				groupId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
			remove(cpDefinitionOptionRel);
		}
	}
135190
function(sGroup) {
        this.logger.log("Removing from group: " + sGroup);
        if (this.groups[sGroup]) {
            delete this.groups[sGroup];
        }

        this.DDM.removeDDFromGroup(this, sGroup);
    }