Returns a list of all profiles
770431
def deleteAllProfiles(self):
        
        settings = QtCore.QSettings()
        for profGroupName in QtCore.QSettings().childGroups():
            settings.remove(profGroupName)
27804
def get_profiles(self, profile_base="/data/b2g/mozilla", timeout=None):
        

        rv = {}

        if timeout is None:
            timeout = self._timeout

        profile_path = posixpath.join(profile_base, "profiles.ini")
        try:
            proc = self.shell("cat %s" % profile_path, timeout=timeout)
            config = ConfigParser.ConfigParser()
            config.readfp(proc.stdout_file)
            for section in config.sections():
                items = dict(config.items(section))
                if "name" in items and "path" in items:
                    path = items["path"]
                    if "isrelative" in items and int(items["isrelative"]):
                        path = posixpath.normpath("%s/%s" % (profile_base, path))
                    rv[items["name"]] = path
        finally:
            proc.stdout_file.close()
            proc.stderr_file.close()

        return rv
221658
public List<CarbonProfile> getProfileList()
	{
		final List<CarbonProfile> profiles = new ArrayList<CarbonProfile>();

		Element profileList = element.getChild("ProfileList");

		if (profileList != null)
		{
			for (Element profileElement : profileList.getChildren())
			{
				CarbonProfile profile = new CarbonProfile(profileElement);

				profiles.add(profile);
			}
		}

		return profiles;
	}
632614
def show_profiles(self):
        
        for i, (id, profiler, showed) in enumerate(self.profilers):
            if not showed and profiler:
                profiler.show(id)
                # mark it as showed
                self.profilers[i][2] = True
1021380
def getProfile(self, profile=None):
    '''
    
    '''
    if profile is None:
      # todo: what if the configuration `profile.default` does not exist?
      profile = self.config.get('DEFAULT', 'profile.default')
    if profile in self.profiles:
      return self.profiles[profile].init()
    for prof in self.profiles.values():
      if prof.name == profile:
        return prof.init()
    for prof in self.profiles.values():
      if prof.name.lower() == profile.lower():
        return prof.init()
    raise KeyError(profile)
440776
async def get_profile(self, *tags):
        ''''''
        url = '{0.BASE}/profile/{1}'.format(self, ','.join(tags))

        data = await self.request(url)
                
        if isinstance(data, list):
            return [Profile(self, c) for c in data]
        else:
            return Profile(self, data)
558839
public <T, R> List<T> getProfileField(ProfileField<T, R> field) {
		List<R> values = getResourceFactory().getApiResource(
				"/user/profile/" + field.getName()).get(
				new GenericType<List<R>>() {
				});

		List<T> formatted = new ArrayList<T>();
		for (R value : values) {
			formatted.add(field.parse(value));
		}

		return formatted;
	}
30008
public static List<String> explicitlyActivatedProfiles(String... profiles) {
        if (profiles.length == 0) {
            return Collections.<String> emptyList();
        }
        List<String> activated = new ArrayList<String>();
        for (String profileId : profiles) {
            Validate.notNullOrEmpty(profileId, "Invalid name (\"" + profileId + "\") of a profile to be activated");
            if (!(profileId.startsWith("-") || profileId.startsWith("!"))) {
                activated.add(profileId);
            }
        }

        return activated;
    }
553653
def list_(profile="splunk"):
    '''
    
    '''
    client = _get_splunk(profile)
    searches = [x['name'] for x in client.saved_searches]
    return searches
840965
def list_silo_profiles
      r = execute(make_xml('SiloProfileListingRequest'), '1.2')
      arr = []
      if r.success
        r.res.elements.each('SiloProfileListingResponse/SiloProfileSummaries/SiloProfileSummary') do |profile|
          arr << SiloProfileSummary.parse(profile)
        end
      end
      arr
    end
571404
def get_associated_profile_names(profile_path, result_role, org_vm, server,
                                 include_classnames=False):
    
    insts = get_associated_profiles(profile_path, result_role, server)
    names = []
    for inst in insts:
        if include_classnames:
            names.append("(%s)%s" % (inst.classname,
                                     profile_name(org_vm, inst)))
        else:
            names.append(profile_name(org_vm, inst))
    return names
238729
def list_instance_profiles(path_prefix='/', region=None, key=None,
                           keyid=None, profile=None):
    '''
    
    '''
    p = get_all_instance_profiles(path_prefix, region, key, keyid, profile)
    return [i['instance_profile_name'] for i in p]
135891
def get_removes(self, profile=None):
        
        out = []
        for rem in self.removes:
            # Filter Remove by profile
            if ((rem.profile and not profile) or
               (rem.profile and profile and rem.profile != profile)):
                continue
            out.append(rem)
        return out
1176790
Collection<QProfileDto> getChildProfiles() {
    loadDescendants();
    return getProfiles().stream()
      .flatMap(p -> profilesByParentUuid.get(p.getKee()).stream())
      .collect(Collectors.toList());
  }
1300411
def inputtemplates(self):
        """"""
        l = []
        for profile in self.profiles:
            l += profile.input
        return l
424674
def currentProfile(self):
        
        index = self._profileCombo.currentIndex()
        
        if 0 <= index and index < len(self._profiles):
            return self._profiles[index]
        return None
181685
function (){
    var out = {}

    if(this.profiles.length !== 0){
      out.profiles = this.profiles
    }

    if(this.noProfilesFound.length !== 0){
      out.noProfilesFound = this.noProfilesFound;
    }

    if(utils.hasProperties(this.combinedProfile)){
      out.combinedProfile = this.combinedProfile
    }

    return out;
  }