Source code

Download source archive ↓

src/rdflib/plugins/sparql/results/txtresults.py

1from __future__ import annotations
2
3from io import StringIO
4from typing import IO, List, Optional, Union
5
6from rdflib.namespace import NamespaceManager
7from rdflib.query import ResultSerializer
8from rdflib.term import BNode, Literal, URIRef, Variable
9
10
11def _termString(
12    t: Optional[Union[URIRef, Literal, BNode]],
13    namespace_manager: Optional[NamespaceManager],
14) -> str:
15    if t is None:
16        return "-"
17    if namespace_manager:
18        if isinstance(t, URIRef):
19            return namespace_manager.normalizeUri(t)
20        elif isinstance(t, BNode):
21            return t.n3()
22        elif isinstance(t, Literal):
23            return t._literal_n3(qname_callback=namespace_manager.normalizeUri)
24    else:
25        return t.n3()
26
27
28class TXTResultSerializer(ResultSerializer):
29    """
30    A write-only QueryResult serializer for text/ascii tables
31    """
32
33    def serialize(
34        self,
35        stream: IO,
36        encoding: str = "utf-8",
37        *,
38        namespace_manager: Optional[NamespaceManager] = None,
39        **kwargs,
40    ) -> None:
41        """
42        return a text table of query results
43        """
44
45        def c(s, w):
46            """
47            center the string s in w wide string
48            """
49            w -= len(s)
50            h1 = h2 = w // 2
51            if w % 2:
52                h2 += 1
53            return " " * h1 + s + " " * h2
54
55        if self.result.type != "SELECT":
56            raise Exception("Can only pretty print SELECT results!")
57        string_stream = StringIO()
58        if not self.result:
59            string_stream.write("(no results)\n")
60        else:
61            keys: List[Variable] = self.result.vars  # type: ignore[assignment]
62            maxlen = [0] * len(keys)
63            b = [
64                # type error: Value of type "Union[Tuple[Node, Node, Node], bool, ResultRow]" is not indexable
65                # type error: Argument 1 to "_termString" has incompatible type "Union[Node, Any]"; expected "Union[URIRef, Literal, BNode, None]"  [arg-type]
66                # type error: No overload variant of "__getitem__" of "tuple" matches argument type "Variable"
67                # NOTE on type error: The problem here is that r can be more types than _termString expects because result can be a result of multiple types.
68                [_termString(r[k], namespace_manager) for k in keys]  # type: ignore[index, arg-type, call-overload]
69                for r in self.result
70            ]
71            for r in b:
72                for i in range(len(keys)):
73                    maxlen[i] = max(maxlen[i], len(r[i]))
74            string_stream.write(
75                "|".join([c(k, maxlen[i]) for i, k in enumerate(keys)]) + "\n"
76            )
77            string_stream.write("-" * (len(maxlen) + sum(maxlen)) + "\n")
78            for r in sorted(b):
79                string_stream.write(
80                    "|".join([t + " " * (i - len(t)) for i, t in zip(maxlen, r)]) + "\n"
81                )
82        text_val = string_stream.getvalue()
83        try:
84            stream.write(text_val.encode(encoding))
85        except (TypeError, ValueError):
86            stream.write(text_val)