Report a wet state.
357794
def _wet_message_received(self, msg):
        """"""
        for callback in self._dry_wet_callbacks:
            callback(LeakSensorState.WET)
        self._update_subscribers(0x13)
610120
def live_weather(self, live_weather):
        """"""
        summary = live_weather['currently']['summary']
        self.summary(summary)
        click.echo()
825235
def _check_flood_protection(self, component, action, clientuuid):
        """"""

        if clientuuid not in self._flood_counter:
            self._flood_counter[clientuuid] = 0

        self._flood_counter[clientuuid] += 1

        if self._flood_counter[clientuuid] > 100:
            packet = {
                'component': 'hfos.ui.clientmanager',
                'action': 'Flooding',
                'data': True
            }
            self.fireEvent(send(clientuuid, packet))
            self.log('Flooding from', clientuuid)
            return True
93280
@Override
    public void report() {
        for (Map.Entry<FQMethod, MethodInfo> entry : Statistics.getStatistics()) {
            MethodInfo mi = entry.getValue();

            int declaredAccess = mi.getDeclaredAccess();
            if ((declaredAccess & Const.ACC_PRIVATE) != 0) {
                continue;
            }

            if (mi.wasCalledPublicly() || !mi.wasCalled()) {
                continue;
            }

            FQMethod key = entry.getKey();

            String methodName = key.getMethodName();
            if (isGetterSetter(methodName, key.getSignature())) {
                continue;
            }

            if (isOverlyPermissive(declaredAccess) && !isConstrainedByInterface(key)) {
                try {
                    String clsName = key.getClassName();
                    if (!isDerived(Repository.lookupClass(clsName), key)) {

                        BugInstance bi = new BugInstance(this, BugType.OPM_OVERLY_PERMISSIVE_METHOD.name(), LOW_PRIORITY).addClass(clsName).addMethod(clsName,
                                key.getMethodName(), key.getSignature(), (declaredAccess & Const.ACC_STATIC) != 0);

                        String descr = String.format("- Method declared %s but could be declared %s", getDeclaredAccessValue(declaredAccess),
                                getRequiredAccessValue(mi));
                        bi.addString(descr);

                        bugReporter.reportBug(bi);
                    }
                } catch (ClassNotFoundException cnfe) {
                    bugReporter.reportMissingClass(cnfe);
                }
            }
        }
    }
1239434
def dump_stats(self):
        """"""
        log.info('Dumping statistics:')
        stats = []
        stats.append(
            'client-request-errors {}'.format(self._client_request_errors))
        stats.append('denied-allocations {}'.format(self._denied_allocations))
        stats.append('num-ports-managed {}'.format(self._port_pool.num_ports()))
        stats.append('num-ports-checked-for-last-request {}'.format(
            self._port_pool.ports_checked_for_last_request))
        stats.append('total-allocations {}'.format(self._total_allocations))
        for stat in stats:
            log.info(stat)
129544
def report(self, request: 'Request'=None, state: Text=None):
        
        self._make_context(request, state)
        self.client.captureException()
        self._clear_context()
1369386
def report(self, stream):
        """"""
        if not self.enabled:
            return

        # if multiprocessing plugin enabled - get items from results queue
        if self.multiprocessing_enabled:
            for i in range(_results_queue.qsize()):
                try:
                    k, v, s = _results_queue.get(False)
                    self._timed_tests[k] = {
                        'time': v,
                        'status': s,
                    }
                except Queue.Empty:
                    pass

        d = sorted(self._timed_tests.items(), key=lambda item: item[1]['time'], reverse=True)

        if self.json_file:
            dict_type = OrderedDict if self.timer_top_n else dict
            with open(self.json_file, 'w') as f:
                json.dump({'tests': dict_type((k, v) for k, v in d)}, f)

        total_time = sum([vv['time'] for kk, vv in d])

        for i, (test, time_and_status) in enumerate(d):
            time_taken = time_and_status['time']
            status = time_and_status['status']
            if i < self.timer_top_n or self.timer_top_n == -1:
                color = self._get_result_color(time_taken)
                percent = 0 if total_time == 0 else time_taken / total_time * 100
                line = self._format_report_line(
                    test=test,
                    time_taken=time_taken,
                    color=color,
                    status=status,
                    percent=percent,
                )
                _filter = self._COLOR_TO_FILTER.get(color)
                if self.timer_filter is None or _filter is None or _filter in self.timer_filter:
                    stream.writeln(line)
702187
def report_progress(self):
        """"""
        percent = self.calc_percent()
        total = format_bytes(self._total)

        speed = self.calc_speed()
        total_speed_report = '{0} at {1}'.format(total, speed)

        report = '\r{0: <56} {1: >30}'.format(percent, total_speed_report)

        if self._finished:
            print(report)
        else:
            print(report, end="")
        sys.stdout.flush()
1279913
def flush(self):
    """"""
    self.acquire()
    try:
      self.stream.flush()
    except (EnvironmentError, ValueError):
      # A ValueError is thrown if we try to flush a closed file.
      pass
    finally:
      self.release()
230643
def publish_state(self, state):
        
        message = json.dumps({'state': {'reported': state}})
        self.client.publish(self.topic, message)
        self._state = state
1263475
public void printDStreamState()
	{
		System.out.println("State of D-Stream algorithm");
		System.out.println("Time Gap: "+this.gap+", Decay Factor: "+this.decayFactor);
		System.out.println("C_m: "+this.cm+", C_l: "+this.cl);
		System.out.println("D_m: "+this.dm+", D_l: "+this.dl);
		System.out.println("Beta: "+this.beta);
	}
967559
def report_progress(stream=None):
    
    if stream is None:
        stream = sys.stderr
    for reporter in _reporters:
        reporter(stream)
440059
def status(self, status_in):
        """"""
        if isinstance(status_in, PIDStatus):
            status_in = [status_in, ]
        return self.filter(
            self._filtered_pid_class.status.in_(status_in)
        )
883436
def report_again(self, current_status):
        
        # calculate sleep interval based on current status and configured interval
        _m = {'playing': 1, 'paused': 2, 'stopped': 5}[current_status['state']]
        interval = (self.config['status_update_interval'] * _m) / 1000.0
        # sleep for computed interval and kickoff another webhook
        time.sleep(interval)
        self.in_future.report_status()
1010425
def on_status(self, status):
        """"""
        self.out.write(json.dumps(status))
        self.out.write(os.linesep)

        self.received += 1
        return not self.terminate
8724
def report_status(self):
        
        current_status = {
            'current_track': self.core.playback.current_track.get(),
            'state': self.core.playback.state.get(),
            'time_position': self.core.playback.time_position.get(),
        }
        send_webhook(self.config, {'status_report': current_status})
        self.report_again(current_status)
943208
def report_status(self, status):
        """"""
        status = Instance('', TaskStatus).validate(None, status)
        print(r'{taskname} | {percent:>3}% | {message}'.format(
            taskname=self.__class__.__name__,
            percent=int(round(100*status.progress)),
            message=status.message if status.message else '',
        ))