return stored data
        
        Returns:
            unpickled data
6096
def data(self):
        
        try:
            bytestream = super(MimeData, self).data(self._mimeType).data()
            return pickle.loads(bytestream)
        except:
            raise
687711
def unpickle_stats(stats):
    """"""
    stats = cPickle.loads(stats)
    stats.stream = True
    return stats
1076093
def _get_data_from_rawfile(path_to_data, raw_data_id):
    """"""
    loaded = pickle.load(open(path_to_data, "rb"))
    raw_datasets = loaded['handwriting_datasets']
    for raw_dataset in raw_datasets:
        if raw_dataset['handwriting'].raw_data_id == raw_data_id:
            return raw_dataset['handwriting']
    return None
1044071
def get_data(self):
		""
		array = ctypes.POINTER(ctypes.c_char * len(self))
		return ctypes.cast(self.data, array).contents.raw
699920
def get_data(self, linesep=os.linesep):
        

        stream = BytesIO()
        self.store(stream, linesep)
        return stream.getvalue()
500233
def data(self):
        
        return self._buf[self.offset():self.offset() + self.size()]
336929
def data_received(self, data):
        """"""
        self._data_buffer += data.decode()
        if not self._data_buffer.endswith('\r\n'):
            return
        data = self._data_buffer
        self._data_buffer = ''  # clear buffer
        for cmd in data.strip().split('\r\n'):
            data = json.loads(cmd)
            if not isinstance(data, list):
                data = [data]
            for item in data:
                self.handle_data(item)
634916
def _data(self, asa=None):
        
        if asa is not None:
            if self._store is None or self._hashes is None:
                msg = (
                    "Can only use asa functions with built dataframes."
                    " Build this package and try again."
                )
                raise ValueError(msg)
            return asa(self, [self._store.object_path(obj) for obj in self._hashes])
        else:
            if self.__cached_data is None:
                # TODO(dima): Temporary code.
                if self._target() == TargetType.PANDAS:
                    self.__cached_data = self._store.load_dataframe(self._hashes)
                elif self._target() == TargetType.NUMPY:
                    self.__cached_data = self._store.load_numpy(self._hashes)
                else:
                    self.__cached_data = self._store.get_file(self._hashes)
            return self.__cached_data
728301
function () {
        var self = this, data = {};

        self.find('*').each(function (ctrl) {
          var name = ctrl.name(), value = ctrl.value();

          if (name && typeof value != "undefined") {
            data[name] = value;
          }
        });

        return data;
      }
147476
def data(self):
        
        try:
            data = self._data
        except AttributeError:
            data = self._data = json.loads(self.json)
        return data
964726
def deserialize(self, data, fields=None):
        
        # TODO: it can be that we returned data by `get_lines`, that is already deserialized
        if not isinstance(data, (bytes, bytearray)):
            return data
        return msgpack.unpackb(data, encoding='utf-8', object_pairs_hook=decode_to_sorted)
1332363
def data(self):
        """"""
        data=np.empty((self.nRows,self.nCols),dtype=np.float)
        data[:]=np.nan # make everything nan by default
        for colNum,colData in enumerate(self.colData):
            validIs=np.where([np.isreal(v) for v in colData])[0]
            validData=np.ones(len(colData))*np.nan
            validData[validIs]=np.array(colData)[validIs]
            data[:len(colData),colNum]=validData # only fill cells that have data

        return data
969806
def data(self):
        """"""
        data = super(DynamicListSerializer, self).data
        processed_data = ReturnDict(
            SideloadingProcessor(self, data).data,
            serializer=self
        ) if self.child.envelope else ReturnList(
            data,
            serializer=self
        )
        processed_data = post_process(processed_data)
        return processed_data
1183029
def get_data(self):
        
        return {key: "".join(chr(byte) for byte in data)
                for key, data in six.iteritems(self.data)}
133372
def _recv_data(self):
        
        temp = ""
        while True:
            self.data_buffer = self.sslwrap.recv(1024)
            if '\x04' in self.data_buffer.decode('utf-8', 'ignore'):
                temp += self.data_buffer.decode('utf-8', 'ignore')
                break
            else:
                temp += self.data_buffer.decode('utf-8', 'ignore')
                self.data_buffer = bytes(1024)
        temp = temp.replace('\x04', '')
        if 'Ok' in temp:  # Because login
            return temp
        else:
            return ujson.loads(temp.split(' ', 1)[1])
406040
def retrieve_data(self):
        """"""
        local = False
        if self.exp_config.get("mode") == "debug":
            local = True
        filename = export(self.app_id, local=local)
        logger.debug("Data exported to %s" % filename)
        return Data(filename)
529615
def get_internal_data(self):
        
        if self.filetype is "pickle":
            return pickle.load(open(self.location_internal, "rb"))
        elif self.filetype is "hickle":
            import hickle
            return hickle.load(open(self.location_internal, "rb"))
        else:
            raise ValueError(
                "Invalue filetype {} (must be {} or {})".format(
                    self.filetype, "pickle", "hickle"
                )
            )