def test_lp_closure():
v = interface.Variable(types.LiteralType(simple=types.SimpleType.BOOLEAN), 'asdf asdf asdf')
p = interface.Parameter(var=v)
parameter_map = interface.ParameterMap({'ppp': p})
parameter_map.to_flyte_idl()
variable_map = interface.VariableMap({'vvv': v})
obj = launch_plan.LaunchPlanClosure(state=launch_plan.LaunchPlanState.ACTIVE, expected_inputs=parameter_map,
expected_outputs=variable_map)
assert obj.expected_inputs == parameter_map
assert obj.expected_outputs == variable_map
obj2 = launch_plan.LaunchPlanClosure.from_flyte_idl(obj.to_flyte_idl())
assert obj == obj2
assert obj2.expected_inputs == parameter_map
assert obj2.expected_outputs == variable_map
def serialize(self):
"""
Serializing a launch plan should produce an object similar to what the registration step produces,
in preparation for actual registration to Admin.
:rtype: flyteidl.admin.launch_plan_pb2.LaunchPlan
"""
return _launch_plan_models.LaunchPlan(
id=self.id,
spec=self,
closure=_launch_plan_models.LaunchPlanClosure(
state=None,
expected_inputs=_interface_models.ParameterMap({}),
expected_outputs=_interface_models.VariableMap({}),
),
).to_flyte_idl()
def get_serializable_launch_plan(
entity_mapping: OrderedDict,
settings: SerializationSettings,
entity: LaunchPlan,
fast: bool,
) -> _launch_plan_models.LaunchPlan:
wf_spec = get_serializable(entity_mapping, settings, entity.workflow)
lps = _launch_plan_models.LaunchPlanSpec(
workflow_id=wf_spec.template.id,
entity_metadata=_launch_plan_models.LaunchPlanMetadata(
schedule=entity.schedule,
notifications=entity.notifications,
),
default_inputs=entity.parameters,
fixed_inputs=entity.fixed_inputs,
labels=entity.labels or _common_models.Labels({}),
annotations=entity.annotations or _common_models.Annotations({}),
auth_role=entity._auth_role or _common_models.AuthRole(),
raw_output_data_config=entity.raw_output_data_config
or _common_models.RawOutputDataConfig(""),
)
lp_id = _identifier_model.Identifier(
resource_type=_identifier_model.ResourceType.LAUNCH_PLAN,
project=settings.project,
domain=settings.domain,
name=entity.name,
version=settings.version,
)
lp_model = _launch_plan_models.LaunchPlan(
id=lp_id,
spec=lps,
closure=_launch_plan_models.LaunchPlanClosure(
state=None,
expected_inputs=interface_models.ParameterMap({}),
expected_outputs=interface_models.VariableMap({}),
),
)
return lp_model
def get_serializable_launch_plan(
entity_mapping: OrderedDict,
settings: SerializationSettings,
entity: LaunchPlan,
recurse_downstream: bool = True,
options: Optional[Options] = None,
) -> _launch_plan_models.LaunchPlan:
"""
:param entity_mapping:
:param settings:
:param entity:
:param options:
:param recurse_downstream: This boolean indicate is wf for the entity should also be recursed to
:return:
"""
if recurse_downstream:
wf_spec = get_serializable(entity_mapping, settings, entity.workflow,
options)
wf_id = wf_spec.template.id
else:
wf_id = _identifier_model.Identifier(
resource_type=_identifier_model.ResourceType.WORKFLOW,
project=settings.project,
domain=settings.domain,
name=entity.workflow.name,
version=settings.version,
)
if not options:
options = Options()
if options and options.raw_output_data_config:
raw_prefix_config = options.raw_output_data_config
else:
raw_prefix_config = entity.raw_output_data_config or _common_models.RawOutputDataConfig(
"")
lps = _launch_plan_models.LaunchPlanSpec(
workflow_id=wf_id,
entity_metadata=_launch_plan_models.LaunchPlanMetadata(
schedule=entity.schedule,
notifications=options.notifications or entity.notifications,
),
default_inputs=entity.parameters,
fixed_inputs=entity.fixed_inputs,
labels=options.labels or entity.labels or _common_models.Labels({}),
annotations=options.annotations or entity.annotations
or _common_models.Annotations({}),
auth_role=None,
raw_output_data_config=raw_prefix_config,
max_parallelism=options.max_parallelism or entity.max_parallelism,
security_context=options.security_context or entity.security_context,
)
lp_id = _identifier_model.Identifier(
resource_type=_identifier_model.ResourceType.LAUNCH_PLAN,
project=settings.project,
domain=settings.domain,
name=entity.name,
version=settings.version,
)
lp_model = _launch_plan_models.LaunchPlan(
id=lp_id,
spec=lps,
closure=_launch_plan_models.LaunchPlanClosure(
state=None,
expected_inputs=interface_models.ParameterMap({}),
expected_outputs=interface_models.VariableMap({}),
),
)
return lp_model