Merge branch 'main' into improve-display-method

Author: raar1

examples/noodles_fw.ipynb

@@ -1,3 +1,4 @@
 from ._version import __version__
+from .linguistic_system import LinguisticSystem, LINGSYS_ENGLISH, LINGSYS_PYTHON
 from .fairstep import FairStep, FairVariable, is_fairstep
 from .fairworkflow import FairWorkflow, is_fairworkflow

fairworkflows/__init__.py

@@ -1,3 +1,4 @@
+import sys
 import inspect
 import typing
 from copy import deepcopy
@@ -8,7 +9,7 @@
 import rdflib
 from rdflib import RDF, RDFS, DCTERMS
 
-from fairworkflows import namespaces
+from fairworkflows import namespaces, LinguisticSystem, LINGSYS_ENGLISH, LINGSYS_PYTHON
 from fairworkflows.config import DUMMY_FAIRWORKFLOWS_URI, IS_FAIRSTEP_RETURN_VALUE_PARAMETER_NAME
 from fairworkflows.rdf_wrapper import RdfWrapper, replace_in_rdf
 
@@ -85,9 +86,12 @@ class FairStep(RdfWrapper):
 
     def __init__(self, label: str = None, description: str = None, uri=None,
                  is_pplan_step: bool = True, is_manual_task: bool = None,
-                 is_script_task: bool = None, inputs: List[FairVariable] = None,
+                 is_script_task: bool = None,
+                 language: LinguisticSystem = LINGSYS_ENGLISH,
+                 inputs: List[FairVariable] = None,
                  outputs: List[FairVariable] = None, derived_from=None):
-        super().__init__(uri=uri, ref_name='step', derived_from=derived_from)
+        super().__init__(uri=uri, ref_name='step', derived_from=derived_from, language=language)
+
         if label is not None:
             self.label = label
         if description is not None:
@@ -287,39 +291,6 @@ def outputs(self, variables: List[FairVariable]):
         for variable in variables:
             self._add_variable(variable, namespaces.PPLAN.hasOutputVar)
 
-    @property
-    def label(self):
-        """Label.
-
-        Returns the rdfs:label of this step (or a list, if more than one matching triple is found)
-        """
-        return self.get_attribute(RDFS.label)
-
-    @label.setter
-    def label(self, value):
-        """
-        Adds the given text string as an rdfs:label for this FairStep
-        object.
-        """
-        self.set_attribute(RDFS.label, rdflib.term.Literal(value))
-
-    @property
-    def description(self):
-        """Description.
-
-        Returns the dcterms:description of this step (or a list, if more than
-        one matching triple is found)
-        """
-        return self.get_attribute(DCTERMS.description)
-
-    @description.setter
-    def description(self, value):
-        """
-        Adds the given text string as a dcterms:description for this FairStep
-        object.
-        """
-        self.set_attribute(DCTERMS.description, rdflib.term.Literal(value))
-
     def validate(self, shacl=False):
         """Validate step.
 
@@ -454,13 +425,13 @@ def _modify_function(func):
         inputs = _extract_inputs_from_function(func, kwargs)
         outputs = _extract_outputs_from_function(func, kwargs)
 
-
         func._fairstep = FairStep(uri='http://www.example.org/unpublished-'+func.__name__,
                                   label=label,
                                   description=description,
                                   is_pplan_step=is_pplan_step,
                                   is_manual_task=is_manual_task,
                                   is_script_task=is_script_task,
+                                  language=LINGSYS_PYTHON,
                                   inputs=inputs,
                                   outputs=outputs)
 

fairworkflows/fairstep.py

@@ -16,7 +16,7 @@
 from rdflib.tools.rdf2dot import rdf2dot
 from requests import HTTPError
 
-from fairworkflows import namespaces
+from fairworkflows import namespaces, LinguisticSystem, LINGSYS_ENGLISH, LINGSYS_PYTHON
 from fairworkflows.fairstep import FairStep
 from fairworkflows.rdf_wrapper import RdfWrapper
 
@@ -32,8 +32,9 @@ class FairWorkflow(RdfWrapper):
     """
 
     def __init__(self, description: str = None, label: str = None, uri=None,
+                 language: LinguisticSystem = None,
                  is_pplan_plan: bool = True, first_step: FairStep = None, derived_from=None):
-        super().__init__(uri=uri, ref_name='plan', derived_from=derived_from)
+        super().__init__(uri=uri, ref_name='plan', derived_from=derived_from, language=language)
         self._is_published = False
         self.is_pplan_plan = is_pplan_plan
         if description is not None:
@@ -85,8 +86,10 @@ def from_function(cls, func: Callable):
                              'use is_fairworkflow decorator to mark it.')
 
     @classmethod
-    def from_noodles_promise(cls, workflow_level_promise, step_level_promise, description: str = None, label: str =
-                             None, is_pplan_plan: bool = True, derived_from=None):
+    def from_noodles_promise(cls, workflow_level_promise: PromisedObject,
+                             step_level_promise: PromisedObject,
+                             description: str = None, label: str= None,
+                             is_pplan_plan: bool = True, derived_from=None):
         """
 
         Args:
@@ -96,7 +99,8 @@ def from_noodles_promise(cls, workflow_level_promise, step_level_promise, descri
                 nodes but does not bind them together. We use this to extract step information from
                 it.
         """
-        self = cls(description=description, label=label, is_pplan_plan=is_pplan_plan, derived_from=derived_from)
+        self = cls(description=description, label=label, is_pplan_plan=is_pplan_plan,
+                   derived_from=derived_from, language=LINGSYS_PYTHON)
         self.workflow_level_promise = workflow_level_promise
         self.step_level_promise = step_level_promise
 
@@ -286,35 +290,6 @@ def get_step(self, uri):
         """
         return self._steps[uri]
 
-    @property
-    def label(self):
-        """Label.
-
-        Returns the rdfs:label of this workflow (or a list, if more than one matching triple is found)
-        """
-        return self.get_attribute(RDFS.label)
-
-    @label.setter
-    def label(self, value):
-        """
-        Adds the given text string as an rdfs:label for this FairWorkflow
-        object.
-        """
-        self.set_attribute(RDFS.label, rdflib.term.Literal(value))
-
-    @property
-    def description(self):
-        """
-        Description of the workflow. This is the dcterms:description found in
-        the rdf for this workflow (or a list if more than one matching triple
-        found)
-        """
-        return self.get_attribute(DCTERMS.description)
-
-    @description.setter
-    def description(self, value):
-        self.set_attribute(DCTERMS.description, rdflib.term.Literal(value))
-
     def validate(self, shacl=False):
         """Validate workflow.
 

fairworkflows/fairworkflow.py

@@ -0,0 +1,60 @@
+import sys
+import warnings
+from typing import List
+import rdflib
+from rdflib import DC, RDF, RDFS, OWL
+from .namespaces import SCHEMAORG
+
+class LinguisticSystem:
+    def __init__(self, lstype: rdflib.URIRef = None, label: str = None, see_also: rdflib.URIRef = None, version_info: str = None):
+        self.lstype = rdflib.URIRef(lstype)
+        self.label = rdflib.Literal(label)
+        self.see_also = rdflib.URIRef(see_also)
+        self.version_info = rdflib.Literal(version_info)
+
+    @classmethod
+    def from_rdf(cls, rdf):
+        lstype = _check_unique(list(rdf.objects(None, RDF.type)))
+        label = _check_unique(list(rdf.objects(None, RDFS.label)))
+        see_also = _check_unique(list(rdf.objects(None, RDFS.seeAlso)))
+        version_info = _check_unique(list(rdf.objects(None, OWL.versionInfo)))
+        return cls(lstype = lstype,
+                   label=label,
+                   see_also=see_also,
+                   version_info=version_info)
+
+    def generate_rdf(self, ref: rdflib.BNode):
+        rdf = rdflib.Graph()
+        if self.lstype:
+            rdf.add( (ref, RDF.type, self.lstype) )
+        if self.label:
+            rdf.add( (ref, RDFS.label, self.label) )
+        if self.see_also:
+            rdf.add( (ref, RDFS.seeAlso, self.see_also) )
+        if self.version_info:
+            rdf.add( (ref, OWL.versionInfo, self.version_info) )
+        return rdf
+
+    def __str__(self):
+        return (f'LinguisticSystem with type={self.lstype}, label={self.label}, '
+                f'seeAlso={self.see_also}, versionInfo={self.version_info}')
+
+
+def _check_unique(l: List):
+    if len(l) == 0:
+        return None
+    if len(l) > 1:
+        warnings.warn(f'Only one triple expected, but found {len(l)}: {l}')
+    return l[0]
+
+
+
+LINGSYS_ENGLISH = LinguisticSystem(lstype=DC.LinguisticSystem,
+                                   label='en',
+                                   see_also="http://www.datypic.com/sc/xsd/t-xsd_language.html")
+
+LINGSYS_PYTHON = LinguisticSystem(lstype=SCHEMAORG.ComputerLanguage,
+                                  label='python',
+                                  version_info='.'.join([str(v) for v in sys.version_info]),
+                                  see_also="https://en.wikipedia.org/wiki/Python_(programming_language)")
+

fairworkflows/linguistic_system.py

@@ -5,6 +5,7 @@
 DUL = rdflib.Namespace("http://www.ontologydesignpatterns.org/ont/dul/DUL.owl#")
 BPMN = rdflib.Namespace("http://dkm.fbk.eu/index.php/BPMN2_Ontology#")
 PWO = rdflib.Namespace("http://purl.org/spar/pwo/")
+SCHEMAORG = rdflib.Namespace("https://schema.org/")
 
 """
 Namespace for

fairworkflows/namespaces.py

@@ -6,25 +6,35 @@
 
 import pyshacl
 import rdflib
+from rdflib import RDF, RDFS, DCTERMS, OWL
 from nanopub import Publication, NanopubClient
 from rdflib.tools.rdf2dot import rdf2dot
 
-from fairworkflows import namespaces
+from fairworkflows import namespaces, LinguisticSystem
 from fairworkflows.config import PACKAGE_DIR
 
 PLEX_SHAPES_SHACL_FILEPATH = str(PACKAGE_DIR / 'resources' / 'plex-shapes.ttl')
 
-
 class RdfWrapper:
-    def __init__(self, uri, ref_name='fairobject', derived_from: List[str] = None):
+    def __init__(self, uri, ref_name='fairobject', derived_from: List[str] = None,
+                 language: LinguisticSystem = None ):
         self._rdf = rdflib.Graph()
         self._uri = str(uri)
         self.self_ref = rdflib.term.BNode(ref_name)
         self._is_modified = False
         self._is_published = False
         self.derived_from = derived_from
+
         self._bind_namespaces()
 
+        # A blank node to which triples about the linguistic
+        # system for this FAIR object can be added
+        self.lingsys_ref = rdflib.BNode('LinguisticSystem')
+        self._rdf.add((self.self_ref, DCTERMS.language, self.lingsys_ref))
+
+        if language is not None:
+            self.language = language
+
     def _bind_namespaces(self):
         """Bind namespaces used often in fair step and fair workflow.
 
@@ -35,6 +45,9 @@ def _bind_namespaces(self):
         self.rdf.bind("dul", namespaces.DUL)
         self.rdf.bind("bpmn", namespaces.BPMN)
         self.rdf.bind("pwo", namespaces.PWO)
+        self.rdf.bind("schema", namespaces.SCHEMAORG)
+        self.rdf.bind("dc", DCTERMS)
+        self.rdf.bind("owl", OWL)
 
     @property
     def rdf(self) -> rdflib.Graph:
@@ -114,6 +127,57 @@ def remove_attribute(self, predicate, object=None):
         """
         self._rdf.remove((self.self_ref, predicate, object))
 
+    @property
+    def label(self):
+        """Label.
+
+        Returns the rdfs:label of this Fair object (or a list, if more than one matching triple is found)
+        """
+        return self.get_attribute(RDFS.label)
+
+    @label.setter
+    def label(self, value):
+        """
+        Adds the given text string as an rdfs:label for this Fair object.
+        """
+        self.set_attribute(RDFS.label, rdflib.term.Literal(value))
+
+    @property
+    def description(self):
+        """Description.
+
+        Returns the dcterms:description of this Fair object (or a list, if more than
+        one matching triple is found)
+        """
+        return self.get_attribute(DCTERMS.description)
+
+    @description.setter
+    def description(self, value):
+        """
+        Adds the given text string as a dcterms:description for this Fair object.
+        """
+        self.set_attribute(DCTERMS.description, rdflib.term.Literal(value))
+
+    @property
+    def language(self):
+        """Returns the language for this fair objects's description (could be code).
+           Returns a LinguisticSystem object.
+        """
+        lingsys_rdf = rdflib.Graph()
+        for t in self._rdf.triples((self.lingsys_ref, None, None)):
+            lingsys_rdf.add(t)
+        return LinguisticSystem.from_rdf(lingsys_rdf)
+
+    @language.setter
+    def language(self, value: LinguisticSystem):
+        """Sets the language for this fair object's code (takes a LinguisticSystem).
+           Removes the existing linguistic system triples from the RDF decription
+           and replaces them with the new linguistic system."""
+        lingsys_triples = list(self._rdf.triples( (self.lingsys_ref, None, None) ))
+        if len(lingsys_triples) > 0:
+            self._rdf.remove(lingsys_triples)
+        self._rdf += value.generate_rdf(self.lingsys_ref)
+
     def shacl_validate(self):
         sg = rdflib.Graph()
         sg.parse(PLEX_SHAPES_SHACL_FILEPATH, format='ttl')

fairworkflows/rdf_wrapper.py

@@ -1,15 +1,17 @@
+import sys
 from typing import Tuple
 from unittest.mock import patch
 
 import pytest
 import rdflib
+from rdflib import DCTERMS, OWL, RDF
 from nanopub import Publication
 
 from conftest import skip_if_nanopub_server_unavailable, read_rdf_test_resource
 from fairworkflows import FairStep, namespaces, FairVariable, is_fairworkflow
 from fairworkflows.fairstep import _extract_outputs_from_function, is_fairstep
 from fairworkflows.rdf_wrapper import replace_in_rdf
-
+from fairworkflows import LinguisticSystem
 
 def test_construct_fair_variable_get_name_from_uri():
     variable = FairVariable(name=None, uri='http:example.org#input1', computational_type='int')
@@ -273,6 +275,14 @@ def test_step(a:float, b:float) -> float:
     else:
         raise
 
+    assert test_step._fairstep.language is not None
+    assert isinstance(test_step._fairstep.language, LinguisticSystem)
+    assert (None, RDF.type, namespaces.SCHEMAORG.ComputerLanguage) in test_step._fairstep._rdf
+    assert (None, DCTERMS.language, None) in test_step._fairstep._rdf
+    assert (None, OWL.versionInfo, None) in test_step._fairstep._rdf
+    assert 'python' in test_step._fairstep.language.label
+
+
 def test_decorator_semantic_types_multiple_outputs():
     output_tuple = ('http://www.example.org/walrus', 'http://www.example.org/krill')