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)
