# This Python file uses the following encoding: utf-8 # @author runhey # github https://github.com/runhey import copy import datetime import operator import threading from datetime import datetime from module.base.filter import Filter from module.config.config_updater import ConfigUpdater from module.config.config_manual import ConfigManual from module.config.config_watcher import ConfigWatcher from module.config.config_menu import ConfigMenu from module.config.config_model import ConfigModel from module.config.config_state import ConfigState from module.config.utils import * from module.exception import RequestHumanTakeover, ScriptError from module.logger import logger class Function: def __init__(self, key: str, data: dict): """ 输入的是每一个ConfigModel的一个字段对象 :param data: """ if isinstance(data, dict) is False: self.enable = False self.command = "Unknown" self.next_run = DEFAULT_TIME return if data.get("scheduler") is None: self.enable = False self.command = "Unknown" self.next_run = DEFAULT_TIME return self.enable: bool = data['scheduler']['enable'] self.command: str = ConfigModel.type(key) next_run = data['scheduler']['next_run'] if isinstance(next_run, str): next_run = datetime.strptime(next_run, "%Y-%m-%d %H:%M:%S") self.next_run: datetime = next_run # self.enable = deep_get(data, keys="Scheduler.Enable", default=False) # self.command = deep_get(data, keys="Scheduler.Command", default="Unknown") # self.next_run = deep_get(data, keys="Scheduler.NextRun", default=DEFAULT_TIME) def __str__(self): enable = "Enable" if self.enable else "Disable" return f"{self.command} ({enable}, {str(self.next_run)})" __repr__ = __str__ def __eq__(self, other): if not isinstance(other, Function): return False if self.command == other.command and self.next_run == other.next_run: return True else: return False def name_to_function(name): """ Args: name (str): Returns: Function: """ function = Function({}) function.command = name function.enable = True return function class Config(ConfigState, ConfigManual, ConfigWatcher, ConfigMenu): def __init__(self, config_name: str, task=None) -> None: """ :param config_name: :param task: """ super().__init__(config_name) # 调用 ConfigState 的初始化方法 super(ConfigManual, self).__init__() super(ConfigWatcher, self).__init__() super(ConfigMenu, self).__init__() self.model = ConfigModel(config_name=config_name) def __getattr__(self, name): """ 一开始是打算直接继承ConfigModel的,但是pydantic会接管所有的变量 故而选择持有ConfigModel :param name: :return: """ try: return getattr(self.model, name) except AttributeError: logger.error(f'can not ask this variable {name}') return None # 或者抛出异常,或者返回其他默认值 def gui_args(self, task: str) -> str: """ 获取给gui显示的参数 :return: """ return self.model.gui_args(task=task) def get_arg(self, task: str, group: str, argument: str): """ :param task: :param group: :param argument: :return: str/int/float """ try: return self.data[task][group][argument] except: logger.exception(f'have no arg {task}.{group}.{argument}') def set_arg(self, task: str, group: str, argument: str, value) -> None: """ :param task: :param group: :param argument: :param value: :return: """ try: self.data[task][group][argument] = value except: logger.exception(f'have no arg {task}.{group}.{argument}') def save(self) -> None: """ 保存配置文件 :return: """ self.model.write_json(self.config_name, self.model.dict()) def update_scheduler(self) -> None: """ 更新调度器, 设置pending_task and waiting_task :return: """ pending_task = [] waiting_task = [] error = [] now = datetime.now() for key, value in self.model.dict().items(): func = Function(key, value) if not func.enable: continue if not isinstance(func.next_run, datetime): error.append(func) elif func.next_run < now: pending_task.append(func) else: waiting_task.append(func) f = Filter(regex=r"(.*)", attr=["command"]) f.load(self.SCHEDULER_PRIORITY) if pending_task: pending_task = f.apply(pending_task) if waiting_task: waiting_task = f.apply(waiting_task) waiting_task = sorted(waiting_task, key=operator.attrgetter("next_run")) if error: pending_task = error + pending_task self.pending_task = pending_task self.waiting_task = waiting_task def get_next(self) -> Function: """ 获取下一个要执行的任务 :return: """ self.update_scheduler() if self.pending_task: logger.info(f"Pending tasks: {[f.command for f in self.pending_task]}") task = self.pending_task[0] logger.attr("Task", task) return task # 哪怕是没有任务,也要返回一个任务,这样才能保证调度器正常运行 if self.waiting_task: logger.info("No task pending") task = copy.deepcopy(self.waiting_task[0]) # task.next_run = (task.next_run + self.hoarding).replace(microsecond=0) logger.attr("Task", task) return task else: logger.critical("No task waiting or pending") logger.critical("Please enable at least one task") raise RequestHumanTakeover def task_call(self, task: str=None, force_call=True): """ 回调任务,这会是在任务结束后调用 :param task: 调用的任务的大写名称 :param force_call: :return: """ task = convert_to_underscore(task) if self.model.deep_get(self.model, keys=f'{task}.scheduler.next_run') is None: raise ScriptError(f"Task to call: `{task}` does not exist in user config") task_enable = self.model.deep_get(self.model, keys=f'{task}.scheduler.enable') if force_call or task_enable: logger.info(f"Task call: {task}") next_run = datetime.now().replace( microsecond=0 ) self.model.deep_set(self.model, keys=f'{task}.scheduler.next_run', value=next_run) self.save() return True else: logger.info(f"Task call: {task} (skipped because disabled by user)") return False def task_delay(self, task: str, start_time: datetime = None, success: bool=None, server: bool=True, target: timedelta=None) -> None: """ 设置下次运行时间 当然这个也是可以重写的 :param target: 可以自定义的下次运行时间 :param server: True :param success: 判断是成功的还是失败的时间间隔 :param task: 任务名称,大驼峰的 :param finish: 是完成任务后的时间为基准还是开始任务的时间为基准 :return: """ # 任务预处理 if not task: task = self.task.command task = convert_to_underscore(task) task_object = getattr(self.model, task, None) if not task_object: logger.warning(f'No task named {task}') return scheduler = getattr(task_object, 'scheduler', None) if not scheduler: logger.warning(f'No scheduler in {task}') return # 任务开始时间 if not start_time: start_time = datetime.now().replace(microsecond=0) # 依次判断是否有自定义的下次运行时间 run = [] if success is not None: interval = ( scheduler.success_interval if success else scheduler.failure_interval ) run.append(start_time + interval) # if server is not None: # if server: # server = scheduler.server_update # run.append(get_server_next_update(server)) if target is not None: target = [target] if not isinstance(target, list) else target target = nearest_future(target) run.append(target) next_run = None # 排序 if not len(run): raise ScriptError( "Missing argument in delay_next_run, should set at least one" ) run = min(run).replace(microsecond=0) next_run = run # 将这些连接起来,方便日志输出 kv = dict_to_kv( { "success": success, "server_update": server, "target": target, }, allow_none=False, ) logger.info(f"Delay task `{task}` to {next_run} ({kv})") # 强制设定下一次的运行时间 if server and scheduler.server_update != time(hour=9): next_run = parse_tomorrow_server(scheduler.server_update) # 设置 logger.attr(f'{task}.scheduler.next_run', next_run) scheduler.next_run = next_run self.save() if __name__ == '__main__': # config = Config(config_name='oas1') # print(config.get_next()) test = {} test['ww1'] = {} test['ww1']['ww2'] = 3 print(deep_get(test, 'ww1.ww2')) print(test) deep_set(test, 'ww1.ww2', 4) print(deep_get(test, 'ww1.ww2'))