def parse(attribute_type):
"""This method parses the yaml representation for semantic attribute types.
If the type is an enumeration, it generated the EnumAttributeType object,
otherwise it returns the basic type as string.
"""
if isinstance(attribute_type, str):
if AttributeType.is_simple_type(attribute_type):
return attribute_type
# Wrong type used - raise the exception and fill the missing data in the parent
raise ValidationError(
0, 0, "Invalid type: {} is not allowed".format(attribute_type)
)
allowed_keys = ["allow_custom_values", "members"]
mandatory_keys = ["members"]
validate_values(attribute_type, allowed_keys, mandatory_keys)
custom_values = (
bool(attribute_type.get("allow_custom_values"))
if "allow_custom_values" in attribute_type
else False
)
members = []
if (
not isinstance(attribute_type["members"], CommentedSeq)
or len(attribute_type["members"]) < 1
):
raise ValidationError.from_yaml_pos(
attribute_type.lc.data["members"], "Enumeration without members!"
)
allowed_keys = ["id", "value", "brief", "note"]
mandatory_keys = ["id", "value"]
for member in attribute_type["members"]:
validate_values(member, allowed_keys, mandatory_keys)
if not EnumAttributeType.is_valid_enum_value(member["value"]):
raise ValidationError.from_yaml_pos(
member.lc.data["value"][:2],
"Invalid value used in enum: <{}>".format(member["value"]),
)
validate_id(member["id"], member.lc.data["id"])
members.append(
EnumMember(
member_id=member["id"],
value=member["value"],
brief=member.get("brief", member["id"]).strip(),
note=member.get("note", "").strip(),
)
)
enum_type = AttributeType.get_type(members[0].value)
for myaml, m in zip(attribute_type["members"], members):
if enum_type != AttributeType.get_type(m.value):
raise ValidationError.from_yaml_pos(
myaml.lc.data["value"],
"Enumeration member does not have type {}!".format(enum_type),
)
return EnumAttributeType(custom_values, members, enum_type)
def parse(yaml_file):
yaml = YAML().load(yaml_file)
models = []
available_keys = (
"id",
"brief",
"note",
"prefix",
"extends",
"span_kind",
"attributes",
"constraints",
)
mandatory_keys = ("id", "brief")
for group in yaml["groups"]:
validate_values(group, available_keys, mandatory_keys)
validate_id(group["id"], group.lc.data["id"])
span_kind = SpanKind.parse(group.get("span_kind"))
if span_kind is None:
position = group.lc.data["span_kind"]
msg = "Invalid value for span_kind: {}".format(group.get("span_kind"))
raise ValidationError.from_yaml_pos(position, msg)
prefix = group.get("prefix", "")
if prefix != "":
validate_id(prefix, group.lc.data["prefix"])
position = group.lc.data["id"]
model = SemanticConvention(
semconv_id=group["id"].strip(),
brief=str(group["brief"]).strip(),
note=group.get("note", "").strip(),
prefix=prefix.strip(),
extends=group.get("extends", "").strip(),
span_kind=span_kind,
attrs_by_name=SemanticAttribute.parse(prefix, group.get("attributes"))
if "attributes" in group
else {},
constraints=SemanticConvention.parse_constraint(
group.get("constraints", ())
),
_position=position,
)
models.append(model)
return models
def parse(
prefix, semconv_stability, yaml_attributes
) -> "Dict[str, SemanticAttribute]":
"""This method parses the yaml representation for semantic attributes
creating the respective SemanticAttribute objects.
"""
attributes = {} # type: Dict[str, SemanticAttribute]
allowed_keys = (
"id",
"type",
"brief",
"examples",
"ref",
"tag",
"deprecated",
"stability",
"required",
"sampling_relevant",
"note",
)
if not yaml_attributes:
return attributes
for attribute in yaml_attributes:
validate_values(attribute, allowed_keys)
attr_id = attribute.get("id")
ref = attribute.get("ref")
position_data = attribute.lc.data
position = position_data[next(iter(attribute))]
if attr_id is None and ref is None:
msg = "At least one of id or ref is required."
raise ValidationError.from_yaml_pos(position, msg)
if attr_id is not None:
validate_id(attr_id, position_data["id"])
attr_type, brief, examples = SemanticAttribute.parse_id(attribute)
if prefix:
fqn = "{}.{}".format(prefix, attr_id)
else:
fqn = attr_id
else:
# Ref
attr_type = None
if "type" in attribute:
msg = "Ref attribute '{}' must not declare a type".format(ref)
raise ValidationError.from_yaml_pos(position, msg)
brief = attribute.get("brief")
examples = attribute.get("examples")
ref = ref.strip()
fqn = ref
required_value_map = {
"always": Required.ALWAYS,
"conditional": Required.CONDITIONAL,
"": Required.NO,
}
required_msg = ""
required_val = attribute.get("required", "")
required: Optional[Required]
if isinstance(required_val, CommentedMap):
required = Required.CONDITIONAL
required_msg = required_val.get("conditional", None)
if required_msg is None:
position = position_data["required"]
msg = "Missing message for conditional required field!"
raise ValidationError.from_yaml_pos(position, msg)
else:
required = required_value_map.get(required_val)
if required == Required.CONDITIONAL:
position = position_data["required"]
msg = "Missing message for conditional required field!"
raise ValidationError.from_yaml_pos(position, msg)
if required is None:
position = position_data["required"]
msg = "Value '{}' for required field is not allowed".format(
required_val
)
raise ValidationError.from_yaml_pos(position, msg)
tag = attribute.get("tag", "").strip()
stability, deprecated = SemanticAttribute.parse_stability_deprecated(
attribute.get("stability"), attribute.get("deprecated"), position_data
)
if (
semconv_stability == StabilityLevel.DEPRECATED
and stability is not StabilityLevel.DEPRECATED
):
position = (
position_data["stability"]
if "stability" in position_data
else position_data["deprecated"]
)
msg = "Semantic convention stability set to deprecated but attribute '{}' is {}".format(
attr_id, stability
)
raise ValidationError.from_yaml_pos(position, msg)
stability = stability or semconv_stability or StabilityLevel.STABLE
sampling_relevant = (
AttributeType.to_bool("sampling_relevant", attribute)
if attribute.get("sampling_relevant")
else False
)
note = attribute.get("note", "")
fqn = fqn.strip()
parsed_brief = TextWithLinks(brief.strip() if brief else "")
parsed_note = TextWithLinks(note.strip())
attr = SemanticAttribute(
fqn=fqn,
attr_id=attr_id,
ref=ref,
attr_type=attr_type,
brief=parsed_brief,
examples=examples,
tag=tag,
deprecated=deprecated,
stability=stability,
required=required,
required_msg=str(required_msg).strip(),
sampling_relevant=sampling_relevant,
note=parsed_note,
position=position,
)
if attr.fqn in attributes:
position = position_data[list(attribute)[0]]
msg = (
"Attribute id "
+ fqn
+ " is already present at line "
+ str(attributes[fqn].position[0] + 1)
)
raise ValidationError.from_yaml_pos(position, msg)
attributes[fqn] = attr
return attributes
def test_validate_id__invalid(id):
with pytest.raises(ValidationError) as err:
validate_id(id, _POSITION)
assert err.value.message.startswith("Invalid id")
def test_validate_id__valid(id):
# valid ids are namespaced, dot separated. The topmost name must start with
# a lowercase letter. The rest of the id may contain only lowercase letters,
# numbers, underscores, and dashes
validate_id(id, _POSITION)
def validate_values(self):
super().validate_values()
if self.prefix:
validate_id(self.prefix, self._position)
def parse(prefix, yaml_attributes):
""" This method parses the yaml representation for semantic attributes
creating the respective SemanticAttribute objects.
"""
attributes = {}
allowed_keys = (
"id",
"type",
"brief",
"examples",
"ref",
"tag",
"deprecated",
"required",
"sampling_relevant",
"note",
)
for attribute in yaml_attributes:
validate_values(attribute, allowed_keys)
attr_id = attribute.get("id")
ref = attribute.get("ref")
position = attribute.lc.data[list(attribute)[0]]
if attr_id is None and ref is None:
msg = "At least one of id or ref is required."
raise ValidationError.from_yaml_pos(position, msg)
if attr_id is not None:
validate_id(attr_id, attribute.lc.data["id"])
attr_type, brief, examples = SemanticAttribute.parse_id(
attribute)
fqn = "{}.{}".format(prefix, attr_id)
attr_id = attr_id.strip()
else:
# Ref
attr_type = None
if "type" in attribute:
position = attribute.lc.data[list(attribute)[0]]
msg = "Ref attribute '{}' must not declare a type".format(
ref)
raise ValidationError.from_yaml_pos(position, msg)
brief = attribute.get("brief")
examples = attribute.get("examples")
ref = ref.strip()
fqn = ref
required_value_map = {
"always": Required.ALWAYS,
"conditional": Required.CONDITIONAL,
"": Required.NO,
}
required_msg = ""
required_val = attribute.get("required", "")
if isinstance(required_val, CommentedMap):
required = Required.CONDITIONAL
required_msg = required_val.get("conditional", None)
if required_msg is None:
position = attribute.lc.data["required"]
msg = "Missing message for conditional required field!"
raise ValidationError.from_yaml_pos(position, msg)
else:
required = required_value_map.get(required_val)
if required == Required.CONDITIONAL:
position = attribute.lc.data["required"]
msg = "Missing message for conditional required field!"
raise ValidationError.from_yaml_pos(position, msg)
if required is None:
position = attribute.lc.data["required"]
msg = "Value '{}' for required field is not allowed".format(
required_val)
raise ValidationError.from_yaml_pos(position, msg)
tag = attribute.get("tag", "").strip()
deprecated = attribute.get("deprecated")
if deprecated is not None:
if AttributeType.get_type(
deprecated) != "string" or deprecated == "":
position = attribute.lc.data["deprecated"]
msg = (
"Deprecated field expects a string that specify why the attribute is deprecated and/or what"
" to use instead! ")
raise ValidationError.from_yaml_pos(position, msg)
deprecated = deprecated.strip()
sampling_relevant = (AttributeType.to_bool("sampling_relevant",
attribute) if
attribute.get("sampling_relevant") else False)
note = attribute.get("note", "")
fqn = fqn.strip()
attr = SemanticAttribute(
fqn=fqn,
attr_id=attr_id,
ref=ref,
attr_type=attr_type,
brief=brief.strip() if brief else "",
examples=examples,
tag=tag,
deprecated=deprecated,
required=required,
required_msg=str(required_msg).strip(),
sampling_relevant=sampling_relevant,
note=note.strip(),
position=position,
)
if attr.fqn in attributes:
position = attribute.lc.data[list(attribute)[0]]
msg = ("Attribute id " + fqn + " is already present at line " +
str(attributes.get(fqn).position[0] + 1))
raise ValidationError.from_yaml_pos(position, msg)
attributes[fqn] = attr
return attributes