get value by range
        :param spreadsheet_id:
        :param range_name:
        :return:
434166
def get_value(self, spreadsheet_id: str, range_name: str) -> dict:
        
        service = self.__get_service()
        result = service.spreadsheets().values().get(spreadsheetId=spreadsheet_id, range=range_name).execute()
        return result.get('values', [])
1033773
def extract_named_ranges(defined_names) #:nodoc:
      named_ranges = []

      defined_names.each do |defined_name|
        name, index, range = defined_name

        # Skip autoFilter ranges.
        next if name == '_xlnm._FilterDatabase'

        # We are only interested in defined names with ranges.
        if range =~ /^([^!]+)!/
          sheet_name = $1

          # Match Print_Area and Print_Titles xlnm types.
          if name =~ /^_xlnm\.(.*)$/
            xlnm_type = $1
            name = "#{sheet_name}!#{xlnm_type}"
          elsif index != -1
            name = "#{sheet_name}!#{name}"
          end

          named_ranges << name
        end
      end

      named_ranges
    end
898622
def get_worksheet(self):
        
        url = self.build_url('')
        q = self.q().select('name').expand('worksheet')
        response = self.session.get(url, params=q.as_params())
        if not response:
            return None
        data = response.json()

        ws = data.get('worksheet')
        if ws is None:
            return None
        return WorkSheet(parent=self.parent, **{self._cloud_data_key: ws})
953905
function (id) {
      id = id.replace(/\$/g, '');
      return instance.helper.cellValue.call(this, id);
    }
1349269
public Range<Integer> getCardRange(String id) {
        Preconditions.checkState(mGroupBasicAdapter != null, "Must call bindView() first");
        return this.mGroupBasicAdapter.getCardRange(id);
    }
396846
def _get_row(self, id):
        """"""
        return {name: d['func'](id) for (name, d) in self._columns.items()}
590835
async function getRanges(
  auth,
  spreadsheetId,
  ranges,
  fields = 'properties.title,sheets.properties,sheets.data(rowData.values.effectiveValue,rowData.values.formattedValue,rowData.values.effectiveFormat.numberFormat)'
) {
  var sheets = google.sheets('v4');
  const response = await Q.ninvoke(sheets.spreadsheets, 'get', {
    auth: auth,
    spreadsheetId: spreadsheetId,
    // https://developers.google.com/sheets/guides/concepts, https://developers.google.com/sheets/samples/sheet
    fields: fields,
    includeGridData: true,
    ranges: ranges
  });
  const spreadsheet = response.data;
  return spreadsheet;
}
1207386
public static function get($name = null, $range = null, $inherit=true)
    {
        $range = $range ?: self::$range;
        
        // load default
        static::autoload($range);
        
        $value = null;
        if (empty($name)) {// get all
            $value = isset(self::$data[$range]) ? self::$data[$range] : null;
        } elseif (isset(self::$data[$range][$name])){
            $value = self::$data[$range][$name];
        } elseif (strpos($name, '.')) { // has '.'
            $names    = explode('.', $name, 3);
            if (count($names) > 2) {
                $value = isset(self::$data[$range][$names[0]][$names[1]][$names[2]]) ? self::$data[$range][$names[0]][$names[1]][$names[2]] : null;
            } else {
                $value = isset(self::$data[$range][$names[0]][$names[1]]) ? self::$data[$range][$names[0]][$names[1]] : null;
            }
        }
        
        // if inherit get default range config  && 
        if ($range !== self::$range && $inherit) {
            if ($value === null) {
                $value = self::get($name, self::$range, false);
            } elseif (is_array($value)) {
                $vd = self::get($name, self::$range, false);
                $value = ArrayHelper::merge($vd, $value);
            }
        }
        
        return $value;
    }
192269
def get_by(cls, field, value):
        '''  '''
        redis = cls.get_redis()
        key = cls.cls_key()+':index_'+field

        id = redis.hget(key, value)

        if id:
            return cls.get(debyte_string(id))

        return None
62750
def get_value(self, name):
        """"""
        ns = self._get_current_namespace()
        value = ns[name]
        try:
            self.send_spyder_msg('data', data=value)
        except:
            # * There is no need to inform users about
            #   these errors.
            # * value = None makes Spyder to ignore
            #   petitions to display a value
            self.send_spyder_msg('data', data=None)
        self._do_publish_pdb_state = False
695401
def get_named_range(self, name):
        
        url = self.build_url(self._endpoints.get('get_named_range').format(name=name))
        response = self.session.get(url)
        if not response:
            return None
        return self.named_range_constructor(parent=self, **{self._cloud_data_key: response.json()})
878164
def get_range_response(self, range_start, range_end, sort_order=None,
                           sort_target='key', **kwargs):
        """"""
        range_request = self._build_get_range_request(
            key=range_start,
            range_end=range_end,
            sort_order=sort_order,
            sort_target=sort_target,
            **kwargs
        )

        return self.kvstub.Range(
            range_request,
            self.timeout,
            credentials=self.call_credentials,
            metadata=self.metadata
        )
1122218
def get_range_data(row_start, col_start, row_end, col_end) # :nodoc:
      # TODO. Check for worksheet limits.

      # Iterate through the table data.
      data = []
      (row_start .. row_end).each do |row_num|
        # Store nil if row doesn't exist.
        if !@cell_data_table[row_num]
          data << nil
          next
        end

        (col_start .. col_end).each do |col_num|
          if cell = @cell_data_table[row_num][col_num]
            data << cell.data
          else
            # Store nil if col doesn't exist.
            data << nil
          end
        end
      end

      return data
    end
376807
def get_chart_range(range) #:nodoc:
      # Split the range formula into sheetname and cells at the last '!'.
      pos = range.rindex('!')
      return nil unless pos

      if pos > 0
        sheetname = range[0, pos]
        cells = range[pos + 1 .. -1]
      end

      # Split the cell range into 2 cells or else use single cell for both.
      if cells =~ /:/
        cell_1, cell_2 = cells.split(/:/)
      else
        cell_1, cell_2 = cells, cells
      end

      # Remove leading/trailing apostrophes and convert escaped quotes to single.
      sheetname.sub!(/^'/, '')
      sheetname.sub!(/'$/, '')
      sheetname.gsub!(/''/, "'")

      row_start, col_start = xl_cell_to_rowcol(cell_1)
      row_end,   col_end   = xl_cell_to_rowcol(cell_2)

      # Check that we have a 1D range only.
      return nil if row_start != row_end && col_start != col_end
      return [sheetname, row_start, col_start, row_end, col_end]
    end
882678
def get_range_by_partition_key_range_id(self, partition_key_range_id):
        
        t = self._rangeById.get(partition_key_range_id)

        if t is None:
            return None
        return t[0]
614241
def get_cell(self, row, column):
        
        url = self.build_url(self._endpoints.get('get_cell').format(row=row, column=column))
        response = self.session.get(url)
        if not response:
            return None
        return self.range_constructor(parent=self, **{self._cloud_data_key: response.json()})
1050665
def get_field_value(self, instance, field_name):
        
        # XXX: can we come up w/ a better API?
        # Ensure we map ``percent`` to the ``id`` column
        if field_name == 'percent':
            field_name = 'id'
        value = getattr(instance, field_name)
        if callable(value):
            value = value()
        return value