Show profile configuration content.
16422
def profile_view(name, **kwargs):
    
    ctx = Context(**kwargs)
    ctx.execute_action('profile:view', **{
        'storage': ctx.repo.create_secure_service('storage'),
        'name': name,
    })
326162
def show(self, baseAppInstance):
        """"""
        self.from_dict_to_fields(self.configDict)
        super(ProjectConfigurationDialog, self).show(baseAppInstance)
248099
def show_distribution_section(config, title, section_name):
    
    payload = requests.get(config.apps_url).json()
    distributions = sorted(payload.keys(), reverse=True)
    latest_distribution = payload[distributions[0]]
    click.echo("{} {}".format("Release".rjust(7), title))
    click.echo("------- ---------------")
    section = latest_distribution[section_name]
    names = sorted(section.keys())
    for name in names:
        click.echo("{} {}".format(section[name].rjust(7), name))
650139
def run_show_config(args):
    """"""
    # TODO Proposal: remove the "hidden" configuration. Only show config. If
    # the system needs to be configured, then display information on how to
    # configure the system.
    config = copy.deepcopy(bigchaindb.config)
    del config['CONFIGURED']
    print(json.dumps(config, indent=4, sort_keys=True))
932577
def show_configure(self):
        
        logging.info("Displaying configuration window")
        if self.configWindow is None:
            self.configWindow = ConfigWindow(self)
            self.configWindow.show()
        else:
            self.configWindow.deiconify()
57059
protected function _profilerRenderEcho()
    {
        $output = PHP_EOL;
        foreach ($this->_bufferInfo as $key => $mark) {
            $output .= "\t" . self::_profilerFormatMark($mark) . PHP_EOL;
        }
        $this->_dumpRenderLite($output, '! profiler !');
    }
671339
def log(self):
        """"""
        log.info('PyPhi v%s', __about__.__version__)
        if self._loaded_files:
            log.info('Loaded configuration from %s', self._loaded_files)
        else:
            log.info('Using default configuration (no configuration file '
                     'provided)')
        log.info('Current PyPhi configuration:\n %s', str(self))
482057
def show_profiles(name, server, org_vm):
    
    rows = []
    for profile_inst in server.profiles:
        pn = profile_name(org_vm, profile_inst)
        deps = get_associated_profile_names(
            profile_inst.path, "dependent", org_vm, server,
            include_classnames=False)
        dep_refs = get_references(profile_inst.path, "antecedent", pn, server)
        ants = get_associated_profile_names(
            profile_inst.path, "antecedent", org_vm, server,
            include_classnames=False)
        ant_refs = get_references(profile_inst.path, "dependent",
                                  profile_name, server)

        # get unique class names
        dep_ref_clns = set([ref.classname for ref in dep_refs])
        ant_ref_clns = set([ref.classname for ref in ant_refs])
        row = (pn,
               fold_list(deps),
               fold_list(list(dep_ref_clns)),
               fold_list(ants),
               fold_list(list(ant_ref_clns)))
        rows.append(row)

        # append this server to the  dict of servers for this profile
        SERVERS_FOR_PROFILE[profile_name].append(name)

    title = '%s: Advertised profiles showing Profiles associations' \
        'Dependencies are Associators, AssocClass=CIM_ReferencedProfile' \
        'This table shows the results for ' % name
    headers = ['Profile',
               'Assoc CIMReferencedProfile\nResultRole\nDependent',
               'Ref classes References\nRole=Dependent',
               'Assoc CIMReferencedProfile\nResultRole\nAntecedent',
               'Ref classesReferences\nRole=Dependent']
    print_table(title, headers, rows, sort_columns=[1, 0])
532315
def show(ctx, component):
    """"""

    col = ctx.obj['col']

    if col.count({'name': component}) > 1:
        log('More than one component configuration of this name! Try '
            'one of the uuids as argument. Get a list with "config '
            'list"')
        return

    if component is None:
        configurations = col.find()
        for configuration in configurations:
            log("%-15s : %s" % (configuration.name,
                                configuration.uuid),
                emitter='MANAGE')
    else:
        configuration = col.find_one({'name': component})

        if configuration is None:
            configuration = col.find_one({'uuid': component})

        if configuration is None:
            log('No component with that name or uuid found.')
            return

        print(json.dumps(configuration.serializablefields(), indent=4))
791154
def show_service_profile(self, flavor_profile, **_params):
        """"""
        return self.get(self.service_profile_path % (flavor_profile),
                        params=_params)
200738
public function ProfileExtenderPrep() {
      $ProfileKeyData = $this->SQL->Select('m.Name')->Distinct()->From('UserMeta m')->Like('m.Name', 'Profile_%')->Get();
      $ExistingKeys = array_filter((array)explode(',', C('Plugins.ProfileExtender.ProfileFields', '')));
      foreach ($ProfileKeyData->Result() as $Key) {
         $Name = str_replace('Profile.', '', $Key->Name);
         if (!in_array($Name, $ExistingKeys)) {
            $ExistingKeys[] = $Name;
         }
      }
      if (count($ExistingKeys))
         SaveToConfig('Plugins.ProfileExtender.ProfileFields', implode(',', $ExistingKeys));
   }
237115
def _config(self):
        """"""
        cfg_wr = self.repo.config_writer()
        cfg_wr.add_section('user')
        cfg_wr.set_value('user', 'name', self.metadata.author)
        cfg_wr.set_value('user', 'email', self.metadata.email)
        cfg_wr.release()
440652
def profile_list(self, provider, lookup='all'):
        '''
        
        '''
        data = {}
        lookups = self.lookup_profiles(provider, lookup)

        if not lookups:
            return data

        for alias, driver in lookups:
            if alias not in data:
                data[alias] = {}
            if driver not in data[alias]:
                data[alias][driver] = {}
        return data
1006271
def dump_profile(profile):
    '''
    '''
    profile = profile.copy()
    path = os.path.join(Config.CONF_DIR, profile['username'])
    if profile['remember-password'] and profile['password']:
        for i in range(RETRIES):
            try:
                keyring.set_password(Config.DBUS_APP_NAME, profile['username'],
                                     profile['password'])
                break
            except dbus.exceptions.DBusException:
                logger.error(traceback.format_exc())
    profile['password'] = ''
    with open(path, 'w') as fh:
        json.dump(profile, fh)
1253435
def server_show(server_id, profile=None, **kwargs):
    '''
    
    '''
    conn = _auth(profile, **kwargs)
    return conn.server_show(server_id)
107701
def outputtemplate(self, template_id):
        """"""
        for profile in self.profiles:
            for outputtemplate in profile.outputtemplates():
                if outputtemplate.id == template_id:
                    return outputtemplate
        return KeyError("Outputtemplate " + template_id + " not found")
373467
def _config(self, args, config):
        
        listings = dict((x.args, x) for x in config.subsections('listing'))
        listing = listings.get(args.listing)
        if listing is None:
            if args.listing == u'default':
                return {'pattern': self._profile.list_default_pattern,
                        'order': self._profile.list_default_order}
            else:
                raise KolektoRuntimeError('Unknown listing %r' % args.listing)
        else:
            return {'pattern': listing.get('pattern'),
                    'order': listing.get('order')}