Python filter_requests_by_tags 예제들

예제 #1

def test_solve_all_request_scenarios_with_gurobi(substrate):
    requests = [
        create_request(request_id) for request_id in filter_requests_by_tags()
    ]
    for req in requests:
        req.profit = 1.0

    scenario = datamodel.Scenario("test",
                                  substrate,
                                  requests,
                                  objective=datamodel.Objective.MAX_PROFIT)
    mc = commutativity_model.CommutativityModelCreator(scenario)
    mc.init_model_creator()
    solution = mc.compute_fractional_solution()

    assert solution is not None
    for req in requests:
        assert len(solution.request_mapping[req]) > 0

예제 #2

    mc.preprocess_input()
    mc._create_sub_lp_variables()

    ku_index = frozenset([(k, u)])

    ij_sub_lp = mc.edge_sub_lp[triangle_request][ij][ku_index]

    ij_sub_lp.var_node_flow_source[u].x = 1.0
    partial_mapping = solutions.Mapping("", triangle_request, substrate, True)
    partial_mapping.mapping_nodes[i] = "u"
    with pytest.raises(ValueError) as e:
        ij_sub_lp.extract_edge_mapping(partial_mapping)
    assert str(e.value) == "Did not find valid edge mapping for ('i', 'j')"


@pytest.mark.parametrize("request_id", filter_requests_by_tags("decomposition"))
def test_decomposition_full_request(request_id, substrate):
    req = create_request(request_id)
    req.graph["root"] = example_requests[request_id]["assumed_root"]
    scenario = datamodel.Scenario("test", substrate, [req])

    mc = commutativity_model.CommutativityModelCreator(scenario)
    mc.model = MockModel("mockmodel")

    if example_requests[request_id].get("ignore_bfs", False):
        mc.dag_requests[req] = req

    mc.preprocess_input()
    mc.create_variables()

    def node_mapping_var(i, index, u):

예제 #3

파일: commutativity_model_test.py 프로젝트: vnep-approx-latency/vnep-approx

pytestmark = pytest.mark.usefixtures("mock_gurobi")

i, j, k = "ijk"
ij = i, j
jk = j, k
ik = i, k
u, v, w = "uvw"
uv = u, v
vu = v, u
uw = u, w
wu = w, u
vw = v, w
wv = w, v


@pytest.mark.parametrize("request_id", filter_requests_by_tags())
def test_find_node_labels(request_id):
    expected = example_requests[request_id]["labels"]
    request = create_request(request_id)
    assert commutativity_model.CommutativityLabels.create_labels(request).node_labels == expected


@pytest.mark.parametrize("request_id", filter_requests_by_tags("bags"))
def test_calculate_edge_label_bags(request_id):
    request = create_request(request_id)
    labels = commutativity_model.CommutativityLabels.create_labels(request)
    expected = example_requests[request_id]["bags"]
    obtained = {i: labels.calculate_edge_label_bags(i) for i in request.nodes}
    assert obtained == expected

예제 #4

파일: decomposition_test.py 프로젝트: vnep-approx-latency/vnep-approx

    mc._create_sub_lp_variables()

    ku_index = frozenset([(k, u)])

    ij_sub_lp = mc.edge_sub_lp[triangle_request][ij][ku_index]

    ij_sub_lp.var_node_flow_source[u].x = 1.0
    partial_mapping = solutions.Mapping("", triangle_request, substrate, True)
    partial_mapping.mapping_nodes[i] = "u"
    with pytest.raises(ValueError) as e:
        ij_sub_lp.extract_edge_mapping(partial_mapping)
    assert str(e.value) == "Did not find valid edge mapping for ('i', 'j')"


@pytest.mark.parametrize("request_id",
                         filter_requests_by_tags("decomposition"))
def test_decomposition_full_request(request_id, substrate):
    req = create_request(request_id)
    req.graph["root"] = example_requests[request_id]["assumed_root"]
    scenario = datamodel.Scenario("test", substrate, [req])

    mc = commutativity_model.CommutativityModelCreator(scenario)
    mc.model = MockModel("mockmodel")

    if example_requests[request_id].get("ignore_bfs", False):
        mc.dag_requests[req] = req

    mc.preprocess_input()
    mc.create_variables()

    def node_mapping_var(i, index, u):

예제 #5

파일: model_creation_variables_constraints_test.py 프로젝트: vnep-approx-latency/vnep-approx

    assert extract_var_names(
        mc.edge_sub_lp[triangle_request][ik][ku_index].var_node_flow_sink
    ) == {
        u:
        "node_flow_sink_req[test_req]_snode[u]_vedge[('i','k')]_comm_index[k_u]",
    }
    assert extract_var_names(
        mc.edge_sub_lp[triangle_request][ik][kv_index].var_node_flow_sink
    ) == {
        v:
        "node_flow_sink_req[test_req]_snode[v]_vedge[('i','k')]_comm_index[k_v]",
    }


@pytest.mark.parametrize(
    "request_id", filter_requests_by_tags("flow_preservation_constraints"))
def test_create_sub_lp_flow_preservation_constraints(request_id,
                                                     tiny_substrate,
                                                     import_gurobi_mock):
    MockModel = import_gurobi_mock.MockModel
    MockConstr = import_gurobi_mock.MockConstr
    MockLinExpr = import_gurobi_mock.MockLinExpr

    req = create_request(request_id)
    req.graph["root"] = example_requests[request_id]["assumed_root"]
    scenario = datamodel.Scenario("test", tiny_substrate, [req])
    mc = commutativity_model.CommutativityModelCreator(scenario)
    mc.model = MockModel("mock_model")

    mc.preprocess_input()
    mc._create_sub_lp_variables()