Returns the current output level by querying the remote controller.
359353
def level(self):
    """"""
    ev = self._query_waiters.request(self.__do_query_level)
    ev.wait(1.0)
    return self._level
1163420
public function getStatus($raw_output = true)
    {
        if ($raw_output) {
            return $this->_status;
        }
        return self::$_statusToString[$this->_status];
    }
24634
def level(self, new_level):
    """"""
    if self._level == new_level:
      return
    self._lutron.send(Lutron.OP_EXECUTE, Output._CMD_TYPE, self._integration_id,
        Output._ACTION_ZONE_LEVEL, "%.2f" % new_level)
    self._level = new_level
727944
def getOutput(self):
        
        output = self.stdout
        if self.stdout:
            output += '\r\n'
        output += self.stderr
        return output
638806
def getLevel(self):
        
        lvl = 0
        p = self
        while True:
            p = p.parent
            if not isinstance(p, LPort):
                break
            lvl += 1
        return lvl
1302870
def fetch(name = remote.name)
      logger.info 'Fetching the latest changes from the server'
      output = self.command(:fetch, ['-p', name])

      log_fetch_changes(fetch_changes(output))

      return output
    end
769488
public String getLevel() {
        try {
            LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();
            return loggerContext.getLogger("root").getLevel().toString();
        } catch (Exception e) {
            e.printStackTrace();
            return "";
        }
    }
1053593
def _get_toplevel(path, user=None, password=None, output_encoding=None):
    '''
    
    '''
    return _git_run(
        ['git', 'rev-parse', '--show-toplevel'],
        cwd=path,
        user=user,
        password=password,
        output_encoding=output_encoding)['stdout']
42601
private function getLevel($level)
    {
        $result = \common_Logger::TRACE_LEVEL;
        switch ($level) {
            case 'fatal' :
                $result = \common_Logger::FATAL_LEVEL;
                break;
            case 'error' :
                $result = \common_Logger::ERROR_LEVEL;
                break;
            case 'warn' :
                $result = \common_Logger::WARNING_LEVEL;
                break;
            case 'info' :
                $result = \common_Logger::INFO_LEVEL;
                break;
            case 'debug' :
                $result = \common_Logger::DEBUG_LEVEL;
                break;
            case 'trace' :
                $result = \common_Logger::DEBUG_LEVEL;
                break;
        }
        return $result;
    }
1310355
@VisibleForTesting
  static Level getLogLevel(Throwable t) {
    if (t instanceof IOException && t.getMessage() != null) {
      for (String msg : QUIET_ERRORS) {
        if (t.getMessage().equals(msg)) {
          return Level.FINE;
        }
      }
    }
    return Level.INFO;
  }
1181106
def get_output_from_input(self):
        
        input_path = self.layer.currentLayer().source()
        output_path = (
            os.path.splitext(input_path)[0] + '_multi_buffer'
            + os.path.splitext(input_path)[1])
        self.output_form.setText(output_path)
885718
def get(self, timeout=None):
        """"""
        result = None
        for stage in self._output_stages:
            result = stage.get(timeout)
        return result
232166
private int getIsoLevel(String isoLevel)
    {
        if (isoLevel.equalsIgnoreCase(LITERAL_IL_READ_UNCOMMITTED))
        {
            return IL_READ_UNCOMMITTED;
        }
        else if (isoLevel.equalsIgnoreCase(LITERAL_IL_READ_COMMITTED))
        {
            return IL_READ_COMMITTED;
        }
        else if (isoLevel.equalsIgnoreCase(LITERAL_IL_REPEATABLE_READ))
        {
            return IL_REPEATABLE_READ;
        }
        else if (isoLevel.equalsIgnoreCase(LITERAL_IL_SERIALIZABLE))
        {
            return IL_SERIALIZABLE;
        }
        else if (isoLevel.equalsIgnoreCase(LITERAL_IL_OPTIMISTIC))
        {
            return IL_OPTIMISTIC;
        }
        //logger.warn("unknown isolation-level: " + isoLevel + " using RW_UNCOMMITTED as default");
        return defIsoLevel;
    }
301526
def check_storage_controllers():
    
    if ctrl_flag:
        ctrl = walk_data(sess, oid_ctrl, helper)[0]
        for x, data in enumerate(ctrl, 1):
            ctrl_summary_output, ctrl_long_output = state_summary(data, 'Controller %d' % x, normal_state, helper)
            add_output(ctrl_summary_output, ctrl_long_output, helper)
467826
def get_output_content(job_id, max_size=1024, conn=None):
    
    content = None
    if RBO.index_list().contains(IDX_OUTPUT_JOB_ID).run(conn):
        # NEW
        check_status = RBO.get_all(job_id, index=IDX_OUTPUT_JOB_ID).run(conn)
    else:
        # OLD
        check_status = RBO.filter({OUTPUTJOB_FIELD: {ID_FIELD: job_id}}).run(conn)
    for status_item in check_status:
        content = _truncate_output_content_if_required(status_item, max_size)
    return content
609637
@VisibleForTesting
  static Level getLogLevel(Throwable t) {
    if (t instanceof IOException
        && t.getMessage() != null
        && QUIET_ERRORS.contains(t.getMessage())) {
      return Level.FINE;
    }
    return Level.INFO;
  }
42017
def getStreamLevel(self):
        
        shlvl = 0
        for i in range(0,len(self.handlers)):
            h = self.handlers[i]
            if isinstance(h,logging.StreamHandler):
                shlvl = h.level
        return shlvl