Retrieves the integrations which the group has
486138
def groups_get_integrations(self, room_id, **kwargs):
        """"""
        return self.__call_api_get('groups.getIntegrations', roomId=room_id, kwargs=kwargs)
140221
private void calculateIndexGroupByInfo(IndexScanPlanNode root,
            IndexGroupByInfo gbInfo) {
        String fromTableAlias = root.getTargetTableAlias();
        assert(fromTableAlias != null);

        Index index = root.getCatalogIndex();
        if ( ! IndexType.isScannable(index.getType())) {
            return;
        }

        ArrayList<AbstractExpression> bindings = new ArrayList<>();
        gbInfo.m_coveredGroupByColumns = calculateGroupbyColumnsCovered(
                index, fromTableAlias, bindings);
        gbInfo.m_canBeFullySerialized =
                (gbInfo.m_coveredGroupByColumns.size() ==
                m_parsedSelect.groupByColumns().size());
    }
891250
def list(ctx, remote):
    """"""
    logger.debug("running command %s (%s)", ctx.command.name, ctx.params,
                 extra={"command": ctx.command.name, "params": ctx.params})

    click.secho("[*] Installed integrations:")
    home = ctx.obj["HOME"]
    integrations_path = os.path.join(home, INTEGRATIONS)
    plugin_type = "integration"

    def get_integration_details(integration_name):
        logger.debug("loading {}".format(integration_name))
        integration = register_integration(os.path.join(integrations_path, integration_name))
        supported_event_types = integration.supported_event_types
        if not supported_event_types:
            supported_event_types = "All"

        return "{:s} ({:s}) [Supported event types: {}]".format(integration.name, integration.description,
                                                                supported_event_types)

    installed_integrations = list_local_plugins(plugin_type, integrations_path, get_integration_details)

    if remote:
        list_remote_plugins(installed_integrations, plugin_type)
    else:
        click.secho("\n[*] Try running `honeycomb integrations list -r` "
                    "to see integrations available from our repository")
1071180
def logical_interconnect_groups(self):
        
        if not self.__logical_interconnect_groups:
            self.__logical_interconnect_groups = LogicalInterconnectGroups(
                self.__connection)
        return self.__logical_interconnect_groups
534993
def getent(refresh=False):
    '''
    
    '''
    if 'group.getent' in __context__ and not refresh:
        return __context__['group.getent']

    ret = []
    for grinfo in grp.getgrall():
        ret.append(info(grinfo.gr_name))

    __context__['group.getent'] = ret
    return ret
1097775
def get_groups(self, roles):
        """"""
        ret = {}
        for role in roles:
            if role not in self.flatten:
                raise MissingRole(role)
            for b in self.flatten[role]['backends_groups']:
                if b not in ret:
                    ret[b] = []
                ret[b] = ret[b] + self.flatten[role]['backends_groups'][b]
        return ret
1025022
public int getNumberOfAvailableSlotsForGroup(AbstractID groupId) {
		synchronized (lock) {
			Map<ResourceID, List<SharedSlot>> available = availableSlotsPerJid.get(groupId);

			if (available != null) {
				Set<SharedSlot> set = new HashSet<SharedSlot>();

				for (List<SharedSlot> list : available.values()) {
					for (SharedSlot slot : list) {
						set.add(slot);
					}
				}

				return set.size();
			}
			else {
				// if no entry exists for a JobVertexID so far, then the vertex with that ID can
				// add a subtask into each shared slot of this group. Consequently, all
				// of them are available for that JobVertexID.
				return allSlots.size();
			}
		}
	}
1258854
def sas_logical_interconnect_groups(self):
        
        if not self.__sas_logical_interconnect_groups:
            self.__sas_logical_interconnect_groups = SasLogicalInterconnectGroups(self.__connection)
        return self.__sas_logical_interconnect_groups
1018737
def scope_groups(self):
        
        import ns1.rest.ipam
        return ns1.rest.ipam.Scopegroups(self.config)
174797
def memberships(self, group, include=None):
        
        return self._get(self._build_url(self.endpoint.memberships(id=group, include=include)))
1082715
def devices_in_group(self):
        """"""
        try:
            devices = self.get_parameter('devices')
        except AttributeError:
            return []

        ctor = DeviceFactory
        return [ctor(int(x), lib=self.lib) for x in devices.split(',') if x]
141318
def get_bonds(input_group):
    """"""
    out_list = []
    for i in range(len(input_group.bond_order_list)):
        out_list.append((input_group.bond_atom_list[i * 2], input_group.bond_atom_list[i * 2 + 1],))
    return out_list
186322
def indices(self):
        """"""
        self._prep_pandas_groupby()

        def extract_group_indices(frame):
            return (frame[0], frame[1].index)

        return self._mergedRDD.map(extract_group_indices).collectAsMap()
679667
def getGroups(self, proteinId):
        """"""
        return [self.groups[gId] for gId in self._proteinToGroupIds[proteinId]]
1151468
def groups(self):
        
        if not self._groups:
            self._groups = ComponentGroups(self.api_client)
        return self._groups
572731
def step_indices(group_idx):
    """"""
    ilen = step_count(group_idx) + 1
    indices = np.empty(ilen, np.int64)
    indices[0] = 0
    indices[-1] = group_idx.size
    cmp_pos = 0
    ri = 1
    for i in range(len(group_idx)):
        if group_idx[cmp_pos] != group_idx[i]:
            cmp_pos = i
            indices[ri] = i
            ri += 1
    return indices
702075
def Subgroups(self):
		

		return(Groups(alias=self.alias,groups_lst=self.data['groups'],session=self.session))