Returns the @GROUPID.

        If derived_from is set, returns that group_id.
443
def group_id(self):
        
        if self.derived_from is not None:
            return self.derived_from.group_id()
        if self.file_uuid is None:
            return None
        return utils.GROUP_ID_PREFIX + self.file_uuid
1108803
def get_group(id):
    
    acl_url = urljoin(_acl_url(), 'groups/{}'.format(id))
    try:
        r = http.get(acl_url)
        return r.json()
    except DCOSHTTPException as e:
        if e.response.status_code != 400:
            raise
909904
def runGetReadGroupSet(self, id_):
        
        compoundId = datamodel.ReadGroupSetCompoundId.parse(id_)
        dataset = self.getDataRepository().getDataset(compoundId.dataset_id)
        readGroupSet = dataset.getReadGroupSet(id_)
        return self.runGetRequest(readGroupSet)
100542
def get_group(self, group_id):
        
        response = self._do_request(
            'GET', '/v2/groups/{group_id}'.format(group_id=group_id))
        return self._parse_response(response, MarathonGroup)
1346982
def getReadGroupSet(self, id_):
        
        compoundId = datamodel.ReadGroupSetCompoundId.parse(id_)
        dataset = self.getDataset(compoundId.dataset_id)
        return dataset.getReadGroupSet(id_)
233149
def next_group_id(self) -> int:
        
        ids: typing.Set[int] = set()
        for group in chain(self._blue_coa.groups, self._red_coa.groups):  # type: ignore

            id_ = group.group_id
            if id_ in ids:
                raise IndexError(group.group_name)
            ids.add(id_)
        return max(ids) + 1
914292
@Override
    public IGroupMember getGroupMember(EntityIdentifier underlyingEntityIdentifier)
            throws GroupsException {
        return getGroupMember(
                underlyingEntityIdentifier.getKey(), underlyingEntityIdentifier.getType());
    }
837084
public static Group get(final long _id)
        throws CacheReloadException
    {
        final Cache<Long, Group> cache = InfinispanCache.get().<Long, Group>getCache(Group.IDCACHE);
        if (!cache.containsKey(_id) && !Group.getGroupFromDB(Group.SQL_ID, _id)) {
            cache.put(_id, Group.NULL, 100, TimeUnit.SECONDS);
        }
        final Group ret = cache.get(_id);
        return ret.equals(Group.NULL) ? null : ret;
    }
390737
def childIds(self) -> BaseReferenceSet:
        
        if self._childIds is None:
            self._childIds = self.getReffs()
        return self._childIds
942481
def gid
      return group.kind_of?(Integer) ? group : Etc.getgrnam(group.to_s).gid if group
      return Etc.getpwuid(uid).gid if using_login?
      nil
    end
234959
public function getGroupId()
    {
        if (!$this->isGroupEvent()) {
            throw new InvalidEventSourceException('This event source is not a group type');
        }
        return isset($this->event['source']['groupId'])
            ? $this->event['source']['groupId']
            : null;
    }
583900
def get_securitygroup(self, group_id, **kwargs):
        
        if 'mask' not in kwargs:
            kwargs['mask'] = (
                'id,'
                'name,'
                'description,'
                '''rules[id, remoteIp, remoteGroupId,
                         direction, ethertype, portRangeMin,
                         portRangeMax, protocol, createDate, modifyDate],'''
                '''networkComponentBindings[
                    networkComponent[
                        id,
                        port,
                        guest[
                            id,
                            hostname,
                            primaryBackendIpAddress,
                            primaryIpAddress
                        ]
                    ]
                ]'''
            )

        return self.security_group.getObject(id=group_id, **kwargs)
747517
public function getGid()
    {
        if (!array_key_exists(self::GID, $this->group)) {
            throw new \Exception('Could not get group\'s group id from group id.');
        }
        return $this->group[self::GID];
    }
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();
			}
		}
	}
1236250
def gid(self):
        
        if not self._gid:
            if self.controller.config.daemon.group:
                self._gid = grp.getgrnam(self.config.daemon.group).gr_gid
            else:
                self._gid = os.getgid()
        return self._gid
1250909
def cn_groups_nested
          @cn_groups_nested = cn_groups
          cn_groups.each do |group|
            ado = Adauth::AdObjects::Group.where('name', group).first
            if ado
              groups = convert_to_objects ado.cn_groups
              groups.each do |g|
                @cn_groups_nested.push g if !(@cn_groups_nested.include?(g))
              end
            end
          end
          return @cn_groups_nested
        end
1229049
private String getPrimaryGroupId(List<String> uniqueGroupIds) {
        return uniqueGroupIds.isEmpty() ? null : uniqueGroupIds.get(0);
    }