Return collected data.
339458
def get_data(self, contract=None):
        """"""
        if contract is None:
            return self._data
        if contract in self._data.keys():
            return {contract: self._data[contract]}
        raise PyHydroQuebecError("Contract {} not found".format(contract))
505467
def get_data_points(self, points=None):
        """"""
        if points is None:
            points = self.points
        points = self.crdmap.to_data(points)
        return points
511048
def data(self):
        """"""
        if self._data is None:
            # reset after possible parsing failure
            self.__init__(self.tokens)
            return self._parse()
        else:
            return self._data
1107221
def filedata(self):
        """"""
        if self._filedata_api is None:
            self._filedata_api = self.get_filedata_api()
        return self._filedata_api
716551
def _get_data(self, read_size):
        """"""
        if NIX:
            return super(Mouse, self)._get_data(read_size)
        return self._pipe.recv_bytes()
1161374
def files(self):
        """"""
        self._check_session()
        status, data = self._rest.get_request('files')
        return data
298845
def items(self):
        """"""
        if self.scraper.current_item is not self:
            self._move_here()

        if self._items is None:
            self._items = ItemList()
            self._items.scraper = self.scraper
            self._items.collection = self
            for i in self.scraper._fetch_itemslist(self):
                i.parent = self
                if i.type == TYPE_DATASET and i.dialect is None:
                    i.dialect = self.scraper.dialect
                self._items.append(i)
        return self._items
238357
def _extract_return(self, data):
        '''
        
        '''
        if isinstance(data, dict):
            data = data.get('return', data)

        return data
1307138
def fetch_data(self):
        """"""
        # Get http session
        yield from self._get_httpsession()
        # Post login page
        yield from self._post_login_page()
        # Get token
        token_uuid = yield from self._get_token()
        # Get account number
        account_number = yield from self._get_account_number(*token_uuid)
        # List phone numbers
        self._phone_numbers = yield from self._list_phone_numbers(account_number)
        # Get balance
        balance = yield from self._get_balance(account_number)
        self._data['balance'] = balance
        # Get fido dollar
        for number in self._phone_numbers:
            fido_dollar = yield from self._get_fido_dollar(account_number,
                                                           number)
            self._data[number]= {'fido_dollar': fido_dollar}
        # Get usage
        for number in self._phone_numbers:
            usage = yield from self._get_usage(account_number, number)
            self._data[number].update(usage)
771409
def data(self, data=None):
        
        if data is not None:
            self.response_model.data = data
        return self.response_model.data
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
471034
def values(self):
        """"""
        values = []
        for __, data in self.items():
            values.append(data)
        return values
604647
def collect(self):
        """"""
        local_df = self._schema_rdd.toPandas()
        correct_idx_df = _update_index_on_df(local_df, self._index_names)
        return correct_idx_df
1167262
def dataset(self, ref, load_all=False, exception=True):
        """"""
        return self.database.dataset(ref, load_all=load_all, exception=exception)
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
1007549
def pickdata(self, data):
        
        """
        attrs = data.get(self.__options['attrkey']) or {}
        values = data.get(self.__options['valuekey']) or ''
        return (attrs, values)
783776
def get(self):
        """"""
        data = b''
        with self.lock:
            data, self.buf = self.buf, b''

        return data