def test_get_node_and_edge_trace_for_plotly_network():
"""test_get_node_and_edge_trace_for_plotly_network."""
task1 = BaseTask("task1")
task1.state_record_list = [
BaseTaskState.READY,
BaseTaskState.READY,
BaseTaskState.WORKING,
BaseTaskState.FINISHED,
BaseTaskState.FINISHED,
]
task2 = BaseTask("task2")
task2.state_record_list = [
BaseTaskState.READY,
BaseTaskState.READY,
BaseTaskState.WORKING,
BaseTaskState.FINISHED,
BaseTaskState.FINISHED,
]
task2.append_input_task(task1)
w = BaseWorkflow([task1, task2])
(
task_node_trace,
auto_task_node_trace,
edge_trace,
) = w.get_node_and_edge_trace_for_plotly_network()
# TODO
# assert...
(
task_node_trace,
auto_task_node_trace,
edge_trace,
) = w.get_node_and_edge_trace_for_plotly_network()
def test_create_gantt_plotly(tmpdir):
"""test_create_gantt_plotly."""
task1 = BaseTask("task1")
task1.state_record_list = [
BaseTaskState.READY,
BaseTaskState.READY,
BaseTaskState.WORKING,
BaseTaskState.FINISHED,
BaseTaskState.FINISHED,
]
task2 = BaseTask("task2")
task2.state_record_list = [
BaseTaskState.READY,
BaseTaskState.READY,
BaseTaskState.WORKING,
BaseTaskState.FINISHED,
BaseTaskState.FINISHED,
]
task2.append_input_task(task1)
w = BaseWorkflow([task1, task2])
init_datetime = datetime.datetime(2020, 4, 1, 8, 0, 0)
timedelta = datetime.timedelta(days=1)
for ext in ["png", "html", "json"]:
save_fig_path = os.path.join(str(tmpdir), "test." + ext)
w.create_gantt_plotly(init_datetime,
timedelta,
save_fig_path=save_fig_path)
def test_get_networkx_graph():
task1 = BaseTask("task1")
task1.start_time_list = [1]
task1.ready_time_list = [0]
task1.finish_time_list = [3]
task2 = BaseTask("task2")
task2.start_time_list = [4]
task2.ready_time_list = [4]
task2.finish_time_list = [6]
task2.append_input_task(task1)
w = BaseWorkflow([task1, task2])
w.get_networkx_graph()
def test_perform():
"""test_perform."""
task = BaseTask("task")
task.state = BaseTaskState.WORKING
w1 = BaseWorker("w1")
w2 = BaseWorker("w2")
w1.workamount_skill_mean_map = {"task": 1.0}
task.allocated_worker_list = [w1, w2]
w1.assigned_task_list = [task]
w2.assigned_task_list = [task]
c = BaseComponent("a")
c.append_targeted_task(task)
auto_task = BaseTask("auto", auto_task=True)
auto_task.state = BaseTaskState.WORKING
w = BaseWorkflow([task, auto_task])
w.perform(10)
assert task.remaining_work_amount == task.default_work_amount - 1.0
assert auto_task.remaining_work_amount == auto_task.default_work_amount - 1.0
assert task.target_component == c
# autotask testing
w.initialize()
task.state = BaseTaskState.WORKING
auto_task.state = BaseTaskState.WORKING
w.perform(10, only_auto_task=True)
assert task.remaining_work_amount == task.default_work_amount
assert auto_task.remaining_work_amount == auto_task.default_work_amount - 1.0
def test_perform():
task = BaseTask("task")
task.state = BaseTaskState.WORKING
w1 = BaseResource("w1")
w2 = BaseResource("w2")
w1.workamount_skill_mean_map = {"task": 1.0}
task.allocated_worker_list = [w1, w2]
w1.assigned_task_list = [task]
w2.assigned_task_list = [task]
c = BaseComponent("a")
c.append_targeted_task(task)
w = BaseWorkflow([task])
w.perform(10)
assert task.remaining_work_amount == task.default_work_amount - 1.0
assert task.target_component == c
def test_draw_plotly_network():
task0 = BaseTask("auto", auto_task=True)
task1 = BaseTask("task1")
task1.start_time_list = [1]
task1.ready_time_list = [0]
task1.finish_time_list = [3]
task2 = BaseTask("task2")
task2.start_time_list = [4]
task2.ready_time_list = [4]
task2.finish_time_list = [6]
task2.append_input_task(task1)
w = BaseWorkflow([task1, task2, task0])
w.draw_plotly_network(save_fig_path="test.png")
if os.path.exists("test.png"):
os.remove("test.png")
def test_create_gantt_plotly():
task1 = BaseTask("task1")
task1.start_time_list = [1]
task1.ready_time_list = [0]
task1.finish_time_list = [3]
task2 = BaseTask("task2")
task2.start_time_list = [4]
task2.ready_time_list = [4]
task2.finish_time_list = [6]
task2.append_input_task(task1)
w = BaseWorkflow([task1, task2])
init_datetime = datetime.datetime(2020, 4, 1, 8, 0, 0)
timedelta = datetime.timedelta(days=1)
w.create_gantt_plotly(init_datetime, timedelta, save_fig_path="test.png")
if os.path.exists("test.png"):
os.remove("test.png")
def test_init():
"""test_init."""
task1 = BaseTask("task1")
task2 = BaseTask("task2")
task2.append_input_task(task1)
w = BaseWorkflow([task1, task2])
assert w.task_list == [task1, task2]
assert w.critical_path_length == 0.0
def test_create_data_for_gantt_plotly():
task1 = BaseTask("task1")
task1.start_time_list = [1]
task1.ready_time_list = [0]
task1.finish_time_list = [3]
task2 = BaseTask("task2")
task2.start_time_list = [4]
task2.ready_time_list = [4]
task2.finish_time_list = [6]
task2.append_input_task(task1)
w = BaseWorkflow([task1, task2])
init_datetime = datetime.datetime(2020, 4, 1, 8, 0, 0)
timedelta = datetime.timedelta(days=1)
df = w.create_data_for_gantt_plotly(init_datetime,
timedelta,
view_ready=True)
assert df[0]["Start"] == (
init_datetime +
task1.ready_time_list[0] * timedelta).strftime("%Y-%m-%d %H:%M:%S")
assert df[0]["Finish"] == (
init_datetime +
(task1.start_time_list[0]) * timedelta).strftime("%Y-%m-%d %H:%M:%S")
assert df[0]["Type"] == "Task"
assert df[1]["Start"] == (
init_datetime +
task1.start_time_list[0] * timedelta).strftime("%Y-%m-%d %H:%M:%S")
assert df[1]["Finish"] == (init_datetime +
(task1.finish_time_list[0] + 1.0) *
timedelta).strftime("%Y-%m-%d %H:%M:%S")
assert df[1]["Type"] == "Task"
assert df[2]["Start"] == (
init_datetime +
task2.ready_time_list[0] * timedelta).strftime("%Y-%m-%d %H:%M:%S")
assert df[2]["Finish"] == (
init_datetime +
(task2.start_time_list[0]) * timedelta).strftime("%Y-%m-%d %H:%M:%S")
assert df[2]["Type"] == "Task"
assert df[3]["Start"] == (
init_datetime +
task2.start_time_list[0] * timedelta).strftime("%Y-%m-%d %H:%M:%S")
assert df[3]["Finish"] == (init_datetime +
(task2.finish_time_list[0] + 1.0) *
timedelta).strftime("%Y-%m-%d %H:%M:%S")
assert df[3]["Type"] == "Task"
def dummy_workflow(scope="function"):
task1 = BaseTask("task1")
task2 = BaseTask("task2")
task3 = BaseTask("task3")
task4 = BaseTask("task4")
task5 = BaseTask("task5")
task3.extend_input_task_list([task1, task2])
task5.extend_input_task_list([task3, task4])
w = BaseWorkflow([task1, task2, task3, task4, task5])
return w
def SF_workflow(scope="function"):
"""
Simple workflow including StartToFinish dependency
"""
task1 = BaseTask("task1")
task2 = BaseTask("task2")
task3 = BaseTask("task3")
task2.append_input_task(task1, task_dependency_mode=BaseTaskDependency.SF)
task3.append_input_task(task1, task_dependency_mode=BaseTaskDependency.FS)
task3.append_input_task(task2, task_dependency_mode=BaseTaskDependency.SS)
return BaseWorkflow([task1, task2, task3])
def test_get_networkx_graph():
"""test_get_networkx_graph."""
task1 = BaseTask("task1")
task1.state_record_list = [
BaseTaskState.READY,
BaseTaskState.READY,
BaseTaskState.WORKING,
BaseTaskState.FINISHED,
BaseTaskState.FINISHED,
]
task2 = BaseTask("task2")
task2.state_record_list = [
BaseTaskState.READY,
BaseTaskState.READY,
BaseTaskState.WORKING,
BaseTaskState.FINISHED,
BaseTaskState.FINISHED,
]
task2.append_input_task(task1)
w = BaseWorkflow([task1, task2])
w.get_networkx_graph()
def test_initialize():
task = BaseTask("task")
task.est = 2.0
task.eft = 10.0
task.lst = 3.0
task.lft = 11.0
task.remaining_work_amount = 7
task.actual_work_amount = 6
task.state = BaseTaskState.FINISHED
task.ready_time_list = [1]
task.start_time_list = [2]
task.finish_time_list = [15]
task.additional_task_flag = True
task.allocated_worker_list = [BaseResource("w1")]
task_after1 = BaseTask("task_after1")
task_after2 = BaseTask("task_after2", default_work_amount=5.0)
task_after1.append_input_task(task)
task_after2.append_input_task(task)
w = BaseWorkflow([task, task_after1, task_after2])
w.critical_path_length = 100.0
w.initialize()
assert w.critical_path_length == 20.0
assert w.task_list[0].est == 0.0
assert w.task_list[0].eft == 10.0
assert w.task_list[0].lst == 0.0
assert w.task_list[0].lft == 10.0
assert w.task_list[0].state == BaseTaskState.READY
assert w.task_list[1].est == 10.0
assert w.task_list[1].eft == 20.0
assert w.task_list[1].lst == 10.0
assert w.task_list[1].lft == 20.0
assert w.task_list[1].state == BaseTaskState.NONE
assert w.task_list[2].est == 10.0
assert w.task_list[2].eft == 15.0
assert w.task_list[2].lst == 15.0
assert w.task_list[2].lft == 20.0
assert w.task_list[2].state == BaseTaskState.NONE
def test_init():
task1 = BaseTask("task1")
task1.start_time_list = [1]
task1.ready_time_list = [0]
task1.finish_time_list = [3]
task2 = BaseTask("task2")
task2.start_time_list = [4]
task2.ready_time_list = [4]
task2.finish_time_list = [6]
task2.append_input_task(task1)
w = BaseWorkflow([task1, task2])
assert w.task_list == [task1, task2]
assert w.critical_path_length == 0.0
def test_create_data_for_gantt_plotly():
"""test_create_data_for_gantt_plotly."""
task1 = BaseTask("task1")
task1.state_record_list = [
BaseTaskState.READY,
BaseTaskState.READY,
BaseTaskState.WORKING,
BaseTaskState.FINISHED,
BaseTaskState.FINISHED,
]
task2 = BaseTask("task2")
task2.state_record_list = [
BaseTaskState.READY,
BaseTaskState.READY,
BaseTaskState.WORKING,
BaseTaskState.FINISHED,
BaseTaskState.FINISHED,
]
task2.append_input_task(task1)
w = BaseWorkflow([task1, task2])
init_datetime = datetime.datetime(2020, 4, 1, 8, 0, 0)
timedelta = datetime.timedelta(days=1)
w.create_data_for_gantt_plotly(init_datetime, timedelta, view_ready=True)
def test_get_node_and_edge_trace_for_plotly_network():
task1 = BaseTask("task1")
task1.start_time_list = [1]
task1.ready_time_list = [0]
task1.finish_time_list = [3]
task2 = BaseTask("task2")
task2.start_time_list = [4]
task2.ready_time_list = [4]
task2.finish_time_list = [6]
task2.append_input_task(task1)
w = BaseWorkflow([task1, task2])
(
task_node_trace,
auto_task_node_trace,
edge_trace,
) = w.get_node_and_edge_trace_for_plotly_network()
# TODO
# assert...
(
task_node_trace,
auto_task_node_trace,
edge_trace,
) = w.get_node_and_edge_trace_for_plotly_network()
def test_draw_plotly_network(tmpdir):
"""test_draw_plotly_network."""
task0 = BaseTask("auto", auto_task=True)
task1 = BaseTask("task1")
task1.state_record_list = [
BaseTaskState.READY,
BaseTaskState.READY,
BaseTaskState.WORKING,
BaseTaskState.FINISHED,
BaseTaskState.FINISHED,
]
task2 = BaseTask("task2")
task2.state_record_list = [
BaseTaskState.READY,
BaseTaskState.READY,
BaseTaskState.WORKING,
BaseTaskState.FINISHED,
BaseTaskState.FINISHED,
]
task2.append_input_task(task1)
w = BaseWorkflow([task1, task2, task0])
for ext in ["png", "html", "json"]:
save_fig_path = os.path.join(str(tmpdir), "test." + ext)
w.draw_plotly_network(save_fig_path=save_fig_path)
def dummy_simple_project(scope="function"):
c = BaseComponent("c", space_size=1.0)
task1 = BaseTask("task1", default_work_amount=2.0)
task2 = BaseTask("task2", default_work_amount=2.0)
auto_task2 = BaseTask("auto_task2",
auto_task=True,
default_work_amount=2.0)
task2.append_input_task(auto_task2)
task3 = BaseTask("task3", default_work_amount=2.0)
auto_task3 = BaseTask("auto_task3",
auto_task=True,
default_work_amount=4.0)
task3.append_input_task(auto_task3)
workflow = BaseWorkflow([task1, task2, task3, auto_task2, auto_task3])
c.extend_targeted_task_list([task1, task2, task3])
product = BaseProduct([c])
# BaseTeams in BaseOrganization
team = BaseTeam("team")
team.extend_targeted_task_list([task1, task2, task3])
# BaseWorkers in each BaseTeam
w1 = BaseWorker("w1", team_id=team.ID)
w1.workamount_skill_mean_map = {
task1.name: 1.0,
}
team.add_worker(w1)
w2 = BaseWorker("w1", team_id=team.ID)
w2.workamount_skill_mean_map = {
task2.name: 1.0,
}
team.add_worker(w2)
w3 = BaseWorker("w3", team_id=team.ID)
w3.workamount_skill_mean_map = {
task3.name: 1.0,
}
team.add_worker(w3)
project = BaseProject(
init_datetime=datetime.datetime(2020, 4, 1, 8, 0, 0),
unit_timedelta=datetime.timedelta(days=1),
product=product,
workflow=workflow,
organization=BaseOrganization(team_list=[team]),
)
return project
def dummy_workflow_for_extracting(scope="function"):
"""dummy_workflow_for_extracting."""
task1 = BaseTask("task1")
task1.state_record_list = [
BaseTaskState.WORKING,
BaseTaskState.FINISHED,
BaseTaskState.FINISHED,
BaseTaskState.FINISHED,
BaseTaskState.FINISHED,
]
task2 = BaseTask("task2")
task2.state_record_list = [
BaseTaskState.WORKING,
BaseTaskState.WORKING,
BaseTaskState.FINISHED,
BaseTaskState.FINISHED,
BaseTaskState.FINISHED,
]
task3 = BaseTask("task3")
task3.state_record_list = [
BaseTaskState.READY,
BaseTaskState.WORKING,
BaseTaskState.WORKING,
BaseTaskState.FINISHED,
BaseTaskState.FINISHED,
]
task4 = BaseTask("task4")
task4.state_record_list = [
BaseTaskState.NONE,
BaseTaskState.READY,
BaseTaskState.WORKING,
BaseTaskState.WORKING,
BaseTaskState.FINISHED,
]
task5 = BaseTask("task5")
task5.state_record_list = [
BaseTaskState.NONE,
BaseTaskState.NONE,
BaseTaskState.READY,
BaseTaskState.READY,
BaseTaskState.WORKING,
]
return BaseWorkflow([task1, task2, task3, task4, task5])
def test_remove_insert_absence_time_list():
"""test_remove_insert_absence_time_list."""
w1 = BaseTask("w1", "----")
w1.allocated_worker_id_record = ["aa", "bb", "cc", "dd", "ee", "ff"]
w1.allocated_facility_id_record = ["aa", "bb", "cc", "dd", "ee", "ff"]
w1.state_record_list = [0, 1, 2, 3, 4, 5]
w2 = BaseTask("w2", "----")
w2.allocated_worker_id_record = ["aa", "bb", "cc", "dd", "ee", "ff"]
w2.allocated_facility_id_record = ["aa", "bb", "cc", "dd", "ee", "ff"]
w2.state_record_list = [0, 1, 2, 3, 4, 5]
w2.append_input_task(w1)
workflow = BaseWorkflow([w1, w2])
absence_time_list = [3, 4]
workflow.remove_absence_time_list(absence_time_list)
assert w1.allocated_worker_id_record == ["aa", "bb", "cc", "ff"]
assert w1.allocated_facility_id_record == ["aa", "bb", "cc", "ff"]
assert w1.state_record_list == [0, 1, 2, 5]
assert w2.allocated_worker_id_record == ["aa", "bb", "cc", "ff"]
assert w2.allocated_facility_id_record == ["aa", "bb", "cc", "ff"]
assert w2.state_record_list == [0, 1, 2, 5]
workflow.insert_absence_time_list(absence_time_list)
assert w1.allocated_worker_id_record == [
"aa", "bb", "cc", "cc", "cc", "ff"
]
assert w1.allocated_facility_id_record == [
"aa", "bb", "cc", "cc", "cc", "ff"
]
assert w1.state_record_list == [0, 1, 2, 1, 1, 5]
assert w2.allocated_worker_id_record == [
"aa", "bb", "cc", "cc", "cc", "ff"
]
assert w2.allocated_facility_id_record == [
"aa", "bb", "cc", "cc", "cc", "ff"
]
assert w2.state_record_list == [0, 1, 2, 1, 1, 5]
def test_plot_simple_gantt(tmpdir):
"""test_plot_simple_gantt."""
task0 = BaseTask("auto", auto_task=True)
task0.state_record_list = [
BaseTaskState.READY,
BaseTaskState.WORKING,
BaseTaskState.FINISHED,
BaseTaskState.WORKING,
BaseTaskState.WORKING,
BaseTaskState.FINISHED,
]
task1 = BaseTask("task1")
task1.state_record_list = [
BaseTaskState.WORKING,
BaseTaskState.WORKING,
BaseTaskState.FINISHED,
BaseTaskState.WORKING,
BaseTaskState.FINISHED,
BaseTaskState.FINISHED,
]
task2 = BaseTask("task2")
task2.state_record_list = [
BaseTaskState.WORKING,
BaseTaskState.WORKING,
BaseTaskState.FINISHED,
BaseTaskState.WORKING,
BaseTaskState.FINISHED,
BaseTaskState.FINISHED,
]
w = BaseWorkflow([task1, task2, task0])
w.plot_simple_gantt(finish_margin=1.0,
view_auto_task=True,
view_ready=False)
for ext in ["png"]:
save_fig_path = os.path.join(str(tmpdir), "test." + ext)
w.plot_simple_gantt(view_ready=True,
view_auto_task=True,
save_fig_path=save_fig_path)
def test_create_simple_gantt():
task0 = BaseTask("auto", auto_task=True)
task0.start_time_list = [1]
task0.ready_time_list = [0]
task0.finish_time_list = [3]
task1 = BaseTask("task1")
task1.start_time_list = [1]
task1.ready_time_list = [0]
task1.finish_time_list = [3]
task2 = BaseTask("task2")
task2.start_time_list = [4]
task2.ready_time_list = [4]
task2.finish_time_list = [6]
task2.append_input_task(task1)
w = BaseWorkflow([task1, task2, task0])
w.create_simple_gantt(finish_margin=1.0,
view_auto_task=True,
view_ready=False)
w.create_simple_gantt(view_ready=True,
view_auto_task=True,
save_fig_path="test.png")
if os.path.exists("test.png"):
os.remove("test.png")
def dummy_conveyor_project_with_child_component():
"""dummy_conveyor_project_with_child_component."""
c1_1 = BaseComponent("c1_1")
c1_2 = BaseComponent("c1_2")
c2_1 = BaseComponent("c2_1")
c2_2 = BaseComponent("c2_2")
c3_1 = BaseComponent("c3_1")
c3_2 = BaseComponent("c3_2")
c1_2.append_child_component(c1_1)
c2_2.append_child_component(c2_1)
c3_2.append_child_component(c3_1)
taskA1 = BaseTask("A1", need_facility=True, default_work_amount=6)
taskA2 = BaseTask("A2", need_facility=True, default_work_amount=2)
taskA3 = BaseTask("A3", need_facility=True, default_work_amount=2)
taskB1 = BaseTask("B1", need_facility=True, default_work_amount=2)
taskB2 = BaseTask("B2", need_facility=True, default_work_amount=7)
taskB3 = BaseTask("B3", need_facility=True, default_work_amount=2)
c1_1.append_targeted_task(taskA1)
c1_2.append_targeted_task(taskB1)
c2_1.append_targeted_task(taskA2)
c2_2.append_targeted_task(taskB2)
c3_1.append_targeted_task(taskA3)
c3_2.append_targeted_task(taskB3)
taskB1.append_input_task(taskA1)
taskB2.append_input_task(taskA2)
taskB3.append_input_task(taskA3)
f1 = BaseFacility("f1")
f1.workamount_skill_mean_map = {
taskA1.name: 1.0,
taskA2.name: 1.0,
taskA3.name: 1.0,
}
f2 = BaseFacility("f2")
f2.workamount_skill_mean_map = {
taskA1.name: 1.0,
taskA2.name: 1.0,
taskA3.name: 1.0,
}
f3 = BaseFacility("f3")
f3.workamount_skill_mean_map = {
taskB1.name: 1.0,
taskB2.name: 1.0,
taskB3.name: 1.0,
}
f4 = BaseFacility("f4")
f4.workamount_skill_mean_map = {
taskB1.name: 1.0,
taskB2.name: 1.0,
taskB3.name: 1.0,
}
# Workplace in BaseOrganization
wp1 = BaseWorkplace("workplace1", facility_list=[f1], max_space_size=1.0)
wp1.extend_targeted_task_list([taskA1, taskA2, taskA3])
wp2 = BaseWorkplace("workplace2", facility_list=[f2], max_space_size=2.0)
wp2.extend_targeted_task_list([taskA1, taskA2, taskA3])
wp3 = BaseWorkplace("workplace3", facility_list=[f3], max_space_size=4.0)
wp3.extend_targeted_task_list([taskB1, taskB2, taskB3])
wp4 = BaseWorkplace("workplace4", facility_list=[f4], max_space_size=4.0)
wp4.extend_targeted_task_list([taskB1, taskB2, taskB3])
wp3.append_input_workplace(wp1)
wp4.append_input_workplace(wp2)
# BaseTeams in BaseOrganization
team = BaseTeam("team")
team_list = [team]
team.extend_targeted_task_list(
[taskA1, taskA2, taskA3, taskB1, taskB2, taskB3])
# BaseWorkers in each BaseTeam
w1 = BaseWorker("w1", team_id=team.ID)
w1.workamount_skill_mean_map = {
taskA1.name: 1.0,
taskA2.name: 1.0,
taskA3.name: 1.0,
}
w1.facility_skill_map = {f1.name: 1.0}
team.add_worker(w1)
w2 = BaseWorker("w2", team_id=team.ID)
w2.workamount_skill_mean_map = {
taskA1.name: 1.0,
taskA2.name: 1.0,
taskA3.name: 1.0,
}
w2.facility_skill_map = {f2.name: 1.0}
team.add_worker(w2)
w3 = BaseWorker("w3", team_id=team.ID)
w3.workamount_skill_mean_map = {
taskB1.name: 1.0,
taskB2.name: 1.0,
taskB3.name: 1.0,
}
w3.facility_skill_map = {f3.name: 1.0}
team.add_worker(w3)
w4 = BaseWorker("w4", team_id=team.ID)
w4.workamount_skill_mean_map = {
taskB1.name: 1.0,
taskB2.name: 1.0,
taskB3.name: 1.0,
}
w4.facility_skill_map = {f4.name: 1.0}
team.add_worker(w4)
workplace_list = [wp1, wp2, wp3, wp4]
# BaseProject including BaseProduct, BaseWorkflow and Organization
project = BaseProject(
init_datetime=datetime.datetime(2021, 8, 20, 8, 0, 0),
unit_timedelta=datetime.timedelta(days=1),
product=BaseProduct([c1_1, c1_2, c2_1, c2_2, c3_1, c3_2]),
workflow=BaseWorkflow([taskA1, taskA2, taskA3, taskB1, taskB2,
taskB3]),
organization=BaseOrganization(team_list, workplace_list),
)
return project
def dummy_place_check():
c3 = BaseComponent("c3", space_size=1.0)
c1 = BaseComponent("c1", space_size=1.0)
c2 = BaseComponent("c2", space_size=1.0)
task1 = BaseTask("t1", need_facility=True)
task2 = BaseTask("t2", need_facility=True)
task3 = BaseTask("t3", need_facility=True)
c1.append_targeted_task(task1)
c2.append_targeted_task(task2)
c3.append_targeted_task(task3)
# Facilities in factory
f1 = BaseFacility("f1")
f1.solo_working = True
f1.workamount_skill_mean_map = {
task1.name: 1.0,
task2.name: 1.0,
task3.name: 1.0,
}
f2 = BaseFacility("f2")
f2.solo_working = True
f2.workamount_skill_mean_map = {
task1.name: 1.0,
task2.name: 1.0,
task3.name: 1.0,
}
# Factory in BaseOrganization
factory = BaseFactory("factory", facility_list=[f1, f2])
factory.extend_targeted_task_list([task1, task2, task3])
# BaseTeams in BaseOrganization
team = BaseTeam("team")
team.extend_targeted_task_list([task1, task2, task3])
# BaseResources in each BaseTeam
w1 = BaseWorker("w1", team_id=team.ID, cost_per_time=10.0)
w1.workamount_skill_mean_map = {
task1.name: 1.0,
task2.name: 1.0,
task3.name: 1.0,
}
w1.facility_skill_map = {f1.name: 1.0}
team.worker_list.append(w1)
w2 = BaseWorker("w2", team_id=team.ID, cost_per_time=6.0)
w2.workamount_skill_mean_map = {
task1.name: 1.0,
task2.name: 1.0,
task3.name: 1.0,
}
w2.facility_skill_map = {f2.name: 1.0}
team.worker_list.append(w2)
# BaseProject including BaseProduct, BaseWorkflow and Organization
project = BaseProject(
init_datetime=datetime.datetime(2020, 4, 1, 8, 0, 0),
unit_timedelta=datetime.timedelta(days=1),
product=BaseProduct([c1, c2, c3]),
workflow=BaseWorkflow([task1, task2, task3]),
organization=BaseOrganization(team_list=[team],
factory_list=[factory]),
)
return project
def dummy_project2(scope="function"):
# BaseComponents in BaseProduct
c3 = BaseComponent("c3")
c1 = BaseComponent("c1")
c2 = BaseComponent("c2")
c3.extend_child_component_list([c1, c2])
# BaseTasks in BaseWorkflow
task1_1 = BaseTask("task1_1", need_facility=True)
task1_2 = BaseTask("task1_2")
task2_1 = BaseTask("task2_1")
task3 = BaseTask("task3", due_time=30)
task3.extend_input_task_list([task1_2, task2_1])
task1_2.append_input_task(task1_1)
task0 = BaseTask("auto", auto_task=True, due_time=20)
c1.extend_targeted_task_list([task1_1, task1_2])
c2.append_targeted_task(task2_1)
c3.append_targeted_task(task3)
# Facilities in factory
f1 = BaseFacility("f1")
f1.workamount_skill_mean_map = {
task1_1.name: 1.0,
}
# factory.facility_list.append(f1)
# Factory in BaseOrganization
factory = BaseFactory("factory", facility_list=[f1])
factory.extend_targeted_task_list([task1_1, task1_2, task2_1, task3])
# BaseTeams in BaseOrganization
team = BaseTeam("team")
team.extend_targeted_task_list([task1_1, task1_2, task2_1, task3])
# BaseResources in each BaseTeam
w1 = BaseWorker("w1", team_id=team.ID, cost_per_time=10.0)
w1.workamount_skill_mean_map = {
task1_1.name: 1.0,
task1_2.name: 1.0,
task2_1.name: 0.0,
task3.name: 1.0,
}
w1.facility_skill_map = {f1.name: 1.0}
team.worker_list.append(w1)
w2 = BaseWorker("w2", team_id=team.ID, cost_per_time=6.0)
w2.solo_working = True
w2.workamount_skill_mean_map = {
task1_1.name: 1.0,
task1_2.name: 0.0,
task2_1.name: 1.0,
task3.name: 1.0,
}
w2.facility_skill_map = {f1.name: 1.0}
team.worker_list.append(w2)
# BaseProject including BaseProduct, BaseWorkflow and Organization
project = BaseProject(
init_datetime=datetime.datetime(2020, 4, 1, 8, 0, 0),
unit_timedelta=datetime.timedelta(days=1),
product=BaseProduct([c3, c1, c2]),
workflow=BaseWorkflow([task1_1, task1_2, task2_1, task3, task0]),
organization=BaseOrganization(team_list=[team],
factory_list=[factory]),
time=10,
cost_list=[10],
)
project.initialize()
# project.product = BaseProduct([c3, c1, c2])
# project.workflow = BaseWorkflow([task1_1, task1_2, task2_1, task3])
# project.organization = BaseOrganization(team_list=[team], factory_list=[factory])
return project
def test_str():
"""test_str."""
print(BaseWorkflow([]))
def test_check_state():
task1 = BaseTask("task1")
task2 = BaseTask("task2")
task3 = BaseTask("task3")
task4 = BaseTask("task4")
task5 = BaseTask("task5")
task3.extend_input_task_list([task1, task2])
task5.extend_input_task_list([task3, task4])
w = BaseWorkflow([task1, task2, task3, task4, task5])
w1 = BaseResource("w1", assigned_task_list=[task1])
# __check_ready test
task1.state = BaseTaskState.FINISHED
task2.state = BaseTaskState.FINISHED
task3.state = BaseTaskState.NONE
task4.state = BaseTaskState.NONE
task5.state = BaseTaskState.NONE
w.check_state(2, BaseTaskState.READY)
assert task1.state == BaseTaskState.FINISHED
assert task2.state == BaseTaskState.FINISHED
assert task3.state == BaseTaskState.READY
assert task4.state == BaseTaskState.READY
assert task5.state == BaseTaskState.NONE
# __check_working test
task1.state = BaseTaskState.READY
task2.state = BaseTaskState.READY
task2.allocated_worker_list = [w1]
task3.state = BaseTaskState.NONE
task4.state = BaseTaskState.NONE
task5.state = BaseTaskState.NONE
w.check_state(2, BaseTaskState.WORKING)
assert task1.state == BaseTaskState.READY
assert task2.state == BaseTaskState.WORKING
assert task3.state == BaseTaskState.NONE
assert task4.state == BaseTaskState.NONE
assert task5.state == BaseTaskState.NONE
task1.state = BaseTaskState.WORKING
task1.need_facility = True
w2 = BaseResource("w2", assigned_task_list=[task1])
f2 = BaseFacility("f2", assigned_task_list=[task1])
task1.allocated_worker_list = [w2]
task1.allocated_facility_list = [f2]
w.check_state(2, BaseTaskState.WORKING)
# __check_finished test
task1.state = BaseTaskState.WORKING
task1.allocated_worker_list = [w1]
task1.remaining_work_amount = 0.0
task2.state = BaseTaskState.FINISHED
task3.state = BaseTaskState.NONE
task4.state = BaseTaskState.NONE
task5.state = BaseTaskState.NONE
w.check_state(2, BaseTaskState.FINISHED)
assert task1.state == BaseTaskState.FINISHED
assert task2.state == BaseTaskState.FINISHED
assert task3.state == BaseTaskState.NONE
assert task4.state == BaseTaskState.NONE
assert task5.state == BaseTaskState.NONE
def project_for_checking_space_judge(cope="function"):
"""project_for_checking_space_judge."""
project = BaseProject(
init_datetime=datetime.datetime(2021, 4, 2, 8, 0, 0),
unit_timedelta=datetime.timedelta(minutes=1),
)
# Components in Product
a = BaseComponent("a")
b = BaseComponent("b")
# Register Product including Components in Project
project.product = BaseProduct([a, b])
# Tasks in Workflow
# define work_amount and whether or not to need facility for each task
task_a = BaseTask(
"task_a",
need_facility=True,
worker_priority_rule=ResourcePriorityRuleMode.HSV,
default_work_amount=2,
)
task_b = BaseTask(
"task_b",
need_facility=True,
worker_priority_rule=ResourcePriorityRuleMode.HSV,
default_work_amount=2,
)
# Register Workflow including Tasks in Project
project.workflow = BaseWorkflow([task_a, task_b])
# workplace in workplace model
# define max_space_size which decide how many components can be placed
workplace1 = BaseWorkplace("workplace1", max_space_size=3.0)
workplace2 = BaseWorkplace("workplace2", max_space_size=3.0)
# facility in workplace model
# define workplace_id (each facility is placed which workplace) and cost_per_time
machine1 = BaseFacility("machine1",
workplace_id=workplace1.ID,
cost_per_time=10,
solo_working=True)
machine2 = BaseFacility("machine2",
workplace_id=workplace2.ID,
cost_per_time=10,
solo_working=True)
# define each facility task skill value
machine1.workamount_skill_mean_map = {task_a.name: 1.0, task_b.name: 1.0}
machine2.workamount_skill_mean_map = {task_a.name: 1.0, task_b.name: 1.0}
# define facilities belonging to wach workplace
workplace1.add_facility(machine1)
workplace2.add_facility(machine2)
# Team in team mode
team = BaseTeam("factory_A")
# worker in team model
# define cost_per_time and add each worker to the relevant team
w1 = BaseWorker("w1", cost_per_time=10.0)
team.add_worker(w1)
w2 = BaseWorker("w2", cost_per_time=10.0)
team.add_worker(w2)
# define each worker task skill value
# (Set the skill value of an average worker as 1.0)
w1.workamount_skill_mean_map = {task_a.name: 1.0, task_b.name: 1.0}
w2.workamount_skill_mean_map = {task_a.name: 1.0, task_b.name: 1.0}
# define each worker facility skill value
w1.facility_skill_map = {machine1.name: 1.0}
w2.facility_skill_map = {machine2.name: 1.0}
# Register Organization including Team in Project
team_list = [team]
workplace_list = [workplace1, workplace2]
project.organization = BaseOrganization(team_list, workplace_list)
# Component <-> Task
a.append_targeted_task(task_a)
b.append_targeted_task(task_b)
# Team <-> Task
team.extend_targeted_task_list([task_a, task_b])
# Workplace <-> Task
workplace1.extend_targeted_task_list([task_a, task_b])
workplace2.extend_targeted_task_list([task_a, task_b])
return project
def test_str():
print(BaseWorkflow([]))
