Hugging Face's logo

Spaces:
vish07anth
/
ATA
Running on Zero

App Files Community
ATA
File size: 2,707 Bytes
f234112
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
from src.integration.topology import JunctionTopology
from src.integration.conflict_graph import ConflictGraph
from src.integration.phase_generator import PhaseGenerator
from src.integration.decision_engine import DecisionEngine


def test_full_decision_pipeline():

    # -----------------------------
    # 1. Create topology
    # -----------------------------

    topology = JunctionTopology("J1")

    topology.add_road("A", lanes=2)
    topology.add_road("B", lanes=2)
    topology.add_road("C", lanes=1)

    topology.add_movement(
        "A_to_B",
        "A",
        "B",
        lanes=2
    )

    topology.add_movement(
        "A_to_C",
        "A",
        "C",
        lanes=1
    )

    topology.add_movement(
        "B_to_A",
        "B",
        "A",
        lanes=2
    )

    topology.add_movement(
        "C_to_A",
        "C",
        "A",
        lanes=1
    )

    assert topology.validate() is True

    # -----------------------------
    # 2. Create conflict graph
    # -----------------------------

    graph = ConflictGraph(topology)

    graph.add_conflict(
        "A_to_B",
        "C_to_A"
    )

    graph.add_conflict(
        "A_to_C",
        "B_to_A"
    )

    assert graph.validate() is True

    # -----------------------------
    # 3. Generate valid phases
    # -----------------------------

    generator = PhaseGenerator(graph)

    phases = generator.generate_maximal_phases()

    assert len(phases) > 0

    # -----------------------------
    # 4. Create Decision Engine
    # -----------------------------

    engine = DecisionEngine()

    # -----------------------------
    # 5. Score each phase
    # -----------------------------

    phase_scores = {}

    for index, phase in enumerate(phases, start=1):

        score = engine.calculate_phase_score(
            demand=0.8,
            prediction=0.7,
            priority=0.5,
            fairness=0.6,
            risk=0.2
        )

        phase_scores[f"Phase_{index}"] = score

    # -----------------------------
    # 6. Select best phase
    # -----------------------------

    result = engine.select_best_phase(
        phase_scores
    )

    # -----------------------------
    # 7. Validate result
    # -----------------------------

    assert result["selected_phase"] in phase_scores

    assert 0 <= result["score"] <= 1

    assert len(result["all_scores"]) == len(phases)

    print()
    print("Full Decision Pipeline:")
    print("Topology        : PASS")
    print("Conflict Graph  : PASS")
    print("Phase Generator : PASS")
    print("Decision Engine  : PASS")
    print()
    print("Selected Phase:", result["selected_phase"])
    print("Score:", result["score"])