From ce43114e71031ae2c4a3e1bb20fe438199059516 Mon Sep 17 00:00:00 2001 From: Alex Nelson Date: Tue, 28 Sep 2021 16:51:22 -0400 Subject: [PATCH 1/2] Bump rdflib dependency to 6.0.1, deprecating local guess_format rdflib 6.0.1 upgraded `guess_format()` to report JSON-LD (via PRs 1403 and 1408). With the functionality upstream, this patch moves towards completing tech. transfer by deprecating the local implementation. References: * https://github.com/RDFLib/rdflib/pull/1403 * https://github.com/RDFLib/rdflib/pull/1408 Signed-off-by: Alex Nelson --- case_utils/__init__.py | 28 ++++----------------------- setup.cfg | 2 +- tests/case_utils/test_guess_format.py | 2 -- 3 files changed, 5 insertions(+), 27 deletions(-) diff --git a/case_utils/__init__.py b/case_utils/__init__.py index 0190a05..ee43a52 100644 --- a/case_utils/__init__.py +++ b/case_utils/__init__.py @@ -13,33 +13,13 @@ __version__ = "0.2.1" +import warnings + import rdflib.util from . import local_uuid def guess_format(fpath, fmap=None): - """ - This function is a wrapper around rdflib.util.guess_format(), adding that the .json extension should be recognized as JSON-LD. - - :param fpath: File path. - :type fpath: string - - :param fmap: Mapper dictionary; see rdflib.util.guess_format() for further description. Note that as in rdflib 5.0.0, supplying this argument overwrites, not augments, the suffix format map used by rdflib. - :type fmap: dict - - :returns: RDF file format, fit for rdflib.Graph.parse() or .serialize(); or, None if file extension not mapped. - :rtype: string - """ - - assert fmap is None or isinstance(fmap, dict), "Type check failed" - - if fmap is None: - updated_fmap = {key:rdflib.util.SUFFIX_FORMAT_MAP[key] for key in rdflib.util.SUFFIX_FORMAT_MAP} - if not "json" in updated_fmap: - updated_fmap["json"] = "json-ld" - if not "jsonld" in updated_fmap: - updated_fmap["jsonld"] = "json-ld" - else: - updated_fmap = {k:fmap[k] for k in fmap} + warnings.warn("The functionality in case_utils.guess_format is now upstream. Please revise your code to use rdflib.util.guess_format. The function arguments remain the same. case_utils.guess_format will be removed in case_utils 0.4.0.", DeprecationWarning) - return rdflib.util.guess_format(fpath, updated_fmap) + return rdflib.util.guess_format(fpath, fmap) diff --git a/setup.cfg b/setup.cfg index 66d100d..ca1a136 100644 --- a/setup.cfg +++ b/setup.cfg @@ -20,7 +20,7 @@ classifiers = install_requires = pandas pyparsing < 3.0.0 - rdflib >= 6.0.0 + rdflib >= 6.0.1 requests tabulate packages = find: diff --git a/tests/case_utils/test_guess_format.py b/tests/case_utils/test_guess_format.py index d54f4aa..d33bea5 100644 --- a/tests/case_utils/test_guess_format.py +++ b/tests/case_utils/test_guess_format.py @@ -38,11 +38,9 @@ def test_rdflib_util_guess_format_ttl_default(): def test_rdflib_util_guess_format_ttl_fmap(): assert rdflib.util.guess_format(PATH_TO_TTL, FMAP_XHTML_GRDDL) == "turtle", "Failed to recognize .ttl RDF file extension when using fmap" -@pytest.mark.xfail(reason="rdflib 5.0.0 known to not recognize .json", strict=True) def test_rdflib_util_guess_format_json(): assert rdflib.util.guess_format(PATH_TO_JSON) == "json-ld", "Failed to recognize .json RDF file extension" -@pytest.mark.xfail(reason="rdflib 5.0.0 known to not recognize .jsonld", strict=True) def test_rdflib_util_guess_format_jsonld(): assert rdflib.util.guess_format(PATH_TO_JSONLD) == "json-ld", "Failed to recognize .jsonld RDF file extension" From eeae6acf964f8041ff73e0aaa3670a6a27997534 Mon Sep 17 00:00:00 2001 From: Alex Nelson Date: Tue, 28 Sep 2021 16:57:04 -0400 Subject: [PATCH 2/2] Remove 'format=' parameter from graph parse() and serialize() calls rdflib 6.0.0 improved filename-based format recognition. (Tests for recognition were upgraded to support JSON-LD in PR 1408.) This patch removes explicit-but-redundant functionality. References: * https://github.com/RDFLib/rdflib/pull/1408 Signed-off-by: Alex Nelson --- case_utils/case_sparql_construct/__init__.py | 2 +- case_utils/case_sparql_select/__init__.py | 2 +- tests/case_file/test_case_file.py | 2 +- tests/case_sparql_construct/test_case_sparql_construct.py | 2 +- tests/src/glom_graph.py | 4 ++-- tests/src/isomorphic_diff.py | 4 ++-- 6 files changed, 8 insertions(+), 8 deletions(-) diff --git a/case_utils/case_sparql_construct/__init__.py b/case_utils/case_sparql_construct/__init__.py index 4eaeceb..fcc9434 100644 --- a/case_utils/case_sparql_construct/__init__.py +++ b/case_utils/case_sparql_construct/__init__.py @@ -41,7 +41,7 @@ def main(): in_graph = rdflib.Graph() for in_graph_filename in args.in_graph: - in_graph.parse(in_graph_filename, format=case_utils.guess_format(in_graph_filename)) + in_graph.parse(in_graph_filename) _logger.debug("len(in_graph) = %d.", len(in_graph)) out_graph = rdflib.Graph() diff --git a/case_utils/case_sparql_select/__init__.py b/case_utils/case_sparql_select/__init__.py index 357e3b0..d3d6f51 100644 --- a/case_utils/case_sparql_select/__init__.py +++ b/case_utils/case_sparql_select/__init__.py @@ -55,7 +55,7 @@ def main(): graph = rdflib.Graph() for in_graph_filename in args.in_graph: - graph.parse(in_graph_filename, format=case_utils.guess_format(in_graph_filename)) + graph.parse(in_graph_filename) # Inherit prefixes defined in input context dictionary. nsdict = {k:v for (k,v) in graph.namespace_manager.namespaces()} diff --git a/tests/case_file/test_case_file.py b/tests/case_file/test_case_file.py index 6f71727..8d3bd10 100644 --- a/tests/case_file/test_case_file.py +++ b/tests/case_file/test_case_file.py @@ -39,7 +39,7 @@ def load_graph(filename): in_graph = rdflib.Graph() - in_graph.parse(filename, format=rdflib.util.guess_format(filename)) + in_graph.parse(filename) return in_graph @pytest.fixture diff --git a/tests/case_sparql_construct/test_case_sparql_construct.py b/tests/case_sparql_construct/test_case_sparql_construct.py index 9eb2002..68f6757 100644 --- a/tests/case_sparql_construct/test_case_sparql_construct.py +++ b/tests/case_sparql_construct/test_case_sparql_construct.py @@ -23,7 +23,7 @@ def _test_templates_with_blank_nodes_result(filename): ground_truth_negative = set() graph = rdflib.Graph() - graph.parse(filename, format=case_utils.guess_format(filename)) + graph.parse(filename) computed = set() query_string = """\ diff --git a/tests/src/glom_graph.py b/tests/src/glom_graph.py index 6e5829b..cf101ab 100644 --- a/tests/src/glom_graph.py +++ b/tests/src/glom_graph.py @@ -24,8 +24,8 @@ def main(): g = rdflib.Graph() for in_graph in args.in_graph: - g.parse(in_graph, format=case_utils.guess_format(in_graph)) - g.serialize(args.out_graph, format=case_utils.guess_format(args.out_graph)) + g.parse(in_graph) + g.serialize(args.out_graph) if __name__ == "__main__": import argparse diff --git a/tests/src/isomorphic_diff.py b/tests/src/isomorphic_diff.py index aba8a48..02b411c 100644 --- a/tests/src/isomorphic_diff.py +++ b/tests/src/isomorphic_diff.py @@ -52,8 +52,8 @@ def main(): g1 = rdflib.Graph() g2 = rdflib.Graph() - g1.parse(args.in_graph_1, format=case_utils.guess_format(args.in_graph_1)) - g2.parse(args.in_graph_2, format=case_utils.guess_format(args.in_graph_2)) + g1.parse(args.in_graph_1) + g2.parse(args.in_graph_2) #_logger.debug("type(g1) = %r.", type(g1)) #_logger.debug("type(g2) = %r.", type(g2))