def main(): parser = make_parser() args = parser.parse_args() task_mngr = TaskManager() task_mngr.add_task_enum("test", "test_type", "regr", "RF", args.param, 10, 100, 10) task_mngr.dump_queue("q")
def start_task_manager(self, task): """Takes information from GUI, instantiates a task manager, and runs appropriate task""" file = self.text_input[0].get() user = self.text_input[1].get() doc = self.text_input[2].get() manager = TaskManager(file, doc, user) manager.run(task)
def __init__(self, task_loader, conf): self.lock = threading.Lock() self.workerManager = WorkerManager(conf) self.taskManager = TaskManager(task_loader) self.running_tasks = {} self.conf = conf self.load_tasks()
def new_task(args): name = ' '.join(args.name) if not name: print(INVALID_NAME_MSG) return date_str = args.date if date_str: try: date = interpret_date(date_str) except ValueError as e: print(e) return else: date = None estimated_hours = float(args.est_hours) manager = TaskManager(fileio.load()) id = manager.new_task(name, estimated_hours, date) fileio.save(manager.task_dict) print_table(manager, id)
def get_one_page(self, keyword, page): task_manager = TaskManager() task_manager.task_begin(keyword, page) res = Fetch.get_one_page_by_keyword(keyword, page) if res: task_manager.task_end(keyword, page) else: task_manager.task_failed(keyword, page)
def __init__(self, reader, writer, token): super().__init__( Platform.PlayStation, # choose platform from available list "0.1", # version reader, writer, token) self.games_cache = GamesCache(self) self.backend_client = BackendClient(self.games_cache) self.task_manager = TaskManager(self, self.games_cache)
def main(): """Entry point. Gets user input, runs GUI or task manager depending on the input""" user_input = UserInput() if user_input.gui_flag: g = Gui(user_input.get_file(), user_input.get_docid(), user_input.get_userid()) g.run() else: manager = TaskManager(user_input.get_file(), user_input.get_docid(), user_input.get_userid()) task = user_input.task manager.run(task)
def __init__(self, world, image, direction, location, nest): super(Ant, self).__init__(world, location, (1, 1), image) self.world = world self.image = image self.nest = nest self.direction = direction self.location = location self.food = 0 self.health = 1 self.food_scent_strength = 0 self.home_scent_strength = 0 self.task_manager = TaskManager()
def clock(args): manager = TaskManager(fileio.load()) task_id = args.id to_deduct = args.to_deduct # TODO Complete if less than/eq 0? try: old_task: task.Task = manager.task_dict[task_id] old_task.hours_remaining -= to_deduct fileio.save(manager.task_dict) print_table(manager, task_id) except KeyError: print(INVALID_ID_MSG)
async def main(port, log_storage="/home/tbjc1magic/log"): server = aio.server() task_manager = TaskManager() task_manager_thread = asyncio.to_thread(task_manager.run) data_collector_service_pb2_grpc.add_DataCollectorServicer_to_server( DataCollectorServicer(log_storage, task_manager), server) service_names = ( data_collector_service_pb2.DESCRIPTOR. services_by_name["DataCollector"].full_name, reflection.SERVICE_NAME, ) reflection.enable_server_reflection(service_names, server) server.add_insecure_port(f"[::]:{port}") await server.start() await asyncio.gather(server.wait_for_termination(), task_manager_thread)
def complete_task(args): manager = TaskManager(fileio.load()) ids = args.id if not ids: print(INVALID_ID_MSG) else: completed_tasks_dict = dict() for i in ids: try: completed_tasks_dict[i] = manager.task_dict[i] manager.complete(i) fileio.save(manager.task_dict) except KeyError: print(INVALID_ID_MSG) print_table(manager) print() print_completed_tasks(completed_tasks_dict)
def __init__(self): def get_input_handlers(controller, app_config): handlers = [PygameInputHandler(controller, app_config)] try: from pi_input_handler import PiInputHandler handlers.append(PiInputHandler(controller, app_config)) except ImportError: print('Unable to import raspberrypi input handler') return handlers def get_zoneminder_client(app_config): zm_client = ZoneMinderClient(app_config.config[SERVER_HOST], app_config.config[SERVER_PORT], app_config.config[ZM_WEB_PATH], app_config.config[USER_NAME], app_config.config[PASSWORD], app_config.config[ZMS_WEB_PATH]) return zm_client config = AppConfig() event_bus = EventBus() client = get_zoneminder_client(config) self.app_state = AppState() self.app_context = AppContext(config, client, event_bus) self.display = PygameDisplay(config) self.display.init() self.app_context.display_size = self.display.get_display_size() zm_stream_component = MonitorStreamComponent(self.app_context) group_selector_component = GroupSelectorComponent(self.app_context) monitor_selector_component = MonitorSelectorComponent(self.app_context) shutdown_prompt_component = ShutdownPromptSelector(self.app_context) menu_selector = MenuSelector(self.app_context) startup_component = StartUpComponent(self.app_context) self.component_manager = AppComponentManager( self.display, event_bus, startup_component, zm_stream_component, [ group_selector_component, monitor_selector_component, shutdown_prompt_component, menu_selector ]) self.input_manager = InputManager(get_input_handlers( event_bus, config)) self.app_controller = AppController(self.app_context, self.input_manager, self.app_state) self.task_manager = TaskManager(event_bus)
def run(user_ids, tweet_ids, curr_datetime, root_dir): """ This run method assumes that data is periodically collected from Twitter and stored in folders ordered by timestamp of data collection. The task_manager scans the previously stored data, and saves the delta. - In the case of followers/followees, it stores the list of followers added/subtracted at each run. - In the case of timelines, it stores the new tweets by a user after the last fetched tweet from a user's timeline. Parameters: - user_ids (Twitter username/user_id): The list of users for which data needs to be collected. - tweet_ids: The list of tweets for which data needs to be collected. - curr_datetime (str): The current timestamp used to create the corresponding directory to store the Twitter data. - root_dir (str): The root directory path where all the timestamp folders are created. """ print(" --- Collecting twitter data for {} tweets and {} users ---".format( len(tweet_ids), len(user_ids))) apis = create_api_objects() base_folder_path = root_dir + '/' # Load list of users to ignore user_ignore_list = set() if os.path.exists(base_folder_path + 'user_ignore_list.txt'): with open(base_folder_path + 'user_ignore_list.txt') as f: for line in f: user_ignore_list.add(line.strip()) twitter_folder_path = base_folder_path + curr_datetime + '/' + 'twitter/' if not os.path.exists(twitter_folder_path): os.makedirs(twitter_folder_path) task_manager = TaskManager(base_folder_path, twitter_folder_path) process_tweets(tweet_ids, user_ignore_list, task_manager, apis) process_users(user_ids, user_ignore_list, task_manager, apis)
def parse_using_file(filepath, n): """ Собственно загрузка данных Создаем менеджер задач, читаем из файла код акции и тут же кладем задания на скачивание данныъ по этой акции В конце ждем выполнения всех задач и выходим :param filepath: путь до файла :param n: количество потоков для скачивания :return: """ tm = TaskManager(n) with open(filepath) as f: for symbol in f: symbol = symbol.strip().upper() create_tasks(symbol=symbol, tm=tm) tm.finish()
def modify_task(args): manager = TaskManager(fileio.load()) task_id = args.id try: old_task: task.Task = manager.task_dict[task_id] new_name = args.name if args.name else old_task.name if args.date: new_date = interpret_date(args.date) elif args.floating or isinstance(old_task, task.FloatingTask): new_date = None else: new_date = old_task.due_date new_hours_remaining = args.est_hours if args.est_hours else old_task.hours_remaining manager.new_task(new_name, new_hours_remaining, new_date, task_id) fileio.save(manager.task_dict) print_table(manager, task_id) except KeyError: print(INVALID_ID_MSG) except ValueError as e: print(e)
def on_connect_button_clicked(self): '''当连接按钮按下时''' if self.has_connected == False: #尚未建立连接 # 则根据输入的ip、port、user、password连接到服务器 ip = self.ipInput.text() port = self.portInput.text() user = self.userInput.text() password = self.passwordInput.text() if not self.client.open(ip, port): #连接失败 QMessageBox.information(self.centralwidget, "连接错误","ip或者port错误",QMessageBox.Yes) return self.client.user(user) reply = self.client.password(password) if reply.startswith("5"): #若登录失败 QMessageBox.information(self.centralwidget, "连接错误", "user或者password错误", QMessageBox.Yes) else: #登录成功 self.update_folder() #更新文件浏览窗体 self.connectButton.setText("disconnect") self.has_connected = True self.task_manager = TaskManager(ip, port, user, password) #创建任务工厂 self.timer.start(self.interval) #开始刷新数据传输进度 self.menubar.setEnabled(True) self.statusbar.setEnabled(True) else: #如果已经建立连接 self.timer.stop() #停止数据传输进度的刷新 # 则客户端断开连接 self.client.bye() self.client.close() self.connectButton.setText("connect") self.has_connected = False del self.task_manager self.task_manager = None self.menubar.setEnabled(False) self.statusbar.setEnabled(False)
def eval(self): tm = TaskManager() # models = [ # "/data/nlp/corpora/multi_word_embedding/data/models/unsupervised/mwe_f_ft_2_200_complete_rs1_wd00005", # "/data/nlp/corpora/multi_word_embedding/data/models/unsupervised/mwe_f_ft_2_200_complete_rs2_wd00005", # "/data/nlp/corpora/multi_word_embedding/data/models/unsupervised/mwe_f_ft_2_200_complete_rs3_wd00005", # "/data/nlp/corpora/multi_word_embedding/data/models/unsupervised/mwe_f_ft_2_200_complete_rs4_wd00005", # "/data/nlp/corpora/multi_word_embedding/data/models/unsupervised/mwe_f_ft_2_200_complete_rs5_wd00005", # ] models = [ "/data/nlp/corpora/multi_word_embedding/data/models/supervised/mwe_f_ft_2_200_normal_complete_rs1", "/data/nlp/corpora/multi_word_embedding/data/models/supervised/mwe_f_ft_2_200_normal_complete_rs2", "/data/nlp/corpora/multi_word_embedding/data/models/supervised/mwe_f_ft_2_200_normal_complete_rs3", "/data/nlp/corpora/multi_word_embedding/data/models/supervised/mwe_f_ft_2_200_normal_complete_rs4", "/data/nlp/corpora/multi_word_embedding/data/models/supervised/mwe_f_ft_2_200_normal_complete_rs5", # "/data/nlp/corpora/multi_word_embedding/data/models/supervised/mwe_f_ft_2_200_sentencewise_frt_complete_rs1", # "/data/nlp/corpora/multi_word_embedding/data/models/supervised/mwe_f_ft_2_200_sentencewise1_complete_frt_rs2", # "/data/nlp/corpora/multi_word_embedding/data/models/supervised/mwe_f_ft_2_200_sentencewise1_complete_frt_rs3", # "/data/nlp/corpora/multi_word_embedding/data/models/supervised/mwe_f_ft_2_200_sentencewise1_complete_frt_rs4", # "/data/nlp/corpora/multi_word_embedding/data/models/supervised/mwe_f_ft_2_200_sentencewise1_complete_frt_rs5", # "/data/nlp/corpora/multi_word_embedding/data/models/supervised/mwe_f_ft_2_200_sentencewise_complete_rs1", # "/data/nlp/corpora/multi_word_embedding/data/models/supervised/mwe_f_ft_2_200_sentencewise1_complete_rs2", # "/data/nlp/corpora/multi_word_embedding/data/models/supervised/mwe_f_ft_2_200_sentencewise1_complete_rs3", # "/data/nlp/corpora/multi_word_embedding/data/models/supervised/mwe_f_ft_2_200_sentencewise1_complete_rs4", # "/data/nlp/corpora/multi_word_embedding/data/models/supervised/mwe_f_ft_2_200_sentencewise1_complete_rs5", ] # for i, model in enumerate(models): # init_random(i+1) # print(model) # self.task_model.mwe_f.load_state_dict(torch.load(f"{model}.pt", map_location=self.device)) # self.task_model.eval() score, model_number = tm.evaluateOnTratzBestModel(self.params, self.task_model.mwe_f, self.sg_embeddings, self.embedding_device, self.device) # print(f"Score: {score} - {model_number}\n") return 0
import logging import hashlib from flask import jsonify, make_response, request, redirect, session from flask_restful import Resource, reqparse from docker_verify import docker_verify from models import Answer, User, db from task_manager import TaskManager import os # Challenge data file URL CHALLENGES_PATH = 'data/challenges.json' # Static variables manager = TaskManager(CHALLENGES_PATH) best_answer = [{ 'cc':float('inf'), 'java':float('inf'), 'js':float('inf'), 'py':float('inf')} for _ in manager.get_tasks()] tokens = {} # REST API Endpoints class AnswerResource(Resource): def post(self, task_id): ''' Endpoint for submitting code ''' parser = reqparse.RequestParser() parser.add_argument('language', required=True) parser.add_argument('code', required=True) args = parser.parse_args() task = manager.get_task(task_id)
#!/usr/bin/python3 import os import time import re from slackclient import SlackClient import config from task_manager import TaskList, TaskManager, Status # instantiate Slack client slack_client = SlackClient(config.auth["bot_access_token"]) # starterbot's user ID in Slack: value is assigned after the bot starts up starterbot_id = None taskmanager = TaskManager() RECONNECT_DELAY = 10 HIGH_ACTIVITY_WINDOW_SEC = 30 HIGH_ACTIVITY_DELAY_S = 0.1 LOW_ACTIVITY_DELAY_S = 1.0 # constants kPublishToChannel = config.general["post_to_channel"] class Bot: def __init__(self): self.user_list = {} self.conversations = {} self.channels = {} self.high_activity_mode = False self.last_activity_ts = time.time()
def make_taskmanager(self): self.task_manager = TaskManager(tk.Toplevel(self), self, MainApplication.default_distribution) self.task_manager.grid(row=2, column=1) self.task_manager.master.focus_set()
def __init__(self): self.tm = TaskManager() self.p = Profile() CANVAS_SIZE = 600 self.root = Tk() self.root.title("Try, Do it !") self.root.configure(bg="white") self.root.geometry( str(CANVAS_SIZE) + "x" + str(CANVAS_SIZE - 300) + "+300+100") self.root.resizable(False, False) lb1 = Label(self.root, text='Add Tasks', bg="white") lb1.grid(row=0, column=2) lb2 = Label(self.root, text='To do List', bg="white") lb2.grid(row=0, column=7) lb3 = Label(self.root, text='Doing Task', bg="white") lb3.grid(row=7, column=2) # Add Tasks Part self.task = Entry(self.root, width=40, relief="solid", bd=1) self.task.grid(row=1, column=0, columnspan=5) self.priority = IntVar(self.root, 1) frame = Frame(self.root, relief="solid", bd=1, bg="white") frame.grid(row=2, column=0, rowspan=4) rd1 = Radiobutton(frame, bg="white", text="중요 & 긴급", value=1, variable=self.priority, command=self.check_priority) rd1.pack() rd2 = Radiobutton(frame, bg="white", text="중요 & 긴급X", value=2, variable=self.priority, command=self.check_priority) rd2.pack() rd3 = Radiobutton(frame, bg="white", text="중요X & 긴급", value=3, variable=self.priority, command=self.check_priority) rd3.pack() rd4 = Radiobutton(frame, bg="white", text="중요X & 긴급X", value=4, variable=self.priority, command=self.check_priority) rd4.pack() self.tag = Entry(self.root, width=20, relief="solid", bd=1) self.tag.grid(row=2, column=2, columnspan=3) self.year = Entry(self.root, width=6, relief="solid", bd=1) self.year.grid(row=3, column=2) self.month = Entry(self.root, width=6, relief="solid", bd=1) self.month.grid(row=3, column=3) self.day = Entry(self.root, width=6, relief="solid", bd=1) self.day.grid(row=3, column=4) self.bt_add_task = Button(self.root, bg="white", text="Add Task", width=20, command=self.add) self.bt_add_task.grid(row=4, column=2, columnspan=3) # Doing Tasks Part self.task_selected = Entry(self.root, width=40, bg="white", relief="solid", bd=1) self.task_selected.grid(row=8, column=0, columnspan=5) self.bt_update = Button(self.root, text="Update", fg="blue", width=15, bg="white", command=self.update) self.bt_update.grid(row=9, column=0, columnspan=2) self.percent = Entry(self.root, width=10, relief="solid", bd=1) self.percent.grid(row=9, column=3) lb4 = Label(self.root, text="%", bg="white") lb4.grid(row=9, column=4) self.bt_open = Button(self.root, text="Open Your Closet", width=40, bg="white", command=self.open) self.bt_open.grid(row=10, column=0, columnspan=5) # To do List Part self.bt_show_list = Button(self.root, text="Show List", fg="blue", width=40, bg="white", command=self.show_list) self.bt_show_list.grid(row=1, column=5, columnspan=5) self.bt_show_list = Button(self.root, text="Sort", fg="blue", width=40, bg="white", command=self.sort) self.bt_show_list.grid(row=2, column=5, columnspan=5) self.lb_tasks = Listbox(self.root, width=40, relief="solid", bd=1) self.lb_tasks.grid(row=3, column=5, rowspan=7, columnspan=5) self.bt_delete = Button(self.root, text="Delete", fg="brown", width=15, bg="white", command=self.delete) self.bt_delete.grid(row=10, column=5, columnspan=2) self.bt_complete = Button(self.root, text="Doing Tasks", fg="blue", width=8, bg="white", command=self.list_select) self.bt_complete.grid(row=10, column=7) self.bt_complete = Button(self.root, text="Complete", fg="green", width=15, bg="white", command=self.closet) self.bt_complete.grid(row=10, column=8, columnspan=2) self.root.mainloop()
def main(): m = TaskManager() # m.initialize({"犯罪": 100}) print(m.get_all_undo_tasks())
def start(self): if self._use_taskmanager: self._taskmanager = TaskManager(None, self.provider.name, self.provider.rate) self._taskmanager.start() self.resetClient()
from flask import Flask from task_manager import TaskManager from task import Task import threading app = Flask(__name__) tm = TaskManager() ''' flask interface ''' @app.route("/AddTask") def addTask(): # Create a task task = Task("Train") # Insert it into task manager tm.addTask(task) return "Success" @app.route("/RunningTaskCount") def RunningTaskCount(): return "We have {} running tasks.".format(tm.runningTaskCount) if __name__ == "__main__": # Main threading to handle tasks. tm.start() # Create a threading to run flask servers. serverTheading = threading.Thread(target = app.run, daemon=True, name='FLASK_SERVER', kwargs=({'host':'0.0.0.0', 'port':5000, 'debug':False}))
def set_other_params(self): self.client = discord.Client() self.taskman = TaskManager()
from task_manager import TaskManager from workspace import Workspace from sensor_arduino import Sensor laser = configLaser() # init file manager filemanager = FileManager(rootPath=COMPUTED_FOLDER, webRootPath=HTML_FOLDER) configFileManager(filemanager) # init workspace workspace = Workspace(filemanager=filemanager, laser=laser) configWorkspace(workspace) # init task manager taskmanager = TaskManager(laser, workspace) loadProfiles(taskmanager) # init sensor sensor = Sensor(config['sensor']['config']['port'], config['sensor']['config']['baud'], indexMap=config['sensor']['indexMap']) def getStatus(): sensor.update() payload = { "status": { "laser": laser.isActive(), "usb": laser.isInit(), "airAssist": sensor.airAssist.val,
def train(self): tm = TaskManager() begin_time = time.time() running_loss = [] train_iter = 0 f = open('output', 'w+') performance = None epochs_since_last_improvement = 0 for epoch in range(self.num_epochs): running_epoch_loss = [] if epochs_since_last_improvement < self.params['early_stopping']: running_epoch_loss=tm.step(task_model=self.task_model, generator=self.generator, optimizer=self.optimizer, batch_construction=self.minimization_types[self.params['train_objective']]) else: # Stop, because no improvement for more than threshold print( f"No improvements for {epochs_since_last_improvement}. Training stopped. Report saved at: {self.params['save_path']}_report") if not os.path.exists(f'{self.params["save_path"]}_report'): with open(f'{self.params["save_path"]}_report', 'w+') as report_f: # write header report_f.write( f"Performance\tTime\tEval\tSeed\tTime\n") with open(f'{self.params["save_path"]}_report', 'a+') as report_f: # write lines report_f.write( f"{performance}\t{format_number(time.time() - begin_time)}\t{self.params['evaluation']['evaluation_dev_file']}\t{self.params['random_seed']}\t{datetime.now()}\n") return torch.save(self.task_model.mwe_f.state_dict(), f"{self.save_path}_{epoch}.pt") # Evaluate. Separate branch for clarity if epochs_since_last_improvement < self.params['early_stopping']: # Prepare for evaluation # Zero the gradients self.optimizer.zero_grad() # Freeze the network for evaluation for param in self.task_model.mwe_f.parameters(): param.requires_grad = False self.task_model.eval() if 'heldout_data' in self.params: score = -tm.evaluateOnHeldoutDataset(params=self.params, task_model=self.task_model, generator=self.dev_generator, batch_construction=self.minimization_types[self.params['train_objective']]) else: score, model_number = tm.evaluateOnTratz(self.params, self.task_model.mwe_f, self.sg_embeddings, self.embedding_device, self.device) print(f'Max was with: {model_number}') # Unfreeze the network after evaluation for param in self.task_model.mwe_f.parameters(): param.requires_grad = True # Zero whatever gradients might have been computed self.optimizer.zero_grad() # Keeping the better model if performance is None: performance = score print(f"Save new best: {score}") torch.save(self.task_model.mwe_f.state_dict(), f"{self.save_path}.pt") if self.params['train_objective'] == 'JointTrainingSkipGramMinimization': self.task_model.embedding_function.to_saved_file(f"{self.save_path}_embeddings.pt") elif performance < score: epochs_since_last_improvement = 0 performance = score print(f"Save new best: {score}") torch.save(self.task_model.mwe_f.state_dict(), f"{self.save_path}.pt") if self.params['train_objective'] == 'JointTrainingSkipGramMinimization': self.task_model.embedding_function.to_saved_file(f"{self.save_path}_embeddings.pt") # else: epochs_since_last_improvement += 1 # self.scheduler.step(metrics=-score) print( f"{epoch} - {format_number(score)}; {self.optimizer.param_groups[0]['lr']}. Current score {format_number(np.mean(running_epoch_loss))}. Took a total of {format_number(time.time() - begin_time)}s; {self.optimizer.param_groups[0]['lr']}. Model norm: {format_number(np.sum([torch.sum(torch.abs(x)) for x in self.task_model.mwe_f.parameters()]))}. Best is {format_number(performance)}. Epochs {epochs_since_last_improvement}") self.task_model.train() f.close()
def main(): task_manager = TaskManager(Config.NUMBER_OF_PROCESSES, Config.NUMBER_OF_CPUS, Config.RANGE_PROCESSES_LOAD) task_manager.execute_all()
task_manager = None state_manager = StateManager() if args.dev: logging.basicConfig(level=logging.DEBUG) # noinspection PyBroadException try: if args.action == action_get: if args.state_id: state = state_manager.get_state(args.state_id) else: state = state_manager.get_latest_state(args.file_path) context = json.loads(args.context) if args.context else None task_manager = TaskManager() tasks = task_manager.get_suggested_tasks(state, context) print(json.dumps(tasks)) task_manager.close_db() elif args.action == action_execute: task_manager = TaskManager() new_state = task_manager.execute_task(args.task_id) state_manager.add_state(new_state) print( json.dumps(state_manager.jsonify(new_state), indent=(3 if args.dev else None))) task_manager.close_db() except Exception: if args.dev:
def list_tasks(args): manager = TaskManager(fileio.load()) print_table(manager)