def _validate(self, value):
if isinstance(value, six.string_types):
param = PARAM_REGEX.search(value)
if not param:
super(RefOrObject, self)._validate(value)
else:
super(RefOrObject, self)._validate(value)
def _validate(self, value):
if isinstance(value, str):
param = PARAM_REGEX.search(value)
if not param:
super()._validate(value)
else:
super()._validate(value)
def entity_value(self) -> Optional[str]:
if not self.is_ref:
return None
value_parts = PARAM_REGEX.search(self.value)
if value_parts:
value_parts = value_parts.group(1)
else:
value_parts = self.value
return value_parts.split(".")[-1]
def get_ref_or_obj(container, value):
try:
return container.deserialize(value)
except (ValueError, TypeError, ValidationError):
pass
if not isinstance(value, six.string_types):
raise ValidationError(
"This field expects an {container} or a str containing a param reference."
.format(container=container.__class__.__name__))
param = PARAM_REGEX.search(value)
if not param:
raise ValidationError(
"This field expects an {container} or a param ref inside {{ }}.".
format(container=container.__class__.__name__))
return value
def validate_image(image, allow_none=False):
if not image:
if allow_none:
return
else:
raise ValidationError("Image is required")
param = PARAM_REGEX.search(image)
if param:
return
if " " in image:
raise ValidationError("Invalid docker image `{}`".format(image))
tagged_image = image.split(":")
if len(tagged_image) > 3:
raise ValidationError("Invalid docker image `{}`".format(image))
if len(tagged_image) == 3 and ("/" not in tagged_image[1]
or tagged_image[1].startswith("/")):
raise ValidationError("Invalid docker image `{}`".format(image))
def get_spec(self, name: str, iotype: str, is_flag: bool):
"""
Checks if the value is param ref and validates it.
returns: ParamSpec or None
raises: ValidationError
"""
if not self.is_literal:
# value validation is the same for search and ref
value_parts = PARAM_REGEX.search(self.value)
if value_parts:
value_parts = value_parts.group(1)
else:
value_parts = self.value
value_parts = value_parts.split(".")
if len(value_parts) > 3:
raise ValidationError(
"Could not parse value `{}` for param `{}`.".format(
self.value, name))
if len(value_parts) == 1 and value_parts[0] not in CONTEXTS:
raise ValidationError(
"Received an invalid value `{}` for param `{}`. "
"Value must be one of `{}`".format(self.value, name,
CONTEXTS))
# Check the case of current DAG, it should not allow to use outputs
if len(value_parts
) == 1 and self.is_dag_ref and value_parts[0] == OUTPUTS:
raise ValidationError(
"Received an invalid value `{}` for param `{}`. "
"You can not use `{}` of current dag".format(
self.value, name, OUTPUTS))
if len(value_parts
) == 2 and value_parts[0] not in CONTEXTS_WITH_NESTING:
raise ValidationError(
"Received an invalid value `{}` for param `{}`. "
"Value `{}` must be one of `{}`".format(
self.value, name, value_parts[0],
CONTEXTS_WITH_NESTING))
if len(value_parts) == 3 and value_parts[0] != EVENTS:
raise ValidationError(
"Received an invalid value `{}` for param `{}`. "
"Value `{}` must can only be equal to `{}`".format(
self.value, name, value_parts[0], EVENTS))
if self.is_ref:
# validate ref
ref_parts = self.ref.split(".")
if len(ref_parts) > 2:
raise ValidationError(
"Could not parse ref `{}` for param `{}`.".format(
self.ref, name))
if len(ref_parts) == 1 and ref_parts[0] != DAG:
raise ValidationError(
"Could not parse ref `{}` for param `{}`.".format(
ref_parts[0], name))
if len(ref_parts) == 2 and ref_parts[0] not in ENTITIES:
raise ValidationError(
"Could not parse ref `{}` for param `{}`. "
"Ref must be one of `{}`".format(ref_parts[0], name,
ENTITIES))
if ref_parts[0] == RUNS:
try:
uuid.UUID(ref_parts[1])
except (KeyError, ValueError):
raise ValidationError(
"Param value `{}` should reference a valid run uuid.".
format(ref_parts[1]))
return ParamSpec(
name=name,
iotype=iotype,
param=self,
is_flag=is_flag,
)
def get_param(name, value, iotype, is_flag):
"""
Checks if the value is param ref and validates it.
returns: ParamSpec or None
raises: ValidationError
"""
if not isinstance(value, six.string_types):
return ParamSpec(
name=name,
iotype=iotype,
value=value,
entity=None,
entity_ref=None,
entity_value=None,
is_flag=is_flag,
)
param = PARAM_REGEX.search(value)
if not param:
return ParamSpec(
name=name,
iotype=iotype,
value=value,
entity=None,
entity_ref=None,
entity_value=None,
is_flag=is_flag,
)
param = param.group(1)
param_parts = param.split(".")
if len(param_parts) < 3 or len(param_parts) > 4:
raise ValidationError(
"Could not parse value `{}` for param `{}`.".format(value, name)
)
if param_parts[0] not in ENTITIES:
raise ValidationError(
"Could not parse value `{}` for param `{}`.".format(value, name)
)
def process_pipeline_param():
if param_parts[0] != DAG or param_parts[1] != INPUTS:
raise ValidationError(
"Param `{}` value `{}` is not valid, "
"it should follow a format "
"`pipeline.outputs.name`.".format(name, value)
)
return param_parts[0], DAG_ENTITY_REF, param_parts[-1]
def process_op_param():
if param_parts[0] == OPS:
if param_parts[2] not in {INPUTS, OUTPUTS}:
raise ValidationError(
"Param `{}` value `{}` is not valid, "
"it should follow a format "
"`ops.entity-id.[inputs/outputs].name`.".format(name, value)
)
elif param_parts[0] == RUNS:
try:
uuid.UUID(param_parts[1])
except (KeyError, ValueError):
raise ValidationError(
"Param value `{}` should reference a valid uuid.".format(
value, param_parts[1]
)
)
if param_parts[2] != OUTPUTS:
raise ValidationError(
"Param `{}` value `{}` is not valid, "
"it should follow a format "
"`runs.uuid.outputs.name`.".format(name, value)
)
else:
raise ValidationError(
"Param `{}` value `{}` is not valid, "
"it should follow a format "
"`entity.entity-id.[inputs/outputs].name`.".format(name, value)
)
return param_parts[0], param_parts[1], param_parts[-1]
if len(param_parts) == 3:
entity, entity_ref, entity_value = process_pipeline_param()
elif len(param_parts) == 4:
entity, entity_ref, entity_value = process_op_param()
else:
raise ValidationError("Param `{}` value `{}` is not valid.".format(name, value))
return ParamSpec(
name=name,
iotype=iotype,
value=param,
entity=entity,
entity_ref=entity_ref,
entity_value=entity_value,
is_flag=is_flag,
)