chore(up): Remove anytime mode from aries-opt, as it was hard to reconcile it with the expected semantics.

Author: arbimo

planning/unified/plugin/up_aries/solver.py

@@ -285,21 +285,17 @@ def _compile(self) -> str:
         return aries_exe.as_posix()
 
 
-class Aries(AriesEngine, mixins.OneshotPlannerMixin, mixins.AnytimePlannerMixin):
-    """Represents the solver interface."""
-
-    @property
-    def name(self) -> str:
-        return "aries"
+class AriesAbstractPlanner(AriesEngine, mixins.OneshotPlannerMixin):
+    """Base class for the planners (aries and aries-opt)."""
 
     def _prepare_solving(
-        self,
-        problem: "up.model.AbstractProblem",
-        heuristic: Optional[
-            Callable[["up.model.state.ROState"], Optional[float]]
-        ] = None,
-        timeout: Optional[float] = None,
-        output_stream: Optional[IO[str]] = None,
+            self,
+            problem: "up.model.AbstractProblem",
+            heuristic: Optional[
+                Callable[["up.model.state.ROState"], Optional[float]]
+            ] = None,
+            timeout: Optional[float] = None,
+            output_stream: Optional[IO[str]] = None,
     ) -> Tuple["_Server", proto.PlanRequest]:
         # Assert that the problem is a valid problem
         assert isinstance(problem, up.model.AbstractProblem)
@@ -320,16 +316,16 @@ def _prepare_solving(
         return server, req
 
     def _process_response(
-        self,
-        response: proto.PlanGenerationResult,
-        problem: "up.model.AbstractProblem",
+            self,
+            response: proto.PlanGenerationResult,
+            problem: "up.model.AbstractProblem",
     ) -> "up.engines.results.PlanGenerationResult":
         response = self._reader.convert(response, problem)
 
         # if we have a time triggered plan and a recent version of the UP that support setting epsilon-separation,
         # send the result through an additional (in)validation to ensure it meets the minimal separation
         if isinstance(
-            response.plan, up.plans.TimeTriggeredPlan
+                response.plan, up.plans.TimeTriggeredPlan
         ) and "correct_plan_generation_result" in dir(up.engines.results):
             response = up.engines.results.correct_plan_generation_result(
                 response,
@@ -340,32 +336,25 @@ def _process_response(
         return response
 
     def _solve(
-        self,
-        problem: "up.model.AbstractProblem",
-        heuristic: Optional[
-            Callable[["up.model.state.ROState"], Optional[float]]
-        ] = None,
-        timeout: Optional[float] = None,
-        output_stream: Optional[IO[str]] = None,
+            self,
+            problem: "up.model.AbstractProblem",
+            heuristic: Optional[
+                Callable[["up.model.state.ROState"], Optional[float]]
+            ] = None,
+            timeout: Optional[float] = None,
+            output_stream: Optional[IO[str]] = None,
     ) -> "up.engines.results.PlanGenerationResult":
         server, req = self._prepare_solving(problem, heuristic, timeout, output_stream)
         response = server.planner.planOneShot(req)
         return self._process_response(response, problem)
 
-    def _get_solutions(
-        self,
-        problem: "up.model.AbstractProblem",
-        timeout: Optional[float] = None,
-        output_stream: Optional[IO[str]] = None,
-    ) -> Iterator["up.engines.results.PlanGenerationResult"]:
-        server, req = self._prepare_solving(problem, None, timeout, output_stream)
-        stream = server.planner.planAnytime(req)
-        for response in stream:
-            response = self._process_response(response, problem)
-            yield response
-            # The parallel solver implementation in aries are such that intermediate answer might arrive late
-            if response.status != PlanGenerationResultStatus.INTERMEDIATE:
-                break  # definitive answer, exit
+
+class Aries(AriesAbstractPlanner, mixins.AnytimePlannerMixin):
+    """Solver interface for non-optimal solver, supporting oneshot and anytime planning."""
+
+    @property
+    def name(self) -> str:
+        return "aries"
 
     @staticmethod
     def satisfies(optimality_guarantee: OptimalityGuarantee) -> bool:
@@ -384,13 +373,48 @@ def supported_kind() -> up.model.ProblemKind:
     def supports(problem_kind: up.model.ProblemKind) -> bool:
         return problem_kind <= Aries.supported_kind()
 
+    def _get_solutions(
+            self,
+            problem: "up.model.AbstractProblem",
+            timeout: Optional[float] = None,
+            output_stream: Optional[IO[str]] = None,
+    ) -> Iterator["up.engines.results.PlanGenerationResult"]:
+        server, req = self._prepare_solving(problem, None, timeout, output_stream)
+        stream = server.planner.planAnytime(req)
+        for response in stream:
+            response = self._process_response(response, problem)
+            yield response
+            # The parallel solver implementation in aries are such that intermediate answer might arrive late
+            if response.status != PlanGenerationResultStatus.INTERMEDIATE:
+                break  # definitive answer, exit
+
 
-class AriesOpt(Aries):
+class AriesOpt(AriesAbstractPlanner):
     """Variant of Aries that guarantees the optimality of returned solutions."""
+
+    @property
+    def name(self) -> str:
+        return "aries-opt"
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.optimality_metric_required = False
+
     @staticmethod
     def satisfies(optimality_guarantee: OptimalityGuarantee) -> bool:
         return optimality_guarantee in [OptimalityGuarantee.SOLVED_OPTIMALLY, OptimalityGuarantee.SATISFICING]
 
+    @staticmethod
+    def supported_kind() -> up.model.ProblemKind:
+        kind = _ARIES_SUPPORTED_KIND.clone()
+        # optimality cannot be proven for generative planning
+        kind.unset_problem_class("ACTION_BASED")
+        return kind
+
+    @staticmethod
+    def supports(problem_kind: up.model.ProblemKind) -> bool:
+        return problem_kind <= AriesOpt.supported_kind()
+
 
 class AriesVal(AriesEngine, mixins.PlanValidatorMixin):
     """Represents the validator interface."""