def parse_constraint(yaml_constraints): """ This method parses the yaml representation for semantic convention attributes creating a list of Constraint objects. """ constraints = () allowed_keys = ("include", "any_of") for constraint in yaml_constraints: validate_values(constraint, allowed_keys) if len(constraint.keys()) > 1: position = constraint.lc.data[list(constraint)[1]] msg = "Invalid entry in constraint array - multiple top-level keys in entry." raise ValidationError.from_yaml_pos(position, msg) if "include" in constraint: constraints += (Include(constraint.get("include")),) elif "any_of" in constraint: choice_sets = () for constraint_list in constraint.get("any_of"): inner_id_list = () if isinstance(constraint_list, CommentedSeq): inner_id_list = tuple( attr_constraint for attr_constraint in constraint_list ) else: inner_id_list += (constraint_list,) choice_sets += (inner_id_list,) constraints += (AnyOf(choice_sets),) return constraints
def test_validate_values__invalid(load_yaml, allowed, mandatory, expected_message): conventions = load_yaml("basic_example.yml") yaml = conventions["groups"][0] with pytest.raises(ValidationError) as err: validate_values(yaml, allowed, mandatory) assert err.value.message == expected_message
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(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 else: # Wrong type used - rise the exception and fill the missing data in the parent raise ValidationError( 0, 0, "Invalid type: {} is not allowed".format(attribute_type)) else: 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 attribute_type["members"] is None or len( attribute_type["members"]) < 1: # Missing members - rise the exception and fill the missing data in the parent raise ValidationError(0, 0, "Enumeration without values!") allowed_keys = ["id", "value", "brief", "note"] mandatory_keys = ["id", "value"] for member in attribute_type["members"]: validate_values(member, allowed_keys, mandatory_keys) members.append( EnumMember( member_id=member["id"], value=member["value"], brief=member.get("brief") if "brief" in member else member["id"], note=member.get("note") if "note" in member else "", )) enum_type = AttributeType.get_type(members[0].value) for m in members: if enum_type != AttributeType.get_type(m.value): raise ValidationError(0, 0, "Enumeration type inconsistent!") return EnumAttributeType(custom_values, members, enum_type)
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_values(load_yaml, allowed, mandatory): conventions = load_yaml("basic_example.yml") yaml = conventions["groups"][0] validate_values(yaml, allowed, mandatory)
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