mustrd 0.1.0__py3-none-any.whl

src/mustrdAnzo.py

@@ -0,0 +1,236 @@
+"""
+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 requests
+from pyanzo import AnzoClient
+from rdflib import Graph, ConjunctiveGraph, Literal, URIRef
+from requests import ConnectTimeout, Response, HTTPError, RequestException, ConnectionError
+from bs4 import BeautifulSoup
+import logging
+from namespace import MUST
+
+
+# https://github.com/Semantic-partners/mustrd/issues/73
+def manage_anzo_response(response: Response) -> str:
+    content_string = response.content.decode("utf-8")
+    if response.status_code == 200:
+        return content_string
+    elif response.status_code == 403:
+        html = BeautifulSoup(content_string, 'html.parser')
+        title_tag = html.title.string
+        raise HTTPError(f"Anzo authentication error, status code: {response.status_code}, content: {title_tag}")
+    else:
+        raise RequestException(f"Anzo error, status code: {response.status_code}, content: {content_string}")
+
+
+def query_with_bindings(bindings: dict, when: str) -> str:
+    values = ""
+    for key, value in bindings.items():
+        values += f"VALUES ?{key} {{{value.n3()}}} "
+    split_query = when.lower().split("where {", 1)
+    return f"{split_query[0].strip()} WHERE {{ {values} {split_query[1].strip()}"
+
+def execute_select (triple_store: dict,  when: str, bindings: dict = None) -> str:
+    try:
+        if bindings:
+            when = query_with_bindings(bindings, when)
+        when = when.replace("${fromSources}", f"FROM <{triple_store['input_graph']}>\nFROM <{triple_store['output_graph']}>").replace(
+        "${targetGraph}", f"<{triple_store['output_graph']}>")
+        data = {'datasourceURI': triple_store['gqe_uri'], 'query': when,
+                 'skipCache': 'true'}
+        url = f"https://{triple_store['url']}:{triple_store['port']}/sparql?format=application/sparql-results+json"
+        return manage_anzo_response(requests.post(url=url,
+                                                  auth=(triple_store['username'], triple_store['password']),
+                                                  data=data,
+                                                  verify=False))
+    except (ConnectionError, TimeoutError, HTTPError, ConnectTimeout):
+        raise
+
+def execute_update(triple_store: dict, when: str, bindings: dict = None) -> Graph:
+    logging.debug(f"updating in anzo! {triple_store=} {when=}")
+    input_graph = triple_store['input_graph']
+    output_graph = triple_store['output_graph']
+
+    substituted_query = when.replace("${usingSources}", f"USING <{triple_store['input_graph']}> \nUSING <{triple_store['output_graph']}>").replace(
+        "${targetGraph}", f"<{output_graph}>")
+   
+    data = {'datasourceURI': triple_store['gqe_uri'], 'update': substituted_query,
+                'default-graph-uri': input_graph, 'skipCache': 'true'}
+    url = f"https://{triple_store['url']}:{triple_store['port']}/sparql?format=ttl"
+    response = manage_anzo_response(requests.post(url=url,
+            auth=(triple_store['username'],
+                triple_store['password']),
+            data=data,
+            verify=False))
+    logging.debug(f'response {response}')
+    check_data = {'datasourceURI': triple_store['gqe_uri'], 'query': "construct {?s ?p ?o} { ?s ?p ?o }",
+                'default-graph-uri': output_graph, 'skipCache': 'true'}
+    everything_response = manage_anzo_response(requests.post(url=url,
+            auth=(triple_store['username'],
+                triple_store['password']),
+            data=check_data,
+            verify=False))
+    # todo deal with error responses
+    new_graph = Graph().parse(data=everything_response)
+    logging.debug(f"new_graph={new_graph.serialize(format='ttl')}")
+    return new_graph
+
+
+def execute_construct(triple_store: dict, when: str, bindings: dict = None) -> Graph:
+    try:
+        if bindings:
+            when = query_with_bindings(bindings, when)
+        data = {'datasourceURI': triple_store['gqe_uri'], 'query': when,
+                'default-graph-uri': triple_store['input_graph'], 'skipCache': 'true'}
+        url = f"https://{triple_store['url']}:{triple_store['port']}/sparql?format=ttl"
+        response = requests.post(url=url,
+            auth=(triple_store['username'],
+                triple_store['password']),
+            data=data,
+            verify=False)
+        logging.debug(f'response {response}')
+        return Graph().parse(data=manage_anzo_response(response))
+    except (ConnectionError, TimeoutError, HTTPError, ConnectTimeout) as e:
+        logging.error(f'response {e}')
+        raise
+
+
+# Get Given or then from the content of a graphmart
+def get_spec_component_from_graphmart(triple_store: dict, graphmart: URIRef, layer: URIRef = None) -> ConjunctiveGraph:
+    try:
+        anzo_client = AnzoClient(triple_store['url'], triple_store['port'], 
+                                 username=triple_store['username'],
+                                 password=triple_store['password'])
+        return anzo_client.query_graphmart(graphmart=graphmart,
+                                           data_layers=layer,
+                                           query_string="CONSTRUCT {?s ?p ?o} WHERE {?s ?p ?o}",
+                                           skip_cache=True).as_quad_store().as_rdflib_graph()
+    except RuntimeError as e:
+        raise ConnectionError(f"Anzo connection error, {e}")
+
+
+def get_query_from_querybuilder(triple_store: dict, folder_name: Literal, query_name: Literal) -> str:
+    query = f"""SELECT ?query WHERE {{
+        graph ?queryFolder {{
+            ?bookmark a <http://www.cambridgesemantics.com/ontologies/QueryPlayground#QueryBookmark>;
+                        <http://openanzo.org/ontologies/2008/07/System#query> ?query;
+                        <http://purl.org/dc/elements/1.1/title> "{query_name}"
+            }}
+            ?queryFolder a <http://www.cambridgesemantics.com/ontologies/QueryPlayground#QueryFolder>;
+                        <http://purl.org/dc/elements/1.1/title> "{folder_name}"
+    }}"""
+    anzo_client = AnzoClient(triple_store['url'], triple_store['port'], 
+                             username=triple_store['username'],
+                             password=triple_store['password'])
+    
+    result = anzo_client.query_journal(query_string=query).as_table_results().as_record_dictionaries()
+    if len(result) == 0:
+        raise FileNotFoundError(f"Query {query_name} not found in folder {folder_name}")
+    return result[0].get("query")
+
+
+# https://github.com/Semantic-partners/mustrd/issues/102
+def get_query_from_step(triple_store: dict, query_step_uri: URIRef) -> str:
+    query = f"""SELECT ?stepUri ?query WHERE {{
+        BIND(<{query_step_uri}> as ?stepUri)
+            ?stepUri a <http://cambridgesemantics.com/ontologies/Graphmarts#Step>;
+                     <http://cambridgesemantics.com/ontologies/Graphmarts#transformQuery> ?query
+    }}
+    # """
+    anzo_client = AnzoClient(triple_store['url'], triple_store['port'], 
+                             username=triple_store['username'],
+                             password=triple_store['password'])
+    record_dictionaries = anzo_client.query_journal(query_string=query).as_table_results().as_record_dictionaries()
+
+    return record_dictionaries[0].get(
+        "query")
+
+def get_queries_from_templated_step(triple_store: dict, query_step_uri: URIRef) -> dict:
+
+    query = f"""SELECT ?stepUri ?param_query ?query_template WHERE {{
+        BIND(<{query_step_uri}> as ?stepUri)
+            ?stepUri    a <http://cambridgesemantics.com/ontologies/Graphmarts#Step> ;
+   					    <http://cambridgesemantics.com/ontologies/Graphmarts#parametersTemplate> ?param_query ;
+					    <http://cambridgesemantics.com/ontologies/Graphmarts#template> ?query_template .
+    }}
+    """
+    anzo_client = AnzoClient(triple_store['url'], triple_store['port'], 
+                             username=triple_store['username'],
+                             password=triple_store['password'])
+    record_dictionaries = anzo_client.query_journal(query_string=query).as_table_results().as_record_dictionaries()
+    return record_dictionaries[0]
+
+
+def get_queries_for_layer(triple_store: dict, graphmart_layer_uri: URIRef):
+    query = f"""PREFIX graphmarts: <http://cambridgesemantics.com/ontologies/Graphmarts#>
+    PREFIX anzo: <http://openanzo.org/ontologies/2008/07/Anzo#>
+SELECT ?query ?param_query ?query_template
+  {{ <{graphmart_layer_uri}> graphmarts:step ?step .
+  ?step         anzo:index ?index ;
+                anzo:orderedValue ?query_step .
+  ?query_step graphmarts:enabled true ; 
+  OPTIONAL {{  ?query_step
+   				graphmarts:parametersTemplate ?param_query ;
+           		graphmarts:template ?query_template ;
+      . }}
+  OPTIONAL {{  ?query_step
+   				graphmarts:transformQuery ?query ;
+      . }}
+  }}
+  ORDER BY ?index"""
+    anzo_client = AnzoClient(triple_store['url'], triple_store['port'], 
+                             username=triple_store['username'],
+                             password=triple_store['password'])
+    return anzo_client.query_journal(query_string=query).as_table_results().as_record_dictionaries()
+
+
+def upload_given(triple_store: dict, given: Graph):
+    logging.debug(f"upload_given {triple_store} {given}")
+
+    try:
+        input_graph = triple_store['input_graph']
+        output_graph = triple_store['output_graph']
+        clear_graph(triple_store, input_graph)
+        clear_graph(triple_store, output_graph)
+        serialized_given = given.serialize(format="nt")
+        insert_query = f"INSERT DATA {{graph <{triple_store['input_graph']}>{{{serialized_given}}}}}"
+        data = {'datasourceURI': triple_store['gqe_uri'], 'update': insert_query}
+        response = requests.post(url=f"https://{triple_store['url']}:{triple_store['port']}/sparql",
+                                    auth=(triple_store['username'], triple_store['password']), data=data, verify=False)
+        manage_anzo_response(response)
+    except (ConnectionError, TimeoutError, HTTPError, ConnectTimeout):
+        raise
+
+
+def clear_graph(triple_store: dict, graph_uri: str):
+    try:
+        clear_query = f"CLEAR GRAPH <{graph_uri}>"
+        data = {'datasourceURI': triple_store['gqe_uri'], 'update': clear_query}
+        url = f"https://{triple_store['url']}:{triple_store['port']}/sparql"
+        response = requests.post(url=url,
+                                 auth=(triple_store['username'], triple_store['password']), data=data, verify=False)
+        manage_anzo_response(response)
+    except (ConnectionError, TimeoutError, HTTPError, ConnectTimeout):
+        raise
+

src/mustrdGraphDb.py

@@ -0,0 +1,125 @@
+"""
+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 urllib.parse
+import requests
+from rdflib import Graph, Literal
+from requests import ConnectionError, HTTPError, RequestException, Response
+
+
+# https://github.com/Semantic-partners/mustrd/issues/72
+def manage_graphdb_response(response: Response) -> str:
+    content_string = response.content.decode("utf-8")
+    if response.status_code == 200:
+        return content_string
+    elif response.status_code == 204:
+        pass
+    elif response.status_code == 401:
+        raise HTTPError(f"GraphDB authentication error, status code: {response.status_code}, content: {content_string}")
+    elif response.status_code == 406:
+        raise HTTPError(f"GraphDB  error, status code: {response.status_code}, content: {content_string}")
+    else:
+        raise RequestException(f"GraphDb error, status code: {response.status_code}, content: {content_string}")
+
+
+def upload_given(triple_store: dict, given: Graph):
+    if given:
+        try:
+            graph = "default"
+            if triple_store['input_graph']:
+                graph = urllib.parse.urlencode({'graph': triple_store['input_graph']})
+            url = f"{triple_store['url']}:{triple_store['port']}/repositories/{triple_store['repository']}" \
+                  f"/rdf-graphs/service?{graph}"
+            # graph store PUT drop silently the graph or default and upload the payload
+            # https://www.w3.org/TR/sparql11-http-rdf-update/#http-put
+            manage_graphdb_response(requests.put(url=url,
+                                                 auth=(triple_store['username'], triple_store['password']),
+                                                 data=given.serialize(format="ttl"),
+                                                 headers={'Content-Type': 'text/turtle'}))
+        except ConnectionError:
+            raise
+
+
+def parse_bindings(bindings: dict = None) -> dict:
+    return None if not bindings else {f"${k}": str(v.n3()) for k, v in bindings.items()}
+
+
+def execute_select(triple_store: dict, when: str, bindings: dict = None) -> str:
+    return post_query(triple_store, when, "application/sparql-results+json", parse_bindings(bindings))
+
+
+def execute_construct(triple_store: dict, when: str, bindings: dict = None) -> Graph:
+    return Graph().parse(data=post_query(triple_store, when, "text/turtle", parse_bindings(bindings)))
+
+
+def execute_update(triple_store: dict, when: str, bindings: dict = None) -> Graph:
+    post_update_query(triple_store, when, parse_bindings(bindings))
+    return Graph().parse(data=post_query(triple_store, "CONSTRUCT {?s ?p ?o} where { ?s ?p ?o }", 'text/turtle'))
+
+
+def post_update_query(triple_store: dict, query: str, params: dict = None) -> str:
+    params = add_graph_to_params(params, triple_store["input_graph"])
+    try:
+        return manage_graphdb_response(requests.post(
+            url=f"{triple_store['url']}:{triple_store['port']}/repositories/{triple_store['repository']}/statements",
+            data=query,
+            params=params,
+            auth=(triple_store['username'], triple_store['password']),
+            headers={'Content-Type': 'application/sparql-update'}))
+    except (ConnectionError, OSError):
+        raise
+
+
+def post_query(triple_store: dict, query: str, accept: str, params: dict = None) -> str:
+    headers = {
+        'Content-Type': 'application/sparql-query',
+        'Accept': accept
+    }
+    params = add_graph_to_params(params, triple_store["input_graph"])
+    try:
+        return manage_graphdb_response(
+            requests.post(url=f"{triple_store['url']}:{triple_store['port']}/repositories/{triple_store['repository']}",
+                          data=query,
+                          params=params,
+                          auth=(triple_store['username'], triple_store['password']),
+                          headers=headers))
+    except (ConnectionError, OSError):
+        raise
+
+
+def add_graph_to_params(params: dict, graph: Literal) -> dict:
+    graph = graph or "http://rdf4j.org/schema/rdf4j#nil"
+    if params:
+        params['default-graph-uri'] = graph
+        params['using-graph-uri'] = graph
+        params['remove-graph-uri'] = graph
+        params['insert-graph-uri'] = graph
+    else:
+        params = {
+            'default-graph-uri': graph,
+            'using-graph-uri': graph,
+            'remove-graph-uri': graph,
+            'insert-graph-uri': graph
+        }
+    return params

src/mustrdRdfLib.py

@@ -0,0 +1,56 @@
+"""
+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.
+"""
+
+from pyparsing import ParseException
+from rdflib import Graph
+from requests import RequestException
+
+
+def execute_select(triple_store: dict, given: Graph, when: str, bindings: dict = None) -> str:
+    try:
+        return given.query(when, initBindings=bindings).serialize(format="json").decode("utf-8")
+    except ParseException:
+        raise
+    except Exception as e:
+        raise RequestException(e)
+
+
+def execute_construct(triple_store: dict, given: Graph, when: str, bindings: dict = None) -> Graph:
+    try:
+        return given.query(when, initBindings=bindings).graph
+    except ParseException:
+        raise
+    except Exception as e:
+        raise RequestException(e)
+
+
+def execute_update(triple_store: dict, given: Graph, when: str, bindings: dict = None) -> Graph:
+    try:
+        result = given
+        result.update(when, initBindings=bindings)
+        return result
+    except ParseException:
+        raise
+    except Exception as e:
+        raise RequestException(e)

src/mustrdTestPlugin.py

@@ -0,0 +1,175 @@
+from dataclasses import dataclass
+from TestResult import ResultList, TestResult, get_result_list
+import pytest
+import os
+from pathlib import Path
+from rdflib.namespace import Namespace
+from rdflib import Graph
+
+from utils import get_project_root
+from mustrd import get_triple_store_graph, get_triple_stores, SpecSkipped, validate_specs, get_specs, SpecPassed, run_spec
+from namespace import MUST
+from pytest import Session
+from typing import Dict
+
+spnamespace = Namespace("https://semanticpartners.com/data/test/")
+
+project_root = get_project_root()
+
+
+@dataclass
+class TestConfig:
+    test_function: str
+    spec_path: str
+    data_path: str
+    triplestore_spec_path: str
+    filter_on_tripleStore: str
+
+    def __init__(self, test_function: str, spec_path: str, data_path: str, triplestore_spec_path: str,
+                 filter_on_tripleStore: str = None):
+        self.test_function = test_function
+        self.spec_path = spec_path
+        self.data_path = data_path
+        self.triplestore_spec_path = triplestore_spec_path
+        self.filter_on_tripleStore = filter_on_tripleStore
+
+
+class MustrdTestPlugin:
+    md_path: str
+    test_configs: Dict[str, TestConfig]
+
+    def __init__(self, md_path, test_configs):
+        self.md_path = md_path
+        self.test_configs = test_configs
+
+    # Hook called at collection time: reads the configuration of the tests, and generate pytests from it
+    def pytest_generate_tests(self, metafunc):
+
+        if len(metafunc.fixturenames) > 0:
+            if metafunc.function.__name__ in self.test_configs:
+                one_test_config = self.test_configs[metafunc.function.__name__]
+
+                triple_stores = self.get_triple_stores_from_file(one_test_config)
+
+                unit_tests = []
+                if one_test_config.filter_on_tripleStore and not triple_stores:
+                    unit_tests = list(map(lambda triple_store:
+                                      SpecSkipped(MUST.TestSpec, triple_store, "No triplestore found"),
+                                      one_test_config.filter_on_tripleStore))
+                else:
+                    unit_tests = self.generate_tests_for_config({"spec_path": project_root / one_test_config.spec_path,
+                                                                "data_path": project_root / one_test_config.data_path},
+                                                                triple_stores)
+
+                # Create the test in itself
+                if unit_tests:
+                    metafunc.parametrize(metafunc.fixturenames[0], unit_tests, ids=self.get_test_name)
+            else:
+                metafunc.parametrize(metafunc.fixturenames[0],
+                                     [SpecSkipped(MUST.TestSpec, None, "No triplestore found")],
+                                     ids=lambda x: "No configuration found for this test")
+
+    # Generate test for each triple store available
+    def generate_tests_for_config(self, config, triple_stores):
+
+        shacl_graph = Graph().parse(Path(os.path.join(project_root, "model/mustrdShapes.ttl")))
+        ont_graph = Graph().parse(Path(os.path.join(project_root, "model/ontology.ttl")))
+        valid_spec_uris, spec_graph, invalid_spec_results = validate_specs(config, triple_stores,
+                                                                           shacl_graph, ont_graph)
+
+        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
+
+    # Function called to generate the name of the test
+    def get_test_name(self, spec):
+        # FIXME: SpecSkipped should have the same structure?
+        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/", "")
+        test_name = spec.spec_uri.replace(spnamespace, "").replace("_", " ")
+        return triple_store_name + ": " + test_name
+
+    # Get triple store configuration or default
+    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(project_root / test_config.triplestore_spec_path))
+            except Exception:
+                print(f"""No triple store configuration found at {project_root / test_config.triplestore_spec_path}.
+                    Fall back: only embedded rdflib will be executed""")
+                triple_stores = [{'type': MUST.RdfLib}]
+        else:
+            print("No triple store configuration required: using embedded rdflib")
+            triple_stores = [{'type': MUST.RdfLib}]
+
+        if test_config.filter_on_tripleStore:
+            triple_stores = list(filter(lambda triple_store: (triple_store["type"] in test_config.filter_on_tripleStore),
+                                        triple_stores))
+        return triple_stores
+
+    # Hook function. Initialize the list of result in session
+    def pytest_sessionstart(self, session):
+        session.results = dict()
+
+    # Hook function called each time a report is generated by a test
+    # The report is added to a list in the session
+    # so it can be used later in pytest_sessionfinish to generate the global report md file
+    @pytest.hookimpl(tryfirst=True, hookwrapper=True)
+    def pytest_runtest_makereport(self, item, call):
+        outcome = yield
+        result = outcome.get_result()
+
+        if result.when == 'call':
+            # Add the result of the test to the session
+            item.session.results[item] = result
+
+    # Take all the test results in session, parse them, split them in mustrd and standard pytest  and generate md file
+    def pytest_sessionfinish(self, session: Session, exitstatus):
+        # if md path has not been defined in argument, then do not generate md file
+        if not self.md_path:
+            return
+
+        test_results = []
+        for test_conf, result in session.results.items():
+            # Case auto generated tests
+            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("]", "")
+                is_mustrd = True
+            # Case normal unit tests
+            else:
+                module_name = test_conf.parent.parent.name
+                class_name = test_conf.parent.name
+                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: result.module_name,
+                                                       lambda result: result.class_name),
+                                 False)
+
+        md = result_list.render()
+        with open(self.md_path, 'w') as file:
+            file.write(md)
+
+
+# Function called in the test to actually run it
+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 result_type == SpecSkipped:
+        # FIXME: Better exception management
+        pytest.skip("Unsupported configuration")
+    return result_type == SpecPassed