mustrd 0.2.7a0__py3-none-any.whl → 0.3.0.0__py3-none-any.whl

mustrd/anzo_utils.py

@@ -31,16 +31,18 @@ from requests import Response, HTTPError, RequestException
 from bs4 import BeautifulSoup
 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):
     params = {
-        'skipCache': True,
+        'skipCache': 'true',
         'format': format,
         'datasourceURI': anzo_config['gqe_uri'],
-        'default-graph-uri': data_layers,
-        'named-graph-uri': data_layers
+        '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
     }
     url = f"{anzo_config['url']}/sparql"
     return send_anzo_query(anzo_config, url=url, params=params, query=query, is_update=is_update)
@@ -52,7 +54,7 @@ def query_graphmart(anzo_config: dict,
                     format: str = "json",
                     data_layers: List[str] = None):
     params = {
-        'skipCache': True,
+        'skipCache': 'true',
         'format': format,
         'default-graph-uri': data_layers,
         'named-graph-uri': data_layers
@@ -87,7 +89,8 @@ def manage_anzo_response(response: Response) -> str:
 
 def send_anzo_query(anzo_config, url, params, query, is_update=False):
     headers = {"Content-Type": f"application/sparql-{'update' if is_update else 'query' }"}
-    return manage_anzo_response(requests.post(url=url, params=params, data=query,
+    logger.debug(f"send_anzo_query {url=} {query=} {is_update=}")
+    return manage_anzo_response(requests.post(url=url, params=params, data=query.encode('utf-8'),
                                               auth=(anzo_config['username'], anzo_config['password']),
                                               headers=headers, verify=False))
 

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,8 +55,9 @@ import logging
 from http.client import HTTPConnection
 from .steprunner import upload_given, run_when
 from multimethods import MultiMethod
+import traceback
 
-log = logger_setup.setup_logger(__name__)
+log = logging.getLogger(__name__)
 
 requests.packages.urllib3.disable_warnings()
 requests.packages.urllib3.util.ssl_.DEFAULT_CIPHERS += ':HIGH:!DH:!aNULL'
@@ -184,20 +185,33 @@ class UpdateSparqlQuery(SparqlAction):
 
 # https://github.com/Semantic-partners/mustrd/issues/19
 # Validate the specs found in spec_path
-def validate_specs(run_config: dict, triple_stores: List, shacl_graph: Graph, ont_graph: Graph, file_name: str = "*")\
+def validate_specs(run_config: dict,
+                   triple_stores: List,
+                   shacl_graph: Graph,
+                   ont_graph: Graph,
+                   file_name: str = "*",
+                   selected_test_files: List[str] = [])\
         -> Tuple[List, Graph, List]:
     spec_graph = Graph()
     subject_uris = set()
     focus_uris = set()
     invalid_specs = []
-    ttl_files = list(run_config['spec_path'].glob(
-        f'**/{file_name}.mustrd.ttl'))
+    ttl_files = []
+
+    if not selected_test_files:
+        ttl_files = list(run_config['spec_path'].glob(
+            f'**/{file_name}.mustrd.ttl'))
+        log.info(
+            f"Found {len(ttl_files)} {file_name}.mustrd.ttl files in {run_config['spec_path']}")
+    else:
+        ttl_files = selected_test_files
+
+    log.info(f"Using {ttl_files} for test source")
     ttl_files.sort()
-    log.info(
-        f"Found {len(ttl_files)} {file_name}.mustrd.ttl files in {run_config['spec_path']}")
 
     # For each spec file found in spec_path
     for file in ttl_files:
+        # file = file.resolve()
         error_messages = []
 
         log.info(f"Parse: {file}")
@@ -224,7 +238,10 @@ def validate_specs(run_config: dict, triple_stores: List, shacl_graph: Graph, on
                                                          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):
@@ -269,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(
@@ -311,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. " \
@@ -334,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:
@@ -367,23 +398,42 @@ 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("table_comparison")
         return table_comparison(result, spec)
     else:
         graph_compare = graph_comparison(spec.then.value, result)
         if isomorphic(result, spec.then.value):
-            return SpecPassed(spec.spec_uri, spec.triple_store["type"])
+            log.debug(f"isomorphic {spec}")
+            log.debug(f"{spec.spec_uri}")
+            log.debug(f"{spec.triple_store}")
+            ret = SpecPassed(spec.spec_uri, spec.triple_store["type"])
+
+            return ret
         else:
+            log.debug("not isomorphic")
             if spec.when[0].queryType == MUST.ConstructSparql:
+                log.debug("ConstructSpecFailure")
                 return ConstructSpecFailure(spec.spec_uri, spec.triple_store["type"], graph_compare)
             else:
+                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:
@@ -399,10 +449,16 @@ def run_spec(spec: Specification) -> SpecResult:
                 f"Running {when.queryType} spec {spec_uri} on {triple_store['type']}")
             try:
                 result = run_when(spec_uri, triple_store, when)
+                log.info(
+                    f"run {when.queryType} spec {spec_uri} on {triple_store['type']} {result=}")
             except ParseException as e:
+                log.error(
+                    f"parseException {e}")
                 return SparqlParseFailure(spec_uri, triple_store["type"], e)
             except NotImplementedError as ex:
-                return SpecSkipped(spec_uri, triple_store["type"], ex.args[0])
+                log.error(f"NotImplementedError {ex}")
+                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
@@ -413,7 +469,9 @@ def run_spec(spec: Specification) -> SpecResult:
     except (TypeError, RequestException) as e:
         log.error(f"{type(e)} {e}")
         return SparqlExecutionError(spec_uri, triple_store["type"], e)
-
+    except Exception as 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:
@@ -724,33 +782,33 @@ def get_then_update(spec_uri: URIRef, spec_graph: Graph) -> Graph:
     return expected_results
 
 
-def write_result_diff_to_log(res):
+def write_result_diff_to_log(res, info):
     if isinstance(res, UpdateSpecFailure) or isinstance(res, ConstructSpecFailure):
-        log.info(f"{Fore.RED}Failed {res.spec_uri} {res.triple_store}")
-        log.info(f"{Fore.BLUE} In Expected Not In Actual:")
-        log.info(
+        info(f"{Fore.RED}Failed {res.spec_uri} {res.triple_store}")
+        info(f"{Fore.BLUE} In Expected Not In Actual:")
+        info(
             res.graph_comparison.in_expected_not_in_actual.serialize(format="ttl"))
-        log.info(f"{Fore.RED} in_actual_not_in_expected")
-        log.info(
+        info(f"{Fore.RED} in_actual_not_in_expected")
+        info(
             res.graph_comparison.in_actual_not_in_expected.serialize(format="ttl"))
-        log.info(f"{Fore.GREEN} in_both")
-        log.info(res.graph_comparison.in_both.serialize(format="ttl"))
+        info(f"{Fore.GREEN} in_both")
+        info(res.graph_comparison.in_both.serialize(format="ttl"))
 
     if isinstance(res, SelectSpecFailure):
-        log.info(f"{Fore.RED}Failed {res.spec_uri} {res.triple_store}")
-        log.info(res.message)
-        log.info(res.table_comparison.to_markdown())
+        info(f"{Fore.RED}Failed {res.spec_uri} {res.triple_store}")
+        info(res.message)
+        info(res.table_comparison.to_markdown())
     if isinstance(res, SpecPassedWithWarning):
-        log.info(
+        info(
             f"{Fore.YELLOW}Passed with warning {res.spec_uri} {res.triple_store}")
-        log.info(res.warning)
+        info(res.warning)
     if isinstance(res, TripleStoreConnectionError) or isinstance(res, SparqlExecutionError) or \
             isinstance(res, SparqlParseFailure):
-        log.info(f"{Fore.RED}Failed {res.spec_uri} {res.triple_store}")
-        log.info(res.exception)
+        info(f"{Fore.RED}Failed {res.spec_uri} {res.triple_store}")
+        info(res.exception)
     if isinstance(res, SpecSkipped):
-        log.info(f"{Fore.YELLOW}Skipped {res.spec_uri} {res.triple_store}")
-        log.info(res.message)
+        info(f"{Fore.YELLOW}Skipped {res.spec_uri} {res.triple_store}")
+        info(res.message)
 
 
 def calculate_row_difference(df1: pandas.DataFrame,

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
 
@@ -58,7 +59,7 @@ USING <{triple_store['output_graph']}>""").replace(
                                          "${targetGraph}", f"<{output_graph}>")
 
     response = query_azg(anzo_config=triple_store, query=substituted_query, is_update=True,
-                         data_layers=input_graph, format="ttl")
+                         data_layers=[input_graph, output_graph], format="ttl")
     logging.debug(f'response {response}')
     # TODO: deal with error responses
     new_graph = ttl_to_graph(query_azg(anzo_config=triple_store, query="construct {?s ?p ?o} { ?s ?p ?o }",

mustrd/mustrdTestPlugin.py

@@ -1,32 +1,8 @@
-"""
-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
 import os
-from pathlib import Path
+from pathlib import Path, PosixPath
 from rdflib.namespace import Namespace
 from rdflib import Graph, RDF
 from pytest import Session
@@ -34,12 +10,26 @@ from pytest import Session
 from mustrd import logger_setup
 from mustrd.TestResult import ResultList, TestResult, get_result_list
 from mustrd.utils import get_mustrd_root
-from mustrd.mustrd import write_result_diff_to_log, get_triple_store_graph, get_triple_stores
-from mustrd.mustrd import Specification, SpecSkipped, validate_specs, get_specs, SpecPassed, run_spec
+from mustrd.mustrd import (
+    write_result_diff_to_log,
+    get_triple_store_graph,
+    get_triple_stores,
+)
+from mustrd.mustrd import (
+    Specification,
+    SpecSkipped,
+    validate_specs,
+    get_specs,
+    SpecPassed,
+    run_spec,
+)
 from mustrd.namespace import MUST, TRIPLESTORE, MUSTRDTEST
 from typing import Union
 from pyshacl import validate
-import logging
+
+import pathlib
+import traceback
+
 spnamespace = Namespace("https://semanticpartners.com/data/test/")
 
 mustrd_root = get_mustrd_root()
@@ -79,64 +69,96 @@ 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
 
 
 def pytest_configure(config) -> None:
     # Read configuration file
     if config.getoption("mustrd") and config.getoption("configpath"):
-        config.pluginmanager.register(MustrdTestPlugin(config.getoption("mdpath"),
-                                                       Path(config.getoption("configpath")), config.getoption("secrets")))
+        config.pluginmanager.register(
+            MustrdTestPlugin(
+                config.getoption("mdpath"),
+                Path(config.getoption("configpath")),
+                config.getoption("secrets"),
+            )
+        )
 
 
 def parse_config(config_path):
     test_configs = []
-    print(f"{config_path=}")
     config_graph = Graph().parse(config_path)
     shacl_graph = Graph().parse(
-        Path(os.path.join(mustrd_root, "model/mustrdTestShapes.ttl")))
+        Path(os.path.join(mustrd_root, "model/mustrdTestShapes.ttl"))
+    )
     ont_graph = Graph().parse(
-        Path(os.path.join(mustrd_root, "model/mustrdTestOntology.ttl")))
+        Path(os.path.join(mustrd_root, "model/mustrdTestOntology.ttl"))
+    )
     conforms, results_graph, results_text = validate(
         data_graph=config_graph,
         shacl_graph=shacl_graph,
         ont_graph=ont_graph,
         advanced=True,
-        inference='none'
+        inference="none",
     )
     if not conforms:
-        raise ValueError(f"Mustrd test configuration not conform to the shapes. SHACL report: {results_text}",
-                         results_graph)
-
-    for test_config_subject in config_graph.subjects(predicate=RDF.type, object=MUSTRDTEST.MustrdTest):
+        raise ValueError(
+            f"Mustrd test configuration not conform to the shapes. SHACL report: {results_text}",
+            results_graph,
+        )
+
+    for test_config_subject in config_graph.subjects(
+        predicate=RDF.type, object=MUSTRDTEST.MustrdTest
+    ):
         spec_path = get_config_param(
-            config_graph, test_config_subject, MUSTRDTEST.hasSpecPath, str)
+            config_graph, test_config_subject, MUSTRDTEST.hasSpecPath, str
+        )
         data_path = get_config_param(
-            config_graph, test_config_subject, MUSTRDTEST.hasDataPath, str)
+            config_graph, test_config_subject, MUSTRDTEST.hasDataPath, str
+        )
         triplestore_spec_path = get_config_param(
-            config_graph, test_config_subject, MUSTRDTEST.triplestoreSpecPath, str)
+            config_graph, test_config_subject, MUSTRDTEST.triplestoreSpecPath, str
+        )
         pytest_path = get_config_param(
-            config_graph, test_config_subject, MUSTRDTEST.hasPytestPath, str)
-        filter_on_tripleStore = tuple(config_graph.objects(subject=test_config_subject,
-                                                           predicate=MUSTRDTEST.filterOnTripleStore))
+            config_graph, test_config_subject, MUSTRDTEST.hasPytestPath, str
+        )
+        filter_on_tripleStore = tuple(
+            config_graph.objects(
+                subject=test_config_subject, predicate=MUSTRDTEST.filterOnTripleStore
+            )
+        )
 
         # Root path is the mustrd test config path
         root_path = Path(config_path).parent
         spec_path = root_path / Path(spec_path) if spec_path else None
         data_path = root_path / Path(data_path) if data_path else None
-        triplestore_spec_path = root_path / \
-            Path(triplestore_spec_path) if triplestore_spec_path else None
-
-        test_configs.append(TestConfig(spec_path=spec_path, data_path=data_path,
-                                       triplestore_spec_path=triplestore_spec_path,
-                                       pytest_path=pytest_path,
-                                       filter_on_tripleStore=filter_on_tripleStore))
+        triplestore_spec_path = (
+            root_path / Path(triplestore_spec_path) if triplestore_spec_path else None
+        )
+
+        test_configs.append(
+            TestConfig(
+                spec_path=spec_path,
+                data_path=data_path,
+                triplestore_spec_path=triplestore_spec_path,
+                pytest_path=pytest_path,
+                filter_on_tripleStore=filter_on_tripleStore,
+            )
+        )
     return test_configs
 
 
 def get_config_param(config_graph, config_subject, config_param, convert_function):
     raw_value = config_graph.value(
-        subject=config_subject, predicate=config_param, any=True)
+        subject=config_subject, predicate=config_param, any=True
+    )
     return convert_function(raw_value) if raw_value else None
 
 
@@ -179,45 +201,95 @@ 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))
-        self.selected_tests = list(map(lambda arg: Path(arg.split("::")[0]).resolve(),
-                                       # 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)))
-
-        self.path_filter = args[0] if len(
-            args) == 1 and args[0] != os.getcwd() and not "::" in args[0] else None
+        
+        # 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]),
+                mustrd_args 
+            )
+        )
+        logger.info(f"selected_tests is: {self.selected_tests}")
+
+        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:
-            return arg[arg.index("[") + 1: arg.index(".mustrd.ttl ")]
+            return arg[arg.index("[") + 1 : arg.index(".mustrd.ttl ")]
         return None
 
     @pytest.hookimpl
     def pytest_collect_file(self, parent, path):
         logger.debug(f"Collecting file: {path}")
-        mustrd_file = MustrdFile.from_parent(
-            parent, fspath=path, mustrd_plugin=self)
+        # 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
 
     # Generate test for each triple store available
     def generate_tests_for_config(self, config, triple_stores, file_name):
-
-        shacl_graph = Graph().parse(Path(os.path.join(mustrd_root, "model/mustrdShapes.ttl")))
+        logger.debug(f"generate_tests_for_config {config=} {self=} {dir(self)}")
+        shacl_graph = Graph().parse(
+            Path(os.path.join(mustrd_root, "model/mustrdShapes.ttl"))
+        )
         ont_graph = Graph().parse(Path(os.path.join(mustrd_root, "model/ontology.ttl")))
-        valid_spec_uris, spec_graph, invalid_spec_results = validate_specs(config, triple_stores,
-                                                                           shacl_graph, ont_graph, file_name or "*")
-
-        specs, skipped_spec_results = \
-            get_specs(valid_spec_uris, spec_graph, triple_stores, config)
+        logger.debug("Generating tests for config: " + str(config))
+        logger.debug(f"selected_tests {self.selected_tests}")
+
+        valid_spec_uris, spec_graph, invalid_spec_results = validate_specs(
+            config,
+            triple_stores,
+            shacl_graph,
+            ont_graph,
+            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):
@@ -225,9 +297,9 @@ class MustrdTestPlugin:
         if isinstance(spec, SpecSkipped):
             triple_store = spec.triple_store
         else:
-            triple_store = spec.triple_store['type']
-        triple_store_name = triple_store.replace(
-            "https://mustrd.com/model/", "")
+            triple_store = spec.triple_store["type"]
+
+        triple_store_name = triple_store.replace("https://mustrd.com/model/", "")
         test_name = spec.spec_uri.replace(spnamespace, "").replace("_", " ")
         return spec.spec_file_name + " : " + triple_store_name + ": " + test_name
 
@@ -235,21 +307,33 @@ class MustrdTestPlugin:
     def get_triple_stores_from_file(self, test_config):
         if test_config.triplestore_spec_path:
             try:
-                triple_stores = get_triple_stores(get_triple_store_graph(test_config.triplestore_spec_path,
-                                                                         self.secrets))
+                triple_stores = get_triple_stores(
+                    get_triple_store_graph(
+                        test_config.triplestore_spec_path, self.secrets
+                    )
+                )
             except Exception as e:
-                print(f"""Triplestore configuration parsing failed {test_config.triplestore_spec_path}.
-                    Only rdflib will be executed""", e)
+                print(
+                    f"""Triplestore configuration parsing failed {test_config.triplestore_spec_path}.
+                    Only rdflib will be executed""",
+                    e,
+                )
                 triple_stores = [
-                    {'type': TRIPLESTORE.RdfLib, 'uri': TRIPLESTORE.RdfLib}]
+                    {"type": TRIPLESTORE.RdfLib, "uri": TRIPLESTORE.RdfLib}
+                ]
         else:
             print("No triple store configuration required: using embedded rdflib")
-            triple_stores = [
-                {'type': TRIPLESTORE.RdfLib, 'uri': TRIPLESTORE.RdfLib}]
+            triple_stores = [{"type": TRIPLESTORE.RdfLib, "uri": TRIPLESTORE.RdfLib}]
 
         if test_config.filter_on_tripleStore:
-            triple_stores = list(filter(lambda triple_store: (triple_store["uri"] in test_config.filter_on_tripleStore),
-                                        triple_stores))
+            triple_stores = list(
+                filter(
+                    lambda triple_store: (
+                        triple_store["uri"] in test_config.filter_on_tripleStore
+                    ),
+                    triple_stores,
+                )
+            )
         return triple_stores
 
     # Hook function. Initialize the list of result in session
@@ -264,7 +348,7 @@ class MustrdTestPlugin:
         outcome = yield
         result = outcome.get_result()
 
-        if result.when == 'call':
+        if result.when == "call":
             # Add the result of the test to the session
             item.session.results[item] = result
 
@@ -280,8 +364,11 @@ class MustrdTestPlugin:
             if test_conf.originalname != test_conf.name:
                 module_name = test_conf.parent.name
                 class_name = test_conf.originalname
-                test_name = test_conf.name.replace(
-                    class_name, "").replace("[", "").replace("]", "")
+                test_name = (
+                    test_conf.name.replace(class_name, "")
+                    .replace("[", "")
+                    .replace("]", "")
+                )
                 is_mustrd = True
             # Case normal unit tests
             else:
@@ -290,64 +377,132 @@ class MustrdTestPlugin:
                 test_name = test_conf.originalname
                 is_mustrd = False
 
-            test_results.append(TestResult(
-                test_name, class_name, module_name, result.outcome, is_mustrd))
-
-        result_list = ResultList(None, get_result_list(test_results,
-                                                       lambda result: result.type,
-                                                       lambda result: is_mustrd and result.test_name.split("@")[1]),
-                                 False)
+            test_results.append(
+                TestResult(
+                    test_name, class_name, module_name, result.outcome, is_mustrd
+                )
+            )
+
+        result_list = ResultList(
+            None,
+            get_result_list(
+                test_results,
+                lambda result: result.type,
+                lambda result: is_mustrd and result.test_name.split("@")[1],
+            ),
+            False,
+        )
 
         md = result_list.render()
-        with open(self.md_path, 'w') as file:
+        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:
+                if (
+                    self.mustrd_plugin.path_filter is not None
+                    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:
-                    specs = self.mustrd_plugin.generate_tests_for_config({"spec_path": test_config.spec_path,
-                                                                          "data_path": test_config.data_path},
-                                                                         triple_stores, None)
+                
+                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,
+                            "data_path": test_config.data_path,
+                        },
+                        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:
-                    # Check if the current test is in the selected tests in arguments
-                    if spec.spec_source_file.resolve() in self.mustrd_plugin.selected_tests \
-                            or self.mustrd_plugin.selected_tests == []:
-                        item = MustrdItem.from_parent(
-                            self, name=test_config.pytest_path + "/" + spec.spec_file_name, spec=spec)
-                        self.mustrd_plugin.items.append(item)
-                        yield item
-        except BaseException as e:
-            # Catch error here otherwise it will be lost
+                    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:
             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)
@@ -355,11 +510,20 @@ class MustrdItem(pytest.Item):
             raise AssertionError(f"Test {self.name} failed")
 
     def repr_failure(self, excinfo):
-        return f"{self.name} failed: {excinfo.value}"
-
+        # excinfo.value is the exception instance
+        # You can add more context here
+        tb_lines = traceback.format_exception(excinfo.type, excinfo.value, excinfo.tb)
+        tb_str = "".join(tb_lines)
+        return (
+            f"{self.name} failed:\n"
+            f"Spec: {self.spec.spec_uri}\n"
+            f"File: {self.spec.spec_source_file}\n"
+            f"Error: \n{excinfo.value}\n"
+            f"Traceback:\n{tb_str}"
+        )
+    
     def reportinfo(self):
         r = "", 0, f"mustrd test: {self.name}"
-        logger.debug(f"Reporting info for {self.name} {r=}")
         return r
 
 
@@ -368,11 +532,18 @@ def run_test_spec(test_spec):
     if isinstance(test_spec, SpecSkipped):
         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")
     if result_type != SpecPassed:
-        write_result_diff_to_log(result)
+        write_result_diff_to_log(result, logger.info)
+        log_lines = []
+        def log_to_string(message):
+            log_lines.append(message)
+        write_result_diff_to_log(result, log_to_string)
+        raise AssertionError("Test failed: " + "\n".join(log_lines))
+
     return result_type == SpecPassed

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
@@ -65,6 +65,7 @@ class WhenSpec(SpecComponent):
 class AnzoWhenSpec(WhenSpec):
     paramQuery: str = None
     queryTemplate: str = None
+    spec_component_details: any = None
 
 
 @dataclass
@@ -108,6 +109,7 @@ def parse_spec_component(subject: URIRef,
     for spec_component_node in spec_component_nodes:
         data_source_types = get_data_source_types(subject, predicate, spec_graph, spec_component_node)
         for data_source_type in data_source_types:
+            log.debug(f"parse_spec_component {spec_component_node} {data_source_type} {mustrd_triple_store=}")
             spec_component_details = SpecComponentDetails(
                 subject=subject,
                 predicate=predicate,
@@ -117,6 +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?
             spec_component = get_spec_component(spec_component_details)
             if isinstance(spec_component, list):
                 spec_components += spec_component
@@ -429,14 +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.value = get_spec_component_from_graphmart(
-            triple_store=spec_component_details.mustrd_triple_store,
-            graphmart=graphmart,
-            layer=layer)
+        spec_component.spec_component_details = spec_component_details
     else:
         raise ValueError(f"You must define {TRIPLESTORE.Anzo} to use {MUST.AnzoGraphmartDataset}")
 
@@ -468,14 +466,16 @@ def _get_spec_component_AnzoQueryBuilderSparqlSource(spec_component_details: Spe
 
 @get_spec_component.method((MUST.AnzoGraphmartStepSparqlSource, MUST.when))
 def _get_spec_component_AnzoGraphmartStepSparqlSource(spec_component_details: SpecComponentDetails) -> SpecComponent:
-    spec_component = init_spec_component(spec_component_details.predicate)
+    spec_component = AnzoWhenSpec()
 
     # 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)
-        spec_component.value = get_query_from_step(triple_store=spec_component_details.mustrd_triple_store,
-                                                   query_step_uri=query_step_uri)
+        spec_component.spec_component_details = spec_component_details
+        spec_component.query_step_uri = query_step_uri
+        # spec_component.value = get_query_from_step(triple_store=spec_component_details.mustrd_triple_store,
+        #                                            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}")
@@ -529,6 +529,7 @@ def _get_spec_component_AnzoGraphmartLayerSparqlSource(spec_component_details: S
         spec_component.value = query.get("query")
         spec_component.paramQuery = query.get("param_query")
         spec_component.queryTemplate = query.get("query_template")
+        spec_component.spec_component_details = spec_component_details
         if spec_component.value:
             spec_component.queryType = spec_component_details.spec_graph.value(
                 subject=spec_component_details.spec_component_node,

mustrd/steprunner.py

@@ -24,14 +24,13 @@ SOFTWARE.
 
 import json
 
-from . import logger_setup
 from multimethods import MultiMethod, Default
 from .namespace import MUST, TRIPLESTORE
 from rdflib import Graph, URIRef
 from .mustrdRdfLib import execute_select as execute_select_rdflib
 from .mustrdRdfLib import execute_construct as execute_construct_rdflib
 from .mustrdRdfLib import execute_update as execute_update_rdflib
-from .mustrdAnzo import upload_given as upload_given_anzo
+from .mustrdAnzo import get_query_from_step, upload_given as upload_given_anzo
 from .mustrdAnzo import execute_update as execute_update_anzo
 from .mustrdAnzo import execute_construct as execute_construct_anzo
 from .mustrdAnzo import execute_select as execute_select_anzo
@@ -40,8 +39,9 @@ from .mustrdGraphDb import execute_update as execute_update_graphdb
 from .mustrdGraphDb import execute_construct as execute_construct_graphdb
 from .mustrdGraphDb import execute_select as execute_select_graphdb
 from .spec_component import AnzoWhenSpec, WhenSpec
+import logging
 
-log = logger_setup.setup_logger(__name__)
+log = logging.getLogger(__name__)
 
 
 def dispatch_upload_given(triple_store: dict, given: Graph):
@@ -80,7 +80,16 @@ run_when = MultiMethod('run_when', dispatch_run_when)
 
 @run_when.method((TRIPLESTORE.Anzo, MUST.UpdateSparql))
 def _anzo_run_when_update(spec_uri: URIRef, triple_store: dict, when: AnzoWhenSpec):
-    return execute_update_anzo(triple_store, when.value, when.bindings)
+    log.debug(f"_anzo_run_when_update {spec_uri} {triple_store} {when} {type(when)}")
+    if when.value is None:
+        # fetch the query from the query step on anzo
+        query = get_query_from_step(triple_store=when.spec_component_details.mustrd_triple_store,
+                                                    query_step_uri=when.query_step_uri)
+    else: 
+        # we must already have the query
+        query = when.value
+    log.debug(f"_anzo_run_when_update.query {query}")
+    return execute_update_anzo(triple_store, query, when.bindings)
 
 
 @run_when.method((TRIPLESTORE.Anzo, MUST.ConstructSparql))
@@ -152,6 +161,7 @@ def _multi_run_when_anzo_query_driven_update(spec_uri: URIRef, triple_store: dic
 
 @run_when.method(Default)
 def _multi_run_when_default(spec_uri: URIRef, triple_store: dict, when: WhenSpec):
+    log.error(f"run_when not implemented for {spec_uri} {triple_store} {when}")
     if when.queryType == MUST.AskSparql:
         log.warning(f"Skipping {spec_uri}, SPARQL ASK not implemented.")
         msg = "SPARQL ASK not implemented."

{mustrd-0.2.7a0.dist-info → mustrd-0.3.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: mustrd
-Version: 0.2.7a0
+Version: 0.3.0.0
 Summary: A Spec By Example framework for RDF and SPARQL, Inspired by Cucumber.
 License: MIT
 Author: John Placek

{mustrd-0.2.7a0.dist-info → mustrd-0.3.0.0.dist-info}/RECORD

@@ -2,31 +2,31 @@ mustrd/README.adoc,sha256=E5KuShPEl2U6NmRzEAwZtAhBoyJsOvjGS1CM2UsbSQ4,1394
 mustrd/README.md,sha256=CR08uZ4eNELHBdDRXAVKkRZ4hgQB9OXA7tFRy4ER-LI,1364
 mustrd/TestResult.py,sha256=K4yth-rYrK6Pl7SFiTAZkUStBIzHlgq0oxSSpq5F34M,4849
 mustrd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mustrd/anzo_utils.py,sha256=4DXtdZo504Llzmc2fyhe13rLfJXk1mDUnUNDHA8N5YI,4483
-mustrd/logger_setup.py,sha256=6Z3E5_h8vZFn4PZUyJVFdkgwFjDWthWEQVJsI9wQVVU,1720
+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=8xPjdHyGA692zyThCILm8VYuxkSF1ATEf35zXSmLVRU,37750
-mustrd/mustrdAnzo.py,sha256=Fg1mCkuGiVywSt5HJ0KCVJUFuTxNMrsPtt45y_fqSII,8292
+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=Xy7I7yJNwAatzrU13FkBs0ateWQ96w3MDte8gt8Ykto,15548
+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=7BmMjJMy0ACbVBAEZpe5ZprnDZYs6h5f7-fI38l3jAk,31483
-mustrd/steprunner.py,sha256=YKrMSYhethWCAQEI63hK6jXh3ljyoM87w7eHyoRd8rc,7389
+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.7a0.dist-info/LICENSE,sha256=r8nmh5fUct9h2w8_RDl13EIscvmwCLoarPr1kg35MnA,1078
-mustrd-0.2.7a0.dist-info/METADATA,sha256=G7prJE0-fM5tfkmtvCXWdJz6LEo6FxvrZQ5t4EnY9zk,4204
-mustrd-0.2.7a0.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-mustrd-0.2.7a0.dist-info/entry_points.txt,sha256=v7V7sN0_L1aB4Ug_9io5axlQSeJ1C0tNrQWwdXdV58s,50
-mustrd-0.2.7a0.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,,