mustrd 0.2.1__py3-none-any.whl → 0.2.2__py3-none-any.whl

mustrd/spec_component.py

@@ -29,16 +29,17 @@ from typing import Tuple, List, Type
 
 import pandas
 import requests
-from rdflib import RDF, Graph, URIRef, Variable, Literal, XSD, util
+from rdflib import RDF, Graph, URIRef, Variable, Literal, XSD, util, ConjunctiveGraph
 from rdflib.exceptions import ParserError
 from rdflib.term import Node
-import logging 
+from rdflib.plugins.stores.memory import Memory
 
 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 .mustrdAnzo import get_queries_for_layer, get_queries_from_templated_step, get_spec_component_from_graphmart
+from .mustrdAnzo import get_query_from_querybuilder, get_query_from_step
 from .namespace import MUST, TRIPLESTORE
 from multimethods import MultiMethod, Default
-from .utils import  get_mustrd_root
+from .utils import get_mustrd_root
 
 log = logger_setup.setup_logger(__name__)
 
@@ -50,7 +51,7 @@ class SpecComponent:
 
 @dataclass
 class GivenSpec(SpecComponent):
-    value: Graph = None
+    value: ConjunctiveGraph = None
 
 
 @dataclass
@@ -59,11 +60,13 @@ class WhenSpec(SpecComponent):
     queryType: URIRef = None
     bindings: dict = None
 
+
 @dataclass
 class AnzoWhenSpec(WhenSpec):
     paramQuery: str = None
     queryTemplate: str = None
 
+
 @dataclass
 class ThenSpec(SpecComponent):
     value: Graph = Graph()
@@ -86,22 +89,21 @@ class SpecComponentDetails:
     run_config: dict
     root_paths: list
 
+
 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,
                          predicate: URIRef,
                          spec_graph: Graph,
                          run_config: dict,
                          mustrd_triple_store: dict) -> GivenSpec | WhenSpec | ThenSpec | TableThenSpec:
-    # print(f"parse_spec_component {subject=} {predicate=} ")
     spec_component_nodes = get_spec_component_nodes(subject, predicate, spec_graph)
-    # all_data_source_types = []
     spec_components = []
     for spec_component_node in spec_component_nodes:
         data_source_types = get_data_source_types(subject, predicate, spec_graph, spec_component_node)
@@ -113,41 +115,41 @@ 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 
+            if isinstance(spec_component, list):
+                spec_components += spec_component
             else:
                 spec_components += [spec_component]
-
-        # all_data_source_types.extend(data_source_types)
-    # return all_data_source_types
     # merge multiple graphs into one, give error if spec config is a TableThen
     # 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)
+# 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}")
+                                                       predicate=MUST.specSourceFile)
+    roots = []
+    if not where_did_i_load_this_spec_from:
+        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(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:
+    if run_config and 'data_path' in run_config:
         roots.append(run_config['data_path'])
     roots.append(get_mustrd_root())
-    
+
     return roots
 
 
@@ -155,18 +157,20 @@ def get_components_roots(spec_graph: Graph, subject: URIRef, run_config: dict):
 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))
+    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
     spec_type = type(spec_components[0])
     # Loop through the remaining objects in the list and check their types
     for spec_component in spec_components[1:]:
-        if type(spec_component) != spec_type:
+        if not isinstance(spec_component, spec_type):
             # If an object has a different type, raise an error
             raise ValueError("All spec components must be of the same type")
 
@@ -216,7 +220,7 @@ def _combine_then_specs(spec_components: List[ThenSpec]) -> ThenSpec:
 @combine_specs.method(TableThenSpec)
 def _combine_table_then_specs(spec_components: List[TableThenSpec]) -> TableThenSpec:
     if len(spec_components) != 1:
-        raise ValueError(f"Parsing of multiple components of MUST.then for tables not implemented")
+        raise ValueError("Parsing of multiple components of MUST.then for tables not implemented")
     return spec_components[0]
 
 
@@ -224,6 +228,7 @@ def _combine_table_then_specs(spec_components: List[TableThenSpec]) -> TableThen
 def _combine_specs_default(spec_components: List[SpecComponent]):
     raise ValueError(f"Parsing of multiple components of this type not implemented {spec_components}")
 
+
 def get_data_source_types(subject: URIRef, predicate: URIRef, spec_graph: Graph, source_node: Node) -> List[Node]:
     data_source_types = []
     for data_source_type in spec_graph.objects(subject=source_node, predicate=RDF.type):
@@ -233,6 +238,7 @@ def get_data_source_types(subject: URIRef, predicate: URIRef, spec_graph: Graph,
         raise ValueError(f"Node has no rdf type {subject} {predicate}")
     return data_source_types
 
+
 # https://github.com/Semantic-partners/mustrd/issues/99
 def get_spec_component_dispatch(spec_component_details: SpecComponentDetails) -> Tuple[Node, URIRef]:
     return spec_component_details.data_source_type, spec_component_details.predicate
@@ -254,7 +260,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 = get_path('given_path', file_name,spec_component_details)
+    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:
@@ -270,10 +276,11 @@ 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 = get_path('when_path', file_name,spec_component_details)
+    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)
+    spec_component.queryType = spec_component_details.spec_graph.value(
+        subject=spec_component_details.spec_component_node,
+        predicate=MUST.queryType)
     return spec_component
 
 
@@ -283,21 +290,23 @@ 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 = get_path('then_path', file_name,spec_component_details)
+    path = get_path('then_path', file_name, spec_component_details)
 
     return load_dataset_from_file(path, spec_component)
 
+
 @get_spec_component.method((MUST.FileDataset, MUST.given))
 @get_spec_component.method((MUST.FileDataset, MUST.then))
 def _get_spec_component_filedatasource(spec_component_details: SpecComponentDetails) -> GivenSpec:
     spec_component = init_spec_component(spec_component_details.predicate)
     return load_spec_component(spec_component_details, spec_component)
 
+
 def load_spec_component(spec_component_details, spec_component):
     file_path = Path(str(spec_component_details.spec_graph.value(subject=spec_component_details.spec_component_node,
                                                                  predicate=MUST.file)))
     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:
     if path.is_dir():
@@ -326,34 +335,21 @@ def load_dataset_from_file(path: Path, spec_component: ThenSpec) -> ThenSpec:
             return spec_component
 
 
-
 @get_spec_component.method((MUST.FileSparqlSource, MUST.when))
 def _get_spec_component_filedatasource_when(spec_component_details: SpecComponentDetails) -> SpecComponent:
     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)))    
+                                                                 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)
+    spec_component.queryType = spec_component_details.spec_graph.value(
+        subject=spec_component_details.spec_component_node,
+        predicate=MUST.queryType)
 
     return spec_component
 
 
-# @get_spec_component.method((MUST.FileDataset, MUST.then))
-# def _get_spec_component_filedatasource_then(spec_component_details: SpecComponentDetails) -> SpecComponent:
-#     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))
-#     return get_then_from_file(path, spec_component)
-
-
 @get_spec_component.method((MUST.TextSparqlSource, MUST.when))
 def _get_spec_component_TextSparqlSource(spec_component_details: SpecComponentDetails) -> SpecComponent:
     spec_component = init_spec_component(spec_component_details.predicate)
@@ -364,8 +360,9 @@ def _get_spec_component_TextSparqlSource(spec_component_details: SpecComponentDe
                                                 predicate=MUST.queryText))
 
     spec_component.bindings = get_when_bindings(spec_component_details.subject, spec_component_details.spec_graph)
-    spec_component.queryType = spec_component_details.spec_graph.value(subject=spec_component_details.spec_component_node,
-                                                                       predicate=MUST.queryType)
+    spec_component.queryType = spec_component_details.spec_graph.value(
+        subject=spec_component_details.spec_component_node,
+        predicate=MUST.queryType)
     return spec_component
 
 
@@ -379,9 +376,10 @@ def _get_spec_component_HttpDataset(spec_component_details: SpecComponentDetails
     # Get specComponent with http GET protocol
     spec_component.value = requests.get(str(
         spec_component_details.spec_graph.value(subject=spec_component_details.spec_component_node,
-                                                predicate=MUST.dataSourceUrl)).content)    
-    spec_component.queryType = spec_component_details.spec_graph.value(subject=spec_component_details.spec_component_node,
-                                                                       predicate=MUST.queryType)
+                                                predicate=MUST.dataSourceUrl)).content)
+    spec_component.queryType = spec_component_details.spec_graph.value(
+        subject=spec_component_details.spec_component_node,
+        predicate=MUST.queryType)
     return spec_component
 
 
@@ -413,10 +411,14 @@ def _get_spec_component_EmptyGraph(spec_component_details: SpecComponentDetails)
 @get_spec_component.method((MUST.StatementsDataset, MUST.then))
 def _get_spec_component_StatementsDataset(spec_component_details: SpecComponentDetails) -> SpecComponent:
     spec_component = init_spec_component(spec_component_details.predicate)
-
-    spec_component.value = Graph().parse(
-        data=get_spec_from_statements(spec_component_details.subject, spec_component_details.predicate,
-                                      spec_component_details.spec_graph))
+    store = Memory()
+    g = URIRef("http://localhost:7200/test-graph")
+    spec_component.value = ConjunctiveGraph(store=store)
+    spec_graph = Graph(store=store, identifier=g)
+
+    data = get_spec_from_statements(spec_component_details.subject, spec_component_details.predicate,
+                                    spec_component_details.spec_graph)
+    spec_graph.parse(data=data)
     return spec_component
 
 
@@ -458,8 +460,9 @@ def _get_spec_component_AnzoQueryBuilderSparqlSource(spec_component_details: Spe
     else:
         raise ValueError(f"You must define {TRIPLESTORE.Anzo} to use {MUST.AnzoQueryBuilderSparqlSource}")
 
-    spec_component.queryType = spec_component_details.spec_graph.value(subject=spec_component_details.spec_component_node,
-                                                                       predicate=MUST.queryType)
+    spec_component.queryType = spec_component_details.spec_graph.value(
+        subject=spec_component_details.spec_component_node,
+        predicate=MUST.queryType)
     return spec_component
 
 
@@ -470,62 +473,72 @@ def _get_spec_component_AnzoGraphmartStepSparqlSource(spec_component_details: Sp
     # Get WHEN specComponent from query builder
     if spec_component_details.mustrd_triple_store["type"] == TRIPLESTORE.Anzo:
         query_step_uri = spec_component_details.spec_graph.value(subject=spec_component_details.spec_component_node,
-                                                             predicate=MUST.anzoQueryStep)
+                                                                 predicate=MUST.anzoQueryStep)
         spec_component.value = get_query_from_step(triple_store=spec_component_details.mustrd_triple_store,
-                                                    query_step_uri=query_step_uri)
+                                                   query_step_uri=query_step_uri)
     # If anzo specific function is called but no anzo defined
     else:
         raise ValueError(f"You must define {TRIPLESTORE.Anzo} to use {MUST.AnzoGraphmartStepSparqlSource}")
 
-    spec_component.queryType = spec_component_details.spec_graph.value(subject=spec_component_details.spec_component_node,
-                                                                       predicate=MUST.queryType)
+    spec_component.queryType = spec_component_details.spec_graph.value(
+        subject=spec_component_details.spec_component_node,
+        predicate=MUST.queryType)
     return spec_component
 
+
 @get_spec_component.method((MUST.AnzoGraphmartQueryDrivenTemplatedStepSparqlSource, MUST.when))
-def _get_spec_component_AnzoGraphmartQueryDrivenTemplatedStepSparqlSource(spec_component_details: SpecComponentDetails) -> SpecComponent:
-    spec_component = init_spec_component(spec_component_details.predicate, spec_component_details.mustrd_triple_store["type"] )
+def _get_spec_component_AnzoGraphmartQueryDrivenTemplatedStepSparqlSource(spec_component_details: SpecComponentDetails) -> SpecComponent: # noqa
+    spec_component = init_spec_component(
+        spec_component_details.predicate, spec_component_details.mustrd_triple_store["type"])
 
     # Get WHEN specComponent from query builder
     if spec_component_details.mustrd_triple_store["type"] == TRIPLESTORE.Anzo:
         query_step_uri = spec_component_details.spec_graph.value(subject=spec_component_details.spec_component_node,
-                                                             predicate=MUST.anzoQueryStep)
+                                                                 predicate=MUST.anzoQueryStep)
         queries = get_queries_from_templated_step(triple_store=spec_component_details.mustrd_triple_store,
-                                                    query_step_uri=query_step_uri)
-        spec_component.paramQuery= queries["param_query"]
+                                                  query_step_uri=query_step_uri)
+        spec_component.paramQuery = queries["param_query"]
         spec_component.queryTemplate = queries["query_template"]
     # If anzo specific function is called but no anzo defined
     else:
-        raise ValueError(f"You must define {TRIPLESTORE.Anzo} to use {MUST.AnzoGraphmartQueryDrivenTemplatedStepSparqlSource}")
+        raise ValueError(f"""You must define {TRIPLESTORE.Anzo}
+                         to use {MUST.AnzoGraphmartQueryDrivenTemplatedStepSparqlSource}""")
 
-    spec_component.queryType = spec_component_details.spec_graph.value(subject=spec_component_details.spec_component_node,
-                                                                       predicate=MUST.queryType)
+    spec_component.queryType = spec_component_details.spec_graph.value(
+        subject=spec_component_details.spec_component_node,
+        predicate=MUST.queryType)
     return spec_component
 
+
 @get_spec_component.method((MUST.AnzoGraphmartLayerSparqlSource, MUST.when))
 def _get_spec_component_AnzoGraphmartLayerSparqlSource(spec_component_details: SpecComponentDetails) -> list:
     spec_components = []
     # Get the ordered  WHEN specComponents which is the transform and query driven template queries for the Layer
     if spec_component_details.mustrd_triple_store["type"] == TRIPLESTORE.Anzo:
-        graphmart_layer_uri = spec_component_details.spec_graph.value(subject=spec_component_details.spec_component_node,
-                                                             predicate=MUST.anzoGraphmartLayer)
+        graphmart_layer_uri = spec_component_details.spec_graph.value(
+            subject=spec_component_details.spec_component_node,
+            predicate=MUST.anzoGraphmartLayer)
         queries = get_queries_for_layer(triple_store=spec_component_details.mustrd_triple_store,
-                                                    graphmart_layer_uri=graphmart_layer_uri)
+                                        graphmart_layer_uri=graphmart_layer_uri)
     # If anzo specific function is called but no anzo defined
     else:
-        raise ValueError(f"This test specification is specific to Anzo and can only be run against that platform.")
+        raise ValueError("This test specification is specific to Anzo and can only be run against that platform.")
     for query in queries:
-        spec_component = init_spec_component(spec_component_details.predicate, spec_component_details.mustrd_triple_store["type"])
-        spec_component.value = query.get("query") 
+        spec_component = init_spec_component(spec_component_details.predicate,
+                                             spec_component_details.mustrd_triple_store["type"])
+        spec_component.value = query.get("query")
         spec_component.paramQuery = query.get("param_query")
         spec_component.queryTemplate = query.get("query_template")
         if spec_component.value:
-            spec_component.queryType = spec_component_details.spec_graph.value(subject=spec_component_details.spec_component_node,
-                                                                       predicate=MUST.queryType)
+            spec_component.queryType = spec_component_details.spec_graph.value(
+                subject=spec_component_details.spec_component_node,
+                predicate=MUST.queryType)
         else:
-            spec_component.queryType  = MUST.AnzoQueryDrivenUpdateSparql   
+            spec_component.queryType = MUST.AnzoQueryDrivenUpdateSparql
         spec_components += [spec_component]
     return spec_components
 
+
 @get_spec_component.method(Default)
 def _get_spec_component_default(spec_component_details: SpecComponentDetails) -> SpecComponent:
     raise ValueError(
@@ -533,7 +546,7 @@ def _get_spec_component_default(spec_component_details: SpecComponentDetails) ->
         f"spec component ({spec_component_details.predicate})")
 
 
-def init_spec_component(predicate: URIRef, triple_store_type: URIRef = None ) -> GivenSpec | WhenSpec | ThenSpec | TableThenSpec:
+def init_spec_component(predicate: URIRef, triple_store_type: URIRef = None) -> GivenSpec | WhenSpec | ThenSpec | TableThenSpec: # noqa
     if predicate == MUST.given:
         spec_component = GivenSpec()
     elif predicate == MUST.when:
@@ -559,9 +572,6 @@ def get_spec_component_nodes(subject: URIRef, predicate: URIRef, spec_graph: Gra
 
 
 def get_spec_component_from_file(path: Path) -> str:
-    # project_root = get_project_root()
-    # file_path = Path(os.path.join(project_root, path))
-
     if path.is_dir():
         raise ValueError(f"Path {path} is a directory, expected a file")
 
@@ -576,14 +586,13 @@ def get_spec_from_statements(subject: URIRef,
                              predicate: URIRef,
                              spec_graph: Graph) -> Graph:
     statements_query = f"""
-    prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> 
+    prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
 
     CONSTRUCT {{ ?s ?p ?o }}
     {{
             <{subject}> <{predicate}> [
                 a <{MUST.StatementsDataset}> ;
                 <{MUST.hasStatement}> [
-                    a rdf:Statement ;
                     rdf:subject ?s ;
                     rdf:predicate ?p ;
                     rdf:object ?o ;
@@ -601,17 +610,17 @@ def get_spec_from_table(subject: URIRef,
                         spec_graph: Graph) -> pandas.DataFrame:
     # query the spec to get the expected result to convert to dataframe for comparison
     then_query = f"""
-        prefix sh:        <http://www.w3.org/ns/shacl#> 
+        prefix sh:        <http://www.w3.org/ns/shacl#>
             SELECT ?row ?variable ?binding ?order
-            WHERE {{ 
+            WHERE {{
                  <{subject}> <{predicate}> [
                         a <{MUST.TableDataset}> ;
                         <{MUST.hasRow}> ?row ].
                           ?row  <{MUST.hasBinding}> [
                                 <{MUST.variable}> ?variable ;
                                 <{MUST.boundValue}> ?binding ; ] .
-                          OPTIONAL {{ ?row sh:order ?order . }}        
-                                     .}} 
+                          OPTIONAL {{ ?row sh:order ?order . }}
+                                     .}}
              ORDER BY ?order"""
 
     expected_results = spec_graph.query(then_query)
@@ -630,7 +639,7 @@ def get_spec_from_table(subject: URIRef,
     for row in expected_results:
         df.loc[str(row.row), row.variable.value] = str(row.binding)
         df.loc[str(row.row), "order"] = row.order
-        if type(row.binding) == Literal:
+        if isinstance(row.binding, Literal):
             literal_type = str(XSD.string)
             if hasattr(row.binding, "datatype") and row.binding.datatype:
                 literal_type = str(row.binding.datatype)
@@ -648,7 +657,9 @@ def get_spec_from_table(subject: URIRef,
 
 def get_when_bindings(subject: URIRef,
                       spec_graph: Graph) -> dict:
-    when_bindings_query = f"""SELECT ?variable ?binding {{ <{subject}> <{MUST.when}> [ a <{MUST.TextSparqlSource}> ; <{MUST.hasBinding}> [ <{MUST.variable}> ?variable ; <{MUST.boundValue}> ?binding ; ] ; ]  ;}}"""
+    when_bindings_query = f"""SELECT ?variable ?binding {{ <{subject}> <{MUST.when}> [ a <{MUST.TextSparqlSource}> ;
+    <{MUST.hasBinding}> [ <{MUST.variable}> ?variable ;
+    <{MUST.boundValue}> ?binding ; ] ; ]  ;}}"""
     when_bindings = spec_graph.query(when_bindings_query)
 
     if len(when_bindings.bindings) == 0:
@@ -663,24 +674,24 @@ def get_when_bindings(subject: URIRef,
 def is_then_select_ordered(subject: URIRef, predicate: URIRef, spec_graph: Graph) -> bool:
     ask_select_ordered = f"""
     ASK {{
-    {{SELECT (count(?binding) as ?totalBindings) {{  
+    {{SELECT (count(?binding) as ?totalBindings) {{
     <{subject}> <{predicate}> [
                 a <{MUST.TableDataset}> ;
                 <{MUST.hasRow}> [ <{MUST.hasBinding}> [
                                     <{MUST.variable}> ?variable ;
                                     <{MUST.boundValue}> ?binding ;
-                            ] ; 
+                            ] ;
               ]
             ]
 }} }}
-    {{SELECT (count(?binding) as ?orderedBindings) {{    
+    {{SELECT (count(?binding) as ?orderedBindings) {{
     <{subject}> <{predicate}> [
                 a <{MUST.TableDataset}> ;
        <{MUST.hasRow}> [ sh:order ?order ;
-                    <{MUST.hasBinding}> [ 
+                    <{MUST.hasBinding}> [
                     <{MUST.variable}> ?variable ;
                                     <{MUST.boundValue}> ?binding ;
-                            ] ; 
+                            ] ;
               ]
             ]
 }} }}

mustrd/test/test_mustrd.py

@@ -2,4 +2,4 @@ from mustrd.mustrdTestPlugin import run_test_spec
 
 
 def test_unit(unit_tests):
-    assert run_test_spec(unit_tests.unit_test)
+    assert run_test_spec(unit_tests.unit_test)

mustrd/utils.py

@@ -30,6 +30,7 @@ from pathlib import Path
 def get_mustrd_root() -> Path:
     return Path(__file__).parent
 
+
 def is_json(myjson: str) -> bool:
     try:
         json.loads(myjson)

{mustrd-0.2.1.dist-info → mustrd-0.2.2.dist-info}/METADATA

@@ -1,17 +1,18 @@
 Metadata-Version: 2.1
 Name: mustrd
-Version: 0.2.1
+Version: 0.2.2
 Summary: A Spec By Example framework for RDF and SPARQL, Inspired by Cucumber.
 Home-page: https://github.com/Semantic-partners/mustrd
 License: MIT
 Author: John Placek
 Author-email: john.placek@semanticpartners.com
-Requires-Python: >=3.11.7,<4.0.0
+Requires-Python: >=3.11,<4.0
 Classifier: Framework :: Pytest
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Natural Language :: English
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Quality Assurance
 Classifier: Topic :: Software Development :: Testing
@@ -23,7 +24,7 @@ Requires-Dist: colorlog (>=6.7.0,<7.0.0)
 Requires-Dist: coverage (==7.4.3)
 Requires-Dist: flake8 (==7.0.0)
 Requires-Dist: multimethods-py (>=0.5.3,<0.6.0)
-Requires-Dist: numpy (>=1.26.0,<2.0.0)
+Requires-Dist: numpy (>=1.26.0,<1.27.0)
 Requires-Dist: openpyxl (>=3.1.2,<4.0.0)
 Requires-Dist: pandas (>=1.5.2,<2.0.0)
 Requires-Dist: pyanzo (>=3.3.10,<4.0.0)
@@ -34,7 +35,7 @@ Requires-Dist: requests (>=2.28.2,<3.0.0)
 Requires-Dist: tabulate (>=0.9.0,<0.10.0)
 Requires-Dist: toml (>=0.10.2,<0.11.0)
 Requires-Dist: tomli (>=2.0.1,<3.0.0)
-Requires-Dist: urllib3 (==1.26.15)
+Requires-Dist: urllib3 (==1.26.19)
 Project-URL: Repository, https://github.com/Semantic-partners/mustrd
 Description-Content-Type: text/plain
 
@@ -95,5 +96,9 @@ We invite you to try it, see where it doesn't fit, and raise an issue, or even b
 We're a specialist consultancy in Semantic Tech, we're putting this out in case it's useful, but if you need more support, kindly contact our business team on info@semanticpartners.com
 
 // tag::body[]
-include::src/README.adoc[tags=body]
+
+include::GETSTARTED.adoc[Get started]
+
+Developer doc:
+include::mustrd/README.adoc[tags=body]
 

{mustrd-0.2.1.dist-info → mustrd-0.2.2.dist-info}/RECORD

@@ -1,5 +1,5 @@
-mustrd/README.adoc,sha256=kj1oGeOo4lkPP1VWSBIdG_A3BH10MA32zbKWZRRobiQ,12410
-mustrd/TestResult.py,sha256=MdDrPgdpXbLUmRXDaA4-mkklxOxJ0_mCSWIumvHsMdw,4850
+mustrd/README.adoc,sha256=E5KuShPEl2U6NmRzEAwZtAhBoyJsOvjGS1CM2UsbSQ4,1394
+mustrd/TestResult.py,sha256=K4yth-rYrK6Pl7SFiTAZkUStBIzHlgq0oxSSpq5F34M,4849
 mustrd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mustrd/logger_setup.py,sha256=pNtG5egdd7OiFdn-Qx-tlf5JITka1yitbzYBpHzrP_4,1582
 mustrd/model/catalog-v001.xml,sha256=IEtaw3FK4KGQWKancEe1HqzUQTrKdk89vNxnoLKGF4o,381
@@ -10,22 +10,22 @@ mustrd/model/ontology.ttl,sha256=AK27qyT8GW_SwJDwTFvtfxndBPEfYT6Y1jiW26Hyjg0,168
 mustrd/model/test-resources/resources.ttl,sha256=1Dsp1nuNxauj9bxeX-HShQsiO-CVy5Irwm2y2x0cdjI,1498
 mustrd/model/triplestoreOntology.ttl,sha256=jK9zJOInlJ8uXzbAsQarBBrZgGrMrMXbrsuXGMbp020,6025
 mustrd/model/triplestoreshapes.ttl,sha256=VqdItpI9qFQSj4leZuwbIoAjWJehhR8bao0EPvtGMR0,1835
-mustrd/mustrd.py,sha256=VqKfceNXWoBBQ4PCspWA_3kpNoz1o1T7Gzj2R3RZvmo,34294
-mustrd/mustrdAnzo.py,sha256=1YyuAOlNecfoWRWgPIl9K5-gscE4ni4wNiTyU7gzxAM,11586
+mustrd/mustrd.py,sha256=TFppEvQraOU2G1D2R1-MAatlY_qtYAosGl4oGQ3uLa8,33953
+mustrd/mustrdAnzo.py,sha256=AfXKcU17_PQwoG1RfUVYgctcXMJPrfZdmEXzVi7E3HM,12155
 mustrd/mustrdGraphDb.py,sha256=ySYYGvKUgXIS8QLLS7FEcppLlSb0qZ3lLlYzPf_Sr3Y,5474
 mustrd/mustrdRdfLib.py,sha256=CvrzEl1-lEPugYVe3y_Ip8JMzUxv6IeWauLOa_WA-XI,2073
-mustrd/mustrdTestPlugin.py,sha256=zA3iu59Hq-0fnYqAzfmUAEEPKEb50BGoJPrCjHMlmpA,14644
-mustrd/namespace.py,sha256=wM4yOJ_ftFghUXURruSovGos5dKvwQLFqr6whsXzItU,3640
-mustrd/run.py,sha256=sudrg26k5CKxwW8EkFhK7PLmK0SMk6b0s__GPkwYPqs,4274
-mustrd/spec_component.py,sha256=Jv1_jYEnRgqeCGCeU36euuuqSZL5ZLd9Cjb8mRbQ4UI,32614
+mustrd/mustrdTestPlugin.py,sha256=zQ6oqLsl4KbyTyCF27-SLiZdiP0o6-tMbGin-qBNvTE,14913
+mustrd/namespace.py,sha256=xGfH-nRP3t_I4rmoGJPqlSGbI0G5HUMlUeAl7l_yW-s,3622
+mustrd/run.py,sha256=5xZUgKPMBQ-03cWROAnwtbOs2Nb0Vat6n8Fi6EyfS-k,4257
+mustrd/spec_component.py,sha256=7BmMjJMy0ACbVBAEZpe5ZprnDZYs6h5f7-fI38l3jAk,31483
 mustrd/steprunner.py,sha256=YKrMSYhethWCAQEI63hK6jXh3ljyoM87w7eHyoRd8rc,7389
 mustrd/templates/md_ResultList_leaf_template.jinja,sha256=IzwZjliCx7-viipATDQK6MQg_5q1kLMKdeNSZg1sXXY,508
 mustrd/templates/md_ResultList_template.jinja,sha256=_8joJ7vtw_qoqxv3HhUtBgRfhOeqmgfaRFwEo4MROvQ,203
 mustrd/templates/md_stats_template.jinja,sha256=96W62cMWu9UGLNv65ZQ8RYLjkxKHhJy-FlUtXgud6XY,155
-mustrd/test/test_mustrd.py,sha256=ImGwG6rBIgRo7v6js5rtt26pF5K1pBZgD_vAYgiNOps,125
-mustrd/utils.py,sha256=VLp8r7FtgFqKZdRSAhIHAawtWraBMn1BuYdtBRnGqaQ,1386
-mustrd-0.2.1.dist-info/LICENSE,sha256=r8nmh5fUct9h2w8_RDl13EIscvmwCLoarPr1kg35MnA,1078
-mustrd-0.2.1.dist-info/METADATA,sha256=aoswqG7pcGx1rk8RZJX7V4pklsoQO4laHIcw0T3yNj4,4227
-mustrd-0.2.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-mustrd-0.2.1.dist-info/entry_points.txt,sha256=v7V7sN0_L1aB4Ug_9io5axlQSeJ1C0tNrQWwdXdV58s,50
-mustrd-0.2.1.dist-info/RECORD,,
+mustrd/test/test_mustrd.py,sha256=ku4-UQ2railFo6z9apaIkPFOk980XSwCPBEHjhwWZUE,126
+mustrd/utils.py,sha256=OGdLvw7GvjrFgTJo0J97Xwdh-_ZgSmapmOistrEchO0,1387
+mustrd-0.2.2.dist-info/LICENSE,sha256=r8nmh5fUct9h2w8_RDl13EIscvmwCLoarPr1kg35MnA,1078
+mustrd-0.2.2.dist-info/METADATA,sha256=PhkQpayIladpIEDKm-Q6JvGsoYUEPL1x7X1FSPBJB3w,4333
+mustrd-0.2.2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+mustrd-0.2.2.dist-info/entry_points.txt,sha256=v7V7sN0_L1aB4Ug_9io5axlQSeJ1C0tNrQWwdXdV58s,50
+mustrd-0.2.2.dist-info/RECORD,,