def walk_fluent_exp(self, expression: FNode, args: List[FNode]) -> FNode:
if expression.fluent() not in self.static_fluents:
return self.manager.FluentExp(expression.fluent(), tuple(args))
else:
assert self.problem is not None
for a in args:
if not a.is_constant():
return self.manager.FluentExp(expression.fluent(),
tuple(args))
return self.problem.initial_value(
self.manager.FluentExp(expression.fluent(), tuple(args)))
def walk_fluent_exp(self, expression: model.FNode,
args: List[proto.Expression]) -> proto.Expression:
sub_list = []
sub_list.append(
proto.Expression(
atom=proto.Atom(symbol=expression.fluent().name),
kind=proto.ExpressionKind.Value("FLUENT_SYMBOL"),
type=str(expression.fluent().type),
))
sub_list.extend(args)
return proto.Expression(
atom=None,
list=sub_list,
kind=proto.ExpressionKind.Value("STATE_VARIABLE"),
type=str(expression.fluent().type),
)
def _get_ground_fluent(self, fluent: FNode,
assignments: Dict[Expression, Expression]) -> FNode:
assert fluent.is_fluent_exp()
new_args = []
for p in fluent.args:
new_args.append(self._subs_simplify(p, assignments))
return self.manager.FluentExp(fluent.fluent(), tuple(new_args))
def walk_fluent_exp(self, expression: FNode, args: List[FNode]) -> FNode:
new_exp = self.manager.FluentExp(expression.fluent(), tuple(args))
assert self._assignments is not None
res = self._assignments.get(new_exp, None)
if res is not None:
res, = self.manager.auto_promote(res)
assert type(res) is FNode
return res
else:
raise UPProblemDefinitionError(
f"Value of Fluent {str(expression)} not found in {str(self._assignments)}"
)
def walk_fluent_exp(
self, expression: FNode,
args: List['unified_planning.model.types.Type']
) -> Optional['unified_planning.model.types.Type']:
assert expression.is_fluent_exp()
f = expression.fluent()
if len(args) != len(f.signature):
return None
for (arg, param) in zip(args, f.signature):
if not self.is_compatible_type(arg, param.type):
return None
return f.type