Process more data.
484972
def update(self, data):
        """"""
        self._md.update(data)
        bufpos = self._nbytes & 63
        self._nbytes += len(data)

        if self._rarbug and len(data) > 64:
            dpos = self.block_size - bufpos
            while dpos + self.block_size <= len(data):
                self._corrupt(data, dpos)
                dpos += self.block_size
621030
def process_data(self, block):
        """"""
        if hasattr(block, 'send_destinations') and block.send_destinations:
            self.fire(events.FileProcessed(block))
            self._log_in_db(block)
            if self._sent_log_file:
                self._log_in_sent_log(block)
            self.log.info("Sent to '%s' file '%s' containing files: %s",
                          str(block.send_destinations),
                          block.processed_data_file_info.basename,
                          str([file_info.path for file_info in block.content_file_infos]))
        else:
            self.log.info("File %s wasn't sent", block.processed_data_file_info.basename)
        return block
402541
def process_files():
    

    with enlighten.Counter(total=100, desc='Simple', unit='ticks') as pbar:
        for num in range(100):  # pylint: disable=unused-variable
            time.sleep(0.05)
            pbar.update()
134270
protected void processData(Collection<RI> data) {
        // Check data against all rules
        for (Rule<Collection<RI>, RO> rule : rules) {
            processResult(rule.validate(data));
        }
    }
368793
def _process(self, data):
        ""
        parts = data.split(':')
        if self._debug:
            self.error('packet: %r' % data)
        if not parts:
            return

        # interpret the packet and update stats
        stats = self._stats
        key = parts[0].translate(KEY_TABLE, KEY_DELETIONS)
        if self._key_prefix:
            key = '.'.join([self._key_prefix, key])
        for part in parts[1:]:
            srate = 1.0
            fields = part.split('|')
            length = len(fields)
            if length < 2:
                continue
            value = fields[0]
            stype = fields[1].strip()

            with stats_lock:
                # timer (milliseconds)
                if stype == 'ms':
                    stats.timers[key].append(float(value if value else 0))

                # counter with optional sample rate
                elif stype == 'c':
                    if length == 3 and fields[2].startswith('@'):
                        srate = float(fields[2][1:])
                    value = float(value if value else 1) * (1 / srate)
                    stats.counts[key] += value
                elif stype == 'g':
                    value = float(value if value else 1)
                    stats.gauges[key] = value
1216527
function _processData(){
                    if(_.isEmpty($scope.mdtRow)) {
                        return;
                    }

                    //local search/filter
                    if (angular.isUndefined($scope.mdtRowPaginator)) {
                        $scope.$watch('mdtRow', function (mdtRow) {
                            vm.dataStorage.storage = [];

                            _addRawDataToStorage(mdtRow['data']);
                        }, true);
                    }else{
                        //if it's used for 'Ajax pagination'
                    }
                }
66549
def _Write(self, data, length, progress_callback=None):
        """"""
        if progress_callback:
            progress = self._HandleProgress(length, progress_callback)
            next(progress)
        while length:
            tmp = data.read(self.chunk_kb * 1024)
            length -= len(tmp)
            self.usb.BulkWrite(tmp)

            if progress_callback and progress:
                progress.send(len(tmp))
1164228
def process (self, c):
        """"""
        if isinstance(c, bytes):
            c = self._decode(c)
        self.state.process(c)
988074
def process_data(self):
        

        further_processing = False

        if self.state == self.WaitingForReportType and len(self.raw_data) > 0:
            self.current_type = self.raw_data[0]

            try:
                self.current_header_size = self.calculate_header_size(self.current_type)
                self.state = self.WaitingForReportHeader
                further_processing = True
            except Exception as exc:
                self.state = self.ErrorState

                if self.error_callback:
                    self.error_callback(self.ErrorFindingReportType, str(exc), self.context)
                else:
                    raise

        if self.state == self.WaitingForReportHeader and len(self.raw_data) >= self.current_header_size:
            try:
                self.current_report_size = self.calculate_report_size(self.current_type,
                                                                      self.raw_data[:self.current_header_size])
                self.state = self.WaitingForCompleteReport
                further_processing = True
            except Exception as exc:
                self.state = self.ErrorState

                if self.error_callback:
                    self.error_callback(self.ErrorParsingReportHeader, str(exc), self.context)
                else:
                    raise

        if self.state == self.WaitingForCompleteReport and len(self.raw_data) >= self.current_report_size:
            try:
                report_data = self.raw_data[:self.current_report_size]
                self.raw_data = self.raw_data[self.current_report_size:]

                report = self.parse_report(self.current_type, report_data)
                self._handle_report(report)
                self.state = self.WaitingForReportType
                further_processing = True
            except Exception as exc:
                self.state = self.ErrorState

                if self.error_callback:
                    self.error_callback(self.ErrorParsingCompleteReport, str(exc), self.context)
                else:
                    raise

        return further_processing
298461
def add_data(self, data):
        

        if self.state == self.ErrorState:
            return

        self.raw_data += bytearray(data)

        still_processing = True
        while still_processing:
            still_processing = self.process_data()
1243877
def load_data(self, idx):
        """"""
        for subseqs in self:
            if isinstance(subseqs, abctools.InputSequencesABC):
                subseqs.load_data(idx)
1055322
def process_data(self, text, colsep=u"\t", rowsep=u"\n",
                     transpose=False, skiprows=0, comments='#'):
        """"""
        data = self._shape_text(text, colsep, rowsep, transpose, skiprows,
                                comments)
        self._model = PreviewTableModel(data)
        self.setModel(self._model)
416669
def process_data(self, file_info):
        """"""
        if self._is_already_processed(file_info):
            self.log.debug("Content file already processed '%s'", str(file_info))
            self.fire(events.FilteredFile(file_info))
            self.fire(events.FileInfoAlreadyProcessed(file_info))
        else:
            return file_info
        return None
82650
def process(self, data):
        
        fields = []
        for res in data:
            for epname, out in six.iteritems(res.status):
                fields.append(
                    [out.get('state'),
                     epname,
                     out.get('formatted_filename'),
                     out.get('messages')])

        if fields:
            table.write_output(fields)
1108283
def process_raw_data(cls, raw_data):
        """"""
        raw_settings = raw_data.get("qosSettings", {})
        qos_settings = QosSettings.from_raw_data(raw_settings)
        raw_data["qosSettings"] = qos_settings
        return super(PortSettings, cls).process_raw_data(raw_data)
860813
private void processResourceRates()
   {
      List<Row> rows = getRows("rsrcrate", null, null);
      m_reader.processResourceRates(rows);
   }
1351300
def handle_data(self, data):
        """"""
        # Only process the data when we are in an active a tag and have an URL.
        if not self.active_url:
            return

        # The visible text can have a final slash so strip it off
        if data.strip('/') == self.active_url:
            self.entries.append(self.active_url)