Delete given group.

        Args:
            name (string): Name of group.

        Raises:
            requests.HTTPError on failure.
962929
def delete_group(self, name):
        
        self.service.delete_group(
            name, self.url_prefix, self.auth, self.session,
            self.session_send_opts)
780817
def deletePerson(self, name):
        
        self.organizer.deletePerson(self.organizer.personByName(name))
1069188
def remove_from_group(name, items)
      group = group_items(name)

      items.each do |item|
        utf8_item = item.encode("UTF-8")
        deallocate(utf8_item)
        group.delete(utf8_item)
      end

      replace_group(name, group)

      return items
    end
876301
def remove_from_cluster(self, name, *args):
        
        cluster = self.get_cluster(name=name)
        attrs_ = cluster['cluster']
        for a in args:
            del attrs_[a]
245796
def GroupsUsersDelete(self, group_id, user_id):
        
        if self.__SenseApiCall__('/groups/{group_id}/users/{user_id}.json'.format(group_id = group_id, user_id = user_id), 'DELETE'):
            return True
        else:
            self.__error__ = "api call unsuccessful"
            return False
282036
def delete_by_resource_group_name(resource_group_name, budget_name, custom_headers:nil)
      response = delete_by_resource_group_name_async(resource_group_name, budget_name, custom_headers:custom_headers).value!
      nil
    end
942900
def remove_group(id):
    
    acl_url = urljoin(_acl_url(), 'groups/{}'.format(id))
    try:
        r = http.delete(acl_url)
        print(r.status_code)
    except DCOSHTTPException as e:
        if e.response.status_code != 400:
            raise
1082852
public boolean deleteGroup(String name)
	{
		if (ADMINISTRATOR_GROUP_ID.equals(name))
		{
			throw new SystemException(String.format("Cannot delete '%s' group.", ADMINISTRATOR_GROUP_ID));
		}

		if (USER_GROUP_ID.equals(name))
		{
			throw new SystemException(String.format("Cannot delete '%s' group.", USER_GROUP_ID));
		}

		if (!isGroupExist(name))
		{
			throw new SystemException(String.format("Group '%s' does not exist.", name));
		}

		if (getGroupUserCount(name) > 0)
		{
			throw new SystemException("Cannot delete a group containing users.");
		}

		return allGroups.remove(name);
	}
322150
def delete(name):
    '''
    '''
    with Session() as session:
        try:
            session.VFolder(name).delete()
            print_done('Deleted.')
        except Exception as e:
            print_error(e)
            sys.exit(1)
983022
def delete_group(group_id, purge_data,**kwargs):
    
    user_id = kwargs.get('user_id')
    try:
        group_i = db.DBSession.query(ResourceGroup).filter(ResourceGroup.id == group_id).one()
    except NoResultFound:
        raise ResourceNotFoundError("Group %s not found"%(group_id))

    group_items = db.DBSession.query(ResourceGroupItem).filter(
                                                    ResourceGroupItem.group_id==group_id).all()
    for gi in group_items:
        db.DBSession.delete(gi)

    if purge_data == 'Y':
        _purge_datasets_unique_to_resource('GROUP', group_id)

    log.info("Deleting group %s, id=%s", group_i.name, group_id)

    group_i.network.check_write_permission(user_id)
    db.DBSession.delete(group_i)
    db.DBSession.flush()
1337795
def deletegroup(self, group_id):
        
        request = requests.delete(
            '{0}/{1}'.format(self.groups_url, group_id),
            headers=self.headers, verify=self.verify_ssl, auth=self.auth, timeout=self.timeout)

        return request.status_code == 200
807310
def delete(self, group_id, session):
        ''''''
        request = TOPRequest('taobao.crm.group.delete')
        request['group_id'] = group_id
        self.create(self.execute(request, session), fields=['is_success',])
        return self.is_success
4568
public boolean deleteGroup(String groupName) {
		if (groupsFile != null) {
			lock.writeLock().lock();
			try {
				reloadGroupsFromFile();
				groups.remove(groupName);
				return writeGroupFile();
			} finally {
				lock.writeLock().unlock();
			}
		} // end if resourcePath not null
		return false;
	}
670358
def delete(self, name):
        
        if name not in self._parent:
            raise KeyError('model "{}" not present'.format(name))
        del self._parent[name]
        if self._current_model_group == name:
            self._current_model_group = None
1099769
def _delete(self, *args, **kwargs):
        
        response = requests.delete(*args, **kwargs)
        response.raise_for_status()
303719
def get_group(self, name, default=NoGroupError):
        '''
        
        '''

        if name in self.groups:
            return self.groups[name]

        if default is NoGroupError:
            raise NoGroupError('No such group: {0}'.format(name))

        return default
218023
def remove_user_from_group(self, username, groupname):
        
        url = self._options['server'] + '/rest/api/latest/group/user'
        x = {'groupname': groupname,
             'username': username}

        self._session.delete(url, params=x)

        return True