1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
|
# coding=utf-8
#
# Copyright (C) 2019 Martin Owens
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA.
#
"""
This API provides methods for calling Inkscape to execute a given
Inkscape command. This may be needed for various compiling options
(e.g., png), running other extensions or performing other options only
available via the shell API.
Best practice is to avoid using this API except when absolutely necessary,
since it is resource-intensive to invoke a new Inkscape instance.
However, in any circumstance when it is necessary to call Inkscape, it
is strongly recommended that you do so through this API, rather than calling
it yourself, to take advantage of the security settings and testing functions.
"""
import os
from subprocess import Popen, PIPE
from lxml.etree import ElementTree
from .utils import TemporaryDirectory, PY3
from .elements import SvgDocumentElement
INKSCAPE_EXECUTABLE_NAME = os.environ.get('INKSCAPE_COMMAND', 'inkscape')
class CommandNotFound(IOError):
"""Command is not found"""
pass
class ProgramRunError(ValueError):
"""Command returned non-zero output"""
pass
def which(program):
"""
Attempt different methods of trying to find if the program exists.
"""
if os.path.isabs(program) and os.path.isfile(program):
return program
try:
# Python2 and python3, but must have distutils and may not always
# work on windows versions (depending on the version)
from distutils.spawn import find_executable
prog = find_executable(program)
if prog:
return prog
except ImportError:
pass
try:
# Python3 only version of which
from shutil import which as warlock
prog = warlock(program)
if prog:
return prog
except ImportError:
pass # python2
# There may be other methods for doing a `which` command for other
# operating systems; These should go here as they are discovered.
raise CommandNotFound("Can not find the command: '{}'".format(program))
def write_svg(svg, *filename):
"""Writes an svg to the given filename"""
filename = os.path.join(*filename)
if os.path.isfile(filename):
return filename
with open(filename, 'wb') as fhl:
if isinstance(svg, SvgDocumentElement):
svg = ElementTree(svg)
if hasattr(svg, 'write'):
# XML document
svg.write(fhl)
elif isinstance(svg, bytes):
fhl.write(svg)
else:
raise ValueError("Not sure what type of SVG data this is.")
return filename
def to_arg(arg, oldie=False):
"""Convert a python argument to a command line argument"""
if isinstance(arg, (tuple, list)):
(arg, val) = arg
arg = '-' + arg
if len(arg) > 2 and not oldie:
arg = '-' + arg
if val is True:
return arg
if val is False:
return None
return '{}={}'.format(arg, str(val))
return str(arg)
def to_args(prog, *positionals, **arguments):
"""
Convert positional arguments and key word arguments
into a list of strings which Popen will understand.
Values can be:
args = *[
'strait_up_string',
'--or_manual_kwarg=1',
('ordered list', 'version of kwargs (as below)'),
...
]
kwargs = **{
'name': 'val', # --name="val"'
'name': ['foo', 'bar'], # --name=foo --name=bar
'name': True, # --name
'n': 'v', # -n=v
'n': True, # -n
}
All args appear after the kwargs, so if you need args before,
use the ordered list tuple and don't use kwargs.
"""
args = [prog]
oldie = arguments.pop('oldie', False)
for arg, value in arguments.items():
arg = arg.replace('_', '-').strip()
if isinstance(value, tuple):
value = list(value)
elif not isinstance(value, list):
value = [value]
for val in value:
args.append(to_arg((arg, val), oldie))
args += [to_arg(pos, oldie) for pos in positionals if pos is not None]
# Filter out empty non-arguments
return [arg for arg in args if arg is not None]
def _call(program, *args, **kwargs):
stdin = kwargs.pop('stdin', None)
if PY3 and isinstance(stdin, str):
stdin = stdin.encode('utf-8')
inpipe = PIPE if stdin else None
args = to_args(which(program), *args, **kwargs)
process = Popen(
args,
shell=False, # Never have shell=True
stdin=inpipe, # StdIn not used (yet)
stdout=PIPE, # Grab any output (return it)
stderr=PIPE, # Take all errors, just incase
)
(stdout, stderr) = process.communicate(input=stdin)
if process.returncode == 0:
return stdout
raise ProgramRunError("Return Code: {}: {}\n{}\nargs: {}".format(
process.returncode, stderr, stdout, args))
def call(program, *args, **kwargs):
"""
Generic caller to open any program and return its stdout.
stdout = call('executable', arg1, arg2, dash_dash_arg='foo', d=True, ...)
Will raise ProgramRunError() if return code is not 0.
"""
return _call(program, *args, **kwargs)
def inkscape(svg_file, *args, **kwargs):
"""
Call Inkscape with the given svg_file and the given arguments
"""
return call(INKSCAPE_EXECUTABLE_NAME, svg_file, *args, **kwargs)
def inkscape_command(svg, select=None, verbs=()):
"""
Executes a list of commands, a mixture of verbs, selects etc.
inkscape_command('<svg...>', ('verb', 'VerbName'), ...)
"""
with TemporaryDirectory(prefix='inkscape-command') as dirname:
svg_file = write_svg(svg, dirname, 'input.svg')
select = ('select', select) if select else None
verbs += ('FileSave', 'FileQuit')
inkscape(svg_file, select, batch_process=True, verb=';'.join(verbs))
with open(svg_file, 'rb') as fhl:
return fhl.read()
def take_snapshot(svg, dirname, name='snapshot', ext='png', dpi=96, **kwargs):
"""
Take a snapshot of the given svg file.
Resulting filename is yielded back, after generator finishes, the
file is deleted so you must deal with the file inside the for loop.
"""
svg_file = write_svg(svg, dirname, name + '.svg')
ext_file = os.path.join(dirname, name + '.' + str(ext).lower())
inkscape(svg_file, export_dpi=dpi, export_filename=ext_file, export_type=ext, **kwargs)
return ext_file
def is_inkscape_available():
"""Return true if the Inkscape executable is available."""
try:
return bool(which(INKSCAPE_EXECUTABLE_NAME))
except CommandNotFound:
return False
|
