def test_perform():
auto = BaseTask("a", auto_task=True, state=BaseTaskState.WORKING)
auto.perform(0, seed=1234)
assert auto.remaining_work_amount == auto.default_work_amount - 1
task = BaseTask("task")
task.state = BaseTaskState.READY
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)
task.perform(10)
assert task.remaining_work_amount == task.default_work_amount
assert task.target_component == c
# assert c.error == 0.0
task.state = BaseTaskState.WORKING
task.perform(10)
assert task.remaining_work_amount == task.default_work_amount - 1.0
assert task.target_component == c
# assert c.error == 0.0
# Next test case
w1.workamount_skill_sd_map = {"task": 0.2}
# w1.quality_skill_mean_map = {"task": 0.9}
# w1.quality_skill_sd_map = {"task": 0.02}
task.perform(11, seed=1234)
assert task.remaining_work_amount == 7.905712967253502
def test_init():
c1 = BaseComponent("c1")
assert c1.name == "c1"
assert len(c1.ID) > 0
c2 = BaseComponent("c2")
task = BaseTask("task")
c = BaseComponent(
"c",
ID="xx88xx",
child_component_list=[c1],
parent_component_list=[c2],
targeted_task_list=[task],
space_size=2.0,
placed_factory=BaseFactory("t"),
placed_factory_id_record=["fff"],
)
assert c.name == "c"
assert c.ID == "xx88xx"
assert c.child_component_list == [c1]
assert c.parent_component_list == [c2]
assert c.targeted_task_list == [task]
assert c.space_size == 2.0
assert c.placed_factory.name == "t"
assert c.placed_factory_id_record == ["fff"]
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_create_data_for_gantt_plotly():
c = BaseComponent("c")
task1 = BaseTask("task1")
task2 = BaseTask("task2")
c.extend_targeted_task_list([task1, task2])
# Set test case (start time = 0, finish time = 5)
task1.start_time_list = [0, 2]
task1.ready_time_list = [0, 2]
task1.finish_time_list = [3, 5]
task2.start_time_list = [1]
task2.ready_time_list = [2]
task2.finish_time_list = [5]
init_datetime = datetime.datetime(2020, 4, 1, 8, 0, 0)
# timedelta = 1day
timedelta = datetime.timedelta(days=1)
df = c.create_data_for_gantt_plotly(init_datetime, timedelta)
assert df[0]["Start"] == (init_datetime + 0 * timedelta).strftime(
"%Y-%m-%d %H:%M:%S"
)
assert df[0]["Finish"] == (init_datetime + (5 + 1.0) * timedelta).strftime(
"%Y-%m-%d %H:%M:%S"
)
assert df[0]["Type"] == "Component"
def test_init():
"""test_init."""
c1 = BaseComponent("c1")
assert c1.name == "c1"
assert len(c1.ID) > 0
c2 = BaseComponent("c2")
task = BaseTask("task")
c = BaseComponent(
"c",
ID="xx88xx",
child_component_list=[c1],
parent_component_list=[c2],
targeted_task_list=[task],
space_size=2.0,
state=BaseComponentState.FINISHED,
state_record_list=["aa"],
placed_workplace=BaseWorkplace("t"),
placed_workplace_id_record=["fff"],
)
assert c.name == "c"
assert c.ID == "xx88xx"
assert c.child_component_list == [c1]
assert c.parent_component_list == [c2]
assert c.targeted_task_list == [task]
assert c.space_size == 2.0
assert c.placed_workplace.name == "t"
assert c.placed_workplace_id_record == ["fff"]
def test_append_targeted_task():
c = BaseComponent("c")
assert c.parent_component_list == []
task = BaseTask("task1")
assert task.target_component is None
c.append_targeted_task(task)
assert c.targeted_task_list == [task]
assert task.target_component == c
def test_extend_targeted_task_list():
c = BaseComponent("c")
assert c.parent_component_list == []
task1 = BaseTask("task1")
task2 = BaseTask("task2")
c.extend_targeted_task_list([task1, task2])
assert c.targeted_task_list == [task1, task2]
assert task1.target_component == c
assert task2.target_component == c
def test_create_data_for_gantt_plotly():
"""test_create_data_for_gantt_plotly."""
c = BaseComponent("c")
c.state_record_list = [
BaseComponentState.WORKING,
BaseComponentState.FINISHED,
BaseComponentState.FINISHED,
BaseComponentState.FINISHED,
BaseComponentState.FINISHED,
]
init_datetime = datetime.datetime(2020, 4, 1, 8, 0, 0)
timedelta = datetime.timedelta(days=1)
c.create_data_for_gantt_plotly(init_datetime, timedelta)
def test_can_put():
c1 = BaseComponent("c1", space_size=2.0)
c2 = BaseComponent("c2", space_size=2.0)
factory = BaseFactory("f", max_space_size=1.0)
assert factory.can_put(c1) is False
assert factory.can_put(c2) is False
factory.max_space_size = 3.0
assert factory.can_put(c1) is True
assert factory.can_put(c2) is True
factory.set_placed_component(c1)
assert factory.can_put(c2) is False
factory.max_space_size = 4.0
assert factory.can_put(c2) is True
def test_create_gantt_plotly():
c1 = BaseComponent("c1")
task11 = BaseTask("task11")
task12 = BaseTask("task12")
c1.extend_targeted_task_list([task11, task12])
c2 = BaseComponent("c2")
task2 = BaseTask("task2")
c2.append_targeted_task(task2)
product = BaseProduct([c1, c2])
# Set test case
task11.start_time_list = [0, 2]
task11.ready_time_list = [0, 2]
task11.finish_time_list = [3, 5]
task12.start_time_list = [1]
task12.ready_time_list = [2]
task12.finish_time_list = [5]
task2.start_time_list = [1]
task2.ready_time_list = [2]
task2.finish_time_list = [5]
init_datetime = datetime.datetime(2020, 4, 1, 8, 0, 0)
timedelta = datetime.timedelta(days=1)
product.create_gantt_plotly(init_datetime,
timedelta,
save_fig_path="test.png")
if os.path.exists("test.png"):
os.remove("test.png")
def test_create_data_for_gantt_plotly():
c1 = BaseComponent("c1")
task11 = BaseTask("task11")
task12 = BaseTask("task12")
c1.extend_targeted_task_list([task11, task12])
c2 = BaseComponent("c2")
task2 = BaseTask("task2")
c2.append_targeted_task(task2)
product = BaseProduct([c1, c2])
# Set test case
task11.start_time_list = [0, 2]
task11.ready_time_list = [0, 2]
task11.finish_time_list = [3, 5]
task12.start_time_list = [1]
task12.ready_time_list = [2]
task12.finish_time_list = [5]
task2.start_time_list = [1]
task2.ready_time_list = [2]
task2.finish_time_list = [5]
init_datetime = datetime.datetime(2020, 4, 1, 8, 0, 0)
timedelta = datetime.timedelta(days=1)
df = product.create_data_for_gantt_plotly(init_datetime, timedelta)
assert df[0]["Start"] == (init_datetime +
0 * timedelta).strftime("%Y-%m-%d %H:%M:%S")
assert df[0]["Finish"] == (
init_datetime + (5 + 1.0) * timedelta).strftime("%Y-%m-%d %H:%M:%S")
assert df[0]["Type"] == "Component"
assert df[1]["Start"] == (init_datetime +
1 * timedelta).strftime("%Y-%m-%d %H:%M:%S")
assert df[1]["Finish"] == (
init_datetime + (5 + 1.0) * timedelta).strftime("%Y-%m-%d %H:%M:%S")
assert df[1]["Type"] == "Component"
def test_can_put():
"""test_can_put."""
c1 = BaseComponent("c1", space_size=2.0)
c2 = BaseComponent("c2", space_size=2.0)
workplace = BaseWorkplace("f", max_space_size=1.0)
assert workplace.can_put(c1) is False
assert workplace.can_put(c2) is False
workplace.max_space_size = 3.0
assert workplace.can_put(c1) is True
assert workplace.can_put(c2) is True
workplace.set_placed_component(c1)
assert workplace.can_put(c2) is False
workplace.max_space_size = 4.0
assert workplace.can_put(c2) is True
def test_append_child_component():
c = BaseComponent("c")
assert c.parent_component_list == []
c1 = BaseComponent("c1")
c2 = BaseComponent("c2")
c.append_child_component(c1)
c1.append_child_component(c2)
assert c.child_component_list == [c1]
assert c1.child_component_list == [c2]
assert c2.parent_component_list == [c1]
assert c1.parent_component_list == [c]
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_remove_placed_component():
"""test_remove_placed_component."""
c = BaseComponent("c")
c1 = BaseComponent("c1")
c2 = BaseComponent("c2")
c.append_child_component(c1)
c1.append_child_component(c2)
workplace = BaseWorkplace("workplace")
workplace.set_placed_component(c)
assert workplace.placed_component_list == [c, c1, c2]
workplace.remove_placed_component(c)
assert workplace.placed_component_list == []
def test_init():
"""test_init."""
workplace = BaseWorkplace("workplace")
assert workplace.name == "workplace"
assert len(workplace.ID) > 0
assert workplace.facility_list == []
assert workplace.targeted_task_list == []
assert workplace.parent_workplace is None
assert workplace.max_space_size == 1.0
assert workplace.input_workplace_list == []
assert workplace.output_workplace_list == []
assert workplace.cost_list == []
workplace.cost_list.append(1)
assert workplace.cost_list == [1.0]
w1 = BaseFacility("w1")
t1 = BaseTask("task1")
workplace1 = BaseWorkplace(
"workplace1",
parent_workplace=workplace,
targeted_task_list=[t1],
facility_list=[w1],
max_space_size=2.0,
cost_list=[10],
placed_component_list=[BaseComponent("c")],
placed_component_id_record=["xxxx"],
)
assert workplace1.facility_list == [w1]
assert workplace1.targeted_task_list == [t1]
assert workplace1.parent_workplace == workplace
assert workplace1.max_space_size == 2.0
assert workplace1.cost_list == [10]
assert workplace1.placed_component_list[0].name == "c"
assert workplace1.placed_component_id_record == ["xxxx"]
def test_init():
factory = BaseFactory("factory")
assert factory.name == "factory"
assert len(factory.ID) > 0
assert factory.facility_list == []
assert factory.targeted_task_list == []
assert factory.parent_factory is None
assert factory.max_space_size == 1.0
assert factory.cost_list == []
factory.cost_list.append(1)
assert factory.cost_list == [1.0]
w1 = BaseFacility("w1")
t1 = BaseTask("task1")
factory1 = BaseFactory(
"factory1",
parent_factory=factory,
targeted_task_list=[t1],
facility_list=[w1],
max_space_size=2.0,
cost_list=[10],
placed_component_list=[BaseComponent("c")],
placed_component_id_record=["xxxx"],
)
assert factory1.facility_list == [w1]
assert factory1.targeted_task_list == [t1]
assert factory1.parent_factory == factory
assert factory1.max_space_size == 2.0
assert factory1.cost_list == [10]
assert factory1.placed_component_list[0].name == "c"
assert factory1.placed_component_id_record == ["xxxx"]
def test_remove_placed_component():
c = BaseComponent("c")
factory = BaseFactory("factory")
factory.set_placed_component(c)
assert factory.placed_component_list == [c]
factory.remove_placed_component(c)
assert factory.placed_component_list == []
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 test_get_available_space_size():
"""test_get_available_space_size."""
max_space_size = 5.0
workplace = BaseWorkplace("f", max_space_size=max_space_size)
assert workplace.get_available_space_size() == max_space_size
c1_space_size = 3.0
workplace.set_placed_component(BaseComponent("c1", space_size=c1_space_size))
assert workplace.get_available_space_size() == max_space_size - c1_space_size
def test_remove_insert_absence_time_list():
"""test_remove_insert_absence_time_list."""
c1 = BaseComponent("c1", "----")
c1.placed_workplace_id_record = ["aa", "bb", "cc", "dd", "ee", "ff"]
c1.state_record_list = [0, 1, 2, 3, 4, 5]
c2 = BaseComponent("c2", "----")
c2.placed_workplace_id_record = ["ff", "ee", "dd", "cc", "bb", "aa"]
c2.state_record_list = [5, 4, 3, 2, 1, 0]
c2.append_child_component(c1)
product = BaseProduct([c1, c2])
absence_time_list = [0, 1]
product.remove_absence_time_list(absence_time_list)
assert c1.placed_workplace_id_record == ["cc", "dd", "ee", "ff"]
assert c1.state_record_list == [2, 3, 4, 5]
assert c2.placed_workplace_id_record == ["dd", "cc", "bb", "aa"]
assert c2.state_record_list == [3, 2, 1, 0]
product.insert_absence_time_list(absence_time_list)
assert c1.placed_workplace_id_record == [
None, None, "cc", "dd", "ee", "ff"
]
assert c1.state_record_list == [
BaseComponentState.NONE,
BaseComponentState.READY,
2,
3,
4,
5,
]
assert c2.placed_workplace_id_record == [
None, None, "dd", "cc", "bb", "aa"
]
assert c2.state_record_list == [
BaseComponentState.NONE,
BaseComponentState.NONE,
3,
2,
1,
0,
]
def test_get_time_list_for_gannt_chart():
w = BaseComponent("w1", "----")
w.state_record_list = [
BaseComponentState.NONE,
BaseComponentState.READY,
BaseComponentState.WORKING,
]
ready_time_list, working_time_list = w.get_time_list_for_gannt_chart()
assert ready_time_list == [(1, 1)]
assert working_time_list == [(2, 1)]
w.state_record_list = [
BaseComponentState.NONE,
BaseComponentState.READY,
BaseComponentState.READY,
]
ready_time_list, working_time_list = w.get_time_list_for_gannt_chart()
assert ready_time_list == [(1, 2)]
assert working_time_list == []
w.state_record_list = [
BaseComponentState.NONE,
BaseComponentState.WORKING,
BaseComponentState.FINISHED,
]
ready_time_list, working_time_list = w.get_time_list_for_gannt_chart()
assert ready_time_list == []
assert working_time_list == [(1, 1)]
# for backward
w.state_record_list = [
BaseComponentState.FINISHED,
BaseComponentState.WORKING,
BaseComponentState.READY,
BaseComponentState.READY,
BaseComponentState.FINISHED,
BaseComponentState.WORKING,
BaseComponentState.WORKING,
BaseComponentState.READY,
]
ready_time_list, working_time_list = w.get_time_list_for_gannt_chart()
assert ready_time_list == [(2, 2), (7, 1)]
assert working_time_list == [(1, 1), (5, 2)]
def test_plot_simple_gantt(tmpdir):
"""test_plot_simple_gantt."""
c1 = BaseComponent("c1")
c2 = BaseComponent("c2")
product = BaseProduct([c1, c2])
# Set test case
c1.state_record_list = [
BaseTaskState.READY,
BaseTaskState.WORKING,
BaseTaskState.FINISHED,
BaseTaskState.WORKING,
BaseTaskState.WORKING,
BaseTaskState.FINISHED,
]
c2.state_record_list = [
BaseTaskState.WORKING,
BaseTaskState.WORKING,
BaseTaskState.FINISHED,
BaseTaskState.WORKING,
BaseTaskState.FINISHED,
BaseTaskState.FINISHED,
]
for ext in ["png"]:
save_fig_path = os.path.join(str(tmpdir), "test." + ext)
product.plot_simple_gantt(save_fig_path=save_fig_path)
def test_create_data_for_gantt_plotly():
"""test_create_data_for_gantt_plotly."""
c1 = BaseComponent("c1")
c2 = BaseComponent("c2")
product = BaseProduct([c1, c2])
# Set test case
c1.state_record_list = [
BaseTaskState.READY,
BaseTaskState.WORKING,
BaseTaskState.FINISHED,
BaseTaskState.WORKING,
BaseTaskState.WORKING,
BaseTaskState.FINISHED,
]
c2.state_record_list = [
BaseTaskState.WORKING,
BaseTaskState.WORKING,
BaseTaskState.FINISHED,
BaseTaskState.WORKING,
BaseTaskState.FINISHED,
BaseTaskState.FINISHED,
]
init_datetime = datetime.datetime(2020, 4, 1, 8, 0, 0)
timedelta = datetime.timedelta(days=1)
product.create_data_for_gantt_plotly(init_datetime, timedelta)
def test_create_gantt_plotly(tmpdir):
"""test_create_gantt_plotly."""
c1 = BaseComponent("c1")
c2 = BaseComponent("c2")
product = BaseProduct([c1, c2])
# Set test case
c1.state_record_list = [
BaseTaskState.READY,
BaseTaskState.WORKING,
BaseTaskState.FINISHED,
BaseTaskState.WORKING,
BaseTaskState.WORKING,
BaseTaskState.FINISHED,
]
c2.state_record_list = [
BaseTaskState.WORKING,
BaseTaskState.WORKING,
BaseTaskState.FINISHED,
BaseTaskState.WORKING,
BaseTaskState.FINISHED,
BaseTaskState.FINISHED,
]
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)
product.create_gantt_plotly(init_datetime,
timedelta,
save_fig_path=save_fig_path)
def test_get_networkx_graph():
c1 = BaseComponent("c1")
c2 = BaseComponent("c2")
c3 = BaseComponent("c3")
c2.parent_component_list = [c1]
c2.child_component_list = [c3]
product = BaseProduct([c3, c2, c1])
product.get_networkx_graph()
def test_extend_child_component_list():
c = BaseComponent("c")
assert c.parent_component_list == []
c1 = BaseComponent("c1")
c2 = BaseComponent("c2")
c.extend_child_component_list([c1, c2])
assert c.child_component_list == [c1, c2]
assert c1.parent_component_list == [c]
assert c2.parent_component_list == [c]
def test_get_node_and_edge_trace_for_plotly_network():
c1 = BaseComponent("c1")
c2 = BaseComponent("c2")
c3 = BaseComponent("c3")
c2.parent_component_list = [c1]
c2.child_component_list = [c3]
product = BaseProduct([c3, c2, c1])
node_trace, edge_trace = product.get_node_and_edge_trace_for_plotly_network(
)
def test_draw_plotly_network():
c1 = BaseComponent("c1")
c2 = BaseComponent("c2")
c3 = BaseComponent("c3")
c2.parent_component_list = [c1]
c2.child_component_list = [c3]
product = BaseProduct([c3, c2, c1])
product.draw_plotly_network(save_fig_path="test.png")
if os.path.exists("test.png"):
os.remove("test.png")
def test_get_component_list():
"""test_get_component_list."""
# TODO if we have enough time for setting test case...
c1 = BaseComponent("c1")
product = BaseProduct([c1])
assert (len(
product.get_component_list(
name="test",
ID="test",
parent_component_list=[],
child_component_list=[],
targeted_task_list=[],
space_size=99876,
placed_workplace="test",
placed_workplace_id_record=[],
))) == 0
