def __new__(cls, **kargs): task_id = TaskManager().find_task(cls.__name__, kargs) if task_id: log.warning("make-torrent task exists.task_id: %s" % task_id) return TaskManager().tasks[task_id] else: log.warning("create a new make-torrent task!") return super(MakeTorrentTask, cls).__new__(cls)
def do(self): task_id = self.data.get("task_id", "-1") #log.debug("get a task status query request: %s" % task_id) ret = TaskManager().query_task(task_id) #log.debug("task status query end.") if ret["ret"] in (JOB_STATUS_SUCCESS, JOB_STATUS_FAILED): print "task_id:", task_id, type(task_id) TaskManager().del_task(task_id) return ret
def run(spin=SPIN): _log.debug("run spin=%r", spin) global running, taskManager, deferredFns, sleeptime # reference the task manager (a singleton) taskManager = TaskManager() # count how many times we are going through the loop loopCount = 0 running = True while running: # _log.debug("time: %r", time.time()) loopCount += 1 # get the next task task, delta = taskManager.get_next_task() try: # if there is a task to process, do it if task: # _log.debug("task: %r", task) taskManager.process_task(task) # if delta is None, there are no tasks, default to spinning if delta is None: delta = spin # there may be threads around, sleep for a bit if sleeptime and (delta > sleeptime): time.sleep(sleeptime) delta -= sleeptime # if there are deferred functions, use a small delta if deferredFns: delta = min(delta, 0.001) # _log.debug("delta: %r", delta) # loop for socket activity asyncore.loop(timeout=delta, count=1) # check for deferred functions while deferredFns: # get a reference to the list fnlist = deferredFns deferredFns = [] # call the functions for fn, args, kwargs in fnlist: # _log.debug("call: %r %r %r", fn, args, kwargs) fn( *args, **kwargs) # done with this list del fnlist except KeyboardInterrupt: _log.info("keyboard interrupt") running = False except Exception, e: _log.exception("an error has occurred: %s", e)
def manager(): """Aplicație ce permite gestiunea evenimentelor.""" task_manager = TaskManager() task_manager.map_tasks() flag = True while flag: list_options() option = raw_input("Insert option: ") if option == "1": print("Task list:") task_manager.list_tasks() elif option == "2": print("Adding new task:") task = task_manager.add_task(get_input("add")) task_manager.task_list.append(task) elif option == "3": print("Editing Task") task_manager.edit_task(int(get_input("get_id")) - 1) elif option == "4": print("Deleting task") task_manager.delete_task(int(get_input("get_id")) - 1) elif option == "0": flag = False else: print("Invalid input. Try Again") task_manager.persist_tasks()
def executor(): """Procesează informațile din cadrul unei sarcini și încearcă să le îndeplinească. """ task_manager = TaskManager() task_manager.map_tasks() task_manager.task_list[0].initialize_task() task_manager.task_list[0].execute_task() task_manager.delete_task(0) task_manager.persist_tasks()
def __init__(self, editors, root_location, spreadsheetId): super(GSheetsRequest, self).__init__() self.editors = editors self.root_location = root_location self.service = None self.tasks = TaskManager(tasks) self.dropdown = DropdownMenu(names) self.lockcells = LockCells(self.editors) self.spreadsheetId = spreadsheetId self.write_body = {} self.request_body = {}
def do(cls, **data): result = dict() try: d = cls.task_cls(**data) ret = TaskManager().add_task(d) log.debug("==============Task %s start=============" % cls.__name__) log.debug("Task param: %s" % data) if ret[0] == 0: log.debug("task start...") d.start() result["ret"], result["msg"] = ret result["task_id"] = d.task_id except VtransError, e: msg = "%s request failed. detail: %s" % (cls.__name__, e) result['ret'], result['msg'] = e.code(), msg log.error(msg) traceback.print_exc()
def run_once(): """ Make a pass through the scheduled tasks and deferred functions just like the run() function but without the asyncore call (so there is no socket IO actviity) and the timers. """ _log.debug("run_once") global taskManager, deferredFns # reference the task manager (a singleton) taskManager = TaskManager() try: delta = 0.0 while delta == 0.0: # get the next task task, delta = taskManager.get_next_task() _log.debug(" - task, delta: %r, %r", task, delta) # if there is a task to process, do it if task: taskManager.process_task(task) # check for deferred functions while deferredFns: # get a reference to the list fnlist = deferredFns deferredFns = [] # call the functions for fn, args, kwargs in fnlist: _log.debug(" - call: %r %r %r", fn, args, kwargs) fn( *args, **kwargs) # done with this list del fnlist except KeyboardInterrupt: _log.info("keyboard interrupt") except Exception, e: _log.exception("an error has occurred: %s", e)
def scheduler(): """Planifică evenimentele.""" task_manager = TaskManager() task_manager.map_tasks() print("Current task queue: ") task_manager.list_tasks() list_options() input_option = raw_input("Choose schedule type") if input_option == "1": task_manager.task_list = \ schedule_by_deadline(task_manager.task_list) if input_option == "2": pass if input_option == "3": task_order = raw_input("Order tasks: ") task_manager.task_list = schedule_manually(task_manager.task_list, task_order.split(' ')) task_manager.list_tasks() task_manager.update_id() task_manager.list_tasks() task_manager.persist_tasks()
async def post(self): user_id = int(self.get_secure_cookie("user_id")) file_id = self.get_body_argument('fileID', default=None, strip=False) with self.make_session() as session: mode = self.get_argument("mode", None) task_manager = TaskManager(self.settings["mongo_db"]) if mode == "add_task": task_id = await task_manager.add_task(user_id, file_id, session) self.set_status(200) task = await as_future( session.query(Task).filter(Task.id == task_id).first) file = await as_future( session.query(File).filter(File.id == task.file_id).first) json_task = { "image_url": self.static_url(task.image), "filename": file.filename.split("/")[-1], "status": task.status, "current_stage": task.current_stage, "completion": task.completion } self.finish(json_task) await TaskManager(self.settings["mongo_db"] ).run_task(task_id, session) elif mode == "rerun_task": task_id = self.get_argument("taskID", None) if task_id is not None: task = await as_future( session.query(Task).filter(Task.id == task_id).first) if task: if user_id == task.user_id: self.set_status(200) self.finish() await task_manager.run_task(task_id, session)
def __init__(self, editors, names, tasks, spreadsheetId, month_file=None, new_page=False): super(GSheetsRequest, self).__init__() self.editors = editors self.service = None self.spreadsheetId = spreadsheetId self.write_body = {} self.request_body = {} self.service = self.start() if new_page: self.new_page() self.full_send(request_only=True) contact_info, task_info = self.get_contact_task_information( self.spreadsheetId) self.contacts = Contacts(contact_info) self.tasks = TaskManager(task_info) self.current_sheet_name, self.current_sheet_id, self.totals_sheet_id = self.get_sheet_name_and_id( self.spreadsheetId) self.months = [ Month(self.contacts, self.tasks, self.current_sheet_id, self.spreadsheetId, self.current_sheet_name, self.editors) if month_file is None else Month.load(month_file) ] self.recent_month = self.months[0] self.sheet_name_date_start = None self.sheet_name_date_end = None self.save()
from config import ConfigManager from task import TaskManager from models import MySQLDatabase, database_proxy my_config = ConfigManager() database = MySQLDatabase(**my_config.content_mysql) database_proxy.initialize(database) manager = TaskManager(config=my_config) if __name__ == "__main__": manager.run()
import argparse import platform from utils.sqlitedao import create_database from cfg import DataConfig, TaskConfig from task import TaskManager, ImgInfoPool, get_cfgDataHandler import importlib def args_parse(): parser = argparse.ArgumentParser() parser.add_argument('-i', type=str, help='input video') return parser.parse_args() if __name__ == "__main__": # Linux平台启动 if platform.system() == 'Linux': mp.set_start_method('spawn', force=True) img_info_pool = ImgInfoPool(max_size=30) tm = TaskManager(img_info_pool) args = args_parse() cfg_data = { "task_type": "collectTrack", "filepath": args.i, } task_type = cfg_data['task_type'] get_cfg = importlib.import_module(TaskConfig.SIMPLE_CFG_DIR + task_type).get_injected_cfg task_cfg = get_cfg(cfg_data) tm.submit(task_name=os.path.basename(args.i), task_cfg=task_cfg) tm.resume(task_name=os.path.basename(args.i), is_join=True)
def __init__(self, worklog_file_name): self.worklog_file_name = worklog_file_name self.task_manager = TaskManager(worklog_file_name)
if not os.path.exists(FILE_DIR): os.mkdir(FILE_DIR) # ------------------------------------------------ # # Init background scheduler for processing tasks # & set background executors. # ------------------------------------------------ # executors = {'default': ThreadPoolExecutor(8)} scheduler = BackgroundScheduler(executors=executors) scheduler.start() # ------------------------------------------------ # # Init managers # ------------------------------------------------ # manager = TaskManager() add_to_scheduler(scheduler, manager) # ------------------------------------------------ # # Init schema for validation input data # ------------------------------------------------ # schema = { 'type': 'object', 'properties': { 'url': { 'type': 'string' }, }, 'required': ['url'] }
def CancelTask(data): task_id = data.get("task_id", None) if not task_id: raise InvalidParamError("task_id param is needed.") tmgr = TaskManager() return tmgr.cancel_task(task_id)
def __init__(self): self.account_mgr = AccountManager() self.board = Board() self.task_mgr = TaskManager() self.pixels = []
SCOPES = 'https://www.googleapis.com/auth/spreadsheets' store = file.Storage('credentials.json') creds = store.get() if not creds or creds.invalid: flow = client.flow_from_clientsecrets('client_secret_3.json', SCOPES) creds = tools.run_flow(flow, store) service = build('sheets', 'v4', http=creds.authorize(Http())) # Call the Sheets API SPREADSHEET_ID = '1vMFRfLKJV2hJv1KW2KgP52Ltv6-g8MzCL0sNyt9pApM' RANGE_NAME = 'TEST!A2:E2' result = service.spreadsheets().values().get(spreadsheetId=SPREADSHEET_ID, range=RANGE_NAME).execute() tasks_file = "tasks.csv" task_manager = TaskManager(tasks_file) tasks = task_manager.generate_task_fields() print(tasks) # dropdown_menu = DropdownMenu("names.csv") # dropdown_request = dropdown_menu.generate_request(0, 3, 4, 1, 5) # editors = ["*****@*****.**"] # lock_cells = LockCells(editors) # lock_cells_request = lock_cells.generate_request(0, 5, 6, 0, 5) # body = { # "requests": [dropdown_request, lock_cells_request] # } # response = service.spreadsheets() \ # .batchUpdate(spreadsheetId=SPREADSHEET_ID, body=body).execute()
import config from flask_caching import Cache from task import TaskManager app = Flask(__name__) recaptcha = ReCaptcha(app=app, site_key=config.CAPTCHA_SITE_KEY, secret_key=config.CAPTCHA_SECRET_KEY) app.secret_key = config.FLASK_SECRET db = Database("db.sqlite3") cache = Cache(app, config={'CACHE_TYPE': 'simple'}) app.jinja_env.globals.update(truncate_path=od_util.truncate_path) app.jinja_env.globals.update(get_color=od_util.get_color) app.jinja_env.globals.update(get_mime=od_util.get_mime) tm = TaskManager() @app.template_filter("datetime_format") def datetime_format(value, format='%Y-%m-%d %H:%M UTC'): return time.strftime(format, time.gmtime(value)) @app.route("/dl") def downloads(): try: export_file_stats = os.stat("static/out.csv.xz") except FileNotFoundError: print("No export file") export_file_stats = None
return jsonify({ 'code': 20000, 'data': { 'roles': ['admin'], 'introduction': 'I am a super administrator', 'avatar': 'https://wpimg.wallstcn.com/f778738c-e4f8-4870-b634-56703b4acafe.gif', 'name': 'Super Admin' } }) @app.route('/api/vue-admin-template/user/logout', methods=['POST']) def user_logout(): """ 退出登录 :return: """ return jsonify({'code': 20000, 'data': 'success'}) if __name__ == "__main__": # Linux平台启动 if platform.system() == 'Linux': mp.set_start_method('spawn', force=True) server_loger = get_logger() create_database(True) img_info_pool = ImgInfoPool(max_size=30) task_manger = TaskManager(img_info_pool) app.run(port=3001, debug=True)
def __init__(self): self.taskmanager = TaskManager() self.currentoption = None
#! /usr/bin/env python3 # -*- coding:utf-8 -*- from task import TaskManager from server import EchoHandler, CommanderServer task_manager = TaskManager() class CommandHandler(EchoHandler): task = None def handle(self): print('Got connection from: ', self.client_address) # 告诉士兵,连接建立完毕 self.send_command(b'done') while True: report = self.request.recv(1024) self.deal(report) def deal(self, report): if report == b'start': """士兵报告可以开始""" # 获取任务 self.task = task_manager.get_task() # 读取图片,并发给士兵 with open(self.task.person.person_image, 'rb') as file: self.wfile.write(file.read())