mustrd 0.2.6.3__py3-none-any.whl → 0.3.0.0__py3-none-any.whl

mustrd/__init__.py

@@ -1 +0,0 @@
-

mustrd/anzo_utils.py

@@ -33,6 +33,7 @@ import logging
 
 logger = logging.getLogger()
 
+
 def query_azg(anzo_config: dict, query: str,
               format: str = "json", is_update: bool = False,
               data_layers: List[str] = None):
@@ -41,7 +42,7 @@ def query_azg(anzo_config: dict, query: str,
         'format': format,
         'datasourceURI': anzo_config['gqe_uri'],
         'using-graph-uri' if is_update else 'default-graph-uri': data_layers,
-        'using-named-graph-uri' if is_update else'named-graph-uri': data_layers
+        'using-named-graph-uri' if is_update else 'named-graph-uri': data_layers
     }
     url = f"{anzo_config['url']}/sparql"
     return send_anzo_query(anzo_config, url=url, params=params, query=query, is_update=is_update)

mustrd/logger_setup.py

@@ -35,6 +35,7 @@ def setup_logger(name: str) -> logging.Logger:
     log = logging.getLogger(name)
     log.setLevel(LOG_LEVEL)
     
+
     stderr_handler = logging.StreamHandler(sys.stderr)
     stderr_handler.setLevel(logging.ERROR)
     log.addHandler(stderr_handler)

mustrd/model/mustrdShapes.ttl

@@ -249,5 +249,14 @@ must:AnzoGraphmartQueryDrivenTemplatedStepSparqlSourceShape
                      sh:minCount    1 ;
                      sh:maxCount    1 ; ]  .
 
-
-
+must:SpadeEdnGroupSourceShape
+    a              sh:NodeShape ;
+    sh:targetClass must:SpadeEdnGroupSource ;
+    sh:property    [ sh:path     must:file ;
+                     sh:message "A SpadeEdnGroupSource must have a file property pointing to the spade.edn config." ;
+                     sh:minCount 1 ;
+                     sh:maxCount 1 ; ] ;
+    sh:property    [ sh:path     must:groupId ;
+                     sh:message "A SpadeEdnGroupSource must have a groupId property referencing the group in the EDN file." ;
+                     sh:minCount 1 ;
+                     sh:maxCount 1 ; ] .

mustrd/model/ontology.ttl

@@ -461,6 +461,11 @@ sh:order rdf:type owl:DatatypeProperty ;
                          rdfs:isDefinedBy : ;
                          rdfs:label "AnzoGraphmartQueryDrivenTemplatedStepSparqlSource" .
 
+### https://mustrd.com/model/SpadeEdnGroupSource
+:SpadeEdnGroupSource rdf:type owl:Class ;
+    rdfs:subClassOf :SparqlSource ;
+    rdfs:comment "Allows reference to a spade.edn file, and a specific groupid (think Anzo layer), within that" ; 
+    rdfs:label "SpadeEdnGroupSource" .
 
 ###  https://mustrd.com/model/Then
 :Then rdf:type owl:Class ;

mustrd/mustrd.py

@@ -55,7 +55,6 @@ import logging
 from http.client import HTTPConnection
 from .steprunner import upload_given, run_when
 from multimethods import MultiMethod
-import logging
 import traceback
 
 log = logging.getLogger(__name__)
@@ -239,7 +238,10 @@ def validate_specs(run_config: dict,
                                                          advanced=True,
                                                          js=False,
                                                          debug=False)
-
+        if str(file.name).endswith("_duplicate"):
+            log.debug(f"Validation of {file.name} against SHACL shapes: {conforms}")
+            log.debug(f"{results_graph.serialize(format='turtle')}")
+        # log.debug(f"SHACL validation results: {results_text}")
         # Add error message if not conform to spec shapes
         if not conforms:
             for msg in results_graph.objects(predicate=SH.resultMessage):
@@ -284,6 +286,10 @@ def add_spec_validation(file_graph: Graph, subject_uris: set, file: Path, triple
                         error_messages: list, invalid_specs: list, spec_graph: Graph):
 
     for subject_uri in file_graph.subjects(RDF.type, MUST.TestSpec):
+        # Always add file name and source file to the graph for error reporting
+        file_graph.add([subject_uri, MUST.specSourceFile, Literal(str(file))])
+        file_graph.add([subject_uri, MUST.specFileName, Literal(file.name)])
+
         # If we already collected a URI, then we tag it as duplicate and it won't be executed
         if subject_uri in subject_uris:
             log.warning(
@@ -326,8 +332,11 @@ def get_specs(spec_uris: List[URIRef], spec_graph: Graph, triple_stores: List[di
                         specs += [get_spec(spec_uri, spec_graph,
                                            run_config, triple_store)]
                     except (ValueError, FileNotFoundError, ConnectionError) as e:
+                        # Try to get file name/path from the graph, but fallback to "unknown"
+                        file_name = spec_graph.value(subject=spec_uri, predicate=MUST.specFileName) or "unknown"
+                        file_path = spec_graph.value(subject=spec_uri, predicate=MUST.specSourceFile) or "unknown"
                         skipped_results += [SpecSkipped(spec_uri, triple_store['type'],
-                                                        e, get_spec_file(spec_uri, spec_graph))]
+                                                        str(e), str(file_name), Path(file_path))]
 
     except (BadSyntax, FileNotFoundError) as e:
         template = "An exception of type {0} occurred when trying to parse the triple store configuration file. " \
@@ -349,7 +358,14 @@ def run_specs(specs) -> List[SpecResult]:
 
 
 def get_spec_file(spec_uri: URIRef, spec_graph: Graph):
-    return str(spec_graph.value(subject=spec_uri, predicate=MUST.specFileName, default="default.mustrd.ttl"))
+    file_name = spec_graph.value(subject=spec_uri, predicate=MUST.specFileName)
+    if file_name:
+        return str(file_name)
+    # fallback: try to get from MUST.specSourceFile
+    file_path = spec_graph.value(subject=spec_uri, predicate=MUST.specSourceFile)
+    if file_path:
+        return str(Path(file_path).name)
+    return "default.mustrd.ttl"
 
 
 def get_spec(spec_uri: URIRef, spec_graph: Graph, run_config: dict, mustrd_triple_store: dict = None) -> Specification:
@@ -382,10 +398,11 @@ def get_spec(spec_uri: URIRef, spec_graph: Graph, run_config: dict, mustrd_tripl
 
 
 def check_result(spec: Specification, result: Union[str, Graph]):
+    
     log.debug(
         f"check_result {spec.spec_uri=}, {spec.triple_store=}, {result=} {type(spec.then)}")
     if isinstance(spec.then, TableThenSpec):
-        log.debug(f"table_comparison")
+        log.debug("table_comparison")
         return table_comparison(result, spec)
     else:
         graph_compare = graph_comparison(spec.then.value, result)
@@ -397,20 +414,26 @@ def check_result(spec: Specification, result: Union[str, Graph]):
 
             return ret
         else:
-            log.debug(f"not isomorphic")
+            log.debug("not isomorphic")
             if spec.when[0].queryType == MUST.ConstructSparql:
-                log.debug(f"ConstructSpecFailure")
-
+                log.debug("ConstructSpecFailure")
                 return ConstructSpecFailure(spec.spec_uri, spec.triple_store["type"], graph_compare)
             else:
-                log.debug(f"UpdateSpecFailure")
+                log.debug("UpdateSpecFailure")
                 return UpdateSpecFailure(spec.spec_uri, spec.triple_store["type"], graph_compare)
 
 
 def run_spec(spec: Specification) -> SpecResult:
     spec_uri = spec.spec_uri
     triple_store = spec.triple_store
-    # close_connection = True
+
+    if not isinstance(spec, Specification):
+        log.warning(f"check_result called with non-Specification: {type(spec)}")
+        return spec
+        # return SpecSkipped(getattr(spec, 'spec_uri', None), getattr(spec, 'triple_store', {}), "Spec is not a valid Specification instance")
+    
+    log.debug(
+        f"run_spec {spec=}")
     log.debug(
         f"run_when {spec_uri=}, {triple_store=}, {spec.given=}, {spec.when=}, {spec.then=}")
     if spec.given:
@@ -434,7 +457,8 @@ def run_spec(spec: Specification) -> SpecResult:
                 return SparqlParseFailure(spec_uri, triple_store["type"], e)
             except NotImplementedError as ex:
                 log.error(f"NotImplementedError {ex}")
-                return SpecSkipped(spec_uri, triple_store["type"], ex.args[0])
+                raise ex
+                # return SpecSkipped(spec_uri, triple_store["type"], ex.args[0])
         return check_result(spec, result)
     except (ConnectionError, TimeoutError, HTTPError, ConnectTimeout, OSError) as e:
         # close_connection = False
@@ -446,12 +470,8 @@ def run_spec(spec: Specification) -> SpecResult:
         log.error(f"{type(e)} {e}")
         return SparqlExecutionError(spec_uri, triple_store["type"], e)
     except Exception as e:
-        if e:
-            log.error(f"Unknown error {e}\n{traceback.format_exc()}")
-            raise
-        else:
-            log.error(f"Unknown error")
-        return RuntimeError(spec_uri, triple_store["type"], e)
+        log.error(f"Unexpected error {e}")
+        return RuntimeError(spec_uri, triple_store["type"], f"{type(e).__name__}: {e}")
     # https://github.com/Semantic-partners/mustrd/issues/78
     # finally:
     #     if type(mustrd_triple_store) == MustrdAnzo and close_connection:

mustrd/mustrdAnzo.py

@@ -29,6 +29,7 @@ from mustrd.anzo_utils import query_azg, query_graphmart
 from mustrd.anzo_utils import query_configuration, json_to_dictlist, ttl_to_graph
 
 
+
 def execute_select(triple_store: dict,  when: str, bindings: dict = None) -> str:
     try:
         if bindings:
@@ -39,7 +40,7 @@ def execute_select(triple_store: dict,  when: str, bindings: dict = None) -> str
                             f"FROM <{triple_store['input_graph']}>\nFROM <{triple_store['output_graph']}>").replace(
                                 "${targetGraph}", f"<{triple_store['output_graph']}>")
         # TODO: manage results here
-        return query_azg(anzo_config=triple_store, query=when)
+        return query_azg(anzo_config=triple_store, query=when, data_layers=[triple_store['input_graph']])
     except (ConnectionError, TimeoutError, HTTPError, ConnectTimeout):
         raise
 

mustrd/mustrdTestPlugin.py

@@ -1,27 +1,3 @@
-"""
-MIT License
-
-Copyright (c) 2023 Semantic Partners Ltd
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-"""
-
 import logging
 from dataclasses import dataclass
 import pytest
@@ -93,6 +69,14 @@ def pytest_addoption(parser):
         default=None,
         help="Give the secrets by command line in order to be able to store secrets safely in CI tools",
     )
+    group.addoption(
+        "--pytest-path",
+        action="store",
+        dest="pytest_path",
+        metavar="PytestPath",
+        default=None,
+        help="Filter tests based on the pytest_path property in .mustrd.ttl files.",
+    )
     return
 
 
@@ -217,27 +201,39 @@ class MustrdTestPlugin:
     @pytest.hookimpl(tryfirst=True)
     def pytest_collection(self, session):
         logger.info("Starting test collection")
+        
         self.unit_tests = []
         args = session.config.args
-        logger.info("Used arguments: " + str(args))
+        
+        # Split args into mustrd and regular pytest args
+        mustrd_args = [arg for arg in args if ".mustrd.ttl" in arg]
+        pytest_args = [arg for arg in args if arg != os.getcwd() and ".mustrd.ttl" not in arg]
+        
         self.selected_tests = list(
             map(
                 lambda arg: Path(arg.split("::")[0]),
-                # By default the current directory is given as argument
-                # Remove it as it is not a test
-                filter(lambda arg: arg != os.getcwd() and "::" in arg, args),
+                mustrd_args 
             )
         )
         logger.info(f"selected_tests is: {self.selected_tests}")
 
-        self.path_filter = (
-            args[0]
-            if len(args) == 1 and args[0] != os.getcwd() and not "::" in args[0]
-            else None
-        )
+        self.path_filter = session.config.getoption("pytest_path") or None
+
         logger.info(f"path_filter is: {self.path_filter}")
+        logger.info(f"Args: {args}")
+        logger.info(f"Mustrd Args: {mustrd_args}")
+        logger.info(f"Pytest Args: {pytest_args}")
+        logger.info(f"Path Filter: {self.path_filter}")
+
+        # Only modify args if we have mustrd tests to run
+        if self.selected_tests:
+            # Keep original pytest args and add config file for mustrd
+            session.config.args = pytest_args + [str(self.test_config_file.resolve())]
+        else:
+            # Keep original args unchanged for regular pytest
+            session.config.args = args
 
-        session.config.args = [str(self.test_config_file.resolve())]
+        logger.info(f"Final session.config.args: {session.config.args}")
 
     def get_file_name_from_arg(self, arg):
         if arg and len(arg) > 0 and "[" in arg and ".mustrd.ttl " in arg:
@@ -247,6 +243,13 @@ class MustrdTestPlugin:
     @pytest.hookimpl
     def pytest_collect_file(self, parent, path):
         logger.debug(f"Collecting file: {path}")
+        # Only collect .ttl files that are mustrd suite config files
+        if not str(path).endswith('.ttl'):
+            return None
+        if Path(path).resolve() != Path(self.test_config_file).resolve():
+                logger.debug(f"{self.test_config_file}: Skipping non-matching-config file: {path}")
+                return None
+        
         mustrd_file = MustrdFile.from_parent(parent, path=pathlib.Path(path), mustrd_plugin=self)
         mustrd_file.mustrd_plugin = self
         return mustrd_file
@@ -269,13 +272,24 @@ class MustrdTestPlugin:
             file_name or "*",
             selected_test_files=self.selected_tests,
         )
+        # Convert invalid specs to SpecInvalid instead of SpecSkipped
+        invalid_specs = [
+            SpecInvalid(
+                spec.spec_uri,
+                spec.triple_store,
+                spec.message,
+                spec.spec_file_name,
+                spec.spec_source_file
+            ) for spec in invalid_spec_results
+        ]
+
 
         specs, skipped_spec_results = get_specs(
             valid_spec_uris, spec_graph, triple_stores, config
         )
 
         # Return normal specs + skipped results
-        return specs + skipped_spec_results + invalid_spec_results
+        return specs + skipped_spec_results + invalid_specs
 
     # Function called to generate the name of the test
     def get_test_name(self, spec):
@@ -383,39 +397,47 @@ class MustrdTestPlugin:
         with open(self.md_path, "w") as file:
             file.write(md)
 
+@dataclass(frozen=True)
+class SpecInvalid:
+    spec_uri: str
+    triple_store: str
+    message: str
+    spec_file_name: str = None
+    spec_source_file: Path = None
 
 class MustrdFile(pytest.File):
     mustrd_plugin: MustrdTestPlugin
 
     def __init__(self, *args, mustrd_plugin, **kwargs):
+        logger.debug(f"Creating MustrdFile with args: {args}, kwargs: {kwargs}")
         self.mustrd_plugin = mustrd_plugin
         super(pytest.File, self).__init__(*args, **kwargs)
 
     def collect(self):
         try:
-            logger.debug(f"Collecting tests from file: {self.fspath}")
-            test_configs = parse_config(self.fspath)
+            logger.info(f"{self.mustrd_plugin.test_config_file}: Collecting tests from file: {self.path=}")
+            # Only process the specific mustrd config file we were given
+            
+            # if not str(self.fspath).endswith(".ttl"):
+            #     return []
+            # Only process the specific mustrd config file we were given
+            # if str(self.fspath) != str(self.mustrd_plugin.test_config_file):
+            #     logger.info(f"Skipping non-config file: {self.fspath}")
+            #     return []
+                
+            test_configs = parse_config(self.path)
+            from collections import defaultdict
+            pytest_path_grouped = defaultdict(list)
             for test_config in test_configs:
-                # Skip if there is a path filter and it is not in the pytest path
                 if (
                     self.mustrd_plugin.path_filter is not None
-                    and self.mustrd_plugin.path_filter not in test_config.pytest_path
+                    and not str(test_config.pytest_path).startswith(str(self.mustrd_plugin.path_filter))
                 ):
+                    logger.info(f"Skipping test config due to path filter: {test_config.pytest_path=} {self.mustrd_plugin.path_filter=}")
                     continue
-                triple_stores = self.mustrd_plugin.get_triple_stores_from_file(
-                    test_config
-                )
-
-                if test_config.filter_on_tripleStore and not triple_stores:
-                    specs = list(
-                        map(
-                            lambda triple_store: SpecSkipped(
-                                MUST.TestSpec, triple_store, "No triplestore found"
-                            ),
-                            test_config.filter_on_tripleStore,
-                        )
-                    )
-                else:
+                
+                triple_stores = self.mustrd_plugin.get_triple_stores_from_file(test_config)
+                try:
                     specs = self.mustrd_plugin.generate_tests_for_config(
                         {
                             "spec_path": test_config.spec_path,
@@ -424,27 +446,63 @@ class MustrdFile(pytest.File):
                         triple_stores,
                         None,
                     )
+                except Exception as e:
+                    logger.error(f"Error generating tests: {e}\n{traceback.format_exc()}")
+                    specs = [
+                        SpecInvalid(
+                            MUST.TestSpec,
+                            triple_store["uri"] if isinstance(triple_store, dict) else triple_store,
+                            f"Test generation failed: {str(e)}",
+                            spec_file_name=str(test_config.spec_path.name) if test_config.spec_path else "unknown.mustrd.ttl",
+                            spec_source_file=self.path if test_config.spec_path else Path("unknown.mustrd.ttl"),
+                        )
+                        for triple_store in (triple_stores or test_config.filter_on_tripleStore)
+                    ]
+                pytest_path = getattr(test_config, "pytest_path", "unknown")
                 for spec in specs:
-                    item = MustrdItem.from_parent(
-                        self,
-                        name=test_config.pytest_path + "/" + spec.spec_file_name,
-                        spec=spec,
-                    )
-                    self.mustrd_plugin.items.append(item)
-                    yield item
+                    pytest_path_grouped[pytest_path].append(spec)
+
+            for pytest_path, specs_for_path in pytest_path_grouped.items():
+                logger.info(f"pytest_path group: {pytest_path} ({len(specs_for_path)} specs)")
+
+                yield MustrdPytestPathCollector.from_parent(
+                    self,
+                    name=str(pytest_path),
+                    pytest_path=pytest_path,
+                    specs=specs_for_path,
+                    mustrd_plugin=self.mustrd_plugin,
+                )
         except Exception as e:
-            # Catch error here otherwise it will be lost
             self.mustrd_plugin.collect_error = e
-            logger.error(f"Error during collection: {e}")
+            logger.error(f"Error during collection {self.path}: {type(e)} {e} {traceback.format_exc()}")
             raise e
 
 
+class MustrdPytestPathCollector(pytest.Class):
+    def __init__(self, name, parent, pytest_path, specs, mustrd_plugin):
+        super().__init__(name, parent)
+        self.pytest_path = pytest_path
+        self.specs = specs
+        self.mustrd_plugin = mustrd_plugin
+
+    def collect(self):
+        for spec in self.specs:
+            item = MustrdItem.from_parent(
+                self,
+                name=spec.spec_file_name,
+                spec=spec,
+            )
+            self.mustrd_plugin.items.append(item)
+            yield item
+
+
 class MustrdItem(pytest.Item):
     def __init__(self, name, parent, spec):
-        logging.info(f"Creating item: {name}")
+        logging.debug(f"Creating item: {name}")
         super().__init__(name, parent)
         self.spec = spec
         self.fspath = spec.spec_source_file
+        self.originalname = name
 
     def runtest(self):
         result = run_test_spec(self.spec)
@@ -460,8 +518,7 @@ class MustrdItem(pytest.Item):
             f"{self.name} failed:\n"
             f"Spec: {self.spec.spec_uri}\n"
             f"File: {self.spec.spec_source_file}\n"
-            f"Dir: {dir(self.spec)}\n"
-            f"Error: {excinfo.value}\n"
+            f"Error: \n{excinfo.value}\n"
             f"Traceback:\n{tb_str}"
         )
     
@@ -476,6 +533,8 @@ def run_test_spec(test_spec):
         pytest.skip(f"Invalid configuration, error : {test_spec.message}")
     result = run_spec(test_spec)
     result_type = type(result)
+    if isinstance(test_spec, SpecInvalid):
+        raise ValueError(f"Invalid test specification: {test_spec.message} {test_spec}")
     if result_type == SpecSkipped:
         # FIXME: Better exception management
         pytest.skip("Unsupported configuration")

mustrd/spec_component.py

@@ -35,8 +35,8 @@ from rdflib.term import Node
 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
-from .mustrdAnzo import get_query_from_querybuilder, get_query_from_step
+from .mustrdAnzo import get_queries_for_layer, get_queries_from_templated_step
+from .mustrdAnzo import get_query_from_querybuilder
 from .namespace import MUST, TRIPLESTORE
 from multimethods import MultiMethod, Default
 from .utils import get_mustrd_root
@@ -119,8 +119,9 @@ def parse_spec_component(subject: URIRef,
                 data_source_type=data_source_type,
                 run_config=run_config,
                 root_paths=get_components_roots(spec_graph, subject, run_config))
-            
-            # get_spec_component potentially talks to anzo for EVERY spec, massively slowing things down, can we defer it to run time? 
+
+            # get_spec_component potentially talks to anzo for EVERY spec, massively slowing things down
+            # can we defer it to run time?
             spec_component = get_spec_component(spec_component_details)
             if isinstance(spec_component, list):
                 spec_components += spec_component
@@ -433,15 +434,7 @@ def _get_spec_component_AnzoGraphmartDataset(spec_component_details: SpecCompone
 
     if spec_component_details.mustrd_triple_store["type"] == TRIPLESTORE.Anzo:
         # Get GIVEN or THEN from anzo graphmart
-        graphmart = spec_component_details.spec_graph.value(subject=spec_component_details.spec_component_node,
-                                                            predicate=MUST.graphmart)
-        layer = spec_component_details.spec_graph.value(subject=spec_component_details.spec_component_node,
-                                                        predicate=MUST.layer)
         spec_component.spec_component_details = spec_component_details
-        # return get_spec_component_from_graphmart(
-        #     triple_store=spec_component_details.mustrd_triple_store,
-        #     graphmart=graphmart,
-        #     layer=layer)
     else:
         raise ValueError(f"You must define {TRIPLESTORE.Anzo} to use {MUST.AnzoGraphmartDataset}")
 
@@ -555,7 +548,6 @@ def _get_spec_component_default(spec_component_details: SpecComponentDetails) ->
 
 
 def init_spec_component(predicate: URIRef, triple_store_type: URIRef = None) -> GivenSpec | WhenSpec | ThenSpec | TableThenSpec: # noqa
-    log.info(f"init_spec_component {predicate} {triple_store_type}")
     if predicate == MUST.given:
         spec_component = GivenSpec()
     elif predicate == MUST.when:

mustrd/steprunner.py

@@ -24,7 +24,6 @@ SOFTWARE.
 
 import json
 
-from . import logger_setup
 from multimethods import MultiMethod, Default
 from .namespace import MUST, TRIPLESTORE
 from rdflib import Graph, URIRef
@@ -105,8 +104,7 @@ def _anzo_run_when_select(spec_uri: URIRef, triple_store: dict, when: AnzoWhenSp
 
 @run_when.method((TRIPLESTORE.GraphDb, MUST.UpdateSparql))
 def _graphdb_run_when_update(spec_uri: URIRef, triple_store: dict, when: WhenSpec):
-    
-    return execute_update_graphdb(triple_store, query, when.bindings)
+    return execute_update_graphdb(triple_store, when.value, when.bindings)
 
 
 @run_when.method((TRIPLESTORE.GraphDb, MUST.ConstructSparql))

{mustrd-0.2.6.3.dist-info → mustrd-0.3.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: mustrd
-Version: 0.2.6.3
+Version: 0.3.0.0
 Summary: A Spec By Example framework for RDF and SPARQL, Inspired by Cucumber.
 License: MIT
 Author: John Placek
@@ -26,7 +26,7 @@ Requires-Dist: flake8 (==7.0.0)
 Requires-Dist: multimethods-py (>=0.5.3,<0.6.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: pandas (>=2.0,<3.0)
 Requires-Dist: pyshacl (>=0.30.0,<0.31.0)
 Requires-Dist: pytest (>=7.2.0,<8.0.0)
 Requires-Dist: rdflib (>=7.1.3,<8.0.0)

{mustrd-0.2.6.3.dist-info → mustrd-0.3.0.0.dist-info}/RECORD

@@ -1,32 +1,32 @@
 mustrd/README.adoc,sha256=E5KuShPEl2U6NmRzEAwZtAhBoyJsOvjGS1CM2UsbSQ4,1394
 mustrd/README.md,sha256=CR08uZ4eNELHBdDRXAVKkRZ4hgQB9OXA7tFRy4ER-LI,1364
 mustrd/TestResult.py,sha256=K4yth-rYrK6Pl7SFiTAZkUStBIzHlgq0oxSSpq5F34M,4849
-mustrd/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-mustrd/anzo_utils.py,sha256=-i9fE-HArbni4MaKy1rH47U328ERHwkLi2X4TP6nRk4,4675
-mustrd/logger_setup.py,sha256=6Z3E5_h8vZFn4PZUyJVFdkgwFjDWthWEQVJsI9wQVVU,1720
+mustrd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mustrd/anzo_utils.py,sha256=CKNSF_oTFKc4v64EDXJzeirP1GxOIOCUKNfaJKk0oEc,4677
+mustrd/logger_setup.py,sha256=AdHf1_rEYiWleR-8IVatsMu-ntYH3_uiDDhFchQ8BcM,1721
 mustrd/model/catalog-v001.xml,sha256=IEtaw3FK4KGQWKancEe1HqzUQTrKdk89vNxnoLKGF4o,381
-mustrd/model/mustrdShapes.ttl,sha256=6-W8onQBWOwAvsIYLRGOk2FePSp4SPFfWd7dSuNC5ho,9456
+mustrd/model/mustrdShapes.ttl,sha256=3BjiOMLs0sS5Ky4_1YkzqYE7JpW-bsfw7FaFej6Ri8w,10056
 mustrd/model/mustrdTestOntology.ttl,sha256=W7IRbPKrhpYFweZvc9QH8gdjBiuZMHKETIuHBepLnYw,2034
 mustrd/model/mustrdTestShapes.ttl,sha256=5PUpU9AzPSeLpF_UzNBVnACLOhs3hfoQpiz-ybsrbj8,818
-mustrd/model/ontology.ttl,sha256=AK27qyT8GW_SwJDwTFvtfxndBPEfYT6Y1jiW26Hyjg0,16809
+mustrd/model/ontology.ttl,sha256=089FOWtSN107xR04MFxtvPUJVFiT9TSzmKqqNOfm7Gk,17090
 mustrd/model/test-resources/resources.ttl,sha256=1Dsp1nuNxauj9bxeX-HShQsiO-CVy5Irwm2y2x0cdjI,1498
 mustrd/model/triplestoreOntology.ttl,sha256=9K5gj0hDOolRYjHc58UT4igex8cUnq9h7SUe4ToYbdw,5834
 mustrd/model/triplestoreshapes.ttl,sha256=G1kdgASdPa8s5JVGXL4KM2ewp-F5Vmbdist0f77VTBc,1706
-mustrd/mustrd.py,sha256=De-d9jPcvUa8OuaXrKs1BptwfuwtIkQfqfXzLowy3gM,38986
-mustrd/mustrdAnzo.py,sha256=xdwfdBz_bMv5IQHVCcoK9tXTZ7ZMwgFTIDCpJKizynQ,8308
+mustrd/mustrd.py,sha256=-J_Od8Uv0WFWKIt6C2QBl_ZCQtubx3nBUjfTodJ3a4w,40289
+mustrd/mustrdAnzo.py,sha256=0XhLkfagW_HManfZ3iGAf_K2_d-pLVTAOT-0pX8hhM4,8352
 mustrd/mustrdGraphDb.py,sha256=Ro_fxDPFl64r-FAM18awhZydydEY1-IXO0zdKpvZD3U,5405
 mustrd/mustrdRdfLib.py,sha256=CvrzEl1-lEPugYVe3y_Ip8JMzUxv6IeWauLOa_WA-XI,2073
-mustrd/mustrdTestPlugin.py,sha256=jcCi4EtJIZOWKhKxJELlsJn8VssnG5oo34RJZeqSlGY,17117
+mustrd/mustrdTestPlugin.py,sha256=hbYo8i1j4uFuRekXGd4Mnjt9wkSgQrS5o809xtbcLgs,19664
 mustrd/namespace.py,sha256=xGfH-nRP3t_I4rmoGJPqlSGbI0G5HUMlUeAl7l_yW-s,3622
 mustrd/run.py,sha256=5xZUgKPMBQ-03cWROAnwtbOs2Nb0Vat6n8Fi6EyfS-k,4257
-mustrd/spec_component.py,sha256=EdSwO_eYDy5lLdOV0nyA4EzkA2V-OrTgDkoXcZ2yxXw,32076
-mustrd/steprunner.py,sha256=-KGE_bYSBJDVQUQ2ELSY92D-V8HxbBdZMqzfgAiOpc0,7978
+mustrd/spec_component.py,sha256=5WQdvj0v9U-HEiOomoLcwwKfAt6kLDxPKomxyMkleI0,31382
+mustrd/steprunner.py,sha256=73ykrrfZAPAQcr95ewcRfLO0gl_2xVGlEDYnI7FncXg,7951
 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/utils.py,sha256=OGdLvw7GvjrFgTJo0J97Xwdh-_ZgSmapmOistrEchO0,1387
-mustrd-0.2.6.3.dist-info/LICENSE,sha256=r8nmh5fUct9h2w8_RDl13EIscvmwCLoarPr1kg35MnA,1078
-mustrd-0.2.6.3.dist-info/METADATA,sha256=Vjl1v-WM8_u0YRhXtGZ4BkcSK7wCmPNIsqUtyV1-Vl0,4208
-mustrd-0.2.6.3.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-mustrd-0.2.6.3.dist-info/entry_points.txt,sha256=v7V7sN0_L1aB4Ug_9io5axlQSeJ1C0tNrQWwdXdV58s,50
-mustrd-0.2.6.3.dist-info/RECORD,,
+mustrd-0.3.0.0.dist-info/LICENSE,sha256=r8nmh5fUct9h2w8_RDl13EIscvmwCLoarPr1kg35MnA,1078
+mustrd-0.3.0.0.dist-info/METADATA,sha256=Eu_S5x8JM7ZP8LWF6nh9qkhYpjhLCApa2__EGBlNtXk,4204
+mustrd-0.3.0.0.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+mustrd-0.3.0.0.dist-info/entry_points.txt,sha256=v7V7sN0_L1aB4Ug_9io5axlQSeJ1C0tNrQWwdXdV58s,50
+mustrd-0.3.0.0.dist-info/RECORD,,