Returns set of profile names referenced in this Extension

        :return: set of profile name strings
199027
def get_profiles(self):
        
        return set(x.profile for x in self.requires if x.profile)
439156
def get_distribution_names(self):
        
        result = set()
        for locator in self.locators:
            try:
                result |= locator.get_distribution_names()
            except NotImplementedError:
                pass
        return result
461429
def get_hostnames(self):
        
        hosts = set()
        for entry in self._config:
            hosts.update(entry["host"])
        return hosts
504349
def profile_(profile, names, vm_overrides=None, opts=None, **kwargs):
    '''
    
    '''
    client = _get_client()
    if isinstance(opts, dict):
        client.opts.update(opts)
    info = client.profile(profile, names, vm_overrides=vm_overrides, **kwargs)
    return info
572613
def iterargs(self):
    
    iterargs = OrderedDict()
    for name in self._iterargs:
      plural = self._profile.iterargs[name]
      iterargs[name] = tuple(self._values[plural])
    return iterargs
380471
def get_app_names(self):
        
        app_names = set()
        for name in self.apps:
            app_names.add(name)

        return app_names
1328183
def show_cimreferences(server_name, server, org_vm):
    
    try:
        ref_insts = server.conn.EnumerateInstances("CIM_ReferencedProfile",
                                                   namespace=server.interop_ns)

        prof_insts = server.conn.EnumerateInstances("CIM_RegisteredProfile",
                                                    namespace=server.interop_ns)
    except pywbem.Error as er:
        print('CIM_ReferencedProfile failed for conn=%s\nexception=%s'
              % (server, er))
        raise

    # create dictionary of registered profiles with path as key
    profile_dict = NocaseDict()
    for inst in prof_insts:
        profile_dict[str(path_wo_ns(inst))] = inst

    # The output table should look like the following:
    # DEP prof name,  CIM_Ref Subclass, ANT name
    rows = []
    # TODO clean up the try blocks, etc. after we run the complete
    # set of servers.
    for inst in ref_insts:
        try:
            dep_path = inst.get('Dependent')
            ant_path = inst.get('Antecedent')
        except Exception as ex:  # pylint: disable=broad-except
            print('Exception get properties %s in %s' % (ex, inst))
            row = ["Unknown", inst.classname, "Unknown"]
            rows.append(row)
            continue

        try:
            dep = profile_dict[str(path_wo_ns(dep_path))]
        except Exception as ex:  # pylint: disable=broad-except
            print('Exception %s get from profile_dict:  '
                  'Dependent reference in ReferencedProfiles "%s" does '
                  'not match any registered profile instance.\nReference '
                  'instance:\n%s' %
                  (ex, str(path_wo_ns(dep_path)), inst.tomof()))
            row = ["Unknown", inst.classname, "Unknown"]
            rows.append(row)
            continue
        try:
            ant = profile_dict[str(path_wo_ns(ant_path))]
        except Exception as ex:  # pylint: disable=broad-except
            print('Exception get from profile_dict %s. '
                  'Antecedent reference in ReferencedProfiles "%s" does '
                  'not match any registered profile instance.\n'
                  'Reference instance:\n%s' %
                  (ex, str(path_wo_ns(ant_path)), inst.tomof()))
            row = ["Unknown", inst.classname, "Unknown"]
            rows.append(row)
            continue

        try:
            row = [profile_name(org_vm, dep),
                   inst.classname,
                   profile_name(org_vm, ant)]
        except Exception as ex:  # pylint: disable=broad-except
            print('Exception row create %s ' % ex)
            row = ["Unknown", inst.classname, "Unknown"]
        rows.append(row)

    title = '%s: Simplified table of CIM_References with ref class name ' \
            'and profile names' % server_name
    headers = ['Dependent\nProfile Name', 'CIM_Reference\nClass',
               'Antecedent\nProfile Name']
    print_table(title, headers, rows, sort_columns=1)

    # TODO: The following has become a duplicate of the above.
    # Probably drop this.
    if VERBOSE:
        rows = []
        for inst in ref_insts:
            dep_path = inst.get('Dependent')
            ant_path = inst.get('Antecedent')

            dep = profile_dict[str(dep_path)]
            ant = profile_dict[str(ant_path)]
            row = [str(path_wo_ns(dep)),
                   inst.classname,
                   str(path_wo_ns(ant))]
            rows.append(row)

        title = '%s: Table of reference insts' % server_name
        headers = ['Dependent Profile', 'Ref Class', 'Antecedent Profile']
        print_table(title, headers, rows, sort_columns=1)
881181
public String[] getActiveProfiles(){
		String hostname = getHostname();
		List<StringKeyValueBean> config = loadConfiguration();
		for (StringKeyValueBean entry: config){
			String pattern = entry.getKey();
			if ("*".equals(pattern) || !(pattern.contains("\\.") || pattern.contains(".+") || pattern.contains(".*")
					|| StringUtils.containsAny(pattern, '[', '^', '$', '(', '|'))){	// it is not regular expression but with widecards
				String widecard = pattern;
				pattern = widecard.replace(".", "\\.")
						.replace("?", ".")
						.replace("*", ".*");
				if (!pattern.contains("/")){
					pattern += "/?.*";
				}
				logger.debug("Widecard '" + widecard + "' converted to regular expression: '" + pattern + "'.");
			}else{
				if (!pattern.contains("/")){
					pattern += "/?.*";
				}
				logger.debug("Regular expression: '" + pattern + "'.");
			}
			if (Pattern.matches(pattern, hostname)){
				String profiles = (String) entry.getValue();
				logger.debug("Hostname '" + hostname + "' matched by '" + pattern + "'");
				return profiles.split("[ ,\t]+");
			}
		}
		
		// matching not found
		logger.warn("No matching profiles can be found for '" + hostname + "', a profile derived from hostname will be activated.");
		String firstPart = StringUtils.substringBefore(hostname, ".");
		String profile = firstPart.replaceAll("[0-9-]+$", "");
		return new String[]{profile};
	}
421675
def get_all_names() -> Tuple[str]:
    
    names = list(basic_names)
    names.extend(name_data)
    return tuple(sorted(set(names)))
550336
def get_field_names(self):
        
        field_names = super(StationDataIO, self).get_field_names()
        if set(field_names) == set(['meta', 'data']):
            meta_fields = list(self.data[0]['meta'].keys())
            if set(meta_fields) < set(self.getvalue('meta')):
                meta_fields = self.getvalue('meta')
            field_names = list(meta_fields) + ['data']
        return field_names
635458
@Override
    public Set<String> getPossibleUserAttributeNames() {
        final Set<String> names = new HashSet<String>();
        names.addAll(this.possibleUserAttributes);
        names.addAll(localAccountDao.getCurrentAttributeNames());
        names.add(displayNameAttribute);
        return names;
    }
733435
def included_profiles(self):
        """"""
        profiles = []
        for directory in self.tcex_json.get('profile_include_dirs') or []:
            profiles.extend(self._load_config_include(directory))
        return profiles
681488
def get_profile_names_and_default() -> (
        typing.Tuple[typing.Sequence[str], typing.Optional[Profile]]):
    
    with ProfileStore.open() as config:
        return sorted(config), config.default
1043741
def _item_list(profile=None, **connection_args):
    '''
    
    '''
    kstone = auth(profile, **connection_args)
    ret = []
    for item in kstone.items.list():
        ret.append(item.__dict__)
        # ret[item.name] = {
        #         'id': item.id,
        #         'name': item.name,
        #         }
    return ret
1094042
def _get_profile(self, profile_id):
        ''''''
        profile_metadata = self._registry.get(profile_id)
        if not profile_metadata:
            return

        path = self._get_absolute_path(profile_metadata.get('schema_path'))
        if path and os.path.isfile(path):
            return self._load_json_file_or_url(path)

        url = profile_metadata.get('schema')
        if url:
            return self._load_json_file_or_url(url)
218069
def get_associated_profiles(self):
        
        uri = "{}/associatedProfiles".format(self.data['uri'])
        return self._helper.do_get(uri)
443626
def names(self, with_namespace=False):
        '''
        '''
        N = self.count()
        names = self.name.split(settings.splittingnames)[:N]
        n = 0
        while len(names) < N:
            n += 1
            names.append('unnamed%s' % n)
        if with_namespace and self.namespace:
            n = self.namespace
            s = settings.field_separator
            return [n + s + f for f in names]
        else:
            return names