Returns the help text for the configuration options for this handler
975450
def get_default_config_help(self):
        
        config = super(MySQLHandler, self).get_default_config_help()

        config.update({
        })

        return config
1201873
def get_config_items(self):
        
        return (
            ('settings', self.settings),
            ('context_class', self.context_class),
            ('interfaces', self.interfaces),
            ('logging', self.logging),
            ('name', self.name),
            ('init_handler', self.init_handler),
            ('sigusr1_handler', self.sigusr1_handler),
            ('sigusr2_handler', self.sigusr2_handler),
        )
345919
def configuration_to_dict(handlers):
    
    config_dict = defaultdict(dict)

    for handler in handlers:
        for option in handler.set_options:
            value = _get_option(handler.target_obj, option)
            config_dict[handler.section_prefix][option] = value

    return config_dict
948510
def get_default_config_help(self):
        
        config = super(MultiGraphiteHandler, self).get_default_config_help()

        config.update({
            'host': 'Hostname, Hostname, Hostname',
            'port': 'Port',
            'proto': 'udp or tcp',
            'timeout': '',
            'batch': 'How many to store before sending to the graphite server',
            'max_backlog_multiplier': 'how many batches to store before trimming',  # NOQA
            'trim_backlog_multiplier': 'Trim down how many batches',
        })

        return config
507202
def configurations(self):
        
        if self._configuration_manager is None:
            self._configuration_manager = ConfigurationManager(session=self._session)
        return self._configuration_manager
942310
def help(opts, bot, _):
    
    command = opts['<command>']
    if command is None:
        return bot.help_text()

    if command not in bot.commands:
        return "%r is not a known command" % command

    return bot.commands[command].__doc__
1175247
def get_default_config_help(self):
        
        config = super(zmqHandler, self).get_default_config_help()

        config.update({
            'port': '',
        })

        return config
902733
def get_default_config(self):
        
        config = super(DatadogHandler, self).get_default_config()

        config.update({
            'api_key': '',
            'queue_size': '',
        })

        return config
938658
def get_default_config_help(self):
        
        config = super(StatsiteHandler, self).get_default_config_help()

        config.update({
            'host': '',
            'tcpport': '',
            'udpport': '',
            'timeout': '',
        })

        return config
855926
function getHelp() {
  if (HelpText) return HelpText

  var helpFile = path.join(__dirname, utils.COMMAND + ".help.txt" )
  var content  = fs.readFileSync(helpFile, "utf8")

  content = content.replace(/%COMMAND%/g,     utils.COMMAND    )
  content = content.replace(/%PACKAGE%/g,     utils.PACKAGE    )
  content = content.replace(/%VERSION%/g,     utils.VERSION    )
  content = content.replace(/%DESCRIPTION%/g, utils.DESCRIPTION)
  content = content.replace(/%HOMEPAGE%/g,    utils.HOMEPAGE   )

  HelpText = content
  return HelpText
}
763568
def get_default_config_help(self):
        
        config_help = super(PassengerCollector, self).get_default_config_help()
        config_help.update({
            "bin":         "The path to the binary",
            "use_sudo":    "Use sudo?",
            "sudo_cmd":    "Path to sudo",
            "passenger_status_bin":
                           "The path to the binary passenger-status",
            "passenger_memory_stats_bin":
                           "The path to the binary passenger-memory-stats",
        })
        return config_help
157609
def get_default_config_help(self):
        
        config = super(SignalfxHandler, self).get_default_config_help()

        config.update({
            'url': 'Where to send metrics',
            'batch': 'How many to store before sending',
            'filter_metrics_regex': 'Comma separated collector:regex filters',
            'auth_token': 'Org API token to use when sending metrics',
        })

        return config
1365969
def generate_help(self):
        
        result = []
        result.append(self.__class__.__name__)
        result.append(re.sub(r'.', '=', self.__class__.__name__))
        result.append("")
        result.append("DESCRIPTION")
        result.append(self.description())
        result.append("")
        result.append("OPTIONS")
        opts = sorted(self.config.keys())
        for opt in opts:
            result.append(opt)
            helpstr = self.help[opt]
            if helpstr is None:
                helpstr = "-missing help-"
            result.append("\t" + helpstr)
            result.append("")
        return '\n'.join(result)
256042
def get_default_config_help(self):
        
        config_help = super(ConnTrackCollector, self).get_default_config_help()
        config_help.update({
            "dir":      "Directories with files of interest, comma seperated",
            "files":    "List of files to collect statistics from",
        })
        return config_help
585856
def get_config(context):
    

    conf_vars = ['disqus_developer',
                 'disqus_identifier',
                 'disqus_url',
                 'disqus_title',
                 'disqus_category_id'
                 ]

    js = '\tvar {} = "{}";'

    output = [js.format(item, context[item]) for item in conf_vars \
              if item in context]

    return '\n'.join(output)
186957
def configure(self, cfg, handler, path=""):

        

        # configure simple value attributes (str, int etc.)
        for name, attr in handler.attributes():
            if cfg.get(name) is not None:
                continue
            if attr.expected_type not in [list, dict]:
                cfg[name] = self.set(handler, attr, name, path, cfg)
            elif attr.default is None and not hasattr(handler, "configure_%s" % name):
                self.action_required.append(("%s.%s: %s" % (path, name, attr.help_text)).strip("."))

        # configure attributes that have complex handlers defined
        # on the config Handler class (class methods prefixed by
        # configure_ prefix
        for name, attr in handler.attributes():
            if cfg.get(name) is not None:
                continue
            if hasattr(handler, "configure_%s" % name):
                fn = getattr(handler, "configure_%s" % name)
                fn(self, cfg, "%s.%s"% (path, name))
                if attr.expected_type in [list, dict] and not cfg.get(name):
                    try:
                        del cfg[name]
                    except KeyError:
                        pass
211720
def python_sidebar_help(python_input):
    
    token = 'class:sidebar.helptext'

    def get_current_description():
        """
        Return the description of the selected option.
        """
        i = 0
        for category in python_input.options:
            for option in category.options:
                if i == python_input.selected_option_index:
                    return option.description
                i += 1
        return ''

    def get_help_text():
        return [(token, get_current_description())]

    return ConditionalContainer(
        content=Window(
            FormattedTextControl(get_help_text),
            style=token,
            height=Dimension(min=3)),
        filter=ShowSidebar(python_input) &
               Condition(lambda: python_input.show_sidebar_help) & ~is_done)