def __init__(self, nsmap: PrefixMap, shape: Shape, shape_interpreter): self._shape = shape self.containing_schema = shape_interpreter w_shape = PyxbWrapper(shape) self.tripleconstraints = self.depth_first_triples(w_shape) self.predmap = {} mp_num = 0 while mp_num < len(self.tripleconstraints): k = nsmap.uri_for(self.tripleconstraints[mp_num].predicate) self.predmap.setdefault(k, []) self.predmap[k].append(str(mp_num) + ' ') mp_num += 1 self._triple_number = 0 self._pattern = r''.join(self.depth_first_pattern(w_shape)) # Generate an additional match for every extra predicate # Extra patterns are recognized by the leading '0 for e in self._shape.extra: mp_num += 1 ptn = '0' + str(mp_num) + ' ' k = nsmap.uri_for(e.ref) self.predmap.setdefault(k, []) self.predmap[k].append(ptn) self._pattern += "(" + ptn + ")*" self.matchpattern = re.compile(self._pattern)
def shex_shape_constraint(self, sc: ShapeConstraint) -> dict: """ <code>xs:complexType name="ShapeConstraint"</code> :param sc: A complete shape constraint :return: S-JSON expression """ rval = dict() sc_wrapper = PyxbWrapper(sc) for e in sc_wrapper.elements: entry = self.shex_expression_choice({}, e) if "expression" in entry: rval.setdefault("expressions", []).append(entry["expression"]) self.shex_annotations_and_actions(rval, sc_wrapper) self.shex_cardinality(rval, sc_wrapper) return rval
def shex_triple_constraint(self, tc: TripleConstraint) -> dict: """ <code>xs:complexType name="TripleConstraint"</code> :param tc: TripleConstraint to process :return: SJson equivalent """ assert not ((tc.objectConstraint or tc.object or tc.objectShape or tc.objectType) and (tc.subjectConstraint or tc.subject or tc.subjectShape or tc.subjectType)), \ "Cannot mix subject and object constraints" tc_dict = dict(type="tripleConstraint", predicate=self.shex_iri(tc.predicate)) if tc.valueClass: tc_dict["valueClassRef"] = self.shex_value_class_label( tc.valueClass) else: vc_dict = dict(type="valueClass") if tc.objectConstraint: self.shex_triple_constraint_value_class( vc_dict, tc.objectConstraint) if tc.object: vc_dict["values"] = [self.shex_iri(tc.object)] if tc.objectShape: vc_dict["reference"] = self.shex_shape_label(tc.objectShape) if tc.objectType: vc_dict["nodeKind"] = self.shex_node_type(tc.objectType) if tc.subjectConstraint or tc.subject or tc.subjectShape or tc.subjectType or tc.inverse: tc_dict["inverse"] = True if tc.subjectConstraint: self.shex_triple_constraint_value_class( vc_dict, tc.subjectConstraint) if tc.subject: vc_dict["values"] = [self.shex_iri(tc.subject)] if tc.subjectShape: vc_dict["reference"] = self.shex_shape_label(tc.subjectShape) if tc.subjectType: vc_dict["nodeKind"] = self.shex_node_type(tc.subjectType) if tc.datatype: vc_dict["datatype"] = self._uri(tc.datatype) if tc.negated: tc_dict["negated"] = tc.negated tc_wrapper = PyxbWrapper(tc) self.shex_annotations_and_actions(tc_dict, tc_wrapper) self.shex_cardinality(tc_dict, tc_wrapper) tc_dict["value"] = vc_dict return tc_dict
def shex_shape(self, shape: Shape) -> dict: """ <code>xs:complexType name="shape"</code> :param shape: XML Shape :return: S-JSON Shape Entry """ rval = dict(type="shape") w_shape = PyxbWrapper(shape) self.shex_annotations_and_actions(rval, w_shape) [self.shex_expression_choice(rval, e) for e in w_shape.elements] for e in w_shape.elements: if e.type == "import_": rval.setdefault("inherit", []).append(self.shex_shape_ref(e.value.node)) elif e.type == "extra": rval.setdefault(e.type, []).append(self._uri(e.value.node.ref)) # shape.label is the dictionary key in the Schema container if shape.virtual: rval["virtual"] = shape.virtual if shape.closed: rval["closed"] = shape.closed return rval
def shex_inline_value_class_definition( self, vc: dict, ivcd: InlineValueClassDefinition) -> list: """ <code>xs:complexType name="InlineValueClassDefinition"</code> :param vc: dictionary to record the actual elements :param ivcd: :return: """ # valueClassLabel becomes the identity vcd_wrapper = PyxbWrapper(ivcd) for e in vcd_wrapper.elements: if e.type == "nodetype": vc["nodeKind"] = self.shex_node_type(e.value.node) elif e.type == "datatype": vc[e.type] = self._uri(e.value.node) elif e.type == "facet": self.shex_xs_facet(vc, e.value.node) elif e.type == "or_": vc["reference"] = self.shex_group_shape_constr(e.value.node) elif e.type == "valueSet": vc["values"] = self.shex_value_set(e.value.node) else: assert False, "Unknown ValueClassExpression choice entry: %s" % e.type
def _uri(self, element): """ Map element into a complete URI :param element: URI or QNAME :return: URI """ return self._prefixmap.uri_for(PyxbWrapper.proc_unicode(element))
def shex_code_decl(cd: CodeDecl): """ <code>xs:complexType name="CodeDecl" mixed="true"</code> :param cd: :return: """ return PyxbWrapper.mixed_content(cd)