def set_folder(self, tries=3, check_access=True):
"""Set folder to trassir settings
Args:
tries (int, optional): Numbers of tris to set folder. Default 3.
check_access (bool, optional): Check write access if True. Default True.
"""
host.stats()["run_count"] = tries
try:
new_folder = self.folder.mount()
if check_access:
self._check_path(new_folder)
host.stats()["run_count"] = 0
except Exception as err: # pylint: disable=W0703
if tries:
logger.warning("%s attempt failed with error: %s", tries, err)
host.timeout(
1000,
lambda: self.set_folder(
tries=(tries - 1), check_access=check_access
),
)
else:
logger.error("%s attempt failed with error: %s", tries, err)
raise_from_thread(err)
return
self._set_screenshots_folder(new_folder)
if self.folder.rollback is True:
host.register_finalizer(self.rollback)
def video_export(self, dt_start, dt_end):
paths = []
self.get_full_channels_guid()
for (
key,
value,
) in (self.full_channels_guid.iteritems()
): # "ChannelName": "ChannelGuid_ServerGuid"
host.stats()["run_count"] += 1
folder = self.__get_folder(key, dt_start)
file_path = os.path.join(self.default_shots_folder, folder)
task_guid, path = self.ve.export(
value,
dt_start,
dt_end,
prefer_substream=self.prefer_substream,
file_path=file_path,
options={"is_hardware": self.is_hardware},
)
self.working_tasks[task_guid] = {
"path": path,
"folder": folder,
}
logger.debug("%s: task created (%s)", task_guid, path)
paths.append(path)
return paths
def make_reactions(self, channel_obj, ts, alarm_messages, *args, **kwargs):
"""
Args:
channel_obj (:obj: 'Channel'):
ts (int): (Trassir 16 digit timestamp)
alarm_messages:
*args:
**kwargs:
Returns:
"""
if self.schedule is not None and self.schedule.color != self.WORKING_COLOR:
logger.debug(
"Event don't call reaction: schedule color %s, to react must be: %s",
self.schedule.color,
self.WORKING_COLOR,
)
return
host.stats()["run_count"] += 1
for e_name, executor in self.executors.iteritems():
logger.debug("Start make reaction: %s", e_name)
executor.execute(channel_obj, ts, alarm_messages, *args, **kwargs)
def start():
res = commands.getoutput(
"cat /sys/class/thermal/thermal_zone0/temp | cut -c 1-2")
dt_str = datetime.now().strftime("%d.%m.%Y %H:%M:%S")
# raise ValueError(res)
log.write(res + "°C")
host.stats()["run_count"] += 1
host.timeout(1000 * DELAY, start)
def upload_data(self):
f = os.walk(unicode(self.source_path))
while True:
try:
full_path, all_folders, all_files = next(f)
logger.debug("full path: %s", full_path)
except StopIteration:
logger.debug("work done")
host.stats()["run_count"] += 1
break
relative_path = self._relative_path(full_path)
folder_obj = self._folder_obj(relative_path)
for file_name in all_files:
if not file_name.endswith(".jpg"):
continue
person_name, person_gender = self._split_file_name(file_name)
person_name = unicode(person_name)
full_img_path = os.path.join(full_path, file_name)
if folder_obj.persons:
logger.debug(
"person name: %s, person in all persons: %s, all persons: %s",
person_name,
person_name in folder_obj.persons,
folder_obj.persons,
)
if folder_obj.persons and person_name in folder_obj.persons:
logger.debug(
"person with name %s and guid %s found on server in folder: %s, going to update image",
person_name,
folder_obj.persons.get(person_name),
relative_path if relative_path else "persons",
)
if self.update_same_person:
self._update_person(
folder_obj.persons.get(person_name),
folder_obj.guid,
full_img_path,
)
del folder_obj.persons[person_name]
else:
logger.debug("going to create person with name: %s",
person_name)
person_guid = self._create_person(full_img_path,
person_name,
folder_obj.guid,
person_gender)
if person_guid:
logger.debug("Person created with guid: %s",
person_guid)
host.service_fr_person_enroll(person_guid, 10)
time.sleep(0.1)
if folder_obj.persons and self.delete_persons:
self._delete_person(folder_obj)
def ftp_callback(self, task_guid, state):
logger.debug("%s: ftp %s", task_guid, state)
if state in (ftp_status.success, ftp_status.error):
task = self.working_tasks.pop(task_guid, None)
host.stats()["run_count"] -= 1
if task and self.remove:
try:
os.remove(task["path"])
except:
logger.exception("Unhandled exception while removing file", task)
def get_data_from_server():
data_from_server = {}
for srv in host.settings("/").ls():
if srv.type == "RemoteServer" or srv.type == "LocalServer":
logger.debug("Server: name %s, guid %s", srv.name, srv.guid)
data_from_server["server_name"] = srv.name
data_from_server["ip_device_info"] = get_data_from_ip_device(
srv.guid)
host.stats()["run_count"] += 1
yield data_from_server
def ftp_callback(task_guid, state):
write_log("%s: ftp %s" % (task_guid, state), debug=DEBUG)
if state in (ftp_status.success, ftp_status.error):
task = WORKING_TASKS.pop(task_guid, None)
host.stats()["run_count"] -= 1
if task and state == ftp_status.success:
if DELETE_BACKUP:
remove_backup(_win_encode_path(task))
elif state == ftp_status.error:
WORKING_TASKS.pop(task_guid, None)
write_log("Can't send file %s" % task_guid, debug=DEBUG)
def ftp_callback(self, task_guid, state):
logger.debug("%s: ftp %s", task_guid, state)
if state in (ftp_status.success, ftp_status.error):
task = self.working_tasks.pop(task_guid, None)
host.stats()["run_count"] -= 1
if task and self.remove_file:
try:
os.remove(_win_encode_path(task["path"]))
logger.debug("remove file %s", task["path"])
except:
logger.exception("Unhandled exception while removing file",
task)
if not host.stats()["run_count"] and self.delete_empty_folders:
self._remove_all_empty_folders()
def _loop_timer(self):
now = time.time()
for server_guid, down_time in self.disconnected_servers.items():
if now - down_time >= self.delay_before_start:
logger.debug(
"time to enable reversed devices for server %s",
obj_storage.servers.get(server_guid),
)
del self.disconnected_servers[server_guid]
self._enable_reserved_devices(server_guid)
host.stats()["run_count"] += 1
if self.disconnected_servers:
host.timeout(1000, self._loop_timer)
else:
self._launch_running = False
def create_module(guid,
name=None,
lang=None,
icon_path=None,
check_rights=None):
name = name or guid.title()
lang = lang or host.stats().parent()["language"] or host.settings(
"system_wide_options")["i18n_language"]
tmod = host.TrassirModule(guid)
tmod.set_name(name)
tmod.set_lang(lang)
tmod.set_icon_data(_get_icon(icon_path))
def _mod_check_rights(userid, username):
return User(userid, cog_guid=guid).has_view_rights
tmod.set_check_rights(check_rights or _mod_check_rights)
tmod.set_url(guid)
host.trassir_module_add(tmod)
host.cog_create_or_update(guid, name, None)
tmod.name = name
tmod.guid = guid
tmod.name = name
tmod.lang = lang
return tmod
def set_script_name(name):
_scr_default_names = (
"Yeni skript",
"Unnamed Script",
"უსახელო სკრიპტი",
"Жаңа скрипт",
"Script nou",
"Новый скрипт",
"Yeni skript dosyası",
"Новий скрипт",
"未命名脚本",
)
if host.stats().parent().name in _scr_default_names:
host.stats().parent()["name"] = name # pylint: disable=E1137
return True
return False
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 event_handler(ev):
if config.borders.is_working_border(ev.origin):
with lock:
if ev.type in EVENTS_INCREASE:
config.peoples_current.value += 1
else:
config.peoples_current.value -= 1
host.stats()["run_count"] = config.peoples_current.value
def collect_data(self):
f = self._get_folders(host.settings("persons/"), "persons")
folder_guid = None
while True:
try:
folder_guid, path = f.next()
except StopIteration:
logger.debug("folder guid on stop iteration is %s", folder_guid)
host.stats()["run_count"] += 1
break
search_filter = {"filter": {"folder_guids": [folder_guid]}}
full_path = self._make_path_name(path)
time_before = time.time()
new_persons = host.service_get_persons(search_filter, 3)
for record in new_persons.get("records", []):
person_name = unicode(record.get("name"))
gender = unicode(record.get("gender"))
person_guid = record.get("guid")
logger.debug("person name: %s", person_name)
if not person_name:
logger.warning("person name not found for person guid: %s")
person_name = unicode(person_guid)
imgs = person_image(person_guid)
if not imgs:
logger.debug("no pi")
continue
for count, img in enumerate(imgs, 1):
if count > 1:
file_name = u"{name}_{gender}_{count}.jpg".format(
name=person_name, gender=gender, count=count
)
else:
file_name = u"{name}_{gender}.jpg".format(
name=person_name, gender=gender
)
image_full_path = os.path.join(full_path, file_name)
with open(image_full_path, "wb") as of:
of.write(img)
logger.debug(
"download time for path: %s is: %s", path, time.time() - time_before
)
def save_shots(self, channels=None, dt=None):
channels = channels or self.channel_guids
paths = []
for channel in channels:
host.stats()["run_count"] += 1
folder = self.__get_folder(channel, dt=dt)
file_path = os.path.join(self.default_shots_folder, folder)
task_guid, path = self.ss.save(
channel.full_guid, dt=dt, file_path=file_path, figures=FIGURES
)
self.working_tasks[task_guid] = {
"path": path,
"folder": folder,
}
logger.debug("%s: task created (%s)", task_guid, path)
paths.append(path)
return paths
def push_backup(backup_path):
if backup_path:
if not mail and not ftp:
return
if mail:
mail.send(
EMAIL_SUBSCRIBERS,
attachments=[backup_path],
subject="{name} -> AutoBackup Universal".format(
name=SETTINGS_NAME),
)
if ftp:
task_guid = host.random_guid()
WORKING_TASKS[task_guid] = backup_path
host.stats()["run_count"] += 1
ftp.send(backup_path, task_guid=task_guid)
if DELETE_BACKUP and not ftp:
remove_backup(_win_encode_path(backup_path))
def set_script_name():
if SCRIPT_NAME in DEFAULT_SCRIPT_NAMES:
doc = getattr(main_module, "__doc__", None) or ""
title = re.search(r"<title>(.+)</title>", doc)
if title:
version = re.search(r"<version>(.+)</version>", doc)
host.stats().parent()["name"] = "{title} v{version}".format(
title=title.group(1),
version=version.group(1) if version else "?.?.?")
def __init__(self, filename=None):
self.__report_dir = host.settings('system_wide_options')[
'screenshots_folder'] # os.getcwd()
self.__filename = filename if filename else host.stats().parent(
)["name"]
self.__table_header = "No name"
self.__col_headers = []
self.__rows = self.__load_data()
self.__cur_date = datetime.today().strftime("%Y%m%d")
self.__save_pkl = True
def get_script_name(cls):
"""Возвращает имя текущего скрипта
Returns:
:obj:`str`: Имя скрипта
Examples:
>>> BaseUtils.get_script_name()
'Новый скрипт'
"""
return host.stats().parent()["name"] or __name__
def save_shot_callback(self, task_guid, state):
logger.debug("%s: shot %s", task_guid, state)
if state == shot_status.success:
task = self.working_tasks.get(task_guid, None)
if task:
if self.ftp:
try:
if self.ftp_add_relative_path:
remote_dir = task["folder"]
else:
remote_dir = None
self.ftp.send(
task["path"],
remote_dir=remote_dir,
task_guid=task_guid,
callback=self.ftp_callback,
)
except IOError:
logger.exception("Could not send file %s", task["path"])
elif self.email:
self.shots_path_for_send_email.append(task["path"])
self.working_tasks.pop(task_guid, None)
host.stats()["run_count"] -= 1
else:
self.working_tasks.pop(task_guid, None)
host.stats()["run_count"] -= 1
elif state == shot_status.error:
self.working_tasks.pop(task_guid, None)
host.stats()["run_count"] -= 1
logger.warning("Can't save shot %s" % task_guid)
if self.email and not self.working_tasks and self.shots_path_for_send_email:
logger.debug("Time to send email")
self.sending_email()
def on_health_changes():
if host.stats()["run_count"] > 1000:
host.stats()["run_count"] = 0
else:
host.stats()["run_count"] += 1
state = "\n".join(str(ind()) for ind in indicators) + "\n"
if __health["custom_indicators"]:
state += "\n%s" % ";".join(
res.group(2) for res in CUSTOM_INDICATORS_REGEXP.finditer(
__health["custom_indicators"]))
next(
setCmd(
SnmpEngine(),
CommunityData("private"),
UdpTransportTarget(("localhost", PORT)),
ContextData(),
ObjectType(ObjectIdentity(".1.3.6.1.4.1.3333.0"),
p_mod.OctetString(state)),
))
def make_reactions(self, channel, tmstmp, alarm_messages, *args, **kwargs):
"""
Args:
channel (str):
tmstmp (long): Trassir 16 digit timestamp
alarm_messages (dict):
*args:
**kwargs:
Returns:
"""
if self.schedule is not None and self.schedule.color != self.WORKING_COLOR:
logger.debug(
"Event don't call reaction: schedule color %s, to react must be: %s",
self.schedule.color,
self.WORKING_COLOR,
)
return
if self.input_filter_obj:
try:
current_state = self.input_filter_obj.state("gpio_input_level")
if self.input_state_to_react not in current_state:
logger.debug(
"Current state of input is: %s, to react must be %s",
current_state, self.input_state_to_react)
return
except EnvironmentError:
logger.warning(
"Can't get state for input to filter reaction work")
host.stats()["run_count"] += 1
for e_name, executor in self.executors.iteritems():
logger.debug("Start make reaction: %s", e_name)
executor.execute(channel, tmstmp, alarm_messages, *args, **kwargs)
def catch_event(self, ev):
sensor = ev.origin
if sensor in self.temp_dict:
if self.temp_dict[sensor] >= datetime.now() - timedelta(
seconds=self.stop_sensor_time):
return
logger.debug(sensor)
logger.debug(self.temp_dict)
for sens in self.temp_dict.copy():
if self.temp_dict[sens] <= datetime.now() - timedelta(
seconds=self.stop_sensor_time):
del self.temp_dict[sens]
alarm_list = self.orion_assotiation.get(sensor)
logger.debug("%s сработал для каналов %s" % (sensor, alarm_list))
if alarm_list:
obj.fire_event_v2("Association Orion",
data=json.dumps({
"associated_channel": alarm_list,
"ev_type": ev.type
}))
self.alarm_obj.attention(alarm_list)
self.temp_dict[sensor] = datetime.now()
host.stats()["run_count"] += 1
def init_logger(name, debug=False, duplicate_filter=False):
script_ = host.stats().parent()
name = "{name}_({guid})".format(name=name.replace(" ", "_"),
guid=script_.guid)
logger = logging.getLogger(name)
logger.filepath = None
for handler_ in logger.handlers[:]:
handler_.close()
logger.removeHandler(handler_)
logger.setLevel("DEBUG")
host_handler = HostLogHandler()
host_handler.setLevel(logging.DEBUG if debug else logging.INFO)
host_formatter = logging.Formatter(
"%(name)s [%(levelname)-8s] %(lineno)-4s <%(funcName)s> - %(message)s")
host_handler.setFormatter(host_formatter)
logger.addHandler(host_handler)
popup_handler = PopupHandler()
popup_handler.setLevel(logging.INFO if debug else logging.WARNING)
popup_formatter = logging.Formatter(
fmt="<b>[%(levelname)s]</b> Line: %(lineno)s<br><i>%(message).630s</i>"
)
popup_handler.setFormatter(popup_formatter)
logger.addHandler(popup_handler)
if debug:
fmt = "%(asctime)s [%(levelname)-8s] %(lineno)-4s <%(funcName)s> - %(message)s"
file_handler = MyFileHandler("%s.log" % name)
file_handler.setLevel(logging.DEBUG)
file_formatter = logging.Formatter(fmt, datefmt="%Y-%m-%d %H:%M:%S")
if duplicate_filter:
fmt = "%(duplicates)s" + fmt
file_formatter = logging.Formatter(fmt,
datefmt="%Y-%m-%d %H:%M:%S")
file_handler.addFilter(DuplicateFilter())
file_handler.setFormatter(file_formatter)
logger.addHandler(file_handler)
logger.filepath = file_handler.filepath
finalizers.append(lambda l=logger: __check_script_error(l))
logger.info("Starting script %s (%s), helpers v%s", script_.name,
script_.guid, __version__)
logger.debug("Script parameters\n%s", script_["parameters"])
return logger
def schedule_change_handler(self, schedule):
if schedule.color == "Red":
uptime = get_uptime_sec()
if uptime > self.startup_delay:
logger.debug("Time to push restart command -> %s",
self.restart_type)
if self.restart_type == "Reset monitor settings":
if os.path.isfile(self.monitor_settings_file):
os.remove(self.monitor_settings_file)
else:
raise RuntimeError("%s file not found" %
self.monitor_settings_file)
host.stats()["run_count"] = self.exit_codes[self.restart_type]
sys.exit(self.exit_codes[self.restart_type])
else:
logger.debug("Ignore restart event")
def create_module(guid, name=None, lang=None, icon_path=None, check_rights=None, allow_multiple=False, idx=0):
name = name or guid.title()
lang = lang or host.stats().parent()["language"] or host.settings("system_wide_options")["i18n_language"]
if idx:
name_ = "%s (%s)" % (name, idx)
guid_ = "%s%s" % (guid, idx)
else:
name_ = name
guid_ = guid
tmod = host.TrassirModule(guid_)
tmod.set_name(name_)
tmod.set_lang(lang)
tmod.set_icon_data(_get_icon(icon_path))
def _mod_check_rights(userid, username):
return User(userid, cog_guid=guid_).has_view_rights
tmod.set_check_rights(check_rights or _mod_check_rights)
tmod.set_url(guid_)
try:
host.trassir_module_add(tmod)
except RuntimeError as err:
if allow_multiple is True:
return create_module(
guid,
name=name,
lang=lang,
icon_path=icon_path,
check_rights=check_rights,
allow_multiple=allow_multiple,
idx=idx+1
)
raise err
host.cog_create_or_update(guid_, name, None)
tmod.name = name_
tmod.guid = guid_
tmod.lang = lang
tmod.allow_multiple = allow_multiple
return tmod
def init_logger(name, debug=False, duplicate_filter=False):
name = "{name} ({guid})".format(name=name, guid=host.stats().parent().guid)
logger = logging.getLogger(name)
for handler_ in logger.handlers[:]:
handler_.close()
logger.removeHandler(handler_)
logger.setLevel("DEBUG")
host_handler = HostLogHandler()
host_handler.setLevel(logging.DEBUG if debug else logging.INFO)
host_formatter = logging.Formatter(
"%(name)s [%(levelname)-8s] %(lineno)-4s <%(funcName)s> - %(message)s"
)
host_handler.setFormatter(host_formatter)
logger.addHandler(host_handler)
popup_handler = PopupHandler()
popup_handler.setLevel(logging.INFO if debug else logging.WARNING)
popup_formatter = logging.Formatter(
fmt="<b>[%(levelname)s]</b> Line: %(lineno)s<br><i>%(message).630s</i>"
)
popup_handler.setFormatter(popup_formatter)
logger.addHandler(popup_handler)
if debug:
fmt = "%(asctime)s [%(levelname)-8s] %(lineno)-4s <%(funcName)s> - %(message)s"
file_handler = MyFileHandler("%s.log" % name)
file_handler.setLevel(logging.DEBUG)
file_formatter = logging.Formatter(fmt, datefmt="%Y-%m-%d %H:%M:%S")
if duplicate_filter:
fmt = "%(duplicates)s" + fmt
file_formatter = logging.Formatter(fmt, datefmt="%Y-%m-%d %H:%M:%S")
file_handler.addFilter(DuplicateFilter())
file_handler.setFormatter(file_formatter)
logger.addHandler(file_handler)
return logger
def set_script_name(name=None):
"""Set script name
Args:
name (str, optional): Script name, if None - parse name from parameters
Returns:
str: Script name
"""
if name:
default_script_name = str(name)
else:
doc = getattr(main_module, "__doc__", None) or ""
title = re.search(r"<title>(.+)</title>", doc)
version = None
if title:
version = re.search(r"<version>(.+)</version>", doc)
default_script_name = "{title} v{version}".format(
title=title.group(1),
version=version.group(1) if version else "?.?.?")
if SCRIPT_NAME in DEFAULT_SCRIPT_NAMES:
host.stats().parent()["name"] = default_script_name
return default_script_name
# -*- coding: utf-8 -*-
import os
import host
SERVER_NAME = host.settings("").name or "Client"
SERVER_GUID = host.settings("").guid
SCRIPT_NAME = host.stats().parent().name
SCRIPT_PATH = os.path.abspath(os.path.join(__file__, os.pardir, os.pardir))
LANGUAGE_ID = host.stats().parent()["language"] or host.settings("system_wide_options")["i18n_language"]
DEFAULT_SCRIPT_NAMES = {
"Yeni skript",
"Unnamed Script",
"უსახელო სკრიპტი",
"Жаңа скрипт",
"Script nou",
"Новый скрипт",
"Yeni skript dosyası",
"Новий скрипт",
"未命名脚本",
}
