Return the list of supported applications.
338580
def get_applications(self):
        """"""
        applications = []

        # Isolate all of the bnodes referring to target applications
        for target_app in self.get_objects(None,
                                           self.uri('targetApplication')):
            applications.append({
                'guid': self.get_object(target_app, self.uri('id')),
                'min_version': self.get_object(target_app,
                                               self.uri('minVersion')),
                'max_version': self.get_object(target_app,
                                               self.uri('maxVersion'))})
        return applications
396519
def keys(self):
        """"""
        keys = []
        for app_name, __ in self.items():
            keys.append(app_name)
        return keys
1259668
def op_list_apps(self):
        
        self.logger.info('Listing known applications ...')
        apps = self.get_apps()
        for app in apps:
            self.logger.info('Found `%s`' % app)
        else:
            self.logger.info('\nDONE. No applications found in `%s` directory.\n' % APPS_DIRNAME)
        return apps
1369543
def get_installed_apps():
    
    if django.VERSION >= (1, 7):
        from django.apps import apps
        return [a.models_module for a in apps.get_app_configs()
                if a.models_module is not None]
    else:
        from django.db import models
        return models.get_apps()
1195871
public java.util.List<ApplicationDescription> getApplications() {
        if (applications == null) {
            applications = new com.amazonaws.internal.SdkInternalList<ApplicationDescription>();
        }
        return applications;
    }
324476
def list_apps(self):
        

        url = '{0}/v3/apps'.format(self.host)
        return http._get_with_qiniu_mac(url, None, self.auth)
1184612
def getExportsList(self, enable=True):
        
        if enable:
            return [e for e in self._exports]
        else:
            return [e for e in self._exports_all]
636786
def getExtensions(self):
        """"""
        extensions = []
        if isinstance(self.supportedExtensions, list):
            for ext in self.supportedExtensions:
                extensionURL = self._url + "/exts/%s" % ext
                if ext == "SchematicsServer":
                    extensions.append(SchematicsService(url=extensionURL,
                                                        securityHandler=self._securityHandler,
                                                        proxy_url=self._proxy_url,
                                                        proxy_port=self._proxy_port))
            return extensions
        else:
            extensionURL = self._url + "/exts/%s" % self.supportedExtensions
            if self.supportedExtensions == "SchematicsServer":
                extensions.append(SchematicsService(url=extensionURL,
                                                    securityHandler=self._securityHandler,
                                                    proxy_url=self._proxy_url,
                                                    proxy_port=self._proxy_port))
            return extensions
534626
def get_all_handleable(self):
        """"""
        nodes = self.get_device_tree()
        return [node.device
                for node in sorted(nodes.values(), key=DevNode._sort_key)
                if not node.ignored and node.device]
1060586
def supported_providers(self):
        
        req = self.request(self.uri + '/providers', api_version=2)
        providers = req.get().json()
        supported_providers = providers['supported_providers']
        return supported_providers
557745
def get_installed_targets():
        """"""
        try:
            cache = cmsis_pack_manager.Cache(True, True)
            results = []
            for pack in ManagedPacks.get_installed_packs(cache=cache):
                pack_path = os.path.join(cache.data_path, pack.get_pack_name())
                pack = CmsisPack(pack_path)
                results += list(pack.devices)
            return sorted(results, key=lambda dev:dev.part_number)
        except FileNotFoundError:
            # cmsis-pack-manager can raise this exception if the cache is empty.
            pass
637482
def get_application_modules(self):
        
        modules = []
        appgroups = get_application_groups()
        for title, kwargs in appgroups:
            AppListClass = get_class(kwargs.pop('module'))  # e.g. CmsAppIconlist, AppIconlist, Applist
            modules.append(AppListClass(title, **kwargs))
        return modules
356945
def list_extensions(self):
        """"""
        r = request.ListExtensions(display = self.display)
        return r.names
341655
def get_paths(cls, packages):
        """"""
        allowable_packages = dict((app_config.name, app_config) for app_config in apps.get_app_configs())
        app_configs = [allowable_packages[p] for p in packages if p in allowable_packages]
        # paths of requested packages
        return [os.path.join(app.path, 'locale') for app in app_configs]
407799
def get_apps(self):
        
        apps = []
        for resource in self._get_apps()['resources']:
            apps.append(resource['entity']['name'])

        return apps
350648
def list_installed():
    '''
    
    '''
    pkg_re = re.compile(r'^{0}-[\d.-]+-{1}$'.format(
        _package_prefix(), _kernel_type()))
    pkgs = __salt__['pkg.list_pkgs'](versions_as_list=True)
    if pkgs is None:
        pkgs = []

    result = list(filter(pkg_re.match, pkgs))
    if result is None:
        return []

    prefix_len = len(_package_prefix()) + 1

    if six.PY2:
        return sorted([pkg[prefix_len:] for pkg in result], cmp=_cmp_version)
    else:
        return sorted([pkg[prefix_len:] for pkg in result], key=functools.cmp_to_key(_cmp_version))
957764
def which(program):
    """"""
    if (os.path.isabs(program) and os.path.isfile(program)
            and os.access(program, os.X_OK)):
        return [program]

    candidates = []
    locations = os.environ.get("PATH").split(os.pathsep)
    for location in locations:
        candidate = os.path.join(location, program)
        if os.path.isfile(candidate) and os.access(candidate, os.X_OK):
            candidates.append(candidate)
    return candidates