Access the auxillary data here
776409
def tags(self):
     """"""
     if self._tags: return self._tags
     tags = {}
     if not tags: return {}
     for m in [[y.group(1),y.group(2),y.group(3)] for y in [re.match('([^:]{2,2}):([^:]):(.+)$',x) for x in self.entries.optional_fields.split("\t")]]:
        if m[1] == 'i': m[2] = int(m[2])
        elif m[1] == 'f': m[2] = float(m[2])
        tags[m[0]] = TAGDatum(m[1],m[2])
     self._tags = tags
     return self._tags
881522
def data(self):
        
        if self._data:
            return self._data

        retval = {}
        data = self.get_request_data()
        for subdata in data:
            for key, value in subdata.iteritems():
                if not key in retval:
                    retval[key] = value

        self._data = retval
        return retval
644902
function getCurrentData() {
    let currentData = storage.getDataByKey(savedDataKey);

    if (!currentData) {
        let chartType = getCurrentType();
        let {initialDataType} = defaultConfig[chartType];

        currentData = defaultData[chartType][initialDataType];

        storage.setDataByKey(savedDataKey, currentData);
    }

    return currentData;
}
704805
def get_context_data(self, **kwargs):
        """"""
        r = get_r()
        category = kwargs.pop('category', None)
        data = super(AggregateDetailView, self).get_context_data(**kwargs)

        if category:
            slug_set =   r._category_slugs(category)
        else:
            slug_set = set(kwargs['slugs'].split('+'))

        data['granularities'] = list(r._granularities())
        data['slugs'] = slug_set
        data['category'] = category
        return data
1301218
def get_data(self):
        """"""
        return self.x, self.y, self.w, self.h
1230971
function getData(queryString, obj) {
  return queryString.split('.').reduce(function(prev, curr) {
    return prev ? prev[curr] : undefined
  }, obj);
}
1083170
def getAnalogActionData(self, action, unActionDataSize, ulRestrictToDevice):
        

        fn = self.function_table.getAnalogActionData
        pActionData = InputAnalogActionData_t()
        result = fn(action, byref(pActionData), unActionDataSize, ulRestrictToDevice)
        return result, pActionData
568672
def get_interims_data(self):
        
        form = self.request.form
        if 'item_data' not in form:
            return {}

        item_data = {}
        if type(form['item_data']) == list:
            for i_d in form['item_data']:
                for i, d in json.loads(i_d).items():
                    item_data[i] = d
            return item_data

        return json.loads(form['item_data'])
256905
function getData() {
  var o = {}, k, v;
  for(k in this._data) {
    v = this._data[k].v;
    // must coerce to strings here
    if(typeof v === 'number') {
      v = '' + v;
    }
    o[k] = v;
  }
  return o;
}
739805
def handle_data(self, data):
        
        self.log.debug( u'Encountered some data  : {0}'.format(data) )
        if not self.level:
            self.data.append(data)
293617
def data(self):
        """"""
        if self.kind == 'data':
            return self._data.data
        else:
            with self.open() as f:
                return f.read()
458156
def get_current_data(self):
        """"""
        if self.current_imuid in self.calibration_data:
            return self.calibration_data[self.current_imuid]

        return {}
1247400
function () {
        var data = this.data;
        var nodes = this._nodes;

        for (var i = 0, len = nodes.length; i < len; i++) {
            nodes[i].dataIndex = -1;
        }

        for (var i = 0, len = data.count(); i < len; i++) {
            nodes[data.getRawIndex(i)].dataIndex = i;
        }
    }
192974
def touch(self, name, data):
            
            b_OK        = True
            str_here    = self.cwd()
            # print("here!")
            # print(self.snode_current)
            # print(self.snode_current.d_nodes)
            l_path = name.split('/')
            if len(l_path) > 1:
                self.cd('/'.join(l_path[0:-1]))
            name = l_path[-1]
            self.snode_current.d_data[name] = data
            # print(self.snode_current)
            self.cd(str_here)
            return b_OK
846233
def get_accessed(node):
    '''
    '''
    if isinstance(node, ast.Assign):
        return get_accessed(node.value)
    elif isinstance(node, ast.Name):
        return {node.id}
    names = set()
    if isinstance(node, list):
        for x in node:
            names |= get_accessed(x)
    else:
        for x in ast.iter_child_nodes(node):
            names |= get_accessed(x)
    return names
1044071
def get_data(self):
		""
		array = ctypes.POINTER(ctypes.c_char * len(self))
		return ctypes.cast(self.data, array).contents.raw
335839
def cli(obj, ids, query, filters):
    """"""
    client = obj['client']
    if ids:
        query = [('id', x) for x in ids]
    elif query:
        query = [('q', query)]
    else:
        query = build_query(filters)
    alerts = client.search(query)

    headers = {'id': 'ID', 'rawData': 'RAW DATA'}
    click.echo(
        tabulate([{'id': a.id, 'rawData': a.raw_data} for a in alerts], headers=headers, tablefmt=obj['output']))