wip

Author: rupakkatwal

PrismaDotnetApi/PrismaApi.Api/Controllers/SolversController.cs

@@ -4,6 +4,7 @@
 using PrismaApi.Domain.Extensions;
 using System.Net;
 using PrismaApi.Api.Extensions;
+using System.Text.Json;
 
 namespace PrismaApi.Api.Controllers;
 
@@ -70,4 +71,66 @@ public async Task<ActionResult<ApiResponseDto>> GetSolutionWithEvidenceAsync([Fr
 
         return StatusCode((int)fastApiResponse.StatusCode, fastApiResponse.Content);
     }
+
+    [HttpPost("solvers/project/{projectId:guid}/policy_table")]
+    public async Task<ActionResult<List<PolicyTableDecisionOutgoingDto>>> GetPolicyTableAsync([FromRoute] Guid projectId, [FromBody] EvidenceRequestDto? evidence = null, CancellationToken ct = default)
+    {
+        UserOutgoingDto user = HttpContext.GetLoadedUser();
+        var fastApiResponse = await _fastApiService.SendInfluenceDiagramPolicyTableToFastApiAsync(projectId, $"/solvers/project/{projectId}/policy_table", evidence, user, ct);
+        if (fastApiResponse.StatusCode == HttpStatusCode.OK)
+        {
+            if (string.IsNullOrEmpty(fastApiResponse.Content))
+            {
+                return Ok(new List<PolicyTableDecisionOutgoingDto>());
+            }
+
+            var response = JsonSerializer.Deserialize<Dictionary<string, List<Dictionary<string, JsonElement>>>>(
+                fastApiResponse.Content,
+                new JsonSerializerOptions
+                {
+                    PropertyNameCaseInsensitive = true
+                }
+            );
+
+            if (response is null)
+            {
+                return Ok(new List<PolicyTableDecisionOutgoingDto>());
+            }
+
+            var result = response
+                .Select(kvp => new PolicyTableDecisionOutgoingDto
+                {
+                    DecisionId = kvp.Key,
+                    Rows = kvp.Value.Select(row =>
+                    {
+                        var states = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+                        double value = 0;
+
+                        foreach (var entry in row)
+                        {
+                            if (string.Equals(entry.Key, "value", StringComparison.OrdinalIgnoreCase))
+                            {
+                                value = entry.Value.ValueKind == JsonValueKind.Number
+                                    ? entry.Value.GetDouble()
+                                    : double.Parse(entry.Value.ToString());
+                                continue;
+                            }
+
+                            states[entry.Key] = entry.Value.ToString();
+                        }
+
+                        return new PolicyTableRowOutgoingDto
+                        {
+                            States = states,
+                            Value = value
+                        };
+                    }).ToList()
+                })
+                .ToList();
+
+            return Ok(result);
+        }
+
+        return StatusCode((int)fastApiResponse.StatusCode, fastApiResponse.Content);
+    }
 }

PrismaDotnetApi/PrismaApi.Application/Interfaces/Services/IFastApiService.cs

@@ -10,4 +10,5 @@ public interface IFastApiService
     Task<ApiResponseDto> SendInfluenceDiagramToFastApiAsync(Guid projectId, string endpoint, UserOutgoingDto user, CancellationToken ct = default);
     Task<ApiResponseDto> SendPartialInfluenceDiagramToFastApiAsync(Guid projectId, string endpoint, List<List<Guid>> paths, UserOutgoingDto user, CancellationToken ct = default);
     Task<ApiResponseDto> SendInfluenceDiagramWithEvidenceToFastApiAsync(Guid projectId, string endpoint, List<EvidenceRequestDto> data, UserOutgoingDto user, CancellationToken ct = default);
+    Task<ApiResponseDto> SendInfluenceDiagramPolicyTableToFastApiAsync(Guid projectId, string endpoint, EvidenceRequestDto? evidence, UserOutgoingDto user, CancellationToken ct = default);
 }

PrismaDotnetApi/PrismaApi.Application/Services/FastApiService.cs

@@ -64,7 +64,7 @@ public async Task<ApiResponseDto> SendInfluenceDiagramToFastApiAsync(Guid projec
     public async Task<ApiResponseDto> SendPartialInfluenceDiagramToFastApiAsync(Guid projectId, string endpoint, List<List<Guid>> paths, UserOutgoingDto user, CancellationToken ct = default)
     {
         var influenceDiagram = await _influenceDiagramService.GetRestrictedInfluenceDiagramAsync(projectId, user, ct);
-        
+
         var payload = new
         {
             issues = influenceDiagram.issues,
@@ -94,4 +94,20 @@ public async Task<ApiResponseDto> SendInfluenceDiagramWithEvidenceToFastApiAsync
         var content = new StringContent(JsonSerializer.Serialize(payload), Encoding.UTF8, "application/json");
         return await CallDownstreamFastApiPostAsync(endpoint, content, ct);
     }
+    public async Task<ApiResponseDto> SendInfluenceDiagramPolicyTableToFastApiAsync(Guid projectId, string endpoint, EvidenceRequestDto? evidence, UserOutgoingDto user, CancellationToken ct = default)
+    {
+        var influenceDiagram = await _influenceDiagramService.GetRestrictedInfluenceDiagramAsync(projectId, user, ct);
+        var payload = new
+        {
+            issues = influenceDiagram.issues,
+            edges = influenceDiagram.edges,
+            discrete_probabilities = influenceDiagram.discreteProbabilities,
+            discrete_utilities = influenceDiagram.discreteUtilities,
+            restriction_tables = influenceDiagram.restrictionTables,
+            evidence,
+        };
+        var content = new StringContent(JsonSerializer.Serialize(payload), Encoding.UTF8, "application/json");
+        return await CallDownstreamFastApiPostAsync(endpoint, content, ct);
+    }
+
 }

PrismaDotnetApi/PrismaApi.Domain/Dtos/PolicyTableDtos.cs

@@ -0,0 +1,21 @@
+using System.Text.Json.Serialization;
+
+namespace PrismaApi.Domain.Dtos;
+
+public class PolicyTableRowOutgoingDto
+{
+    [JsonPropertyName("states")]
+    public Dictionary<string, string> States { get; set; } = [];
+
+    [JsonPropertyName("value")]
+    public double Value { get; set; }
+}
+
+public class PolicyTableDecisionOutgoingDto
+{
+    [JsonPropertyName("decision_id")]
+    public string DecisionId { get; set; } = string.Empty;
+
+    [JsonPropertyName("rows")]
+    public List<PolicyTableRowOutgoingDto> Rows { get; set; } = [];
+}

PrismaFastApi/src/routes/solver_routes.py

@@ -23,7 +23,10 @@ async def get_optimal_decisions_for_project_from_dtos(
     discrete_utilities: list[DiscreteUtilityOutgoingDto] = [],
     solver_service: SolverService = Depends(get_solver_service),
 ) -> SolutionDto:
-    return await solver_service.find_optimal_decision_pyagrum_from_dtos(issues, edges, discrete_probabilities, discrete_utilities)
+    return await solver_service.find_optimal_decision_pyagrum_from_dtos(
+        issues, edges, discrete_probabilities, discrete_utilities
+    )
+
 
 @router.post("/solvers/project/{project_id}/with_evidence")
 async def get_optimal_decisions_for_project_with_evidence(
@@ -35,29 +38,37 @@ async def get_optimal_decisions_for_project_with_evidence(
     solver_service: SolverService = Depends(get_solver_service),
 ) -> list[EvidenceOutgoingDto]:
     evidence_state_ids = [e.state_ids for e in evidence]
-    results: list[Optional[float]] = await solver_service.get_MEU_given_evidence(issues, edges, discrete_probabilities, discrete_utilities, evidence_state_ids)
+    results: list[Optional[float]] = await solver_service.get_MEU_given_evidence(
+        issues, edges, discrete_probabilities, discrete_utilities, evidence_state_ids
+    )
     # decision_solutions[0].mean is the expected utility for the first optimal decision, i.e. the root node which represents the expected utility for the model
     populated_evidence = [
         EvidenceOutgoingDto(
             evidence_id=evi.evidence_id,
             state_ids=evi.state_ids,
-            expected_utility=results[n] 
-            if len(results) > n and not math.isnan(results[n]) # type: ignore
-            else None,
+            expected_utility=(
+                results[n]
+                if len(results) > n and not math.isnan(results[n])  # type: ignore
+                else None
+            ),
         )
         for n, evi in enumerate(evidence)
     ]
     exception_message = ""
     for n, populated in enumerate(populated_evidence):
         if n == 0 and populated.expected_utility is not None and populated.expected_utility < -1e10:
-            exception_message += f"Impossible state reached due to all possible paths being restricted"
-            
+            exception_message += (
+                "Impossible state reached due to all possible paths being restricted"
+            )
+
         if populated.expected_utility is None:
             exception_message += f"Impossible state reached for evidence {populated.evidence_id} with state_ids {populated.state_ids}\n"
-    # If any of the evidence leads to an impossible state, we raise an exception with the details of which evidence caused the issue. 
+    # If any of the evidence leads to an impossible state, we raise an exception with the details of which evidence caused the issue.
     if exception_message:
-        raise ValueError(f"Restrictions/Evidence states lead to an impossible state:\n{exception_message}")
-    
+        raise ValueError(
+            f"Restrictions/Evidence states lead to an impossible state:\n{exception_message}"
+        )
+
     return populated_evidence
 
 
@@ -91,7 +102,8 @@ async def get_optimal_decisions_for_project_as_tree_tmp_from_dtos(
         return await solver_service.get_decision_tree_for_optimal_decisions_from_dtos(
             project_id, issues, edges, discrete_probabilities, discrete_utilities
         )
-    
+
+
 @router.post("/solvers/project/{project_id}/partial_decision_tree/v3")
 async def get_optimal_decisions_for_project_as_tree_tmp_from_dtos_v3(
     project_id: uuid.UUID,
@@ -105,6 +117,32 @@ async def get_optimal_decisions_for_project_as_tree_tmp_from_dtos_v3(
 ):
     async with lock_manager.acquire_project_lock(project_id):
         return await solver_service.get_decision_tree_for_optimal_decisions_from_dtos_by_constructing_paths(
-            project_id, issues, edges, discrete_probabilities, discrete_utilities, paths,
+            project_id,
+            issues,
+            edges,
+            discrete_probabilities,
+            discrete_utilities,
+            paths,
         )
 
+
+@router.post("/solvers/project/{project_id}/policy_table")
+async def get_policy_table_for_project(
+    project_id: uuid.UUID,
+    issues: list[IssueOutgoingDto],
+    edges: list[EdgeOutgoingDto],
+    discrete_probabilities: list[DiscreteProbabilityOutgoingDto] = [],
+    discrete_utilities: list[DiscreteUtilityOutgoingDto] = [],
+    evidence: Optional[EvidenceIncomingDto] = None,
+    solver_service: SolverService = Depends(get_solver_service),
+    lock_manager: ProjectQueueManager = Depends(get_project_lock_manager),
+) -> dict[str, list[dict[str, str | float]]]:
+    async with lock_manager.acquire_project_lock(project_id):
+        evidence_state_ids = evidence.state_ids if evidence else None
+        return await solver_service.get_policy_table(
+            issues=issues,
+            edges=edges,
+            discrete_probabilities=discrete_probabilities,
+            discrete_utilities=discrete_utilities,
+            evidence=evidence_state_ids,
+        )