Merge pull request #223 from linkml/issue-576

Allow for non-CURIE identifiers to be encoded.

Author: cmungall

linkml_runtime/dumpers/rdflib_dumper.py

@@ -1,4 +1,5 @@
 import logging
+import urllib
 from abc import abstractmethod
 from typing import Optional, Any, Dict
 
@@ -35,13 +36,18 @@ def as_rdf_graph(self, element: YAMLRoot, schemaview: SchemaView, prefix_map: Di
         logging.debug(f'PREFIXMAP={prefix_map}')
         if prefix_map:
             for k, v in prefix_map.items():
-                schemaview.namespaces()[k] = v
-                g.namespace_manager.bind(k, URIRef(v))
+                if k == "@base":
+                    schemaview.namespaces()._base = v
+                else:
+                    schemaview.namespaces()[k] = v
+                    g.namespace_manager.bind(k, URIRef(v))
             for prefix in schemaview.namespaces():
                 g.bind(prefix, URIRef(schemaview.namespaces()[prefix]))
         else:
             for prefix in schemaview.namespaces():
                 g.bind(prefix, URIRef(schemaview.namespaces()[prefix]))
+        if schemaview.namespaces()._base:
+            g.base = schemaview.namespaces()._base
         self.inject_triples(element, schemaview, g)
         return g
 
@@ -84,14 +90,15 @@ def inject_triples(self, element: Any, schemaview: SchemaView, graph: Graph, tar
                 return Literal(element)
         element_vars = {k: v for k, v in vars(element).items() if not k.startswith('_')}
         if len(element_vars) == 0:
-            return URIRef(schemaview.expand_curie(str(element)))
+            id_slot = schemaview.get_identifier_slot(target_type)
+            return self._as_uri(element, id_slot.range, schemaview)
+            #return URIRef(schemaview.expand_curie(str(element)))
         element_type = type(element)
         cn = element_type.class_name
         id_slot = schemaview.get_identifier_slot(cn)
         if id_slot is not None:
             element_id = getattr(element, id_slot.name)
-            logging.debug(f'ELEMENT_ID={element_id} // {id_slot.name}')
-            element_uri = namespaces.uri_for(element_id)
+            element_uri = self._as_uri(element_id, id_slot.range, schemaview)
         else:
             element_uri = BNode()
         type_added = False
@@ -150,3 +157,9 @@ def dumps(self, element: YAMLRoot, schemaview: SchemaView = None,
         return self.as_rdf_graph(element, schemaview, prefix_map=prefix_map).\
             serialize(format=fmt)
 
+    def _as_uri(self, element_id: str, id_slot_range: str, schemaview: SchemaView) -> URIRef:
+        if schemaview.is_type_percent_encoded(id_slot_range):
+            return URIRef(urllib.parse.quote(element_id))
+        else:
+            return schemaview.namespaces().uri_for(element_id)
+

linkml_runtime/loaders/rdflib_loader.py

@@ -1,4 +1,5 @@
 import logging
+import urllib
 from copy import copy
 from dataclasses import dataclass
 from typing import Optional, Any, Dict, Type, Union, TextIO, List, Tuple, Set
@@ -121,7 +122,11 @@ def from_rdf_graph(self, graph: Graph, schemaview: SchemaView, target_class: Typ
                         v = Pointer(o)
                     else:
                         if ClassDefinition.class_name in range_applicable_elements:
-                            v = namespaces.curie_for(o)
+                            if slot.range in schemaview.all_classes():
+                                id_slot = schemaview.get_identifier_slot(slot.range)
+                                v = self._uri_to_id(o, id_slot, schemaview)
+                            else:
+                                v = namespaces.curie_for(o)
                             if v is None:
                                 logging.debug(f'No CURIE for {p}={o} in {subject} [{subject_class}]')
                                 v = str(o)
@@ -201,7 +206,8 @@ def repl(v):
     def _get_id_dict(self, node: VALID_SUBJECT, schemaview: SchemaView, cn: ClassDefinitionName) -> ANYDICT:
         id_slot = schemaview.get_identifier_slot(cn)
         if not isinstance(node, BNode):
-            id_val = schemaview.namespaces().curie_for(node)
+            id_val = self._uri_to_id(node, id_slot, schemaview)
+            #id_val = schemaview.namespaces().curie_for(node)
             if id_val == None:
                 id_val = str(node)
             return {id_slot.name: id_val}
@@ -210,6 +216,12 @@ def _get_id_dict(self, node: VALID_SUBJECT, schemaview: SchemaView, cn: ClassDef
                 raise Exception(f'Unexpected blank node {node}, type {cn} expects {id_slot.name} identifier')
             return {}
 
+    def _uri_to_id(self, node: VALID_SUBJECT, id_slot: SlotDefinition, schemaview: SchemaView) -> str:
+        if schemaview.is_type_percent_encoded(id_slot.range):
+            return urllib.parse.unquote(node).replace(schemaview.namespaces()._base, "")
+        else:
+            return schemaview.namespaces().curie_for(node)
+
 
     def load(self, source: Union[str, TextIO, Graph], target_class: Type[YAMLRoot], *,
              schemaview: SchemaView = None,

linkml_runtime/utils/schemaview.py

@@ -1283,7 +1283,7 @@ def slot_applicable_range_elements(self, slot: SlotDefinition) -> List[ClassDefi
             raise ValueError(f'Unrecognized range: {r}')
         return range_types
 
-    def slot_range_as_union(self, slot: SlotDefinition) -> List[EnumDefinitionName]:
+    def slot_range_as_union(self, slot: SlotDefinition) -> List[ElementName]:
         """
         Returns all applicable ranges for a slot
 
@@ -1338,6 +1338,21 @@ def get_slots_by_enum(self, enum_name: ENUM_NAME = None) -> List[SlotDefinition]
                         enum_slots.append(slot_definition)
         return enum_slots
 
+    def is_type_percent_encoded(self, type: TypeDefinitionName) -> bool:
+        """
+        True if type is has a percent_encoded annotation.
+
+        This is true for type fields that are the range of identifier columns,
+        where the identifier is not guaranteed to be a valid URI or CURIE
+
+        :param type:
+        :return:
+        """
+        id_slot_ranges = self.type_ancestors(type)
+        for t in id_slot_ranges:
+            anns = self.get_type(t).annotations
+            return "percent_encoded" in anns
+
     @lru_cache()
     def usage_index(self) -> Dict[ElementName, List[SchemaUsage]]:
         """

tests/test_issues/input/linkml_issue_576.yaml

@@ -0,0 +1,85 @@
+id: https://w3id.org/linkml/examples/personinfo
+name: personinfo
+prefixes:
+  linkml: https://w3id.org/linkml/
+  personinfo: https://w3id.org/linkml/personinfo/
+  schema: http://schema.org/
+  ex: https://example.org/
+imports:
+  - linkml:types
+default_range: string
+default_prefix: personinfo
+
+types:
+  Code:
+    typeof: string
+    description: >-
+      An identifier that is encoded in a string.  This is used to represent
+      identifiers that are not URIs, but are encoded as strings.  For example,
+      a person's social security number is an encoded identifier.
+    annotations:
+      prefix: "@base"
+      percent_encoded: true
+
+
+classes:
+  Person:
+    class_uri: schema:Person
+    attributes:
+      id:
+        identifier: true
+        range: uriorcurie
+        comments:
+          - person IDs are natively encoded as uris or curies
+      name:
+        range: string
+        slot_uri: schema:name
+      friends:
+        range: Person
+        multivalued: true
+
+  Pet:
+    attributes:
+      id:
+        identifier: true
+        range: string
+        comments:
+          - pet IDs are natively encoded as strings without encoding
+          - they are assumed to be in CURIE form
+      name:
+        range: string
+        slot_uri: schema:name
+      owner:
+        range: Person
+        slot_uri: schema:owner
+
+  Organization:
+    class_uri: schema:Organization
+    attributes:
+      id:
+        identifier: true
+        range: Code
+        comments:
+          - organization IDs are natively encoded as strings with percent encoding
+          - they are encoded before being turned into CURIEs
+      name:
+        range: string
+        slot_uri: schema:name
+      part_of:
+        range: Organization
+        multivalued: true
+
+  Dataset:
+    attributes:
+      persons:
+        multivalued: true
+        range: Person
+        inlined: true
+      organizations:
+        multivalued: true
+        range: Organization
+        inlined: true
+      pets:
+        multivalued: true
+        range: Pet
+        inlined: true

tests/test_issues/input/linkml_issue_576_data.yaml

@@ -0,0 +1,21 @@
+persons:
+  - id: ex:P1
+    name: John Doe
+  - id: ex:P2
+    name: Jane Doe
+    friends:
+      - ex:P1
+organizations:
+  - id: org 1
+    name: Acme Inc. (US)
+  - id: org 2
+    name: Acme Inc. (UK)
+    part_of:
+      - org 1
+pets:
+  - id: ex:PetA
+    name: Fido
+    owner: ex:P1
+  - id: ex:PetB
+    name: Spot
+    owner: ex:P2