mustrd 0.1.8__tar.gz → 0.2.0__tar.gz

{mustrd-0.1.8 → mustrd-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mustrd
-Version: 0.1.8
+Version: 0.2.0
 Summary: A Spec By Example framework for RDF and SPARQL, Inspired by Cucumber.
 Home-page: https://github.com/Semantic-partners/mustrd
 License: MIT

{mustrd-0.1.8 → mustrd-0.2.0}/mustrd/README.adoc

@@ -26,6 +26,15 @@ Run `pytest` from the project root.
 
 If you have got this far then you are probably ready to create your own specifications to test your application SPARQL queries. These will be executed against the default RDFLib triplestore unless you configure one or more alternatives. The instructions for this are included in <<Configuring external triplestores>> below.
 
+=== Paths
+All paths are consired relative. That way mustrd tests can be versionned and shared easily.
+To get absolute path from relative path in a spec file, we prefix it with the first existing result in:
+1) Path where the spec is located
+2) spec_path defined in mustrd test configuration files or cmd line argument
+3) data_path defined in mustrd test configuration files or cmd line argument
+4) Mustrd folder: In case of default resources packaged with mustrd source (will be in venv when mustrd is called as library)
+We intentionally use the same method to build paths in all spec components to avoid confusion.
+
 === Givens
 These are used to specify the dataset against which the SPARQL statement will be run.
 They can be generated from external sources such as an existing graph, or a file or folder containing serialised RDF. It is also possible to specify the dataset as reified RDF directly in the test step. Currently tabular data sources such as csv files or TableDatasets are not supported.

{mustrd-0.1.8 → mustrd-0.2.0}/mustrd/mustrd.py

@@ -304,8 +304,7 @@ def run_specs(specs) -> List[SpecResult]:
     return results
 
 def get_spec_file(spec_uri: URIRef, spec_graph: Graph):
-    test =  str(spec_graph.value(subject = spec_uri, predicate = MUST.specFileName, default = "default.mustrd.ttl"))
-    return test
+    return str(spec_graph.value(subject = spec_uri, predicate = MUST.specFileName, default = "default.mustrd.ttl"))
 
 def get_spec(spec_uri: URIRef, spec_graph: Graph, run_config: dict, mustrd_triple_store: dict = None) -> Specification:
     try:

{mustrd-0.1.8 → mustrd-0.2.0}/mustrd/mustrdAnzo.py

@@ -28,7 +28,6 @@ from rdflib import Graph, ConjunctiveGraph, Literal, URIRef
 from requests import ConnectTimeout, Response, HTTPError, RequestException, ConnectionError
 from bs4 import BeautifulSoup
 import logging
-from .namespace import MUST
 
 
 # https://github.com/Semantic-partners/mustrd/issues/73
@@ -43,7 +42,6 @@ def manage_anzo_response(response: Response) -> str:
     else:
         raise RequestException(f"Anzo error, status code: {response.status_code}, content: {content_string}")
 
-
 def query_with_bindings(bindings: dict, when: str) -> str:
     values = ""
     for key, value in bindings.items():
@@ -52,68 +50,70 @@ def query_with_bindings(bindings: dict, when: str) -> str:
     return f"{split_query[0].strip()} WHERE {{ {values} {split_query[1].strip()}"
 
 def execute_select (triple_store: dict,  when: str, bindings: dict = None) -> str:
+    if bindings:
+        when = query_with_bindings(bindings, when)
+    # Just remove ${fromSources} if we are executing a query step; the sources are defined using http parameters 
+    when = when.replace("${fromSources}", "")
+    return execute_sparql(triple_store, False, when, triple_store['input_graph'])
+
+PARAMS = {
+    # Update parameters for INSERT / DELETE
+    True: {
+        "default-graph-param": "using-graph-uri",
+        "named-graph-param":"using-named-graph-uri",
+        "Content-Type": "application/sparql-update"
+    },
+    # Query parameters for SELECT / CONSTRUCT  
+    False: {
+        "default-graph-param": "default-graph-uri",
+        "named-graph-param":"named-graph-uri",
+        "Content-Type": "application/sparql-query"
+    }
+}
+def execute_sparql(triple_store: dict, is_update: bool, sparql, graph: str, format: str = "application/sparql-results+json"):
+    params = {
+        "format" : format,
+        "datasourceURI" : triple_store['gqe_uri'],
+        "skipCache": "true",
+        # Default and named datasets have different query param for query and update
+        PARAMS[is_update]["default-graph-param"] : graph,
+        PARAMS[is_update]["named-graph-param"] : graph
+    }
+    headers={"Content-Type": PARAMS[is_update]["Content-Type"]}
     try:
-        if bindings:
-            when = query_with_bindings(bindings, when)
-        when = when.replace("${fromSources}", f"FROM <{triple_store['input_graph']}>\nFROM <{triple_store['output_graph']}>").replace(
-        "${targetGraph}", f"<{triple_store['output_graph']}>")
-        data = {'datasourceURI': triple_store['gqe_uri'], 'query': when,
-                 'skipCache': 'true'}
-        url = f"https://{triple_store['url']}:{triple_store['port']}/sparql?format=application/sparql-results+json"
-        return manage_anzo_response(requests.post(url=url,
-                                                  auth=(triple_store['username'], triple_store['password']),
-                                                  data=data,
-                                                  verify=False))
-    except (ConnectionError, TimeoutError, HTTPError, ConnectTimeout):
+        response = manage_anzo_response(requests.post(url=f"https://{triple_store['url']}:{triple_store['port']}/sparql",
+                                                    params=params,
+                                                    auth=(triple_store['username'], triple_store['password']),
+                                                    headers=headers,
+                                                    data=sparql,
+                                                    verify=False))
+        logging.debug(f'response {response}')
+        return response
+    except (ConnectionError, TimeoutError, HTTPError, ConnectTimeout) as e:
+        logging.error(f'response {e}')
         raise
 
 def execute_update(triple_store: dict, when: str, bindings: dict = None) -> Graph:
     logging.debug(f"updating in anzo! {triple_store=} {when=}")
-    input_graph = triple_store['input_graph']
-    output_graph = triple_store['output_graph']
-
-    substituted_query = when.replace("${usingSources}", f"USING <{triple_store['input_graph']}> \nUSING <{triple_store['output_graph']}>").replace(
-        "${targetGraph}", f"<{output_graph}>")
-   
-    data = {'datasourceURI': triple_store['gqe_uri'], 'update': substituted_query,
-                'default-graph-uri': input_graph, 'skipCache': 'true'}
-    url = f"https://{triple_store['url']}:{triple_store['port']}/sparql?format=ttl"
-    response = manage_anzo_response(requests.post(url=url,
-            auth=(triple_store['username'],
-                triple_store['password']),
-            data=data,
-            verify=False))
-    logging.debug(f'response {response}')
-    check_data = {'datasourceURI': triple_store['gqe_uri'], 'query': "construct {?s ?p ?o} { ?s ?p ?o }",
-                'default-graph-uri': output_graph, 'skipCache': 'true'}
-    everything_response = manage_anzo_response(requests.post(url=url,
-            auth=(triple_store['username'],
-                triple_store['password']),
-            data=check_data,
-            verify=False))
-    # todo deal with error responses
-    new_graph = Graph().parse(data=everything_response)
+
+    # FIXME If query doesn't contain ${targetGraph}, then graph should be defined explicitly in the query
+    substituted_query = when.replace("${usingSources}", "").replace(
+        "${targetGraph}", f"<{triple_store['output_graph']}>")
+    
+    execute_sparql(triple_store, True, substituted_query, triple_store['input_graph'], "ttl")
+    
+    new_graph = execute_construct(triple_store, "construct {?s ?p ?o} { ?s ?p ?o }")
+    
     logging.debug(f"new_graph={new_graph.serialize(format='ttl')}")
+    
     return new_graph
 
 
 def execute_construct(triple_store: dict, when: str, bindings: dict = None) -> Graph:
-    try:
-        if bindings:
-            when = query_with_bindings(bindings, when)
-        data = {'datasourceURI': triple_store['gqe_uri'], 'query': when,
-                'default-graph-uri': triple_store['input_graph'], 'skipCache': 'true'}
-        url = f"https://{triple_store['url']}:{triple_store['port']}/sparql?format=ttl"
-        response = requests.post(url=url,
-            auth=(triple_store['username'],
-                triple_store['password']),
-            data=data,
-            verify=False)
-        logging.debug(f'response {response}')
-        return Graph().parse(data=manage_anzo_response(response))
-    except (ConnectionError, TimeoutError, HTTPError, ConnectTimeout) as e:
-        logging.error(f'response {e}')
-        raise
+    if bindings:
+        when = query_with_bindings(bindings, when)
+    response = execute_sparql(triple_store, False, when, triple_store['input_graph'], "ttl")
+    return Graph().parse(data=response)
 
 
 # Get Given or then from the content of a graphmart
@@ -207,30 +207,14 @@ SELECT ?query ?param_query ?query_template
 
 def upload_given(triple_store: dict, given: Graph):
     logging.debug(f"upload_given {triple_store} {given}")
-
-    try:
-        input_graph = triple_store['input_graph']
-        output_graph = triple_store['output_graph']
-        clear_graph(triple_store, input_graph)
-        clear_graph(triple_store, output_graph)
-        serialized_given = given.serialize(format="nt")
-        insert_query = f"INSERT DATA {{graph <{triple_store['input_graph']}>{{{serialized_given}}}}}"
-        data = {'datasourceURI': triple_store['gqe_uri'], 'update': insert_query}
-        response = requests.post(url=f"https://{triple_store['url']}:{triple_store['port']}/sparql",
-                                    auth=(triple_store['username'], triple_store['password']), data=data, verify=False)
-        manage_anzo_response(response)
-    except (ConnectionError, TimeoutError, HTTPError, ConnectTimeout):
-        raise
+    clear_graph(triple_store, triple_store['input_graph'])
+    clear_graph(triple_store, triple_store['output_graph'])
+    serialized_given = given.serialize(format="nt")
+    
+    insert_query = f"INSERT DATA {{graph <{triple_store['input_graph']}>{{{serialized_given}}}}}"
+    execute_sparql(triple_store, True, insert_query, None, None)
 
 
 def clear_graph(triple_store: dict, graph_uri: str):
-    try:
-        clear_query = f"CLEAR GRAPH <{graph_uri}>"
-        data = {'datasourceURI': triple_store['gqe_uri'], 'update': clear_query}
-        url = f"https://{triple_store['url']}:{triple_store['port']}/sparql"
-        response = requests.post(url=url,
-                                 auth=(triple_store['username'], triple_store['password']), data=data, verify=False)
-        manage_anzo_response(response)
-    except (ConnectionError, TimeoutError, HTTPError, ConnectTimeout):
-        raise
+    execute_sparql(triple_store, True, f"CLEAR GRAPH <{graph_uri}>", None, None)
 

mustrd-0.2.0/mustrd/mustrdQueryProcessor.py

@@ -0,0 +1,136 @@
+
+from pyparsing import ParseResults
+from rdflib import RDF, Graph, URIRef, Variable, Literal, XSD, util, BNode
+from rdflib.plugins.sparql.parser import parseQuery, parseUpdate
+from rdflib.plugins.sparql.algebra import translateQuery, translateUpdate, translateAlgebra
+from rdflib.plugins.sparql.sparql import Query
+from rdflib.plugins.sparql.parserutils import CompValue, value, Expr
+from rdflib.namespace import DefinedNamespace, Namespace
+from rdflib.term import Identifier
+from typing import Union
+
+from builtins import list, set, tuple, str
+
+
+namespace = "https://mustrd.com/query/"
+
+class MustrdQueryProcessor:
+    original_query : Union [Query, ParseResults]
+    current_query : Union [Query, ParseResults] 
+    graph : Graph
+    algebra_mode: bool = False
+    graph_mode: bool = True
+
+    def __init__(self, query_str: str, algebra_mode: bool = False, graph_mode: bool = True):
+        parsetree = parseQuery(query_str)
+        # Init original query to algebra or parsed query
+        self.original_query = (algebra_mode and translateQuery(parsetree)) or parsetree
+        self.current_query = self.original_query
+        self.algebra_mode = algebra_mode
+        self.graph_mode = graph_mode
+        self.graph = Graph()
+        if graph_mode:
+            self.query_to_graph((algebra_mode and self.original_query.algebra) or parsetree._toklist, BNode())
+
+    def query_to_graph(self, part: CompValue, partBnode):
+        if not part or not partBnode:
+            return
+        self.graph.add((partBnode, RDF.type, URIRef(namespace + type(part).__name__)))
+        self.graph.add((partBnode, QUERY.has_class , Literal(str(part.__class__.__name__))))
+        if isinstance(part, CompValue) or isinstance(part, ParseResults):
+            self.graph.add((partBnode, QUERY.name , Literal(part.name)))
+        if isinstance(part, CompValue):
+            for key, sub_part in part.items():
+                sub_part_bnode = BNode()
+                self.graph.add((partBnode, URIRef(namespace + str(key)) , sub_part_bnode))
+                self.query_to_graph(sub_part, sub_part_bnode)
+        elif hasattr(part, '__iter__') and not isinstance(part, Identifier) and not isinstance(part, str):
+            for sub_part in part:
+                sub_part_bnode = BNode()
+                self.graph.add((partBnode, QUERY.has_list , sub_part_bnode))
+                self.query_to_graph(sub_part, sub_part_bnode)
+        elif isinstance(part, Identifier) or isinstance(part, str):
+                self.graph.add((partBnode, QUERY.has_value, Literal(part)))
+
+    def serialize_graph(self):
+        if not self.graph_mode:
+            raise Exception("Not able to execute that function if graph mode is not activated: cannot work with two sources of truth")
+        return self.graph.serialize(format = "ttl")
+    
+    def query_graph(self, meta_query: str):
+        if not self.graph_mode:
+            raise Exception("Not able to execute that function if graph mode is not activated: cannot work with two sources of truth")
+        return self.graph.query(meta_query)
+    
+    def update(self, meta_query: str):
+        if not self.graph_mode:
+            # Implement update directly on objects: self.current_query
+            pass
+        return self.graph.update(meta_query)
+    
+    def get_query(self):
+        if self.graph_mode:
+            roots = self.graph.query("SELECT DISTINCT ?sub WHERE {?sub ?prop ?obj FILTER NOT EXISTS {?s ?p ?sub}}")
+            if len(roots) != 1:
+                raise Exception("query graph has more than one root: invalid")
+            
+            for root in roots:
+                new_query = self.graph_to_query(root.sub)
+            if not self.algebra_mode:
+                new_query = ParseResults(toklist=new_query, name=self.original_query.name)
+                new_query = translateQuery(new_query)
+            else:
+                new_query = Query(algebra=new_query, prologue=self.original_query.prologue)
+        else:
+            if not self.algebra_mode:
+                new_query = translateQuery(self.current_query)
+            else:
+                new_query = self.current_query
+        return translateAlgebra(new_query)
+        
+        
+
+    def graph_to_query(self, subject):
+        subject_dict = self.get_subject_dict(subject)
+        if QUERY.has_class in subject_dict:
+            class_name = str(subject_dict[QUERY.has_class])
+            subject_dict.pop(QUERY.has_class)
+            if class_name in globals():
+                clazz = globals()[class_name]
+                if clazz in (CompValue, Expr):
+                    comp_name = str(subject_dict[QUERY.name])
+                    subject_dict.pop(QUERY.name)
+                    subject_dict.pop(RDF.type)
+                    new_dict = dict(map(lambda kv: [str(kv[0]).replace(str(QUERY._NS), ""),
+                                                    self.graph_to_query(kv[1])] ,
+                                        subject_dict.items()))
+                    return clazz(comp_name, **new_dict)
+                elif clazz in (set, list, tuple) and QUERY.has_list in subject_dict:
+                    return clazz(map(lambda item: self.graph_to_query(item), subject_dict[QUERY.has_list]))
+                elif clazz == ParseResults and QUERY.has_list in subject_dict:
+                    return ParseResults(toklist=list(map(lambda item: self.graph_to_query(item), subject_dict[QUERY.has_list])))
+                elif clazz in (Literal, Variable, URIRef, str) and QUERY.has_value in subject_dict:
+                    return clazz(str(subject_dict[QUERY.has_value]))
+                        
+
+    def get_subject_dict(self, subject):
+        dict = {}
+        for key, value in self.graph.predicate_objects(subject):
+            # If key already exists: create or add to a list
+            if key == QUERY.has_list:
+                if key in dict:
+                    dict[key].append(value)
+                else:
+                    dict[key] = [value]
+            else:
+                dict[key] = value
+        return dict
+    
+
+
+class QUERY(DefinedNamespace):
+    _NS = Namespace("https://mustrd.com/query/")
+    has_class : URIRef
+    has_list : URIRef
+    name : URIRef
+    has_value: URIRef

{mustrd-0.1.8 → mustrd-0.2.0}/mustrd/spec_component.py

@@ -24,7 +24,6 @@ SOFTWARE.
 
 import os
 from dataclasses import dataclass, field
-from itertools import groupby
 from pathlib import Path
 from typing import Tuple, List, Type
 
@@ -39,6 +38,7 @@ from . import logger_setup
 from .mustrdAnzo import get_queries_for_layer, get_queries_from_templated_step, get_spec_component_from_graphmart, get_query_from_querybuilder, get_query_from_step
 from .namespace import MUST, TRIPLESTORE
 from multimethods import MultiMethod, Default
+from .utils import  get_mustrd_root
 
 log = logger_setup.setup_logger(__name__)
 
@@ -84,18 +84,14 @@ class SpecComponentDetails:
     spec_component_node: Node
     data_source_type: Node
     run_config: dict
+    root_paths: list
 
-def get_path(path_type: str, run_config: dict) -> Path:
-    try:
-        if str(run_config[path_type]).startswith("/"):
-            return run_config[path_type]
-        else: 
-            return Path(os.path.join(run_config['spec_path'], run_config[path_type]))
-    except(KeyError):
-        if str(run_config['data_path']).startswith("/"):
-            return run_config['data_path']
-        else: 
-            return Path(os.path.join(run_config['spec_path'], run_config['data_path']))
+def get_path(path_type: str, file_name, spec_component_details: SpecComponentDetails) -> Path:
+    if path_type in spec_component_details.run_config:
+        relative_path = os.path.join(spec_component_details.run_config[path_type], file_name)
+    else:
+        relative_path = file_name
+    return get_file_absolute_path(spec_component_details, relative_path)
     
 
 def parse_spec_component(subject: URIRef,
@@ -117,7 +113,8 @@ def parse_spec_component(subject: URIRef,
                 mustrd_triple_store=mustrd_triple_store,
                 spec_component_node=spec_component_node,
                 data_source_type=data_source_type,
-                run_config=run_config)
+                run_config=run_config, 
+                root_paths=get_components_roots(spec_graph, subject, run_config))
             spec_component = get_spec_component(spec_component_details)
             if type(spec_component) == list:
                 spec_components += spec_component 
@@ -130,6 +127,39 @@ def parse_spec_component(subject: URIRef,
     # print(f"calling multimethod with {spec_components}")
     return combine_specs(spec_components)
 
+# Here we retrieve all the possible root paths for a specification component.
+# This defines the order of priority between root paths which is:
+# 1) Path where the spec is located
+# 2) spec_path defined in mustrd test configuration files or cmd line argument
+# 3) data_path defined in mustrd test configuration files or cmd line argument
+# 4) Mustrd source folder: In case of default resources packaged with mustrd source (will be in venv when mustrd is called as library)
+# We intentionally don't try for absolute files, but you should feel free to argue that we should do
+def get_components_roots(spec_graph: Graph, subject: URIRef, run_config: dict):
+    where_did_i_load_this_spec_from = spec_graph.value(subject=subject,
+                                                                 predicate=MUST.specSourceFile)
+    roots = [] 
+    if (where_did_i_load_this_spec_from == None):
+        log.error(f"{where_did_i_load_this_spec_from=} was None for test_spec={subject}, we didn't set the test specifications specSourceFile when loading, spec_graph={spec_graph}")
+    else:
+        roots.append(Path(os.path.dirname(where_did_i_load_this_spec_from))) 
+    if run_config and'spec_path' in run_config:
+        roots.append(Path(run_config['spec_path']))
+    if run_config and 'data_path'  in run_config:
+        roots.append(run_config['data_path'])
+    roots.append(get_mustrd_root())
+    
+    return roots
+
+
+# From the list of component potential roots, return the first path that exists
+def get_file_absolute_path(spec_component_details: SpecComponentDetails, relative_file_path: str):
+    if not relative_file_path:
+        raise ValueError("Cannot get absolute path of None")
+    absolute_file_paths = list(map(lambda root_path: Path(os.path.join(root_path, relative_file_path)), spec_component_details.root_paths))
+    for absolute_file_path in absolute_file_paths:
+        if (os.path.exists(absolute_file_path)):
+            return absolute_file_path
+    raise FileNotFoundError(f"Could not find file {relative_file_path=} in any of the {absolute_file_paths=}")
 
 def get_spec_component_type(spec_components: List[SpecComponent]) -> Type[SpecComponent]:
     # Get the type of the first object in the list
@@ -224,7 +254,7 @@ def _get_spec_component_folderdatasource_given(spec_component_details: SpecCompo
     file_name = spec_component_details.spec_graph.value(subject=spec_component_details.spec_component_node,
                                                         predicate=MUST.fileName)
 
-    path = Path(os.path.join(str(get_path('given_path',spec_component_details.run_config)), str(file_name)))
+    path = get_path('given_path', file_name,spec_component_details)
     try:
         spec_component.value = Graph().parse(data=get_spec_component_from_file(path))
     except ParserError as e:
@@ -240,7 +270,7 @@ def _get_spec_component_foldersparqlsource_when(spec_component_details: SpecComp
     file_name = spec_component_details.spec_graph.value(subject=spec_component_details.spec_component_node,
                                                         predicate=MUST.fileName)
 
-    path = Path(os.path.join(str(get_path('when_path',spec_component_details.run_config)), str(file_name)))
+    path = get_path('when_path', file_name,spec_component_details)
     spec_component.value = get_spec_component_from_file(path)
     spec_component.queryType = spec_component_details.spec_graph.value(subject=spec_component_details.spec_component_node,
                                                                        predicate=MUST.queryType)
@@ -253,7 +283,7 @@ def _get_spec_component_folderdatasource_then(spec_component_details: SpecCompon
 
     file_name = spec_component_details.spec_graph.value(subject=spec_component_details.spec_component_node,
                                                         predicate=MUST.fileName)
-    path = Path(os.path.join(str(get_path('then_path',spec_component_details.run_config)), str(file_name)))
+    path = get_path('then_path', file_name,spec_component_details)
 
     return load_dataset_from_file(path, spec_component)
 
@@ -264,27 +294,9 @@ def _get_spec_component_filedatasource(spec_component_details: SpecComponentDeta
     return load_spec_component(spec_component_details, spec_component)
 
 def load_spec_component(spec_component_details, spec_component):
-    where_did_i_load_this_spec_from = spec_component_details.spec_graph.value(subject=spec_component_details.subject,
-                                                                 predicate=MUST.specSourceFile)
-    if (where_did_i_load_this_spec_from == None):
-        log.error(f"{where_did_i_load_this_spec_from=} was None for test_spec={spec_component_details.subject}, we didn't set the test specifications specSourceFile when loading, spec_graph={spec_component_details.spec_graph}")
     file_path = Path(str(spec_component_details.spec_graph.value(subject=spec_component_details.spec_component_node,
                                                                  predicate=MUST.file)))
-    
-    test_spec_file_path = os.path.dirname(where_did_i_load_this_spec_from)
-
-    # first we try local relative to the test_spec_file_path, then we try relative to the path under test
-    # we intentionally don't try for absolute files, but you should feel free to argue that we should do.
-    paths = [
-        Path(test_spec_file_path, file_path),
-        Path(os.path.join(spec_component_details.run_config['spec_path'], file_path))
-    ]
-    
-    for path in paths:
-        if (os.path.exists(path)):
-            return load_dataset_from_file(path, spec_component)
-
-    raise FileNotFoundError(f"Could not find file {file_path=} in any of the {paths=}")
+    return load_dataset_from_file(get_file_absolute_path(spec_component_details, file_path), spec_component)
     
 
 def load_dataset_from_file(path: Path, spec_component: ThenSpec) -> ThenSpec:
@@ -320,12 +332,8 @@ def _get_spec_component_filedatasource_when(spec_component_details: SpecComponen
     spec_component = init_spec_component(spec_component_details.predicate)
 
     file_path = Path(str(spec_component_details.spec_graph.value(subject=spec_component_details.spec_component_node,
-                                                                 predicate=MUST.file)))
-    if str(file_path).startswith("/"): # absolute path
-        path = file_path
-    else: #relative path
-        path = Path(os.path.join(spec_component_details.run_config['spec_path'], file_path))
-    spec_component.value = get_spec_component_from_file(path)
+                                                                 predicate=MUST.file)))    
+    spec_component.value = get_spec_component_from_file(get_file_absolute_path(spec_component_details, file_path))
 
     spec_component.queryType = spec_component_details.spec_graph.value(subject=spec_component_details.spec_component_node,
                                                                        predicate=MUST.queryType)

{mustrd-0.1.8 → mustrd-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "mustrd"
-version = "0.1.8"
+version = "0.2.0"
 description = "A Spec By Example framework for RDF and SPARQL, Inspired by Cucumber."
 authors = ["John Placek <john.placek@semanticpartners.com>",
     "Juliane Piñeiro-Winkler <juliane.pineiro-winkler@semanticpartners.com>",