get the correct helper depending on the environment variable
       HELPME_CLIENT

       quiet: if True, suppress most output about the client (e.g. speak)
350964
def get_helper(name=None, quiet=True, **kwargs):
    '''
       

    '''
    # Second priority, from environment
    from helpme.defaults import HELPME_CLIENT

    # First priority, from command line
    if name is not None:
        HELPME_CLIENT = name

    # If no obvious credential provided, we can use HELPME_CLIENT
    if   HELPME_CLIENT == 'github': from .github import Helper;
    elif HELPME_CLIENT == 'uservoice': from .uservoice import Helper
    elif HELPME_CLIENT == 'discourse': from .discourse import Helper
    else: from .github import Helper

    Helper.name = HELPME_CLIENT
    Helper.quiet = quiet

    # Initialize the database
    return Helper()
738117
def get_intro_prompt(self):
        '''  '''
        sys_status = open(self.help_path + 'cabin.txt', 'r')
        server_msg = sys_status.read()
        return server_msg + colorize('psiTurk version ' + version_number +
                                     '\nType "help" for more information.',
                                     'green', False)
1140572
def log_assist_request_without_audio(assist_request):
    """"""
    if logging.getLogger().isEnabledFor(logging.DEBUG):
        resp_copy = embedded_assistant_pb2.AssistRequest()
        resp_copy.CopyFrom(assist_request)
        if len(resp_copy.audio_in) > 0:
            size = len(resp_copy.audio_in)
            resp_copy.ClearField('audio_in')
            logging.debug('AssistRequest: audio_in (%d bytes)',
                          size)
            return
        logging.debug('AssistRequest: %s', resp_copy)
527338
def silence_errors(f):
    
    @wraps(f)
    def wrapper(*args, **kwds):
        status = np.seterr(all='ignore')
        result = f(*args, **kwds)
        np.seterr(**status)
        return result
    return wrapper
561622
def cli(env, identifier, enable):
    """"""

    mgr = SoftLayer.HardwareManager(env.client)
    hw_id = helpers.resolve_id(mgr.resolve_ids, identifier, 'hardware')
    result = env.client['Hardware_Server'].toggleManagementInterface(enable, id=hw_id)
    env.fout(result)
1230414
def help_message():
    """"""
    parser = autopep8.create_parser()
    string_io = io.StringIO()
    parser.print_help(string_io)
    # Undo home directory expansion.
    return string_io.getvalue().replace(os.path.expanduser('~'), '~')
928376
def set_muted(self, status):
        """"""
        new_volume = self._client['config']['volume']
        new_volume['muted'] = status
        self._client['config']['volume']['muted'] = status
        yield from self._server.client_volume(self.identifier, new_volume)
        _LOGGER.info('set muted to %s on %s', status, self.friendly_name)
677385
async def jsk_voice(self, ctx: commands.Context):
        

        # if using a subcommand, short out
        if ctx.invoked_subcommand is not None and ctx.invoked_subcommand is not self.jsk_voice:
            return

        # give info about the current voice client if there is one
        voice = ctx.guild.voice_client

        if not voice or not voice.is_connected():
            return await ctx.send("Not connected.")

        await ctx.send(f"Connected to {voice.channel.name}, "
                       f"{'paused' if voice.is_paused() else 'playing' if voice.is_playing() else 'idle'}.")
905201
function outputHelpIfNecessary(cmd, options) {
  options = options || [];
  for (var i = 0; i < options.length; i++) {
    if (options[i] == '--help' || options[i] == '-h') {
      process.on('exit', function() {
        consoleFlush(cmd.helpInformation());
        cmd.emit('--help');
        consoleFlush("");
      });
      process.exit();
    }
    
    return true;
  }
}
1024294
def _file_prompt_quiet(f):
        """"""

        @functools.wraps(f)
        def wrapper(self, *args, **kwargs):
            if not self.prompt_quiet_configured:
                if self.auto_file_prompt:
                    # disable file operation prompts
                    self.device.send_config_set(["file prompt quiet"])
                    self.prompt_quiet_changed = True
                    self.prompt_quiet_configured = True
                else:
                    # check if the command is already in the running-config
                    cmd = "file prompt quiet"
                    show_cmd = "show running-config | inc {}".format(cmd)
                    output = self.device.send_command_expect(show_cmd)
                    if cmd in output:
                        self.prompt_quiet_configured = True
                    else:
                        msg = (
                            "on-device file operations require prompts to be disabled. "
                            "Configure 'file prompt quiet' or set 'auto_file_prompt=True'"
                        )
                        raise CommandErrorException(msg)

            # call wrapped function
            return f(self, *args, **kwargs)

        return wrapper
389077
function (program) {
    var verbosity = program.verbose
    if (program.quiet) {
      verbosity = 0
    } else if (typeof verbosity === 'undefined') {
      verbosity = 1
    }
    return verbosity
  }
841891
def _silent_none(value):
    '''
    
    '''
    if value is None:
        return ''
    if type(value) == int:
        return value
    if type(value) == bool:
        return value
    if not value:
        return ''
    try:
        if str(value) == 'None':
            return ''
    except UnicodeEncodeError:
        pass
    return value
1142455
def get_deps_manager(self, *args, **kwargs):
        
        if 'silent_key_error' not in kwargs:
            kwargs['silent_key_error'] = self.silent_key_error
        return self.deps_manager(*args, **kwargs)
943439
def help(self, command=None):
        
        cmd = 'help'
        if command: cmd += ' %s' % command
        return self.fetch(cmd)[1]
946278
def stop_accepting_passive_host_checks(self):
        
        if self.my_conf.accept_passive_host_checks:
            self.my_conf.modified_attributes |= DICT_MODATTR["MODATTR_PASSIVE_CHECKS_ENABLED"].value
            self.my_conf.accept_passive_host_checks = False
            self.my_conf.explode_global_conf()
            self.daemon.update_program_status()
1075773
def execute_quiet(command, error_message)
      # Ladies and gentleman: More debug, please!
      puts command if @debug
      return_value = -1

      Open3.popen3(environment, command) do |_stdin, stdout, stderr, wait_thread|
        Thread.new do
          stdout.each do |line|
            @last_output << line.strip
            puts line unless @quiet
          end
        end

        Thread.new do
          stderr.each do |line|
            @last_error << line
            puts line unless @quiet
          end
        end

        _stdin.close

        return_value = wait_thread.value

        if @strict and return_value.exitstatus != 0
          dump_error_message(command)
          fail error_message
        end
      end

      puts "Program exited with status #{return_value.exitstatus}." if @debug

      return_value.exitstatus == 0
    end
832047
def set_jinja2_silent_none(config):  # pragma: no cover
    
    config.commit()
    jinja2_env = config.get_jinja2_environment()
    jinja2_env.finalize = _silent_none