Returns information which infomations are selected by the actual configuration
163418
public String getSelectionInfo(){
		StringBuilder result = new StringBuilder();
		
		result.append( "SelectionInfo: "+this.getClass().toString() +"\n" );
		result.append( "Page:"+ CITInfo( pageHandling )+"\n" );
		result.append( "FirstParagraph:" +CITInfo( firstParagraphHandling )+"\n");
		for( String key: sectionHandling.keySet() ){
			final String uss = SectionType.USER_SECTION.toString();
			if( key.startsWith( uss ) )
				result.append(uss+"["+key.substring( uss.length() )+"]:\n");
			else
				result.append(key+":\n");
			
			result.append( SITInfo( sectionHandling.get(key))+"\n" );
		}
 		
		return result.toString();
	}
548584
def get_info(cls):
        
        mod = try_import(cls.mod_name)
        if not mod:
            return None
        version = getattr(mod, '__version__', None) or getattr(mod, 'version',
                                                               None)
        return BackendInfo(version or 'deprecated', '')
885748
def get_info(self):
        
        plugin_infos = {}
        for pc in self.plugins:
            plugin_infos.update(pc.get_info())
        return {
            self.get_plugin_name() : {
                "version"     : self.get_version(),
                "sub-plugins" : plugin_infos,
                "params" : {
                    "multi_plugins" : self.conf['multi_plugins']
                },
            }
        }
744713
def _getConfiguration(self):
        
        info =configuration.getConfiguration()

        try:            
            # This returns only the parameters needed by each wrapper. E. g., for Tor:
            # {
            #    "host" : "127.0.0.1"
            #    "port" : "9150"
            # }    
            return info[self.name]
            
        except KeyError, e:
            errMsg = "ERROR. WTF! There was not found any configuration for " + self.name + " in the configuration file!"
            raise Exception( errMsg )
1135931
private static function getPresetsInfo() {
    $installation_types = self::getInstallationTypes(TRUE);
    $presets_info = [];
    $packages_info = self::getPackages();

    foreach ($installation_types as $preset => $preset_info) {
      $presets_info[$preset] = $preset_info;
      $presets_info[$preset]['packages_expanded'] = [];
      foreach ($preset_info['packages'] as $package) {
        if (empty($packages_info[$package])) {
          continue;
        }
        $presets_info[$preset]['packages_expanded'][$package] = $packages_info[$package];
        if (!isset($packages_info[$package]['usage'])) {
          $packages_info[$package]['usage'] = 0;
        }
        $packages_info[$package]['usage']++;
      }
    }

    return $presets_info;
  }
1224983
def info(self):
        ''' 
        '''
        return sorted(self._checkers.values(), key=lambda x: (x.ns, x.name))
1368436
def show_info(self):
        

        sender = self.sender()
        tree = sender.parent()
        index = tree.selectedIndexes()
        info = ''
        if index != []:
            index = index[0]
            name = str(index.model().itemFromIndex(index).text())

            if name in set(list(self.elements_from_file.keys()) + list(self.elements_selected.keys())):
                probe_name = None
                instrument_name = name
            else:
                instrument_name = str(index.model().itemFromIndex(index).parent().text())
                probe_name = name



            module = __import__('pylabcontrol.instruments', fromlist=[instrument_name])
            if probe_name is None:
                info = getattr(module, instrument_name).__doc__
            else:
                if probe_name in list(getattr(module, instrument_name)._PROBES.keys()):
                    info = getattr(module, instrument_name)._PROBES[probe_name]

        if info is not None:
            self.lbl_info.setText(info)
263979
def get_edited(self, ):
        
        modified = []
        for i in range(len(self.__edited)):
            if self.__edited[i]:
                modified.append(self.__configs[i])
        return modified
802566
def _get_image_infos(config,image):
    '''
    
    '''
    client = _get_client(config)
    infos = None
    try:
        infos = _set_id(client.inspect_image(image))
    except Exception as e:
        pass
    return infos
87010
def choices(self, changelist):
        
        show_all = self.used_parameters.get(self.parameter_name) == "1"
        return (
            {
                'display': _('Current Configuration'),
                'selected': not show_all,
                'query_string': changelist.get_query_string({}, [self.parameter_name]),
            },
            {
                'display': _('All (Show History)'),
                'selected': show_all,
                'query_string': changelist.get_query_string({self.parameter_name: "1"}, []),
            }
        )
421942
def info(self):
        """"""
        if self.descriptions is None:
            choice_list = ['"{}"'.format(choice) for choice in self.choices]
        else:
            choice_list = [
                '"{}" ({})'.format(choice, self.descriptions[choice])
                for choice in self.choices
            ]
        if len(self.choices) == 2:
            return 'either {} or {}'.format(choice_list[0], choice_list[1])
        return 'any of {}'.format(', '.join(choice_list))
719532
def get_modules_info():
    """"""
    module_infos = []
    for (mod, name, version_attr) in Modules:
        if not fileutil.has_module(mod):
            continue
        if hasattr(mod, version_attr):
            attr = getattr(mod, version_attr)
            version = attr() if callable(attr) else attr
            module_infos.append("%s %s" % (name, version))
        else:
            # ignore attribute errors in case library developers
            # change the version information attribute
            module_infos.append(name)
    return u"Modules: %s" % (u", ".join(module_infos))
449350
def info(args):
    "  "

    site = find_site(args.PATH)
    print_header("%s -- install information" % site.get_name())
    LOGGER.debug(site.get_info(full=True))
    return True
975184
function _getConfig () {
    return {
      paced: paced,
      rate: rate,
      deterministic: deterministic,
      time: configuredTime,
      master: master,
      port: port
    }
  }
618975
protected function getInformation($configuration): array
    {
        $info = [];
        if (isset($configuration['type'])) {
            $info[] = 'type: ' . $configuration['type'];
        }
        $check = [
            'userFunc',
            'includeLibs',
            'extensionName',
            'pluginName',
        ];
        foreach ($check as $value) {
            if (isset($configuration['conf'][$value])) {
                $info[] = $value . ': ' . $configuration['conf'][$value];
            }
        }

        return $info;
    }
274330
def get_info(self):
        '''
        
        '''
        self.render()
        info = super(Template, self).get_info()
        res = {}
        res['name'] = self.get_name()
        res['mutation'] = {
            'current_index': self._current_index,
            'total_number': self.num_mutations()
        }
        res['value'] = {
            'rendered': {
                'base64': b64encode(self._current_rendered.tobytes()).decode(),
                'length_in_bytes': len(self._current_rendered.tobytes()),
            }
        }
        res['hash'] = self.hash()
        res['field'] = info
        return res
815443
def info():
    """"""
    rc = texinfo()
    print('Running Texinfo files through makeinfo...')
    builddir = os.path.join(BUILDDIR, 'texinfo')
    subprocess.call(['make', '-C', builddir, 'info'])
    print('makeinfo finished; the Info files are in {}.'.format(builddir))