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()