wip

Author: aucampia

test/test_sparql/test_result.py

@@ -8,6 +8,7 @@
 from dataclasses import dataclass
 from io import BytesIO, StringIO
 from pathlib import Path
+from test.utils.result import ResultType
 from typing import (
     IO,
     BinaryIO,
@@ -111,11 +112,11 @@ def check_serialized(format: str, result: Result, data: str) -> None:
         assert result == parsed_result
 
 
-class ResultType(str, enum.Enum):
-    CONSTRUCT = "CONSTRUCT"
-    DESCRIBE = "DESCRIBE"
-    SELECT = "SELECT"
-    ASK = "ASK"
+# class ResultType(str, enum.Enum):
+#     CONSTRUCT = "CONSTRUCT"
+#     DESCRIBE = "DESCRIBE"
+#     SELECT = "SELECT"
+#     ASK = "ASK"
 
 
 class ResultFormatTrait(enum.Enum):

test/test_w3c_spec/test_sparql_w3c_new.py

@@ -4,12 +4,13 @@
 import logging
 from contextlib import ExitStack
 from dataclasses import dataclass, field
-from pathlib import Path
+from pathlib import Path, PurePath
 from test.data import TEST_DATA_DIR
 from test.utils import ensure_suffix
 from test.utils.iri import URIMapper, file_uri_to_path
 from test.utils.namespace import MF, QT, UT
 from test.utils.rdftest import Manifest, ManifestEntry, params_from_sources
+from test.utils.result import ResultType, ResultTypeTrait
 from typing import Dict, Optional, Set, Type, Union
 from urllib.parse import urljoin
 
@@ -19,6 +20,9 @@
 from rdflib.namespace import RDFS
 from rdflib.plugins.sparql.algebra import translateQuery, translateUpdate
 from rdflib.plugins.sparql.parser import parseQuery, parseUpdate
+from rdflib.plugins.sparql.results.graph import GraphResultParser
+from rdflib.plugins.sparql.results.rdfresults import RDFResultParser
+from rdflib.query import Result
 from rdflib.term import BNode, IdentifiedNode, Identifier, Literal, Node, URIRef
 from rdflib.util import guess_format
 
@@ -133,8 +137,7 @@ def from_graph(cls, graph: Graph, identifier: Identifier) -> "GraphData":
             raise ValueError(f"invalid identifier {identifier!r}")
 
     def load_into(self, manifest: Manifest, dataset: Dataset) -> None:
-        graph_local = manifest.uri_mapper.to_local(self.graph_id)
-        graph_path = file_uri_to_path(graph_local, Path)
+        graph_local, graph_path = manifest.uri_mapper.to_local(self.graph_id)
         graph_text = graph_path.read_text()
         public_id = self.label if self.label is not None else self.graph_id
         logging.debug(
@@ -237,14 +240,53 @@ def __post_init__(self) -> None:
     # def query(self) ->
 
 
+# class ResultType(enum.Enum):
+#     SELECT = "SELECT"
+#     ASK = "ASK"
+
+
+class ResultFileHelper:
+    extentions = {
+        "srx": "xml",
+        "srj": "json",
+        "csv": "csv",
+    }
+
+    # @classmethod
+    # def guess_format(cls, path: PurePath) -> Optional[str]:
+    #     return cls.extentions.get(path.suffix[1:], None)
+
+    @classmethod
+    def load_result(cls, uri_mapper: URIMapper, result_uri: str, type: str) -> Result:
+        result_local, result_path = uri_mapper.to_local(result_uri)
+        ext = result_path.suffix[1:]
+        format = cls.extentions.get(ext)
+        if format is not None:
+            with result_path.open("r") as tio:
+                return Result.parse(tio, format=format)
+        graph = Graph()
+        graph.parse(result_path, publicID=result_uri)
+        return RDFResultParser().parse(graph)
+
+        # if ResultTypeTrait.GRAPH_RESULT in ResultType.ASK.info.traits:
+        #     RDFResultParser
+
+        # format = cls.guess_format(path)
+        # if type in ("ASK", "SELECT"):
+        #     with path.open("r") as tio:
+        #         return Result.parse(tio, format=format)
+        # if type in ("DESCRIBE", "CONSTRUCT"):
+        #   with path.open("rb") as bio:
+        #         return GraphResultParser.parse(bio, format=format)
+
+
 BLANK_GRAPH = Graph()
 
 
 def check_syntax(entry: SPARQLEntry) -> None:
     assert entry.query is not None
     assert entry.type_info.query_type is not None
-    query_local = entry.manifest.uri_mapper.to_local(entry.query)
-    query_path = file_uri_to_path(query_local, Path)
+    query_local, query_path = entry.manifest.uri_mapper.to_local(entry.query)
     query_text = query_path.read_text()
     logging.debug("query = %s\n%s", query_path, query_text)
     catcher: Optional[pytest.ExceptionInfo[Exception]] = None
@@ -270,14 +312,14 @@ def check_update(entry: SPARQLEntry) -> None:
 def check_query(entry: SPARQLEntry) -> None:
     assert entry.query is not None
     # assert entry.action_data is not None or entry.action_graph_data is not None
-    query_local = entry.manifest.uri_mapper.to_local(entry.query)
-    query_path = file_uri_to_path(query_local, Path)
+    query_local, query_path = entry.manifest.uri_mapper.to_local(entry.query)
     query_text = query_path.read_text()
     logging.debug("query = %s\n%s", query_path, query_text)
     dataset = Dataset()
     if entry.action_data is not None:
-        action_data_local = entry.manifest.uri_mapper.to_local(entry.action_data)
-        action_data_path = file_uri_to_path(action_data_local, Path)
+        action_data_local, action_data_path = entry.manifest.uri_mapper.to_local(
+            entry.action_data
+        )
         action_data_text = action_data_path.read_text()
         logging.debug("action_data = %s\n%s", action_data_path, action_data_text)
         dataset.default_context.parse(

test/utils/iri.py

@@ -5,15 +5,13 @@
 
 # import logging
 from dataclasses import dataclass
-from pathlib import PurePath, PurePosixPath, PureWindowsPath
+from pathlib import Path, PurePath, PurePosixPath, PureWindowsPath
 from test.utils import ensure_suffix
 from typing import Callable, Optional, Set, Tuple, Type, TypeVar, Union
 from urllib.parse import quote, unquote, urlparse, urlsplit, urlunsplit
 
 from nturl2path import url2pathname as nt_url2pathname
 
-from rdflib.plugins.sparql.parser import Path
-
 PurePathT = TypeVar("PurePathT", bound=PurePath)
 
 
@@ -92,21 +90,24 @@ def from_tuple(cls, value: URIMappingTupleType) -> "URIMapping":
 class URIMapper:
     mappings: Set[URIMapping]
 
-    def to_local(self, remote: str) -> Path:
+    def to_local_uri(self, remote: str) -> Tuple[str, Path]:
         mapping: URIMapping
         for mapping in self.mappings:
             try:
-                return rebase_url(remote, mapping.remote, mapping.local)
+                file_uri = rebase_url(remote, mapping.remote, mapping.local)
+                file_path = file_uri_to_path(file_uri, Path)
+                return (file_uri, file_path)
             except ValueError:
                 # logging.debug("failed to map using %s", mapping, exc_info=True)
                 continue
         raise LookupError(f"could not map {remote} to local")
 
-    def to_remote(self, local: str) -> Path:
+    def to_remote(self, local: Union[str, PurePath]) -> str:
         mapping: URIMapping
+        local_uri = local.as_uri() if isinstance(local, PurePath) else local
         for mapping in self.mappings:
             try:
-                return rebase_url(local, mapping.local, mapping.remote)
+                return rebase_url(local_uri, mapping.local, mapping.remote)
             except ValueError:
                 # logging.debug("failed to map using %s", mapping, exc_info=True)
                 continue

test/utils/rdftest.py

@@ -149,6 +149,8 @@ def from_sources(
     ) -> Generator["Manifest", None, None]:
         for source in sources:
             source = GraphSource.from_source(source)
+            logging.error("source.path = %s", source.path)
+            logging.error("source.path.absolute() = %s", source.path.absolute())
             source_path_uri = source.path.absolute().as_uri()
             logging.debug("source_path_uri = %s", source_path_uri)
             local_base = urljoin(source_path_uri, ".")

test/utils/result.py

@@ -0,0 +1,46 @@
+import enum
+from dataclasses import dataclass
+from functools import lru_cache
+from typing import Dict, Set
+
+ResultTypeInfoDict = Dict["ResultType", "ResultTypeInfo"]
+
+
+class ResultTypeTrait(enum.Enum):
+    GRAPH_RESULT = enum.auto()
+
+
+class ResultType(str, enum.Enum):
+    CONSTRUCT = "CONSTRUCT"
+    DESCRIBE = "DESCRIBE"
+    SELECT = "SELECT"
+    ASK = "ASK"
+
+    @classmethod
+    @lru_cache(maxsize=None)
+    def info_dict(cls) -> "ResultTypeInfoDict":
+        return ResultTypeInfo.make_dict(
+            ResultTypeInfo(ResultType.CONSTRUCT, {ResultTypeTrait.GRAPH_RESULT}),
+            ResultTypeInfo(ResultType.DESCRIBE, {ResultTypeTrait.GRAPH_RESULT}),
+            ResultTypeInfo(ResultType.CONSTRUCT, set()),
+            ResultTypeInfo(ResultType.CONSTRUCT, set()),
+        )
+
+    @property
+    def info(self) -> "ResultTypeInfo":
+        return self.info_dict()[self]
+
+    @classmethod
+    @lru_cache(maxsize=None)
+    def set(cls) -> Set["ResultType"]:
+        return set(*cls)
+
+
+@dataclass(frozen=True)
+class ResultTypeInfo:
+    type: ResultType
+    traits: Set[ResultTypeTrait]
+
+    @classmethod
+    def make_dict(cls, *items: "ResultTypeInfo") -> ResultTypeInfoDict:
+        return dict((info.type, info) for info in items)