Source code

Download source archive ↓

src/rdflib/tools/rdfpipe.py

1#!/usr/bin/env python
2
3"""
4A commandline tool for parsing RDF in different formats and serializing the
5resulting graph to a chosen format.
6"""
7from __future__ import annotations
8
9import logging
10import sys
11from optparse import OptionParser
12from typing import BinaryIO, Optional
13
14import rdflib
15from rdflib import plugin
16from rdflib.graph import ConjunctiveGraph
17from rdflib.parser import Parser
18from rdflib.serializer import Serializer
19from rdflib.store import Store
20from rdflib.util import guess_format
21
22DEFAULT_INPUT_FORMAT = "xml"
23DEFAULT_OUTPUT_FORMAT = "n3"
24
25
26def parse_and_serialize(
27    input_files,
28    input_format,
29    guess,
30    outfile,
31    output_format,
32    ns_bindings,
33    store_conn="",
34    store_type=None,
35):
36    if store_type:
37        store = plugin.get(store_type, Store)()
38        store.open(store_conn)
39        graph = ConjunctiveGraph(store)
40    else:
41        store = None
42        graph = ConjunctiveGraph()
43
44    for prefix, uri in ns_bindings.items():
45        graph.namespace_manager.bind(prefix, uri, override=False)
46
47    for fpath in input_files:
48        use_format, kws = _format_and_kws(input_format)
49        if fpath == "-":
50            fpath = sys.stdin
51        elif not input_format and guess:
52            use_format = guess_format(fpath) or DEFAULT_INPUT_FORMAT
53        graph.parse(fpath, format=use_format, **kws)
54
55    if outfile:
56        output_format, kws = _format_and_kws(output_format)
57        kws.setdefault("base", None)
58        graph.serialize(destination=outfile, format=output_format, **kws)
59
60    if store:
61        store.rollback()
62
63
64def _format_and_kws(fmt):
65    """
66    ```python
67    >>> _format_and_kws("fmt")
68    ('fmt', {})
69    >>> _format_and_kws("fmt:+a")
70    ('fmt', {'a': True})
71    >>> _format_and_kws("fmt:a")
72    ('fmt', {'a': True})
73    >>> _format_and_kws("fmt:+a,-b") #doctest: +SKIP
74    ('fmt', {'a': True, 'b': False})
75    >>> _format_and_kws("fmt:c=d")
76    ('fmt', {'c': 'd'})
77    >>> _format_and_kws("fmt:a=b:c")
78    ('fmt', {'a': 'b:c'})
79
80    ```
81    """
82    fmt, kws = fmt, {}
83    if fmt and ":" in fmt:
84        fmt, kwrepr = fmt.split(":", 1)
85        for kw in kwrepr.split(","):
86            if "=" in kw:
87                k, v = kw.split("=")
88                kws[k] = v
89            elif kw.startswith("-"):
90                kws[kw[1:]] = False
91            elif kw.startswith("+"):
92                kws[kw[1:]] = True
93            else:  # same as "+"
94                kws[kw] = True
95    return fmt, kws
96
97
98def make_option_parser():
99    parser_names = _get_plugin_names(Parser)
100    serializer_names = _get_plugin_names(Serializer)
101    kw_example = "FORMAT:(+)KW1,-KW2,KW3=VALUE"
102
103    oparser = OptionParser(
104        "%prog [-h] [-i INPUT_FORMAT] [-o OUTPUT_FORMAT] "
105        + "[--ns=PFX=NS ...] [-] [FILE ...]",
106        description=__doc__.strip()
107        + (
108            " Reads file system paths, URLs or from stdin if '-' is given."
109            " The result is serialized to stdout."
110        ),
111        version="%prog " + "(using rdflib %s)" % rdflib.__version__,
112    )
113
114    oparser.add_option(
115        "-i",
116        "--input-format",
117        type=str,  # default=DEFAULT_INPUT_FORMAT,
118        help="Format of the input document(s)."
119        " Available input formats are: %s." % parser_names
120        + " If no format is given, it will be "
121        + "guessed from the file name extension."
122        + " Keywords to parser can be given after format like: %s." % kw_example,
123        metavar="INPUT_FORMAT",
124    )
125
126    oparser.add_option(
127        "-o",
128        "--output-format",
129        type=str,
130        default=DEFAULT_OUTPUT_FORMAT,
131        help="Format of the graph serialization."
132        " Available output formats are: %s." % serializer_names
133        + " Default format is: '%default'."
134        + " Keywords to serializer can be given after format like: %s." % kw_example,
135        metavar="OUTPUT_FORMAT",
136    )
137
138    oparser.add_option(
139        "--ns",
140        action="append",
141        type=str,
142        help="Register a namespace binding (QName prefix to a base URI). "
143        "This can be used more than once.",
144        metavar="PREFIX=NAMESPACE",
145    )
146
147    oparser.add_option(
148        "--no-guess",
149        dest="guess",
150        action="store_false",
151        default=True,
152        help="Don't guess format based on file suffix.",
153    )
154
155    oparser.add_option(
156        "--no-out",
157        action="store_true",
158        default=False,
159        help="Don't output the resulting graph "
160        + "(useful for checking validity of input).",
161    )
162
163    oparser.add_option(
164        "-w",
165        "--warn",
166        action="store_true",
167        default=False,
168        help="Output warnings to stderr (by default only critical errors).",
169    )
170
171    return oparser
172
173
174def _get_plugin_names(kind):
175    return ", ".join(p.name for p in plugin.plugins(kind=kind))
176
177
178def main():
179    oparser = make_option_parser()
180    opts, args = oparser.parse_args()
181    if len(args) < 1:
182        oparser.print_usage()
183        oparser.exit()
184
185    if opts.warn:
186        loglevel = logging.WARNING
187    else:
188        loglevel = logging.CRITICAL
189    logging.basicConfig(level=loglevel)
190
191    ns_bindings = {}
192    if opts.ns:
193        for ns_kw in opts.ns:
194            pfx, uri = ns_kw.split("=")
195            ns_bindings[pfx] = uri
196
197    outfile: Optional[BinaryIO] = sys.stdout.buffer
198
199    if opts.no_out:
200        outfile = None
201
202    parse_and_serialize(
203        args, opts.input_format, opts.guess, outfile, opts.output_format, ns_bindings
204    )
205
206
207if __name__ == "__main__":
208    main()