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

mustrd/README.md

@@ -0,0 +1,29 @@
+# Developer helper
+
+## Try it out
+
+Ensure you have python3 installed, before you begin.
+To install the necessary dependencies, run the following command from the project root.
+
+`pip3 install  -r requirements.txt`
+
+Run the following command to execute the accompanying tests specifications.
+
+`python3 src/run.py -v -p "test/test-specs" -g "test/data" -w "test/data" -t "test/data"`
+
+You will see some warnings. Do not worry, some tests specifications are invalid and intentionally skipped.
+
+For a brief explanation of the meaning of these options use the help option.
+
+`python3 src/run.py --help`
+
+## Run the tests
+
+Run `pytest` from the project root.
+
+## Additional Notes for Developers
+Mustrd remains very much under development. It is anticipated that additional functionality and triplestore support will be added over time. The project uses [Poetry](https://python-poetry.org/docs/) to manage dependencies so it will be necessary to have this installed to contribute towards the project. The link contains instructions on how to install and use this.
+As the project is actually built from the requirements.txt file at the project root, it is necessary to export dependencies from poetry to this file before committing and pushing changes to the repository, using the following command.
+
+`poetry export -f requirements.txt --without-hashes > requirements.txt`
+

mustrd/TestResult.py

@@ -43,7 +43,7 @@ class testStatus(Enum):
     SKIPPED = "skipped"
 
 
-TEMPLATE_FOLDER =  Path(os.path.join(get_mustrd_root(), "templates/"))
+TEMPLATE_FOLDER = Path(os.path.join(get_mustrd_root(), "templates/"))
 
 
 RESULT_LIST_MD_TEMPLATE = "md_ResultList_template.jinja"

mustrd/mustrd.py

@@ -46,12 +46,12 @@ import json
 from pandas import DataFrame
 
 from .spec_component import TableThenSpec, parse_spec_component, WhenSpec, ThenSpec
-from .utils import  is_json,get_mustrd_root
+from .utils import is_json, get_mustrd_root
 from colorama import Fore, Style
 from tabulate import tabulate
 from collections import defaultdict
 from pyshacl import validate
-import logging 
+import logging
 from http.client import HTTPConnection
 from .steprunner import upload_given, run_when
 
@@ -73,6 +73,7 @@ def debug_requests_on():
     requests_log.setLevel(logging.DEBUG)
     requests_log.propagate = True
 
+
 def debug_requests_off():
     '''Switches off logging of the requests module, might be some side-effects'''
     HTTPConnection.debuglevel = 0
@@ -84,8 +85,10 @@ def debug_requests_off():
     requests_log.setLevel(logging.WARNING)
     requests_log.propagate = False
 
+
 debug_requests_off()
 
+
 @dataclass
 class Specification:
     spec_uri: URIRef
@@ -234,25 +237,18 @@ def validate_specs(run_config: dict, triple_stores: List, shacl_graph: Graph, on
             if len(error_messages) > 0:
                 error_messages.sort()
                 error_message = "\n".join(msg for msg in error_messages)
-                invalid_specs += [SpecSkipped(subject_uri, triple_store["type"], error_message, file.name) for triple_store in
-                                triple_stores]
+                invalid_specs += [SpecSkipped(subject_uri, triple_store["type"], error_message, file.name)
+                                  for triple_store in triple_stores]
             else:
                 subject_uris.add(subject_uri)
                 this_spec_graph = Graph()
                 this_spec_graph.parse(file)
                 spec_uris_in_this_file = list(this_spec_graph.subjects(RDF.type, MUST.TestSpec))
                 for spec in spec_uris_in_this_file:
-                    # print(f"adding {tripleToAdd}")
                     this_spec_graph.add([spec, MUST.specSourceFile, Literal(file)])
                     this_spec_graph.add([spec, MUST.specFileName, Literal(file.name)])
-                # print(f"beforeadd: {spec_graph}" )
-                # print(f"beforeadd: {str(this_spec_graph.serialize())}" )
                 spec_graph += this_spec_graph
 
-
-    sourceFiles = list(spec_graph.subject_objects(MUST.specSourceFile))
-    # print(f"sourceFiles: {sourceFiles}")
-
     valid_spec_uris = list(spec_graph.subjects(RDF.type, MUST.TestSpec))
 
     if focus_uris:
@@ -264,7 +260,7 @@ def validate_specs(run_config: dict, triple_stores: List, shacl_graph: Graph, on
         log.info(f"Collected {len(focus_uris)} focus test spec(s)")
         return focus_uris, spec_graph, invalid_focus_specs
     else:
-        log.info(f"Collected {len(valid_spec_uris)} valid test spec(s)")   
+        log.info(f"Collected {len(valid_spec_uris)} valid test spec(s)")
         return valid_spec_uris, spec_graph, invalid_specs
 
 
@@ -276,14 +272,16 @@ def get_specs(spec_uris: List[URIRef], spec_graph: Graph, triple_stores: List[di
         for triple_store in triple_stores:
             if "error" in triple_store:
                 log.error(f"{triple_store['error']}. No specs run for this triple store.")
-                skipped_results += [SpecSkipped(spec_uri, triple_store['type'], triple_store['error'], get_spec_file(spec_uri, spec_graph)) for spec_uri in
+                skipped_results += [SpecSkipped(spec_uri, triple_store['type'], triple_store['error'],
+                                                get_spec_file(spec_uri, spec_graph)) for spec_uri in
                                     spec_uris]
             else:
                 for spec_uri in spec_uris:
                     try:
                         specs += [get_spec(spec_uri, spec_graph, run_config, triple_store)]
                     except (ValueError, FileNotFoundError, ConnectionError) as e:
-                        skipped_results += [SpecSkipped(spec_uri, triple_store['type'], e, get_spec_file(spec_uri, spec_graph))]
+                        skipped_results += [SpecSkipped(spec_uri, triple_store['type'],
+                                                        e, get_spec_file(spec_uri, spec_graph))]
 
     except (BadSyntax, FileNotFoundError) as e:
         template = "An exception of type {0} occurred when trying to parse the triple store configuration file. " \
@@ -303,25 +301,28 @@ def run_specs(specs) -> List[SpecResult]:
         results.append(run_spec(specification))
     return results
 
+
 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"))
+    return str(spec_graph.value(subject=spec_uri, predicate=MUST.specFileName, default="default.mustrd.ttl"))
+
 
 def get_spec(spec_uri: URIRef, spec_graph: Graph, run_config: dict, mustrd_triple_store: dict = None) -> Specification:
     try:
-        if mustrd_triple_store is None:
+        if not mustrd_triple_store:
             mustrd_triple_store = {"type": TRIPLESTORE.RdfLib}
         components = []
         for predicate in MUST.given, MUST.when, MUST.then:
             components.append(parse_spec_component(subject=spec_uri,
-                                                predicate=predicate,
-                                                spec_graph=spec_graph,
-                                                run_config=run_config,
-                                                mustrd_triple_store=mustrd_triple_store))
+                                                   predicate=predicate,
+                                                   spec_graph=spec_graph,
+                                                   run_config=run_config,
+                                                   mustrd_triple_store=mustrd_triple_store))
 
         spec_file_name = get_spec_file(spec_uri, spec_graph)
         # https://github.com/Semantic-partners/mustrd/issues/92
-        return Specification(spec_uri, mustrd_triple_store, components[0].value, components[1], components[2], spec_file_name)
-    
+        return Specification(spec_uri, mustrd_triple_store,
+                             components[0].value, components[1], components[2], spec_file_name)
+
     except (ValueError, FileNotFoundError) as e:
         template = "An exception of type {0} occurred. Arguments:\n{1!r}"
         message = template.format(type(e).__name__, e.args)
@@ -333,7 +334,7 @@ def get_spec(spec_uri: URIRef, spec_graph: Graph, run_config: dict, mustrd_tripl
 
 
 def check_result(spec, result):
-    if type(spec.then) == TableThenSpec:
+    if isinstance(spec.then, TableThenSpec):
         return table_comparison(result, spec)
     else:
         graph_compare = graph_comparison(spec.then.value, result)
@@ -383,27 +384,30 @@ def run_spec(spec: Specification) -> SpecResult:
     #     if type(mustrd_triple_store) == MustrdAnzo and close_connection:
     #         mustrd_triple_store.clear_graph()
 
+
 def get_triple_store_graph(triple_store_graph_path: Path, secrets: str):
     if secrets:
-        return Graph().parse(triple_store_graph_path).parse(data = secrets)
+        return Graph().parse(triple_store_graph_path).parse(data=secrets)
     else:
-        secret_path = triple_store_graph_path.parent / Path(triple_store_graph_path.stem + "_secrets" + triple_store_graph_path.suffix)
+        secret_path = triple_store_graph_path.parent / Path(triple_store_graph_path.stem +
+                                                            "_secrets" + triple_store_graph_path.suffix)
         return Graph().parse(triple_store_graph_path).parse(secret_path)
-    
+
 
 def get_triple_stores(triple_store_graph: Graph) -> list[dict]:
     triple_stores = []
     shacl_graph = Graph().parse(Path(os.path.join(get_mustrd_root(), "model/triplestoreshapes.ttl")))
     ont_graph = Graph().parse(Path(os.path.join(get_mustrd_root(), "model/triplestoreOntology.ttl")))
     conforms, results_graph, results_text = validate(
-            data_graph= triple_store_graph,
-            shacl_graph = shacl_graph,
-            ont_graph  = ont_graph,
-            advanced= True,
-            inference= 'none'
+            data_graph=triple_store_graph,
+            shacl_graph=shacl_graph,
+            ont_graph=ont_graph,
+            advanced=True,
+            inference='none'
         )
     if not conforms:
-        raise ValueError(f"Triple store configuration not conform to the shapes. SHACL report: {results_text}", results_graph)
+        raise ValueError(f"Triple store configuration not conform to the shapes. SHACL report: {results_text}",
+                         results_graph)
     for triple_store_config, rdf_type, triple_store_type in triple_store_graph.triples((None, RDF.type, None)):
         triple_store = {}
         triple_store["type"] = triple_store_type
@@ -413,15 +417,18 @@ def get_triple_stores(triple_store_graph: Graph) -> list[dict]:
             triple_store["url"] = triple_store_graph.value(subject=triple_store_config, predicate=TRIPLESTORE.url)
             triple_store["port"] = triple_store_graph.value(subject=triple_store_config, predicate=TRIPLESTORE.port)
             try:
-                triple_store["username"] = str(triple_store_graph.value(subject=triple_store_config, predicate=TRIPLESTORE.username))
-                triple_store["password"] = str(triple_store_graph.value(subject=triple_store_config, predicate=TRIPLESTORE.password))
+                triple_store["username"] = str(triple_store_graph.value(subject=triple_store_config,
+                                                                        predicate=TRIPLESTORE.username))
+                triple_store["password"] = str(triple_store_graph.value(subject=triple_store_config,
+                                                                        predicate=TRIPLESTORE.password))
             except (FileNotFoundError, ValueError) as e:
                 triple_store["error"] = e
-            triple_store["gqe_uri"] = triple_store_graph.value(subject=triple_store_config, predicate=TRIPLESTORE.gqeURI)
+            triple_store["gqe_uri"] = triple_store_graph.value(subject=triple_store_config,
+                                                               predicate=TRIPLESTORE.gqeURI)
             triple_store["input_graph"] = triple_store_graph.value(subject=triple_store_config,
                                                                    predicate=TRIPLESTORE.inputGraph)
             triple_store["output_graph"] = triple_store_graph.value(subject=triple_store_config,
-                                                                   predicate=TRIPLESTORE.outputGraph)
+                                                                    predicate=TRIPLESTORE.outputGraph)
             try:
                 check_triple_store_params(triple_store, ["url", "port", "username", "password", "input_graph"])
             except ValueError as e:
@@ -431,8 +438,10 @@ def get_triple_stores(triple_store_graph: Graph) -> list[dict]:
             triple_store["url"] = triple_store_graph.value(subject=triple_store_config, predicate=TRIPLESTORE.url)
             triple_store["port"] = triple_store_graph.value(subject=triple_store_config, predicate=TRIPLESTORE.port)
             try:
-                triple_store["username"] = str(triple_store_graph.value(subject=triple_store_config, predicate=TRIPLESTORE.username))
-                triple_store["password"] = str(triple_store_graph.value(subject=triple_store_config, predicate=TRIPLESTORE.password))
+                triple_store["username"] = str(triple_store_graph.value(subject=triple_store_config,
+                                                                        predicate=TRIPLESTORE.username))
+                triple_store["password"] = str(triple_store_graph.value(subject=triple_store_config,
+                                                                        predicate=TRIPLESTORE.password))
             except (FileNotFoundError, ValueError) as e:
                 log.error(f"Credential retrieval failed {e}")
                 triple_store["error"] = e
@@ -461,11 +470,9 @@ def check_triple_store_params(triple_store: dict, required_params: List[str]):
 
 def get_credential_from_file(triple_store_name: URIRef, credential: str, config_path: Literal) -> str:
     log.info(f"get_credential_from_file {triple_store_name}, {credential}, {config_path}")
-    if config_path is None:
+    if not config_path:
         raise ValueError(f"Cannot establish connection defined in {triple_store_name}. "
                          f"Missing required parameter: {credential}.")
-    # if os.path.isrelative(config_path)
-    # project_root = get_project_root()
     path = Path(config_path)
     log.info(f"get_credential_from_file {path}")
 
@@ -480,6 +487,7 @@ def get_credential_from_file(triple_store_name: URIRef, credential: str, config_
         raise ValueError(f"Error reading credentials config file: {e}")
     return config[str(triple_store_name)][credential]
 
+
 # Convert sparql json query results as defined in https://www.w3.org/TR/rdf-sparql-json-res/
 def json_results_to_panda_dataframe(result: str) -> pandas.DataFrame:
     json_result = json.loads(result)
@@ -534,7 +542,8 @@ def table_comparison(result: str, spec: Specification) -> SpecResult:
 
             # Scenario 1: expected no result but got a result
             if then.empty:
-                message = f"Expected 0 row(s) and 0 column(s), got {df.shape[0]} row(s) and {round(df.shape[1] / 2)} column(s)"
+                message = f"""Expected 0 row(s) and 0 column(s),
+                got {df.shape[0]} row(s) and {round(df.shape[1] / 2)} column(s)"""
                 empty_then = create_empty_dataframe_with_columns(df)
                 df_diff = empty_then.compare(df, result_names=("expected", "actual"))
 
@@ -546,14 +555,6 @@ def table_comparison(result: str, spec: Specification) -> SpecResult:
                 if ordered_result is True and not spec.then.ordered:
                     message += ". Actual result is ordered, must:then must contain sh:order on every row."
                     return SelectSpecFailure(spec.spec_uri, spec.triple_store["type"], None, message)
-                    # if df.shape == then.shape and (df.columns == then.columns).all():
-                    #     df_diff = then.compare(df, result_names=("expected", "actual"))
-                    #     if df_diff.empty:
-                    #         df_diff = df
-                    #         print(df_diff.to_markdown())
-                    # else:
-                    #     df_diff = construct_df_diff(df, then)
-                    #     print(df_diff.to_markdown())
                 else:
                     if len(columns) == len(then.columns):
                         if sorted_columns == sorted_then_cols:
@@ -579,15 +580,15 @@ def table_comparison(result: str, spec: Specification) -> SpecResult:
 
             if then.empty:
                 # Scenario 3: expected no result, got no result
-                message = f"Expected 0 row(s) and 0 column(s), got 0 row(s) and 0 column(s)"
+                message = "Expected 0 row(s) and 0 column(s), got 0 row(s) and 0 column(s)"
                 df = pandas.DataFrame()
             else:
                 # Scenario 4: expected a result, but got an empty result
-                message = f"Expected {then.shape[0]} row(s) and {round(then.shape[1] / 2)} column(s), got 0 row(s) and 0 column(s)"
+                message = f"""Expected {then.shape[0]} row(s)
+                              and {round(then.shape[1] / 2)} column(s), got 0 row(s) and 0 column(s)"""
                 then = then[sorted_then_cols]
                 df = create_empty_dataframe_with_columns(then)
             df_diff = then.compare(df, result_names=("expected", "actual"))
-            print(df_diff.to_markdown())
 
         if df_diff.empty:
             if warning:
@@ -595,13 +596,8 @@ def table_comparison(result: str, spec: Specification) -> SpecResult:
             else:
                 return SpecPassed(spec.spec_uri, spec.triple_store["type"])
         else:
-            # message += f"\nexpected:\n{then}\nactual:{df}"
+            log.error("\n" + df_diff.to_markdown())
             log.error(message)
-            # print(spec.spec_uri)
-            # print("actual:")
-            # print(then)
-            # print("expected:")
-            # print(df)
             return SelectSpecFailure(spec.spec_uri, spec.triple_store["type"], df_diff, message)
 
     except ParseException as e:
@@ -622,18 +618,18 @@ def graph_comparison(expected_graph: Graph, actual_graph: Graph) -> GraphCompari
 
 def get_then_update(spec_uri: URIRef, spec_graph: Graph) -> Graph:
     then_query = f"""
-    prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> 
+    prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
 
     CONSTRUCT {{ ?s ?p ?o }}
     {{
-        <{spec_uri}> <{MUST.then}> 
+        <{spec_uri}> <{MUST.then}>
             a <{MUST.StatementsDataset}> ;
             <{MUST.hasStatement}> [
                 a rdf:Statement ;
                 rdf:subject ?s ;
                 rdf:predicate ?p ;
                 rdf:object ?o ;
-            ] ; ] 
+            ] ; ]
     }}
     """
     expected_results = spec_graph.query(then_query).graph
@@ -707,7 +703,7 @@ def create_empty_dataframe_with_columns(df: pandas.DataFrame) -> pandas.DataFram
 
 
 def review_results(results: List[SpecResult], verbose: bool) -> None:
-    print("===== Result Overview =====")
+    log.info("===== Result Overview =====")
     # Init dictionaries
     status_dict = defaultdict(lambda: defaultdict(int))
     status_counts = defaultdict(lambda: defaultdict(int))
@@ -723,7 +719,8 @@ def review_results(results: List[SpecResult], verbose: bool) -> None:
 
     # Convert dictionaries to list for tabulate
     table_rows = [[spec_uri] + [
-        f"{colours.get(status_dict[spec_uri][triple_store], Fore.RED)}{status_dict[spec_uri][triple_store].__name__}{Style.RESET_ALL}"
+        f"""{colours.get(status_dict[spec_uri][triple_store], Fore.RED)}
+        {status_dict[spec_uri][triple_store].__name__}{Style.RESET_ALL}"""
         for triple_store in triple_stores] for spec_uri in set(status_dict.keys())]
 
     status_rows = [[f"{colours.get(status, Fore.RED)}{status.__name__}{Style.RESET_ALL}"] +
@@ -731,8 +728,8 @@ def review_results(results: List[SpecResult], verbose: bool) -> None:
                     for triple_store in triple_stores] for status in set(statuses)]
 
     # Display tables with tabulate
-    print(tabulate(table_rows, headers=['Spec Uris / triple stores'] + triple_stores, tablefmt="pretty"))
-    print(tabulate(status_rows, headers=['Status / triple stores'] + triple_stores, tablefmt="pretty"))
+    log.info(tabulate(table_rows, headers=['Spec Uris / triple stores'] + triple_stores, tablefmt="pretty"))
+    log.info(tabulate(status_rows, headers=['Status / triple stores'] + triple_stores, tablefmt="pretty"))
 
     pass_count = statuses.count(SpecPassed)
     warning_count = statuses.count(SpecPassedWithWarning)
@@ -748,40 +745,34 @@ def review_results(results: List[SpecResult], verbose: bool) -> None:
         overview_colour = Fore.GREEN
 
     logger_setup.flush()
-    print(f"{overview_colour}===== {fail_count} failures, {skipped_count} skipped, {Fore.GREEN}{pass_count} passed, "
+    log.info(f"{overview_colour}===== {fail_count} failures, {skipped_count} skipped, {Fore.GREEN}{pass_count} passed, "
           f"{overview_colour}{warning_count} passed with warnings =====")
 
     if verbose and (fail_count or warning_count or skipped_count):
         for res in results:
-            if type(res) == UpdateSpecFailure:
-                print(f"{Fore.RED}Failed {res.spec_uri} {res.triple_store}")
-                print(f"{Fore.BLUE} In Expected Not In Actual:")
-                print(res.graph_comparison.in_expected_not_in_actual.serialize(format="ttl"))
-                print()
-                print(f"{Fore.RED} in_actual_not_in_expected")
-                print(res.graph_comparison.in_actual_not_in_expected.serialize(format="ttl"))
-                print(f"{Fore.GREEN} in_both")
-                print(res.graph_comparison.in_both.serialize(format="ttl"))
-
-            if type(res) == SelectSpecFailure:
-                print(f"{Fore.RED}Failed {res.spec_uri} {res.triple_store}")
-                print(res.message)
-                print(res.table_comparison.to_markdown())
-            if type(res) == ConstructSpecFailure or type(res) == UpdateSpecFailure:
-                print(f"{Fore.RED}Failed {res.spec_uri} {res.triple_store}")
-            if type(res) == SpecPassedWithWarning:
-                print(f"{Fore.YELLOW}Passed with warning {res.spec_uri} {res.triple_store}")
-                print(res.warning)
-            if type(res) == TripleStoreConnectionError or type(res) == SparqlExecutionError or \
-                    type(res) == SparqlParseFailure:
-                print(f"{Fore.RED}Failed {res.spec_uri} {res.triple_store}")
-                print(res.exception)
-            if type(res) == SpecSkipped:
-                print(f"{Fore.YELLOW}Skipped {res.spec_uri} {res.triple_store}")
-                print(res.message)
-
-
-
-    
-
-
+            if isinstance(res, UpdateSpecFailure):
+                log.info(f"{Fore.RED}Failed {res.spec_uri} {res.triple_store}")
+                log.info(f"{Fore.BLUE} In Expected Not In Actual:")
+                log.info(res.graph_comparison.in_expected_not_in_actual.serialize(format="ttl"))
+                log.info()
+                log.info(f"{Fore.RED} in_actual_not_in_expected")
+                log.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"))
+
+            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())
+            if isinstance(res, ConstructSpecFailure) or isinstance(res, UpdateSpecFailure):
+                log.info(f"{Fore.RED}Failed {res.spec_uri} {res.triple_store}")
+            if isinstance(res, SpecPassedWithWarning):
+                log.info(f"{Fore.YELLOW}Passed with warning {res.spec_uri} {res.triple_store}")
+                log.info(res.warning)
+            if isinstance(res, TripleStoreConnectionError) or type(res, SparqlExecutionError) or \
+                    isinstance(res, SparqlParseFailure):
+                log.info(f"{Fore.RED}Failed {res.spec_uri} {res.triple_store}")
+                log.info(res.exception)
+            if isinstance(res, SpecSkipped):
+                log.info(f"{Fore.YELLOW}Skipped {res.spec_uri} {res.triple_store}")
+                log.info(res.message)

mustrd/mustrdAnzo.py

@@ -51,13 +51,16 @@ def query_with_bindings(bindings: dict, when: str) -> str:
     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:
+
+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,
+                'default-graph-uri': triple_store['input_graph'],
+                'named-graph-uri': triple_store['input_graph'],
                  '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,
@@ -67,6 +70,7 @@ def execute_select (triple_store: dict,  when: str, bindings: dict = None) -> st
     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']
@@ -75,8 +79,11 @@ def execute_update(triple_store: dict, when: str, bindings: dict = None) -> Grap
     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'}
+    data = {'datasourceURI': triple_store['gqe_uri'],
+            'update': substituted_query,
+            'using-graph-uri': [output_graph, input_graph],
+            'using-named-graph-uri': [output_graph, 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'],
@@ -85,7 +92,9 @@ def execute_update(triple_store: dict, when: str, bindings: dict = None) -> Grap
             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'}
+                'default-graph-uri': output_graph,
+                'named-graph-uri': output_graph,
+                  'skipCache': 'true'}
     everything_response = manage_anzo_response(requests.post(url=url,
             auth=(triple_store['username'],
                 triple_store['password']),
@@ -102,7 +111,9 @@ def execute_construct(triple_store: dict, when: str, bindings: dict = None) -> G
         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'}
+                'default-graph-uri': triple_store['input_graph'],
+                'named-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'],
@@ -110,7 +121,9 @@ def execute_construct(triple_store: dict, when: str, bindings: dict = None) -> G
             data=data,
             verify=False)
         logging.debug(f'response {response}')
-        return Graph().parse(data=manage_anzo_response(response))
+        g = Graph().parse(data=manage_anzo_response(response))
+        logging.debug(f"Actual Result = {g.serialize(format='ttl')}")
+        return g
     except (ConnectionError, TimeoutError, HTTPError, ConnectTimeout) as e:
         logging.error(f'response {e}')
         raise
@@ -119,7 +132,7 @@ def execute_construct(triple_store: dict, when: str, bindings: dict = None) -> G
 # 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'], 
+        anzo_client = AnzoClient(triple_store['url'], triple_store['port'],
                                  username=triple_store['username'],
                                  password=triple_store['password'])
         return anzo_client.query_graphmart(graphmart=graphmart,
@@ -140,10 +153,10 @@ def get_query_from_querybuilder(triple_store: dict, folder_name: Literal, query_
             ?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'], 
+    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}")
@@ -158,7 +171,7 @@ def get_query_from_step(triple_store: dict, query_step_uri: URIRef) -> str:
                      <http://cambridgesemantics.com/ontologies/Graphmarts#transformQuery> ?query
     }}
     # """
-    anzo_client = AnzoClient(triple_store['url'], triple_store['port'], 
+    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()
@@ -175,7 +188,7 @@ def get_queries_from_templated_step(triple_store: dict, query_step_uri: URIRef)
 					    <http://cambridgesemantics.com/ontologies/Graphmarts#template> ?query_template .
     }}
     """
-    anzo_client = AnzoClient(triple_store['url'], triple_store['port'], 
+    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()
@@ -189,7 +202,7 @@ 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 ; 
+  ?query_step graphmarts:enabled true ;
   OPTIONAL {{  ?query_step
    				graphmarts:parametersTemplate ?param_query ;
            		graphmarts:template ?query_template ;
@@ -199,7 +212,7 @@ SELECT ?query ?param_query ?query_template
       . }}
   }}
   ORDER BY ?index"""
-    anzo_client = AnzoClient(triple_store['url'], triple_store['port'], 
+    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()
@@ -215,7 +228,10 @@ def upload_given(triple_store: dict, given: 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}
+        data = {'datasourceURI': triple_store['gqe_uri'],
+                'update': insert_query,
+                'using-graph-uri': input_graph,
+                'using-named-graph-uri': input_graph}
         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)
@@ -233,4 +249,3 @@ def clear_graph(triple_store: dict, graph_uri: str):
         manage_anzo_response(response)
     except (ConnectionError, TimeoutError, HTTPError, ConnectTimeout):
         raise
-