Returns information regarding the set
434454
def subset(self, subset_id):
        """"""
        if subset_id in self.subsetcache:
            return self.subsetcache[subset_id]
        set_uri = self.get_set_uri(subset_id)
        for row in self.graph.query("SELECT ?seturi ?setid ?setlabel ?setopen WHERE { ?seturi rdf:type skos:Collection . OPTIONAL { ?seturi skos:notation ?setid } OPTIONAL { ?seturi skos:prefLabel ?setlabel } OPTIONAL { ?seturi fsd:open ?setopen } FILTER (?seturi = <" + str(set_uri)+">) }"):
            self.subsetcache[str(row.setid)] = {'uri': str(row.seturi), 'id': str(row.setid), 'label': str(row.setlabel) if row.setlabel else "", 'open': bool(row.setopen) }
            return self.subsetcache[str(row.setid)]
        raise DeepValidationError("Unable to find subset (set_uri=" + str(set_uri)+")")
622563
def bool_set(operation,*sets):
    ''''''
    if len(sets)<=1:
        return sets
    if operation=='and':
        return and_sets(*sets)
    if operation=='or':
        return or_sets(*sets)
    if operation=='not':
        return not_sets(*sets)
38826
def get_property(self):
        """"""

        scope = self

        def fget(self):
            """Call the HasProperties _get method"""
            return self._get(scope.name)

        def fset(self, value):
            """Validate value and call the HasProperties _set method"""
            if value is not undefined:
                value = scope.validate(self, value)
            self._set(scope.name, value)

        def fdel(self):
            """Set value to utils.undefined on delete"""
            self._set(scope.name, undefined)

        return property(fget=fget, fset=fset, fdel=fdel, doc=scope.sphinx())
1247370
def members(self, as_set=False):
        """"""
        if as_set:
            return frozenset(map(self._members.__getitem__, self._indexes()))
        return tuple(map(self._members.__getitem__, self._indexes()))
920871
def get_dataset(self, key, info):
        """"""
        logger.debug("Reading %s.", key)
        return self.file_content[key.name]
630639
def elements(self):
        """"""
        return (self.gs1_prefix, self.registration_group, self.registrant,
                self.publication, self.check_digit)
41573
def ids(self):
        """"""
        as_list = [seq.description.split()[0] for seq in self]
        as_set = frozenset(as_list)
        assert len(as_set) == len(as_list)
        return as_set
30992
def info(self):
        
        b = self.bin()
        for i in range(len(b), 0, -1):
            if b[:i] in self._range[self.v]:
                return self._range[self.v][b[:i]]
        return 'UNKNOWN'
994028
def _infodict(cls, name):
        """"""
        info = cls._dataset_info.get(name, None)
        if info is None:
            raise ValueError('No such dataset {0} exists, '
                             'use list_datasets() to get a list '
                             'of available datasets.'.format(name))
        return info
749213
def _get_zset(self, name, operation, create=False):
        
        return self._get_by_type(name, operation, create, b'zset', SortedSet(), return_default=False)
117106
def elements(self):
        """"""
        return (self.country_code, self.check_digits, self.bank_identifier,
                self.bank_account_number)
814989
def members(self):
        
        if self.serialized:
            return set(map(
                self._loads, self._client.smembers(self.key_prefix)))
        else:
            return set(map(
                self._decode, self._client.smembers(self.key_prefix)))
311363
def elements(self):
        """"""
        offset = self.EXTRA_DIGITS
        if offset:
            return (self._id[:offset], self.company_prefix, self._reference,
                    self.check_digit)
        else:
            return (self.company_prefix, self._reference, self.check_digit)
380433
def mainset(self):
        """"""
        if self.mainsetcache:
            return self.mainsetcache
        set_uri = self.get_set_uri()
        for row in self.graph.query("SELECT ?seturi ?setid ?setlabel ?setopen ?setempty WHERE { ?seturi rdf:type skos:Collection . OPTIONAL { ?seturi skos:notation ?setid } OPTIONAL { ?seturi skos:prefLabel ?setlabel } OPTIONAL { ?seturi fsd:open ?setopen } OPTIONAL { ?seturi fsd:empty ?setempty } FILTER NOT EXISTS { ?y skos:member ?seturi . ?y rdf:type skos:Collection } }"):
            self.mainsetcache = {'uri': str(row.seturi), 'id': str(row.setid), 'label': str(row.setlabel) if row.setlabel else "", 'open': bool(row.setopen), 'empty': bool(row.setempty) }
            return self.mainsetcache
        raise DeepValidationError("Unable to find main set (set_uri=" + str(set_uri)+"), this should not happen")
1108173
def index_sets(self, as_set=False):
        """"""
        indexes = frozenset if as_set else tuple
        return [indexes(b.iter_set()) for b in self]
220514
def check(self):
        '''
        '''

        for info in self.get_info():
            if info.free < info.limit:
                return info
599625
function(set) {
            if (!set || !set.length) return;
            var i = 1,
                l = set.length,
                current,
                master = set[0],
                tmp;
            master = [
                master._x,
                master._y,
                master._x + master._w,
                master._y + master._h
            ];
            while (i < l) {
                current = set[i];
                tmp = [
                    current._x,
                    current._y,
                    current._x + current._w,
                    current._y + current._h
                ];
                if (tmp[0] < master[0]) master[0] = tmp[0];
                if (tmp[1] < master[1]) master[1] = tmp[1];
                if (tmp[2] > master[2]) master[2] = tmp[2];
                if (tmp[3] > master[3]) master[3] = tmp[3];
                i++;
            }
            tmp = master;
            master = {
                _x: tmp[0],
                _y: tmp[1],
                _w: tmp[2] - tmp[0],
                _h: tmp[3] - tmp[1]
            };

            return master;
        }