refactored

Author: rupakkatwal

PrismaDotnetApi/PrismaApi.Api/Controllers/SolversController.cs

@@ -73,64 +73,30 @@ public async Task<ActionResult<ApiResponseDto>> GetSolutionWithEvidenceAsync([Fr
     }
 
     [HttpPost("solvers/project/{projectId:guid}/policy_table")]
-    public async Task<ActionResult<List<PolicyTableDecisionOutgoingDto>>> GetPolicyTableAsync([FromRoute] Guid projectId, [FromBody] EvidenceRequestDto? evidence = null, CancellationToken ct = default)
+    public async Task<ActionResult<List<PolicyTableOutgoingDto>>> 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))
+            Dictionary<string, List<PolicyTableStatesOutgoingDto>> response = [];
+            if (!string.IsNullOrWhiteSpace(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>());
+                response = JsonSerializer.Deserialize<Dictionary<string, List<PolicyTableStatesOutgoingDto>>>(
+                    fastApiResponse.Content
+                ) ?? [];
             }
 
             var result = response
-                .Select(kvp => new PolicyTableDecisionOutgoingDto
+                .Select(kvp => new PolicyTableOutgoingDto
                 {
                     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()
+                    Rows = kvp.Value
                 })
                 .ToList();
 
             return Ok(result);
         }
-
         return StatusCode((int)fastApiResponse.StatusCode, fastApiResponse.Content);
     }
 }

PrismaDotnetApi/PrismaApi.Domain/Dtos/PolicyTableDtos.cs

@@ -2,20 +2,20 @@
 
 namespace PrismaApi.Domain.Dtos;
 
-public class PolicyTableRowOutgoingDto
+public class PolicyTableStatesOutgoingDto
 {
     [JsonPropertyName("states")]
-    public Dictionary<string, string> States { get; set; } = [];
+    public List<string> States { get; set; } = [];
 
     [JsonPropertyName("value")]
     public double Value { get; set; }
 }
 
-public class PolicyTableDecisionOutgoingDto
+public class PolicyTableOutgoingDto
 {
     [JsonPropertyName("decision_id")]
     public string DecisionId { get; set; } = string.Empty;
 
     [JsonPropertyName("rows")]
-    public List<PolicyTableRowOutgoingDto> Rows { get; set; } = [];
+    public List<PolicyTableStatesOutgoingDto> Rows { get; set; } = [];
 }

PrismaFastApi/src/routes/solver_routes.py

@@ -136,7 +136,7 @@ async def get_policy_table_for_project(
     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]]]:
+) -> dict[str, list[dict[str, list[str] | int]]]:
     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(

PrismaFastApi/src/services/pyagrum_solver.py

@@ -493,22 +493,29 @@ def add_virtual_utilities(self, issues: list[IssueOutgoingDto]):
     def fill_utilities(self, issues: list[IssueOutgoingDto]):
         [self.fill_utility_table(x) for x in issues]
 
-    def get_policy_table(self, decision_issue_id: str) -> list[dict[str, str | float]]:
+    def get_policy_table(self, decision_issue_id: str) -> list[dict[str, list[str] | int]]:
         ie = self.get_inference()
         optimal_decision_tensor = ie.optimalDecision(decision_issue_id)  # type: ignore
         return self._parse_policy_tensor(optimal_decision_tensor)
 
-    def _parse_policy_tensor(self, optimal_decision_tensor: Any) -> list[dict[str, str | float]]:
+    def _parse_policy_tensor(
+        self, optimal_decision_tensor: Any
+    ) -> list[dict[str, list[str] | int]]:
+        """Flatten a policy tensor into row objects with ordered state labels and value.
+
+        Iterates every Instantiation of the tensor, collects each variable's current
+        label into `states` (in tensor variable order), and reads the cell value for
+        that assignment. Integer-like values are emitted as int for cleaner output.
+        """
         inst: Any = gum.Instantiation(optimal_decision_tensor)
         variables: list[Any] = list(inst.variablesSequence())
-        parsed_rows: list[dict[str, str | float]] = []
+        parsed_rows: list[dict[str, list[str] | int]] = []
 
         inst.setFirst()
         while not inst.end():
-            row: dict[str, str | float] = {
-                str(variable): str(variable.label(inst.val(variable))) for variable in variables
-            }
-            row["value"] = float(optimal_decision_tensor.get(inst))
+            states = [str(variable.label(inst.val(variable))) for variable in variables]
+            value: int = int(float(optimal_decision_tensor.get(inst)))
+            row: dict[str, list[str] | int] = {"states": states, "value": value}
             parsed_rows.append(row)
             inst.inc()
         return parsed_rows

PrismaFastApi/src/services/solver_service.py

@@ -295,7 +295,7 @@ async def get_policy_table(
         discrete_probabilities: list[DiscreteProbabilityOutgoingDto],
         discrete_utilities: list[DiscreteUtilityOutgoingDto],
         evidence: Optional[list[uuid.UUID]] = None,
-    ) -> dict[str, list[dict[str, str | float]]]:
+    ) -> dict[str, list[dict[str, list[str] | int]]]:
         solver = PyagrumSolver()
         ie = await solver.build_inference_engine(
             issues=issues,