List all `deelgemeenten` in a `gewest`.

        :param gewest: The :class:`Gewest` for which the \
            `deelgemeenten` are wanted. Currently only Flanders is supported.
        :rtype: A :class:`list` of :class:`Deelgemeente`.
10516
def list_deelgemeenten(self, gewest=2):
        '''
        
        '''
        try:
            gewest_id = gewest.id
        except AttributeError:
            gewest_id = gewest

        if gewest_id != 2:
            raise ValueError('Currently only deelgemeenten in Flanders are known.')

        def creator():
            return [Deelgemeente(dg['id'], dg['naam'], dg['gemeente_niscode']) for dg in self.deelgemeenten.values()]

        if self.caches['permanent'].is_configured:
            key = 'ListDeelgemeentenByGewestId#%s' % gewest_id
            deelgemeenten = self.caches['permanent'].get_or_create(key, creator)
        else:
            deelgemeenten = creator()
        for dg in deelgemeenten:
            dg.set_gateway(self)
        return deelgemeenten
920878
def ListDirectoryAbsolute(directory):
  """"""
  return (os.path.join(directory, path)
          for path in tf.io.gfile.listdir(directory))
543257
@Override
	public com.liferay.commerce.wish.list.model.CommerceWishList createCommerceWishList(
		long commerceWishListId) {
		return _commerceWishListLocalService.createCommerceWishList(commerceWishListId);
	}
401666
def stem(self):

        

        def s(tokens):
            return [PorterStemmer().stem(t) for t in tokens]
        self.stems = list(map(s, self.tokens))
805711
def list_(ctx, search_string, reverse, backend, used, inactive):
    
    if not reverse:
        list_aliases(ctx, search_string, backend, used, inactive=inactive)
    else:
        show_mapping(ctx, search_string, backend)
68778
def getOrderVectorsEGMM(self):
        

        orderVectors = []
        for preference in self.preferences:
            orderVectors.append(preference.getOrderVectorEGMM())
        return orderVectors
277761
function class_list() {
  skip_horiz_white();
  classes = [];
  while (look(ident_chain_pattern)) {
    classes.push(ident_chain());
    skip_horiz_white();
  }
  
  return classes;
}
448222
def all_slots_for(self, cls: ClassDefinition) -> List[SlotDefinitionName]:
        
        if not cls.is_a:
            return cls.slots
        else:
            return [sn for sn in self.all_slots_for(self.schema.classes[cls.is_a]) if sn not in cls.slot_usage] \
                   + cls.slots
932297
def dir_list(self, tgt_env):
        '''
        
        '''
        ret = set()
        tree = self.get_tree(tgt_env)
        if not tree:
            return ret
        if self.root(tgt_env):
            try:
                tree = tree / self.root(tgt_env)
            except KeyError:
                return ret
            relpath = lambda path: os.path.relpath(path, self.root(tgt_env))
        else:
            relpath = lambda path: path
        add_mountpoint = lambda path: salt.utils.path.join(
            self.mountpoint(tgt_env), path, use_posixpath=True)
        for blob in tree.traverse():
            if isinstance(blob, git.Tree):
                ret.add(add_mountpoint(relpath(blob.path)))
        if self.mountpoint(tgt_env):
            ret.add(self.mountpoint(tgt_env))
        return ret
869467
def list(self, platformIdentifier, configuration, libOverrides = {}):
		
		modules = self._getThirdPartyLibs(platformIdentifier, configuration)
		return sorted([m['Name'] for m in modules] + [key for key in libOverrides])
782400
def list(self, dataPath, ext=None, start=None, stop=None, recursive=False):
        
        scheme, bucket_name, keylist = self.getfiles(
            dataPath, ext=ext, start=start, stop=stop, recursive=recursive)

        return ["%s:///%s/%s" % (scheme, bucket_name, key) for key in keylist]
884912
def visit_listcomp(self, node):
        """"""
        return "[%s %s]" % (
            node.elt.accept(self),
            " ".join(n.accept(self) for n in node.generators),
        )
1009583
def _gcs_list(args, _):
  
  target = args['objects']
  project = args['project']
  if target is None:
    return _gcs_list_buckets(project, '*')  # List all buckets.

  bucket_name, key = google.datalab.storage._bucket.parse_name(target)
  if bucket_name is None:
    raise Exception('Cannot list %s; not a valid bucket name' % target)

  # If a target was specified, list keys inside it
  if target:
    if not re.search('\?|\*|\[', target):
      # If no wild characters are present in the key string, append a '/*' suffix to show all keys
      key = key.strip('/') + '/*' if key else '*'

    if project:
      # Only list if the bucket is in the project
      for bucket in google.datalab.storage.Buckets(_make_context(project)):
        if bucket.name == bucket_name:
          break
      else:
        raise Exception('%s does not exist in project %s' % (target, project))
    else:
      bucket = google.datalab.storage.Bucket(bucket_name)

    if bucket.exists():
      return _gcs_list_keys(bucket, key)
    else:
      raise Exception('Bucket %s does not exist' % target)

  else:
    # Treat the bucket name as a pattern and show matches. We don't use bucket_name as that
    # can strip off wildchars and so we need to strip off gs:// here.
    return _gcs_list_buckets(project, target.strip('/')[5:])
150406
def allinstances(cls):
        
        JB_Gui._allinstances = weakref.WeakSet([i for i in cls._allinstances if shiboken.isValid(i)])
        return list(cls._allinstances)
1272373
def catalog_components(self, catalog_name, split_ver):
        
        return sorted(self._split_comp_info_dicts["%s_%s" % (catalog_name, split_ver)].keys())
344627
def list_cloudfront(region, filter_by_kwargs):
    """"""
    conn = boto.connect_cloudfront()
    instances = conn.get_all_distributions()
    return lookup(instances, filter_by=filter_by_kwargs)
1104310
@Override
	public List<CPDefinitionGroupedEntry> findAll() {
		return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
	}