Names of all groups (get-only).

        :getter: Returns names of all groups
        :type: list of str
559196
def groups_names(self):
        
        return _ListProxy(self._get_group_name_by_num(i) for i in range(self.groups_count))
802609
def prior_names(self):
        
        return list(self.prior_information.groupby(
                self.prior_information.index).groups.keys())
246098
def get_all_names(self):
        """"""
        result = set()
        for module in self.names:
            result.update(set(self.names[module]))
        return result
58918
def get_groups_data(self, groups):
        '''
        
        '''

        data = {}

        for group in groups:
            data.update(self.get_group_data(group))

        return data
962900
def get_group_dns(self):
        
        if self._group_dns is None:
            group_infos = self._get_group_infos()
            self._group_dns = set(group_info[0] for group_info in group_infos)

        return self._group_dns
617521
def get_groups(self):
        
        def process_result(result):
            return [self.get_group(group) for group in result]

        return Command('get', [ROOT_GROUPS], process_result=process_result)
1212073
def _groupname():
    '''
    
    '''
    if grp:
        try:
            groupname = grp.getgrgid(os.getgid()).gr_name
        except KeyError:
            groupname = ''
    else:
        groupname = ''

    return groupname
1192806
def GetAll(root_group_id,alias=None,session=None):
		
		if not alias:  alias = clc.v2.Account.GetAlias(session=session)

		groups = []
		for r in clc.v2.API.Call('GET','groups/%s/%s' % (alias,root_group_id),{}, session=session)['groups']:
			groups.append(Group(id=r['id'],alias=alias,group_obj=r,session=session))

		return(groups)
1262788
def select_groups(adata, groups='all', key='louvain'):
    
    strings_to_categoricals(adata)
    if isinstance(groups, list) and isinstance(groups[0], int): groups = [str(n) for n in groups]
    categories = adata.obs[key].cat.categories
    groups_masks = np.array([categories[i] == adata.obs[key].values for i, name in enumerate(categories)])
    if groups == 'all':
        groups = categories.values
    else:
        groups_ids = [np.where(categories.values == name)[0][0] for name in groups]
        groups_masks = groups_masks[groups_ids]
        groups = categories[groups_ids].values
    return groups, groups_masks
1322451
def get_groups(self, filterTerm=None, groupName=None, groupDomain=None):
        
        if groupDomain:
            groupDomain = groupDomain.split('.')[0].upper()

        cur = self.conn.cursor()

        if self.is_group_valid(filterTerm):
            cur.execute("SELECT * FROM groups WHERE id=? LIMIT 1", [filterTerm])

        elif groupName and groupDomain:
            cur.execute("SELECT * FROM groups WHERE LOWER(name)=LOWER(?) AND LOWER(domain)=LOWER(?)", [groupName, groupDomain])

        elif filterTerm and filterTerm !="":
            cur.execute("SELECT * FROM groups WHERE LOWER(name) LIKE LOWER(?)", ['%{}%'.format(filterTerm)])

        else:
            cur.execute("SELECT * FROM groups")

        results = cur.fetchall()
        cur.close()
        logging.debug('get_groups(filterTerm={}, groupName={}, groupDomain={}) => {}'.format(filterTerm, groupName, groupDomain, results))
        return results
131544
def get_groups(self):
        
        response = self.client.list_groups(UserPoolId=self.user_pool_id)
        return [self.get_group_obj(group_data)
                for group_data in response.get('Groups')]
715455
def get_groups(self, table_name):
        
        df = self.dm[table_name]
        return list(df['group'].unique())
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
576599
List<Group> getAllGroups(AccessToken accessToken, String... attributes) {
        return getAllResources(accessToken, attributes);
    }
712150
def get_group(name):
    
    group = cache.get('bits.general.group_%s' % name)
    if not group:
        group = Group.objects.get(name=name)
        cache.set('bits.general.group_%s' % name, group, 365 * 24 * 60 * 60)
    return group
421735
def group_list(auth=None, **kwargs):
    '''
    
    '''
    cloud = get_operator_cloud(auth)
    kwargs = _clean_kwargs(**kwargs)
    return cloud.list_groups(**kwargs)
1185391
def get_all_groups(path_prefix='/', region=None, key=None, keyid=None,
                 profile=None):
    '''
    
    '''
    conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
    if not conn:
        return None
    _groups = conn.get_all_groups(path_prefix=path_prefix)
    groups = _groups.list_groups_response.list_groups_result.groups
    marker = getattr(
        _groups.list_groups_response.list_groups_result, 'marker', None
    )
    while marker:
        _groups = conn.get_all_groups(path_prefix=path_prefix, marker=marker)
        groups = groups + _groups.list_groups_response.list_groups_result.groups
        marker = getattr(
            _groups.list_groups_response.list_groups_result, 'marker', None
        )
    return groups