Indicate if this Monitor is currently recording.
541698
def is_recording(self) -> Optional[bool]:
        """"""
        status_response = self._client.get_state(
            'api/monitors/alarm/id:{}/command:status.json'.format(
                self._monitor_id
            )
        )

        if not status_response:
            _LOGGER.warning('Could not get status for monitor {}'.format(
                self._monitor_id
            ))
            return None

        status = status_response.get('status')
        # ZoneMinder API returns an empty string to indicate that this monitor
        # cannot record right now
        if status == '':
            return False
        return int(status) == STATE_ALARM
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)
695325
private boolean hasReceivedHeartbeat() {
        long currentTimeMillis = System.currentTimeMillis();
        boolean result = lastTimeMessageReceived + heartbeatTimeoutMs >= currentTimeMillis;

        if (!result)
            Jvm.warn().on(getClass(), Integer.toHexString(hashCode()) + " missed heartbeat, lastTimeMessageReceived=" + lastTimeMessageReceived
                    + ", currentTimeMillis=" + currentTimeMillis);
        return result;
    }
1305645
def is_connected(self, use_cached=True):
        """"""
        device_json = self.get_device_json(use_cached)
        return int(device_json.get("dpConnectionStatus")) > 0
231004
def status(self, return_led=0):
        """"""
        status = self.hub.get_device_status(self.device_id, return_led)
        self.logger.info("Dimmer %s status: %s", self.device_id,
                         pprint.pformat(status))
        return status
7277
def monitor(self, target):
        
        if 'monitor-notify' in self._capabilities and not self.is_monitoring(target):
            yield from self.rawmsg('MONITOR', '+', target)
            self._monitoring.add(target)
            return True
        else:
            return False
964917
def recorded(self):
        """"""
        if self.tune and self.tune.get('@src'):
            return True if self.tune.get('@src').startswith('mbr') else False
        else:
            raise PyMediaroomError("No information in <node> about @src")
884325
def inspect_current_object(self):
        """"""
        editor = self.get_current_editor()
        editor.sig_display_signature.connect(self.display_signature_help)
        line, col = editor.get_cursor_line_column()
        editor.request_hover(line, col)
105308
def is_running(self):
        
        return self._process.state() in [self._process.Running, self._process.Starting]
259976
def isChanged(self, min_changed_pixels, screen_state):
        
        r = self.clipRegionToScreen()
        current_state = r.getBitmap()
        diff = numpy.subtract(current_state, screen_state)
        return (numpy.count_nonzero(diff) >= min_changed_pixels)
695131
def monitor(seconds_frozen, test_interval):
    
    current_thread = threading.current_thread()
    hanging_threads = set()
    old_threads = {}  # Threads found on previous iteration.

    while not current_thread.is_stopped():
        new_threads = get_current_frames()

        # Report died threads.
        for thread_id in old_threads.keys():
            if thread_id not in new_threads and thread_id in hanging_threads:
                log_died_thread(thread_id)

        # Process live threads.
        time.sleep(test_interval/1000.)
        now = time.time()
        then = now - seconds_frozen
        for thread_id, thread_data in new_threads.items():
            # Don't report the monitor thread.
            if thread_id == current_thread.ident:
                continue
            frame = thread_data['frame']
            # If thread is new or it's stack is changed then update time.
            if (thread_id not in old_threads or
                    frame != old_threads[thread_id]['frame']):
                thread_data['time'] = now
                # If the thread was hanging then report awaked thread.
                if thread_id in hanging_threads:
                    hanging_threads.remove(thread_id)
                    log_awaked_thread(thread_id)
            else:
                # If stack is not changed then keep old time.
                last_change_time = old_threads[thread_id]['time']
                thread_data['time'] = last_change_time
                # Check if this is a new hanging thread.
                if (thread_id not in hanging_threads and
                        last_change_time < then):
                    # Gotcha!
                    hanging_threads.add(thread_id)
                    # Report the hanged thread.
                    log_hanged_thread(thread_id, frame)
        old_threads = new_threads
1031065
def monitor(i):
    """"""
    count = 0
    for x in i:
        count+=1
        if count % 10000 == 0:
            logger.info("%d records so far, current record is %s",
                count, x["idx"])
        yield x
621869
def is_running(self, family: str) -> bool:
        """"""
        latest_analysis = self.analyses(family=family).first()
        return latest_analysis and latest_analysis.status in TEMP_STATUSES
1033785
def is_running(self):
        
        self.__update_status()
        return self.status == Status.UP or self.status == Status.DECOMMISSIONED
996020
function (port, parent_port) {

	// check if the port wasn't reported
	if (l_ports.hasOwnProperty(port) === false) {
		
		LOG.warn('recording used port [' + port + ']...', 'SR.Monitor');	
		l_ports[port] = parent_port || port;
	}
}
1139213
def has_color(self):
        """"""
        if (self.get_value(CONST.STATUSES_KEY).get('color_mode')
                == str(CONST.COLOR_MODE_ON)):
            return True
        return False
601256
private void doConnectionMonitoring(long startingInstant, String monitorSuffix) {
    InApplicationMonitor.getInstance()
    .addTimerMeasurement(this.monitorBaseName + monitorSuffix,
      System.currentTimeMillis() - startingInstant);

    int noCurrentConnections = this.currentConnections.incrementAndGet();
    if (noCurrentConnections > this.maxConnections.get()) {
      this.maxConnections.set(noCurrentConnections);
    }
  }