def base_connector_bundle_parameter_example(): doc = ProvDocument() doc.add_namespace("ex", "http://example.com") attributes = dict() namespaces = dict() namespaces.update({"ex": "http://example.com"}) type_map = dict() type_map.update({"int value": "int"}) type_map.update({"date value": "xds:datetime"}) metadata = dict() metadata.update( {METADATA_KEY_PROV_TYPE: doc.valid_qualified_name("prov:Bundle")}) metadata.update( {METADATA_KEY_IDENTIFIER: doc.valid_qualified_name("ex:bundle name")}) metadata.update({METADATA_KEY_TYPE_MAP: type_map}) metadata.update({METADATA_KEY_NAMESPACES: namespaces}) return_data = dict() return_data.update({"attributes": attributes}) return_data.update({"metadata": metadata}) return return_data
def base_connector_relation_parameter_example(): doc = ProvDocument() doc.add_namespace("ex", "http://example.com") doc.add_namespace("custom", "http://custom.com") namespaces = dict() namespaces.update({"ex": "http://example.com"}) namespaces.update({"custom": "http://custom.com"}) type_map = dict() type_map.update({"int value": "int"}) type_map.update({"date value": "xds:datetime"}) metadata = dict() metadata.update({METADATA_KEY_PROV_TYPE: PROV_RECORD_IDS_MAP["mentionOf"]}) metadata.update({METADATA_KEY_IDENTIFIER: "identifier for the relation"}) metadata.update({METADATA_KEY_TYPE_MAP: type_map}) metadata.update({METADATA_KEY_NAMESPACES: namespaces}) return_data = dict() return_data.update({"attributes": attributes_dict_example()}) return_data.update({"metadata": metadata}) return_data.update({"from_node": doc.valid_qualified_name("ex:Yoda")}) return_data.update( {"to_node": doc.valid_qualified_name("ex:Luke Skywalker")}) return_data.update({"doc": doc}) return return_data
def base_connector_record_parameter_example(): """ Returns a dict with attributes and metadata for a simple node :return:dict with attributes metadata :rtype: dict """ doc = ProvDocument() namespaces = dict() namespaces.update({"ex": "http://example.com"}) namespaces.update({"custom": "http://custom.com"}) type_map = dict() type_map.update({"int value": "int"}) type_map.update({"date value": "xds:datetime"}) metadata = dict() metadata.update( {METADATA_KEY_PROV_TYPE: doc.valid_qualified_name("prov:Activity")}) metadata.update({ METADATA_KEY_IDENTIFIER: doc.valid_qualified_name("prov:example_node") }) metadata.update({METADATA_KEY_TYPE_MAP: type_map}) metadata.update({METADATA_KEY_NAMESPACES: namespaces}) return_data = dict() return_data.update({"attributes": attributes_dict_example()}) return_data.update({"metadata": metadata}) return return_data
def base_connector_bundle_parameter_example(): """ This example returns a dict with example arguments for a db_adapter :return: dict {attributes, metadata} :rtype: dict """ doc = ProvDocument() doc.add_namespace("ex", "http://example.com") attributes = dict() attributes.update({"prov:type": "prov:Bundle"}) namespaces = dict() namespaces.update({"ex": "http://example.com"}) type_map = dict() type_map.update({"int value": "int"}) type_map.update({"date value": "xds:datetime"}) metadata = dict() metadata.update( {METADATA_KEY_PROV_TYPE: doc.valid_qualified_name("prov:Entity")}) metadata.update( {METADATA_KEY_IDENTIFIER: doc.valid_qualified_name("ex:bundle name")}) metadata.update({METADATA_KEY_TYPE_MAP: type_map}) metadata.update({METADATA_KEY_NAMESPACES: namespaces}) return_data = dict() return_data.update({"attributes": attributes}) return_data.update({"metadata": metadata}) return return_data
def insert_document_with_bundles(instance): args_record = base_connector_record_parameter_example() args_bundle = base_connector_bundle_parameter_example() doc = ProvDocument() doc.add_namespace("ex", "http://example.com") # document with 1 record doc_id = instance.save_document() doc_record_id = instance.save_record(doc_id, args_record["attributes"], args_record["metadata"]) # bundle with 1 record bundle_id = instance.save_bundle(doc_id, args_bundle["attributes"], args_bundle["metadata"]) bundle_record_id = instance.save_record(bundle_id, args_record["attributes"], args_record["metadata"]) # add relation from_record_args = base_connector_record_parameter_example() to_record_args = base_connector_record_parameter_example() relation_args = base_connector_relation_parameter_example() from_label = doc.valid_qualified_name("ex:FROM NODE") to_label = doc.valid_qualified_name("ex:TO NODE") from_record_args["metadata"][METADATA_KEY_IDENTIFIER] = from_label to_record_args["metadata"][METADATA_KEY_IDENTIFIER] = to_label from_record_id = instance.save_record(doc_id, from_record_args["attributes"], from_record_args["metadata"]) to_record_id = instance.save_record(doc_id, to_record_args["attributes"], to_record_args["metadata"]) relation_id = instance.save_relation(doc_id, from_label, doc_id, to_label, relation_args["attributes"], relation_args["metadata"]) return { "relation_id": relation_id, "from_record_id": from_record_id, "to_record_id": to_record_id, "bundle_id": bundle_id, "bundle_record_id": bundle_record_id, "doc_id": doc_id, "doc_record_id": doc_record_id }
def test_get_element_invalid(self): """ Test get element with error """ with self.assertRaises(InvalidArgumentTypeException): self.provapi.get_element(None) with self.assertRaises(NotFoundException): doc = ProvDocument() name = doc.valid_qualified_name("prov:Some unused name") self.provapi.get_element(name)
def _create_unknown_node(self, bundle_id): """ If a relation end or start is "Unknown" (yes this is allowed in PROV) we create a specific node to create the relation :param bundle_id: The database bundle id :return: The identifier of the Unknown node """ uid = uuid4() doc = ProvDocument() identifier = doc.valid_qualified_name("prov:Unknown-{}".format(uid)) record = ProvRecord(bundle=doc, identifier=identifier) (metadata, attributes) = self._get_metadata_and_attributes_for_record(record) self._adapter.save_record(bundle_id, attributes, metadata) return identifier
def prov_api_record_example(): doc = ProvDocument() doc.add_namespace("ex", "http://example.com") doc.add_namespace("custom", "http://custom.com") attributes = attributes_dict_example() del attributes[ "ex:dict value"] # remove dict value because it is not allowed in a prov_record, but for low level adapter tests necessary del attributes[ "ex:list value"] # remove dict value because it is not allowed in a prov_record, but for low level adapter tests necessary attributes.update({ "ex:Qualified name ": doc.valid_qualified_name("custom:qualified name") }) attributes.update({"ex:Qualified name 2": "ex:unqualified_name"}) attributes.update({"ex:Literal": Literal("test literal", langtag="en")}) attributes.update({ "ex:Literal 2": Literal("test literal with datatype", langtag="en", datatype=PROV["InternationalizedString"]) }) attributes.update( {"ex:identifier type": Identifier("http://example.com/#test")}) expected_attributes = dict() for key, value in attributes.items(): new_key = doc.valid_qualified_name(key) expected_attributes.update({new_key: value}) # The prov lib don't require to auto convert string values into qualified names # valid_name = doc.valid_qualified_name("ex:Qualified name 2") # expected_attributes[valid_name] = doc.valid_qualified_name("ex:unqualified_name") namespaces = dict() namespaces.update({"ex": "http://example.com"}) namespaces.update({"custom": "http://custom.com"}) namespaces.update({"prov": "http://www.w3.org/ns/prov#"}) type_map = dict() type_map.update({"ex:date value": {"type": "xsd:dateTime"}}) type_map.update({"ex:double value": {"type": "xsd:double"}}) type_map.update({"ex:int value": {"type": "xsd:int"}}) type_map.update({"ex:Qualified name ": {'type': 'prov:QUALIFIED_NAME'}}) # type_map.update({"ex:Qualified name 2":{'type': 'prov:QUALIFIED_NAME'}}) #The prov lib don't require to auto convert strings into qualified names type_map.update({"ex:Literal": {'lang': 'en'}}) type_map.update({"ex:Literal 2": {'lang': 'en'}}) type_map.update({"ex:identifier type": {'type': 'xsd:anyURI'}}) metadata = dict() metadata.update({METADATA_KEY_PROV_TYPE: PROV_RECORD_IDS_MAP["activity"]}) metadata.update( {METADATA_KEY_IDENTIFIER: doc.valid_qualified_name("ex:record")}) metadata.update({METADATA_KEY_NAMESPACES: namespaces}) metadata.update({METADATA_KEY_TYPE_MAP: type_map}) record = ProvActivity(doc, "ex:record", attributes) Example = namedtuple( "prov_api_metadata_record_example", "metadata, attributes, prov_record, expected_attributes") return Example(metadata, attributes, record, expected_attributes)