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

mustrd/steprunner.py

@@ -1,166 +1,166 @@
-"""
-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 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 execute_update as execute_update_anzo
-from .mustrdAnzo import execute_construct as execute_construct_anzo
-from .mustrdAnzo import execute_select as execute_select_anzo
-from .mustrdGraphDb import upload_given as upload_given_graphdb
-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
-
-log = logger_setup.setup_logger(__name__)
-
-
-def dispatch_upload_given(triple_store: dict, given: Graph):
-    ts = triple_store['type']
-    log.info(f"dispatch_upload_given to {ts}")
-    return ts
-
-
-upload_given = MultiMethod('upload_given', dispatch_upload_given)
-
-
-@upload_given.method(TRIPLESTORE.RdfLib)
-def _upload_given_rdflib(triple_store: dict, given: Graph):
-    triple_store["given"] = given
-
-
-@upload_given.method(TRIPLESTORE.GraphDb)
-def _upload_given_graphdb(triple_store: dict, given: Graph):
-    upload_given_graphdb(triple_store, given)
-
-
-@upload_given.method(TRIPLESTORE.Anzo)
-def _upload_given_anzo(triple_store: dict, given: Graph):
-    upload_given_anzo(triple_store, given)
-
-
-def dispatch_run_when(spec_uri: URIRef, triple_store: dict, when: WhenSpec):
-    ts = triple_store['type']
-    query_type = when.queryType
-    log.info(f"dispatch_run_when to SPARQL type {query_type} to {ts}")
-    return ts, query_type
-
-
-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)
-
-
-@run_when.method((TRIPLESTORE.Anzo, MUST.ConstructSparql))
-def _anzo_run_when_construct(spec_uri: URIRef, triple_store: dict, when: AnzoWhenSpec):
-    return execute_construct_anzo(triple_store, when.value, when.bindings)
-
-
-@run_when.method((TRIPLESTORE.Anzo, MUST.SelectSparql))
-def _anzo_run_when_select(spec_uri: URIRef, triple_store: dict, when: AnzoWhenSpec):
-    return execute_select_anzo(triple_store, when.value, when.bindings)
-
-
-@run_when.method((TRIPLESTORE.GraphDb, MUST.UpdateSparql))
-def _graphdb_run_when_update(spec_uri: URIRef, triple_store: dict, when: WhenSpec):
-    return execute_update_graphdb(triple_store, when.value, when.bindings)
-
-
-@run_when.method((TRIPLESTORE.GraphDb, MUST.ConstructSparql))
-def _graphdb_run_when_construct(spec_uri: URIRef, triple_store: dict, when: WhenSpec):
-    return execute_construct_graphdb(triple_store, when.value, when.bindings)
-
-
-@run_when.method((TRIPLESTORE.GraphDb, MUST.SelectSparql))
-def _graphdb_run_when_select(spec_uri: URIRef, triple_store: dict, when: WhenSpec):
-    return execute_select_graphdb(triple_store, when.value, when.bindings)
-
-
-@run_when.method((TRIPLESTORE.RdfLib, MUST.UpdateSparql))
-def _rdflib_run_when_update(spec_uri: URIRef, triple_store: dict, when: WhenSpec):
-    return execute_update_rdflib(triple_store, triple_store["given"], when.value, when.bindings)
-
-
-@run_when.method((TRIPLESTORE.RdfLib, MUST.ConstructSparql))
-def _rdflib_run_when_construct(spec_uri: URIRef, triple_store: dict, when: WhenSpec):
-    return execute_construct_rdflib(triple_store, triple_store["given"], when.value, when.bindings)
-
-
-@run_when.method((TRIPLESTORE.RdfLib, MUST.SelectSparql))
-def _rdflib_run_when_select(spec_uri: URIRef, triple_store: dict, when: WhenSpec):
-    return execute_select_rdflib(triple_store, triple_store["given"], when.value, when.bindings)
-
-
-@run_when.method((TRIPLESTORE.Anzo, MUST.AnzoQueryDrivenUpdateSparql))
-def _multi_run_when_anzo_query_driven_update(spec_uri: URIRef, triple_store: dict, when: AnzoWhenSpec):
-    # run the parameters query to obtain the values for the template step and put them into a dictionary
-    query_parameters = json.loads(execute_select_anzo(triple_store, when.paramQuery, None))
-    if len(query_parameters['results']['bindings']) > 0:
-        # replace the anzo query placeholders with the input and output graphs
-        when_template = when.queryTemplate.replace(
-            "${usingSources}",
-            f"USING <{triple_store['input_graph']}> \nUSING <{triple_store['output_graph']}>").replace(
-            "${targetGraph}", f"<{triple_store['output_graph']}>")
-
-        # for each set of parameters insert their values into the template an run it
-        for params in query_parameters['results']['bindings']:
-            when_query = when_template
-            for param in params:
-                if params[param].get('datatype'):
-                    value = params[param]['value']
-                else:
-                    if params[param]['type'] == 'uri':
-                        value = '<' + params[param]['value'] + '>'
-                    else:
-                        value = '"' + params[param]['value'] + '"'
-                when_query = when_query.replace("${" + param + "}", value)
-            result = execute_update_anzo(triple_store, when_query, None)
-        return result
-
-
-@run_when.method(Default)
-def _multi_run_when_default(spec_uri: URIRef, triple_store: dict, when: WhenSpec):
-    if when.queryType == MUST.AskSparql:
-        log.warning(f"Skipping {spec_uri}, SPARQL ASK not implemented.")
-        msg = "SPARQL ASK not implemented."
-    elif when.queryType == MUST.DescribeSparql:
-        log.warning(f"Skipping {spec_uri}, SPARQL DESCRIBE not implemented.")
-        msg = "SPARQL DESCRIBE not implemented."
-    elif triple_store['type'] not in [TRIPLESTORE.Anzo, TRIPLESTORE.GraphDb, TRIPLESTORE.RdfLib]:
-        msg = f"{when.queryType} not implemented for {triple_store['type']}"
-    else:
-        log.warning(f"Skipping {spec_uri},  {when.queryType} is not a valid SPARQL query type.")
-        msg = f"{when.queryType} is not a valid SPARQL query type."
-    raise NotImplementedError(msg)
+"""
+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 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 execute_update as execute_update_anzo
+from .mustrdAnzo import execute_construct as execute_construct_anzo
+from .mustrdAnzo import execute_select as execute_select_anzo
+from .mustrdGraphDb import upload_given as upload_given_graphdb
+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
+
+log = logger_setup.setup_logger(__name__)
+
+
+def dispatch_upload_given(triple_store: dict, given: Graph):
+    ts = triple_store['type']
+    log.info(f"dispatch_upload_given to {ts}")
+    return ts
+
+
+upload_given = MultiMethod('upload_given', dispatch_upload_given)
+
+
+@upload_given.method(TRIPLESTORE.RdfLib)
+def _upload_given_rdflib(triple_store: dict, given: Graph):
+    triple_store["given"] = given
+
+
+@upload_given.method(TRIPLESTORE.GraphDb)
+def _upload_given_graphdb(triple_store: dict, given: Graph):
+    upload_given_graphdb(triple_store, given)
+
+
+@upload_given.method(TRIPLESTORE.Anzo)
+def _upload_given_anzo(triple_store: dict, given: Graph):
+    upload_given_anzo(triple_store, given)
+
+
+def dispatch_run_when(spec_uri: URIRef, triple_store: dict, when: WhenSpec):
+    ts = triple_store['type']
+    query_type = when.queryType
+    log.info(f"dispatch_run_when to SPARQL type {query_type} to {ts}")
+    return ts, query_type
+
+
+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)
+
+
+@run_when.method((TRIPLESTORE.Anzo, MUST.ConstructSparql))
+def _anzo_run_when_construct(spec_uri: URIRef, triple_store: dict, when: AnzoWhenSpec):
+    return execute_construct_anzo(triple_store, when.value, when.bindings)
+
+
+@run_when.method((TRIPLESTORE.Anzo, MUST.SelectSparql))
+def _anzo_run_when_select(spec_uri: URIRef, triple_store: dict, when: AnzoWhenSpec):
+    return execute_select_anzo(triple_store, when.value, when.bindings)
+
+
+@run_when.method((TRIPLESTORE.GraphDb, MUST.UpdateSparql))
+def _graphdb_run_when_update(spec_uri: URIRef, triple_store: dict, when: WhenSpec):
+    return execute_update_graphdb(triple_store, when.value, when.bindings)
+
+
+@run_when.method((TRIPLESTORE.GraphDb, MUST.ConstructSparql))
+def _graphdb_run_when_construct(spec_uri: URIRef, triple_store: dict, when: WhenSpec):
+    return execute_construct_graphdb(triple_store, when.value, when.bindings)
+
+
+@run_when.method((TRIPLESTORE.GraphDb, MUST.SelectSparql))
+def _graphdb_run_when_select(spec_uri: URIRef, triple_store: dict, when: WhenSpec):
+    return execute_select_graphdb(triple_store, when.value, when.bindings)
+
+
+@run_when.method((TRIPLESTORE.RdfLib, MUST.UpdateSparql))
+def _rdflib_run_when_update(spec_uri: URIRef, triple_store: dict, when: WhenSpec):
+    return execute_update_rdflib(triple_store, triple_store["given"], when.value, when.bindings)
+
+
+@run_when.method((TRIPLESTORE.RdfLib, MUST.ConstructSparql))
+def _rdflib_run_when_construct(spec_uri: URIRef, triple_store: dict, when: WhenSpec):
+    return execute_construct_rdflib(triple_store, triple_store["given"], when.value, when.bindings)
+
+
+@run_when.method((TRIPLESTORE.RdfLib, MUST.SelectSparql))
+def _rdflib_run_when_select(spec_uri: URIRef, triple_store: dict, when: WhenSpec):
+    return execute_select_rdflib(triple_store, triple_store["given"], when.value, when.bindings)
+
+
+@run_when.method((TRIPLESTORE.Anzo, MUST.AnzoQueryDrivenUpdateSparql))
+def _multi_run_when_anzo_query_driven_update(spec_uri: URIRef, triple_store: dict, when: AnzoWhenSpec):
+    # run the parameters query to obtain the values for the template step and put them into a dictionary
+    query_parameters = json.loads(execute_select_anzo(triple_store, when.paramQuery, None))
+    if len(query_parameters['results']['bindings']) > 0:
+        # replace the anzo query placeholders with the input and output graphs
+        when_template = when.queryTemplate.replace(
+            "${usingSources}",
+            f"USING <{triple_store['input_graph']}> \nUSING <{triple_store['output_graph']}>").replace(
+            "${targetGraph}", f"<{triple_store['output_graph']}>")
+
+        # for each set of parameters insert their values into the template an run it
+        for params in query_parameters['results']['bindings']:
+            when_query = when_template
+            for param in params:
+                if params[param].get('datatype'):
+                    value = params[param]['value']
+                else:
+                    if params[param]['type'] == 'uri':
+                        value = '<' + params[param]['value'] + '>'
+                    else:
+                        value = '"' + params[param]['value'] + '"'
+                when_query = when_query.replace("${" + param + "}", value)
+            result = execute_update_anzo(triple_store, when_query, None)
+        return result
+
+
+@run_when.method(Default)
+def _multi_run_when_default(spec_uri: URIRef, triple_store: dict, when: WhenSpec):
+    if when.queryType == MUST.AskSparql:
+        log.warning(f"Skipping {spec_uri}, SPARQL ASK not implemented.")
+        msg = "SPARQL ASK not implemented."
+    elif when.queryType == MUST.DescribeSparql:
+        log.warning(f"Skipping {spec_uri}, SPARQL DESCRIBE not implemented.")
+        msg = "SPARQL DESCRIBE not implemented."
+    elif triple_store['type'] not in [TRIPLESTORE.Anzo, TRIPLESTORE.GraphDb, TRIPLESTORE.RdfLib]:
+        msg = f"{when.queryType} not implemented for {triple_store['type']}"
+    else:
+        log.warning(f"Skipping {spec_uri},  {when.queryType} is not a valid SPARQL query type.")
+        msg = f"{when.queryType} is not a valid SPARQL query type."
+    raise NotImplementedError(msg)

mustrd/templates/md_ResultList_leaf_template.jinja

@@ -1,19 +1,19 @@
-<table class="table">
-    <thead>
-        <tr>
-            <th scope="col">module</th>
-            <th scope="col">class</th>
-            <th scope="col">test</th>
-            <th scope="col">status</th>
-        <tr>
-    </thead>
-    <tbody>
-    {% for  result in result_list -%}
-        <tr>
-            <td>{{result.module_name}}</td>
-            <td>{{result.class_name}}</td>
-            <td>{{result.test_name}}</td>
-            <td>{{result.status}}</td>
-        </tr>
-    {% endfor %}</tbody>
+<table class="table">
+    <thead>
+        <tr>
+            <th scope="col">module</th>
+            <th scope="col">class</th>
+            <th scope="col">test</th>
+            <th scope="col">status</th>
+        <tr>
+    </thead>
+    <tbody>
+    {% for  result in result_list -%}
+        <tr>
+            <td>{{result.module_name}}</td>
+            <td>{{result.class_name}}</td>
+            <td>{{result.test_name}}</td>
+            <td>{{result.status}}</td>
+        </tr>
+    {% endfor %}</tbody>
 </table>

mustrd/templates/md_ResultList_template.jinja

@@ -1,9 +1,9 @@
-
-{% for  result in result_list %}
-<details>
-{{environment.get_template("md_stats_template.jinja").render(name = result.name, stats = result.stats)}}
-<ul>
-{{result.render()}}
-</ul>
-</details>
+
+{% for  result in result_list %}
+<details>
+{{environment.get_template("md_stats_template.jinja").render(name = result.name, stats = result.stats)}}
+<ul>
+{{result.render()}}
+</ul>
+</details>
 {% endfor %}

mustrd/templates/md_stats_template.jinja

@@ -1,3 +1,3 @@
-<summary>
-{{name}}: <br/> total: {{stats.count}}, success: {{stats.success_count}}, fail: {{stats.fail_count}}, skipped: {{stats.skipped_count}}
+<summary>
+{{name}}: <br/> total: {{stats.count}}, success: {{stats.success_count}}, fail: {{stats.fail_count}}, skipped: {{stats.skipped_count}}
 </summary>

mustrd/test/test_mustrd.py

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

mustrd/utils.py

@@ -1,38 +1,38 @@
-"""
-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 json
-from pathlib import Path
-
-
-# Keep this function in a file directly under project root / src
-def get_mustrd_root() -> Path:
-    return Path(__file__).parent
-
-def is_json(myjson: str) -> bool:
-    try:
-        json.loads(myjson)
-    except ValueError:
-        return False
-    return True
+"""
+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 json
+from pathlib import Path
+
+
+# Keep this function in a file directly under project root / src
+def get_mustrd_root() -> Path:
+    return Path(__file__).parent
+
+def is_json(myjson: str) -> bool:
+    try:
+        json.loads(myjson)
+    except ValueError:
+        return False
+    return True

{mustrd-0.2.0.dist-info → mustrd-0.2.1.dist-info}/LICENSE

@@ -1,21 +1,21 @@
-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.
+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.

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

@@ -1,17 +1,18 @@
 Metadata-Version: 2.1
 Name: mustrd
-Version: 0.2.0
+Version: 0.2.1
 Summary: A Spec By Example framework for RDF and SPARQL, Inspired by Cucumber.
 Home-page: https://github.com/Semantic-partners/mustrd
 License: MIT
 Author: John Placek
 Author-email: john.placek@semanticpartners.com
-Requires-Python: ==3.11.7
+Requires-Python: >=3.11.7,<4.0.0
 Classifier: Framework :: Pytest
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Natural Language :: English
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Quality Assurance
 Classifier: Topic :: Software Development :: Testing
 Classifier: Topic :: Utilities
@@ -22,6 +23,7 @@ Requires-Dist: colorlog (>=6.7.0,<7.0.0)
 Requires-Dist: coverage (==7.4.3)
 Requires-Dist: flake8 (==7.0.0)
 Requires-Dist: multimethods-py (>=0.5.3,<0.6.0)
+Requires-Dist: numpy (>=1.26.0,<2.0.0)
 Requires-Dist: openpyxl (>=3.1.2,<4.0.0)
 Requires-Dist: pandas (>=1.5.2,<2.0.0)
 Requires-Dist: pyanzo (>=3.3.10,<4.0.0)

mustrd-0.2.1.dist-info/RECORD

@@ -0,0 +1,31 @@
+mustrd/README.adoc,sha256=kj1oGeOo4lkPP1VWSBIdG_A3BH10MA32zbKWZRRobiQ,12410
+mustrd/TestResult.py,sha256=MdDrPgdpXbLUmRXDaA4-mkklxOxJ0_mCSWIumvHsMdw,4850
+mustrd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mustrd/logger_setup.py,sha256=pNtG5egdd7OiFdn-Qx-tlf5JITka1yitbzYBpHzrP_4,1582
+mustrd/model/catalog-v001.xml,sha256=IEtaw3FK4KGQWKancEe1HqzUQTrKdk89vNxnoLKGF4o,381
+mustrd/model/mustrdShapes.ttl,sha256=6-W8onQBWOwAvsIYLRGOk2FePSp4SPFfWd7dSuNC5ho,9456
+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/test-resources/resources.ttl,sha256=1Dsp1nuNxauj9bxeX-HShQsiO-CVy5Irwm2y2x0cdjI,1498
+mustrd/model/triplestoreOntology.ttl,sha256=jK9zJOInlJ8uXzbAsQarBBrZgGrMrMXbrsuXGMbp020,6025
+mustrd/model/triplestoreshapes.ttl,sha256=VqdItpI9qFQSj4leZuwbIoAjWJehhR8bao0EPvtGMR0,1835
+mustrd/mustrd.py,sha256=VqKfceNXWoBBQ4PCspWA_3kpNoz1o1T7Gzj2R3RZvmo,34294
+mustrd/mustrdAnzo.py,sha256=1YyuAOlNecfoWRWgPIl9K5-gscE4ni4wNiTyU7gzxAM,11586
+mustrd/mustrdGraphDb.py,sha256=ySYYGvKUgXIS8QLLS7FEcppLlSb0qZ3lLlYzPf_Sr3Y,5474
+mustrd/mustrdRdfLib.py,sha256=CvrzEl1-lEPugYVe3y_Ip8JMzUxv6IeWauLOa_WA-XI,2073
+mustrd/mustrdTestPlugin.py,sha256=zA3iu59Hq-0fnYqAzfmUAEEPKEb50BGoJPrCjHMlmpA,14644
+mustrd/namespace.py,sha256=wM4yOJ_ftFghUXURruSovGos5dKvwQLFqr6whsXzItU,3640
+mustrd/run.py,sha256=sudrg26k5CKxwW8EkFhK7PLmK0SMk6b0s__GPkwYPqs,4274
+mustrd/spec_component.py,sha256=Jv1_jYEnRgqeCGCeU36euuuqSZL5ZLd9Cjb8mRbQ4UI,32614
+mustrd/steprunner.py,sha256=YKrMSYhethWCAQEI63hK6jXh3ljyoM87w7eHyoRd8rc,7389
+mustrd/templates/md_ResultList_leaf_template.jinja,sha256=IzwZjliCx7-viipATDQK6MQg_5q1kLMKdeNSZg1sXXY,508
+mustrd/templates/md_ResultList_template.jinja,sha256=_8joJ7vtw_qoqxv3HhUtBgRfhOeqmgfaRFwEo4MROvQ,203
+mustrd/templates/md_stats_template.jinja,sha256=96W62cMWu9UGLNv65ZQ8RYLjkxKHhJy-FlUtXgud6XY,155
+mustrd/test/test_mustrd.py,sha256=ImGwG6rBIgRo7v6js5rtt26pF5K1pBZgD_vAYgiNOps,125
+mustrd/utils.py,sha256=VLp8r7FtgFqKZdRSAhIHAawtWraBMn1BuYdtBRnGqaQ,1386
+mustrd-0.2.1.dist-info/LICENSE,sha256=r8nmh5fUct9h2w8_RDl13EIscvmwCLoarPr1kg35MnA,1078
+mustrd-0.2.1.dist-info/METADATA,sha256=aoswqG7pcGx1rk8RZJX7V4pklsoQO4laHIcw0T3yNj4,4227
+mustrd-0.2.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+mustrd-0.2.1.dist-info/entry_points.txt,sha256=v7V7sN0_L1aB4Ug_9io5axlQSeJ1C0tNrQWwdXdV58s,50
+mustrd-0.2.1.dist-info/RECORD,,