ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/radiance/src/common/pyradlib/pyrad_proc.py

Comparing src/common/pyradlib/pyrad_proc.py (file contents):
Revision 1.1 by schorsch, Mon Mar 28 17:52:11 2016 UTC vs.
Revision 1.2 by schorsch, Wed Mar 30 18:02:06 2016 UTC

#	Line 27 | Line 27 | class ProcMixin():
27		def __configure_subprocess(self):
28		'''Prevent subprocess module failure in frozen scripts on Windows.
29		Prevent console windows from popping up when not console based.
30	<	Make sure we use the version specific string types.
30	>	Make sure we use the version-specific string types.
31		'''
32		# On Windows, sys.stdxxx may not be available when:
33		# - built as *.exe with "pyinstaller --noconsole"
#	Line 66 | Line 66 | class ProcMixin():
66		return s
67		return  ' '.join([_q(s) for s in sl])
68
69	+	def __parse_args(self, _in, out):
70	+	try: self.__proc_mixin_setup
71	+	except AttributeError: self.__configure_subprocess()
72	+	instr = ''
73	+	if _in == PIPE:
74	+	stdin = _in
75	+	elif isinstance(_in, self._strtypes):
76	+	stdin = open(_in, 'rb')
77	+	instr = ' < "%s"' % _in
78	+	elif hasattr(_in, 'read'):
79	+	stdin = _in
80	+	instr = ' < "%s"' % _in.name
81	+	else: stdin = self._stdin
82	+	outstr = ''
83	+	if out == PIPE:
84	+	stdout = out
85	+	elif isinstance(out, self._strtypes):
86	+	stdout = open(out, 'wb')
87	+	outstr = ' > "%s"' % out
88	+	elif hasattr(out, 'write'):
89	+	stdout = out
90	+	outstr = ' > "%s"' % out.name
91	+	else: stdout = self._stdout
92	+	return stdin, stdout, instr, outstr
93	+
94		def call_one(self, cmdl, actstr, _in=None, out=None,
95		universal_newlines=False):
96		'''Create a single subprocess, possibly with an incoming and outgoing
#	Line 90 | Line 115 | class ProcMixin():
115		If _in or out is a PIPE, the caller should call p.wait() on the
116		returned Popen instance after writing to and closing it.
117		'''
118	<	try: self.__proc_mixin_setup
94	<	except AttributeError: self.__configure_subprocess()
95	<	if _in == PIPE: stdin = _in
96	<	elif isinstance(_in, self._strtypes): stdin = open(_in, 'rb')
97	<	elif hasattr(_in, 'read'): stdin = _in
98	<	else: stdin = self._stdin
99	<	if out == PIPE: stdout = out
100	<	elif isinstance(out, self._strtypes): stdout = open(out, 'wb')
101	<	elif hasattr(out, 'write'): stdout = out
102	<	else: stdout = self._stdout
103	<	displ = cmdl[:]
104	<	if isinstance(_in, self._strtypes): displ[:0] = [_in, '>']
105	<	if isinstance(out, self._strtypes): displ.extend(['>', out])
118	>	stdin, stdout, instr, outstr = self.__parse_args(_in, out)
119		if getattr(self, 'verbose', None):
120		sys.stderr.write('### %s \n' % actstr)
121	<	sys.stderr.write(self.qjoin(displ) + '\n')
121	>	sys.stderr.write(self.qjoin(cmdl) + instr + outstr + '\n')
122		if not getattr(self, 'donothing', None):
123	<	try: p = subprocess.Popen(cmdl, stdin=stdin, stdout=stdout,
124	<	stderr=self._stderr,
123	>	try: p = subprocess.Popen(cmdl,
124	>	stdin=stdin, stdout=stdout, stderr=self._stderr,
125		universal_newlines=universal_newlines, **self._pipeargs)
126		except Exception as e:
127		self.raise_on_error(actstr, str(e))
#	Line 118 | Line 131 | class ProcMixin():
131		if res != 0:
132		self.raise_on_error(actstr,
133		'Nonzero exit (%d) from command [%s].'
134	<	% (res, self.qjoin(displ)))
134	>	% (res, self.qjoin(cmdl)+instr+outstr+'\n'))
135		return p
136
137		def call_two(self, cmdl_1, cmdl_2, actstr_1, actstr_2, _in=None, out=None,
#	Line 131 | Line 144 | class ProcMixin():
144		If _in or out is PIPE, the caller should call p.wait() on both
145		returned popen instances after writing to and closing the first on .
146		'''
147	<	try: self.__proc_mixin_setup
135	<	except AttributeError: self.__configure_subprocess()
136	<	if _in == PIPE: stdin = _in
137	<	elif isinstance(_in, self._strtypes): stdin = open(_in, 'rb')
138	<	elif hasattr(_in, 'read'): stdin = _in
139	<	else: stdin = self._stdin
140	<	outendstr = '\n'
141	<	if out == PIPE:
142	<	stdout = out
143	<	elif isinstance(out, self._strtypes):
144	<	stdout = open(out, 'wb')
145	<	outendstr = ' > "%s"\n' % out
146	<	elif hasattr(out, 'write'):
147	<	stdout = out
148	<	outendstr = ' > "%s"\n' % out.name
149	<	else: stdout = self._stdout
147	>	stdin, stdout, instr, outstr = self.__parse_args(_in, out)
148		if getattr(self, 'verbose', None):
149		sys.stderr.write('### %s \n' % actstr_1)
150		sys.stderr.write('### %s \n' % actstr_2)
151	<	sys.stderr.write(self.qjoin(cmdl_1) + ' | ')
151	>	sys.stderr.write(self.qjoin(cmdl_1) + instr + ' | ')
152		if not getattr(self, 'donothing', None):
153	<	try: p1 = subprocess.Popen(cmdl_1, stdin=stdin,
154	<	stdout=PIPE, stderr=self._stderr, **self._pipeargs)
153	>	try: p1 = subprocess.Popen(cmdl_1,
154	>	stdin=stdin, stdout=PIPE, stderr=self._stderr,
155	>	**self._pipeargs)
156		except Exception as e:
157		self.raise_on_error(actstr_1, str(e))
158		if getattr(self, 'verbose', None):
159	<	sys.stderr.write(self.qjoin(cmdl_2) + outendstr)
159	>	sys.stderr.write(self.qjoin(cmdl_2) + outstr + '\n')
160		if not getattr(self, 'donothing', None):
161		try:
162	<	p2 = subprocess.Popen(cmdl_2, stdin=p1.stdout, stdout=stdout,
163	<	stderr=self._stderr,
162	>	p2 = subprocess.Popen(cmdl_2,
163	>	stdin=p1.stdout, stdout=stdout, stderr=self._stderr,
164		universal_newlines=universal_newlines, **self._pipeargs)
165		p1.stdout.close()
166		except Exception as e:
#	Line 180 | Line 179 | class ProcMixin():
179		% (res, self.qjoin(cmdl_2)))
180		return p1, p2
181
183	–
182		def call_many(self, cmdlines, actstr, _in=None, out=None,
183		universal_newlines=False):
184		'''Create a series of N processes, chained via pipes, possibly with an
#	Line 200 | Line 198 | class ProcMixin():
198		# other than direct call_one(), this returns a one-item tuple!
199		return (self.call_one(cmdlines[0], actstr, _in=_in, out=out,
200		universal_newlines=universal_newlines),)
201	<	try: self.__proc_mixin_setup
204	<	except AttributeError: self.__configure_subprocess()
205	<	if _in == PIPE: stdin = _in
206	<	elif isinstance(_in, self._strtypes): stdin = open(_in, 'rb')
207	<	elif hasattr(_in, 'read'): stdin = _in
208	<	else: stdin = self._stdin
209	<	outendstr = '\n'
210	<	if out == PIPE:
211	<	stdout = out
212	<	elif isinstance(out, self._strtypes):
213	<	stdout = open(out, 'wb')
214	<	outendstr = ' > "%s"\n' % out
215	<	elif hasattr(out, 'write'):
216	<	stdout = out
217	<	outendstr = ' > "%s"\n' % out.name
218	<	else: stdout = self._stdout
201	>	stdin, stdout, instr, outstr = self.__parse_args(_in, out)
202		procs = []
203		if getattr(self, 'verbose', None):
204		sys.stderr.write('### %s \n' % actstr)
205	<	sys.stderr.write(self.qjoin(cmdlines[0]) + ' | ')
205	>	sys.stderr.write(self.qjoin(cmdlines[0]) + instr + ' | ')
206		if not getattr(self, 'donothing', None):
207		try:
208		prevproc = subprocess.Popen(cmdlines[0], stdin=stdin,
#	Line 242 | Line 225 | class ProcMixin():
225		self.raise_on_error(actstr, str(e))
226
227		if getattr(self, 'verbose', None):
228	<	sys.stderr.write(self.qjoin(cmdlines[-1]) + outendstr)
228	>	sys.stderr.write(self.qjoin(cmdlines[-1]) + outstr + '\n')
229		if not getattr(self, 'donothing', None):
230		try:
231		lastproc = subprocess.Popen(cmdlines[-1], stdin=prevproc.stdout,

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)