def initialization(): if CHAN_BAD: bad_list = [host.object(x).guid for x in CHAN_BAD.split(",")] else: bad_list = [] logger.debug(bad_list) logger.debug(choice_dict[CHOICE]) if CHAN: carousel_list = [ host.object(x).guid for x in CHAN.split(",") if not host.object(x).guid in bad_list ] else: carousel_list = [ x[1] for x in host.objects_list(choice_dict[CHOICE]) if not x[1] in bad_list ] logger.debug(carousel_list) for x in [z[1] for z in host.objects_list("IP Device")]: if x in carousel_list: raise ValueError( host.tr("Имеется IP устройство с именем канала %s") % host.object(x).name ) logger.debug("list %s done!" % carousel_list) return {x: z for x, z in enumerate(carousel_list)}
def show_timer(self): """Loop runner. Deletes channels which time to show expired""" self.show_timer_running = True count = 0 now = int(time.time()) for channel, event_info in self._displaying_channels.items(): if event_info.get("start_to_show", 0) and (now - event_info.get("start_to_show", 0) > self.show_channel_duration): if self.no_motion_check and host.object(channel).state( "motion"): logger.debug("Motion detected on channel (%s), skip it", channel) continue logger.debug("deleting expired channel: %s", channel) try: del self._displaying_channels[channel] count += 1 except KeyError: logger.debug("can't delete _displaying_channels[%s]", channel) if not self._displaying_channels: self.show_timer_running = False self._show_channels_on_display() return if count: self._show_channels_on_display() host.timeout(1000, self.show_timer)
def get_object(cls, obj_id): """Возвращает объект Trassir, если он доступен, иначе ``None`` Args: obj_id (:obj:`str`): Guid объекта или его имя Returns: :obj:`ScriptHost.SE_Object`: Объект Trassir или ``None`` Examples: >>> obj = BaseUtils.get_object("EZJ4QnbC") >>> if obj is None: ... host.error("Object not found") ... else: ... host.message("Object name is {0.name}".format(obj)) """ if not isinstance(obj_id, (str, unicode)): raise TypeError("Expected str or unicode, got '{}'".format( type(obj_id).__name__)) obj = host.object(obj_id) try: obj.name except EnvironmentError: # Object not found obj = None return obj
def __init__(self, name=None, guid=None, parent=None): super(ScriptObject, self).__init__("Script") scr_parent = host.stats().parent() self._name = name or SCRIPT_NAME self.set_name(self._name) self._guid = guid or "{}-object".format(scr_parent.guid) self.set_guid(self._guid) self._parent = parent or host.settings("").guid self.set_parent(self._parent) self._folder = "" self._health = "OK" self._check_me = True self.set_initial_state([self._health, self._check_me]) host.object_add(self) self._obj = host.object(self._guid) self.context_menu = []
def __init__( self, alarm_template, base_template, display_number, max_channels, show_channel_duration, no_motion_check, ): self.alarm_template = alarm_template self.base_template = base_template self.display_number = display_number self.max_channels = max_channels self.show_channel_duration = show_channel_duration self.no_motion_check = no_motion_check self._gui = host.object("operatorgui_" + host.settings("").guid) self._CLEAN = "gui7(-1, '')" self._displaying_channels = OrderedDict() self.template_dropped = False self.show_timer_running = False logger.debug( "Display number is: %s, max channels is: %s", self.display_number, self.max_channels, )
def _load_object(self, tries=5): logger.debug("Loading schedule object('%s')...", self._name) for sett in host.settings("scripts").ls(): if sett.type == "Schedule" and sett["enable"] and ( sett.name == self._name or sett.guid == self._name): obj = host.object(sett.guid) logger.debug("Found local schedule %s", sett.guid) break else: logger.warning( "Local schedule not found, get random global object with name %r", self._name) obj = host.object(self._name) try: self._name = obj.name try: obj.state("color") logger.info("Schedule %s (%s) loaded success", obj.name, obj.guid) except KeyError: raise RuntimeError( "Object {obj.name} ({obj.guid}) is not schedule".format( obj=obj)) self.__obj = obj self.__prev_color = self.color if callable(self.color_change_handler): logger.info("Add handler on color changed") host.register_finalizer(self.__del__) # Call handler with timeout need to fix bug: # Restarting schedule with not Green color # calls state changes handler twice: # with Green color and current color self.__obj.activate_on_state_changes( lambda: host.timeout(1, self._state_changes)) except EnvironmentError: if tries: logger.warning("Schedule %s not found, next try after 1000ms", self._name) host.timeout(1000, lambda: self._load_object(tries - 1)) else: raise EnvironmentError( "Schedule with name {} not found".format(self._name))
def attention(self, ev): guid = ev.origin if (host.object(guid).name not in self.carousel_dict and guid in self.chan_on_template): return self.chan_on_template.append(ev.origin) self.show_chans() pass
def __init__(self, carousel_dict, hand_using, func): self.chan_on_template = [] self.gui = host.object("operatorgui_" + host.settings("").guid) self.carousel_dict = carousel_dict self.hand_using = hand_using self.func = func self.idx = 0 self.carousel_go()
def send(self, status, shot_path, alarm_messages, *args, **kwargs): """ Args: status (str): one of "saving", "error", "success", "in_queue" shot_path (List['str']): ['Shot path 1', 'Shot path 2'] alarm_messages (dict): Returns: """ self.contents = [ { "type": "html", "html": ("<!doctype html><head><meta charset='utf-8'></head><body>" "" "{message}" "" "</body></html>").format( message=alarm_messages.get('mail_message', 'No text')), }, ] if kwargs.get("channel") and self.add_video: try: full_channel = kwargs.get("channel") channel, server = full_channel.split("_") self.contents.append({ "type": "trassir_channel", "channel_guid": channel, "name": host.object(channel).name, "server_guid": server, }) except IndexError: logger.debug( "Can't get server name to make video content for alarm") if status == STATUS.success: logger.debug('try to send alarm') self.contents.append({ "type": "image", "format": "jpg", "image_base64": BaseUtils.image_to_base64(shot_path[0]), }) self.description = alarm_messages.get('mail_message', 'No text') super(FireAlarm, self).fire() elif status == STATUS.error: logger.debug('image not saved, try to send text alarm') self.description = alarm_messages.get('mail_message', 'No text') super(FireAlarm, self).fire()
def check_zones_with_objects_presence(self): """ Check long presence of an objects on the zones. Works in a loop """ if not self.presence_check: return logger.debug("simt_zones:: {}".format(self.zones_with_objects_presense)) for zone in self.zones_with_objects_presense: try: if ( host.object(zone["guid"]).state("objects_inside") != "No Objects in Zone" ): zone["timer"] += 1 if zone["timer"] > self.presence_delay: channel = zone["channel_guid"] event_type = "Object presence alarm" zone_or_border = zone["zone_guid"] tmstmp = int(time.time()) zone["timer"] = 0 logger.debug( "Object long-lasting presence alarm on channel: {}, zone: {}".format( host.object(channel).name, host.object(zone_or_border).name, ) ) alarm_messages = make_alarm_message( channel, event_type, zone_or_border, tmstmp ) if self.callback: self.callback(channel, tmstmp, event_type, alarm_messages) else: zone["timer"] = 0 except KeyError: self.zones_with_objects_presense.remove(zone) host.timeout(1000, self.check_zones_with_objects_presence)
def __init__( self, alarm_template, am_type, max_channels, display_duration=30, base_template=None, no_motion_check=False, delay_before_assign=1500, channels_for_same_cell=None, all_displays=None, ): """ Распределяет тревожные каналы по Тревожным мониторам. Максимальное количество мониторов 3. Сначала заполняется шаблон на одном мониторе, затем, по очереди заполняются шаблоны на других мониторах. Если на всех мониторах количество отображаемых каналов достигло максимального, то отправляем канал для отображения на следующий в очереди монитор. Задача класса распределять тревожные каналы равномерно по Тревожным мониторам. Args: alarm_template (str): am_type (int): 1 - show online, 2 - show archive max_channels (int): display_duration (int): base_template (str): no_motion_check (bool): channels_for_same_cell(dict|None): Every time show a channel in the same cell for it if same_cell is not empty all_displays (List(int)| None): display numbers list """ self.alarm_template = alarm_template self.am_type = am_type self._max_channels = 1 self.max_channels = max_channels self.base_template = base_template self.no_motion_check = no_motion_check # TODO: add self.display_duration = display_duration self.delay_before_assign = delay_before_assign self.channels_for_same_cell = channels_for_same_cell self.all_displays = all_displays self._monitor_by_channel = None self._associated_channels_by_monitor_number = None self.associated_channels_by_monitor_number = channels_for_same_cell self.am_objects = {} self._am_before = None self._count = 0 self._gui = host.object("operatorgui_" + host.settings("").guid) self.prepare_before_creation()
def get_channels(): channels = [] for name, guid, _, parent in sorted( host.objects_list("Channel"), key=lambda x: (x[3], x[0]) ): srv = host.object(parent[:-1]) try: name = "%s@%s" % (name, srv.name) except EnvironmentError: name = "%s@%s" % (name, parent[:-1]) channels.append((guid, name)) return channels
def deep_people_border_filter(object_from_list): """ filtering border from deep_people """ border_guid = object_from_list[1] border = host.object(border_guid) try: channel_guid, server_guid = border.associated_channel.split("_") zones_dir = host.settings("/%s/channels/%s/deep_people" % (server_guid, channel_guid)) for i in xrange(16): if zones_dir["zone%02d_guid" % i] == border_guid: return zones_dir["zone%02d_type" % i] == "border" return False except (ValueError, KeyError): return False
def __init__(self, attention_monitor, alarm_template_after, time_to_del): self.attention_monitor = attention_monitor self.operate_gui = host.object("operatorgui_" + host.settings("").guid) self.chan_on_template = [] for tmpl in host.settings("templates").ls(): if tmpl.type == "Template" and tmpl.name == alarm_template_after: alarm_template_after_content = tmpl["content"] break else: raise RuntimeError("Шаблон не найден") self.alarm_template_after = alarm_template_after self.alarm_template_after_content = alarm_template_after_content self.time_to_del = time_to_del self.time_dict = {}
def __init__( self, access_point_name, access_point_type, operation_type, delay_operations, show_message, show_message_delay, ): self.access_point_name = access_point_name self.access_point_obj = host.object(self.access_point_name) self.access_point_type = access_point_type self.operation_type = operation_type self.delay_operations = delay_operations self.show_message = show_message self.show_message_delay = show_message_delay self.ts_to_come_back = 0 self.come_back_timer_is_working = False
def get_data_from_channel(sett, server_guid): channel_info = {} for ch_number in xrange(31): if sett["channel%02d_guid" % ch_number]: try: ch_object = host.object(sett["channel%02d_guid" % ch_number]) channel_info["ch_name"] = ch_object.name channel_info["motion_detector"] = type_motion_detector.get( host.settings("/{}/channels/{}".format( server_guid, ch_object.guid))["software_md_enable"], "Unknown", ) except EnvironmentError: logger.debug( "Channel guid '%s' has no name, most likely the streams are disabled for the registrar channel", sett["channel%02d_guid" % ch_number], ) continue channel_info["codec"] = sett["channel%02d_codec" % ch_number] channel_info["audio_enabled"] = ("On" if sett["channel%02d_audio_enabled" % ch_number] else "Off") channel_info["audio_codec"] = sett["channel%02d_audio_codec" % ch_number] channel_info["main"] = ("On" if sett["channel%02d_main_enabled" % ch_number] else "Off") channel_info["main_fps"] = sett["channel%02d_fps" % ch_number] channel_info["main_gop"] = sett["channel%02d_gop" % ch_number] channel_info["main_resolution"] = sett["channel%02d_resolution" % ch_number] channel_info["sub"] = ("On" if sett["channel%02d_ext_gop" % ch_number] else "Off") channel_info["sub_fps"] = sett["channel%02d_ext_fps" % ch_number] channel_info["sub_gop"] = sett["channel%02d_ext_gop" % ch_number] channel_info["sub_resolution"] = sett["channel%02d_ext_resolution" % ch_number] logger.debug("channel info: %s", channel_info) yield channel_info else: break
def _replace_old(self): """Delete the oldest channel from the list before add new one """ oldest_channel, event_info = next( self._displaying_channels.iteritems()) min_time = event_info.get("start_to_show") for channel, event_info in self._displaying_channels.iteritems(): if self.no_motion_check and host.object(channel).state("motion"): logger.debug("Motion detected on channel (%s), skip it", channel) continue if event_info.get("start_to_show") < min_time: min_time = event_info.get("start_to_show") oldest_channel = channel logger.debug("deleting old channel: %s", oldest_channel) try: del self._displaying_channels[oldest_channel] except KeyError: logger.debug("can't delete _displaying_channels[%s]", oldest_channel)
def __init__(self, name=None, guid=None, parent="", folder="", associated_channel="", **kwargs): self.__obj = None self.classname = self.classname or self.__class__.__name__ self._folder = "" self._name = name or script.name self._guid = guid or "{}-object".format(script.guid) self._parent = parent self.__register_class_if_not_exists() super(BaseObject, self).__init__(self.classname) initial_state = getattr(self, "initial_state", None) if initial_state is None: initial_state = [] if self.states: for state in self.states: initial_state.append(state.values[0].value) self.set_name(self._name) self.set_guid(self._guid) self.set_parent(self._parent) self.set_initial_state(initial_state) if associated_channel: self.set_associated_channel(str(associated_channel)) host.object_add(self) self.__obj = host.object(self._guid) if folder: self.folder = folder self.context_menu = []
def __init__( self, alarm_template, am_type, max_channels, display_duration=30, base_template=None, no_motion_check=False, ): """ Распределяет тревожные каналы по Тревожным мониторам. Максимальное количество мониторов 3. Сначала заполняется шаблон на одном мониторе, затем, по очереди заполняются шаблоны на других мониторах. Если на всех мониторах количество отображаемых каналов достигло максимального, то отправляем канал для отображения на следующий в очереди монитор. Задача класса распределять тревожные каналы равномерно по Тревожным мониторам. Args: alarm_template (str): am_type (int): 1 - show online, 2 - show archive max_channels (int): display_duration (int): base_template (str): no_motion_check (bool): am_type (str): host.tr("Отобразить канал") | host.tr("Открыть момент в архиве") """ self.alarm_template = alarm_template self.am_type = am_type self._max_channels = 1 self.max_channels = max_channels self.base_template = base_template self.no_motion_check = no_motion_check # TODO: add self.display_duration = display_duration self.am_objects = None self._am_before = None self._count = 0 self._gui = host.object("operatorgui_" + host.settings("").guid)
def __init__( self, access_point_name, access_point_type, operation_type, delay_operations, ): """ Args: access_point_name (str): access_point_type (str): "Sigur" or "Orion" operation_type (str): host.tr("открыть дверь") or host.tr("закрыть дверь") delay_operations (int): """ self.access_point_name = access_point_name self.access_point_obj = host.object(self.access_point_name) self.access_point_type = access_point_type self.operation_type = operation_type self.delay_operations = delay_operations self.ts_to_come_back = 0 self.come_back_timer_is_working = False
def __init__( self, access_point_name, access_point_type, operation_type, delay_operations, ): """ Args: access_point_name (str): access_point_type (str):"Sigur" or "Orion" operation_type (str): "open the door" or "close_th_door" delay_operations (int): """ self.access_point_name = access_point_name self.access_point_obj = host.object(self.access_point_name) self.access_point_type = access_point_type self.operation_type = operation_type self.delay_operations = delay_operations self.ts_to_come_back = 0 self.come_back_timer_is_working = False
def get_outputs(names=None): """ Args: names (set): Returns: """ _gpios = [] for x in host.objects_list("GPIO Output"): if names and x[0] not in names: continue obj = host.object(x[1]) if hasattr(obj, "set_output_high") and hasattr(obj, "set_output_low"): try: name = obj.name guid = obj.guid except EnvironmentError: raise EnvironmentError( "Can't get access to %s, check script user rights" % x[0]) else: _gpios.append(OutputObj(obj, name, guid, x[3])) return _gpios
host.activate_on_shortcut( OUTPUT_MAN_ACTIV, output_reactions.manual_activation_of_outputs) # ------------------------------------------------------- # Operations with physical system control ("СКУД") # ------------------------------------------------------- if ACS_ENBL: from reactions import AccessControlOperations assert ACS_TYPE in ["Sigur", "Orion"], "ACS_TYPE must be Sigur or Orion" assert ACS_DOOR, host.tr("Необходимо указать название точки доступа") acs_door_obj = host.object(ACS_DOOR) if ACS_TYPE == "Sigur": assert hasattr( acs_door_obj, "workmode_alwaysopen" ), "{} не является точкой доступа Sigur. Только одно имя м.б. указано".format( ACS_DOOR) if ACS_TYPE == "Orion": assert hasattr( acs_door_obj, "grant_access_once" ), "{} не является точкой доступа Orion. Только одно имя м.б. указано".format( ACS_DOOR) assert ACS_LOGIC in [ host.tr("открыть дверь"), host.tr("закрыть дверь"),
<id>SERVER_GUID</id> <type>server</type> <name>Server</name> <value></value> </parameter> <parameter> <id>MODULE_LINK</id> <type>string</type> <name>Module</name> <value>FaceWorkTime</value> </parameter> </parameters> """ GLOBALS = globals() SERVER_GUID = GLOBALS.get("SERVER_GUID", "") MODULE_LINK = GLOBALS.get("MODULE_LINK", "FaceWorkTime") assert SERVER_GUID, "Server not selected" import host gui = host.object('operatorgui_%s' % host.settings('').guid) source = "%s_%s" % (host.stats().parent().guid, MODULE_LINK) link = "http://exthttp/{server_guid}/{module_link}".format( server_guid=SERVER_GUID, module_link=MODULE_LINK ) host.activate_on_shortcut("F1", lambda: gui.show_html(source, link))
def __init__(self, monitor_to_show_archive_from_popup): self.monitor_to_show_archive_from_popup = monitor_to_show_archive_from_popup self._gui = host.object("operatorgui_" + host.settings('').guid)
import time import random from itertools import cycle from __builtin__ import object import host import helpers helpers.set_script_name() logger = helpers.init_logger(APP_NAME, debug=DEBUG) from schedule import ScheduleObject assert CHANNEL, "Channel not selected" channel = host.object(CHANNEL.split("_")[0]) try: channel.state("signal") except EnvironmentError: raise EnvironmentError("Channel %s not found or disabled" % CHANNEL) def __get_random_timout(): return random.randint(PATROL_PRESET_TIMEOUT, PATROL_PRESET_TIMEOUT_RAND_MAX) if PATROL_PRESET_TIMEOUT == PATROL_PRESET_TIMEOUT_RAND_MAX: def get_timeout(): return PATROL_PRESET_TIMEOUT
except KeyError: raise RuntimeError( "Не доступны настройки севрера, проверьте настройки дсотупа пользователя Script" ) for route in media_route.split(":"): if route.startswith("ip="): module_host = route[3:] break else: raise RuntimeError( "IP сервера %s не найден, возможно вы подключены к серверу через облако<br>" "media_route: %s" % (server.name, media_route)) try: gui = host.object("operatorgui_%s" % local_server.guid) host.message("%s laoded success" % gui.name) except EnvironmentError: raise EnvironmentError("OpertatorGUI is not available") def show_minibrowser(): gui.show( "minibrowser(0,htmltab(,http://{host}:{port}))".format( host=module_host, port=PORT), MONITOR, ) host.activate_on_shortcut(USER_FUNC, show_minibrowser)
def get_object_name(guid): try: return host.object(guid).name except EnvironmentError: return guid
def __init__(self, monitor_to_show_archive_from_popup, display_duration): self.monitor_to_show_archive_from_popup = monitor_to_show_archive_from_popup self.display_duration = display_duration self._gui = host.object("operatorgui_" + host.settings('').guid)