def wait(self):
"""Wait for the module to finish. Call this method if
the run() call was performed with self.false_ = False.
:return: A reference to this object
"""
if self._finished is False:
if self.stdin:
self.stdin = encode(self.stdin)
stdout, stderr = self._popen.communicate(input=self.stdin)
self.outputs["stdout"].value = decode(stdout) if stdout else ""
self.outputs["stderr"].value = decode(stderr) if stderr else ""
self.time = time.time() - self.start_time
self.returncode = self._popen.returncode
self._finished = True
if self._popen.poll():
raise CalledModuleError(
returncode=self._popen.returncode,
code=self.get_bash(),
module=self.name,
errors=stderr,
)
self._popen = None
return self
def ReloadCurrentMapset(self):
"""Reload current mapset tree only."""
def get_first_child(node):
try:
child = mapsetItem.children[0]
except IndexError:
child = None
return child
genv = gisenv()
locationItem, mapsetItem = self.GetCurrentLocationMapsetNode()
if not locationItem or not mapsetItem:
return
if mapsetItem.children:
node = get_first_child(mapsetItem)
while node:
self._model.RemoveNode(node)
node = get_first_child(mapsetItem)
q = Queue()
p = Process(target=getLocationTree,
args=(genv['GISDBASE'], locationItem.data['name'], q,
mapsetItem.data['name']))
p.start()
maps, error = q.get()
if error:
raise CalledModuleError(error)
self._populateMapsetItem(mapsetItem, maps[mapsetItem.data['name']])
self._orig_model = copy.deepcopy(self._model)
self.RefreshNode(mapsetItem)
self.RefreshItems()
def run(self):
"""Run the module
:param node:
:type node:
This function will wait for the process to terminate in case
finish_==True and sets up stdout and stderr. If finish_==False this
function will return after starting the process. Use
self.popen.communicate() of self.popen.wait() to wait for the process
termination. The handling of stdout and stderr must then be done
outside of this function.
"""
G_debug(1, self.get_bash())
if self.inputs['stdin'].value:
self.stdin = self.inputs['stdin'].value
self.stdin_ = PIPE
cmd = self.make_cmd()
start = time.time()
self.popen = Popen(cmd,
stdin=self.stdin_,
stdout=self.stdout_,
stderr=self.stderr_,
env=self.env_)
if self.finish_:
stdout, stderr = self.popen.communicate(input=self.stdin)
self.outputs['stdout'].value = stdout if stdout else ''
self.outputs['stderr'].value = stderr if stderr else ''
self.time = time.time() - start
if self.popen.poll():
raise CalledModuleError(returncode=self.popen.returncode,
code=self.get_bash(),
module=self.name, errors=stderr)
return self
def call_module(module,
stdin=None,
merge_stderr=False,
capture_stdout=True,
capture_stderr=True,
**kwargs):
r"""Run module with parameters given in `kwargs` and return its output.
>>> print (call_module('g.region', flags='pg')) # doctest: +ELLIPSIS
projection=...
zone=...
n=...
s=...
w=...
>>> call_module('m.proj', flags='i', input='-', stdin="50.0 41.5")
'8642890.65|6965155.61|0.00\n'
>>> call_module('g.region', aabbbccc='notexist') # doctest: +IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
...
CalledModuleError: Module run g.region ... ended with error
If `stdin` is not set and `kwargs` contains ``input`` with value set
to ``-`` (dash), the function raises an error.
Note that ``input`` nor ``output`` parameters are used by this
function itself, these are usually module parameters which this
function just passes to it. However, when ``input`` is in parameters
the function checks if its values is correct considering value of
``stdin`` parameter.
:param str module: module name
:param stdin: string to be used as module standard input (stdin) or `None`
:param merge_stderr: if the standard error output should be merged with stdout
:param kwargs: module parameters
:returns: module standard output (stdout) as string or None if apture_stdout is False
:raises CalledModuleError: if module return code is non-zero
:raises ValueError: if the parameters are not correct
.. note::
The data read is buffered in memory, so do not use this method
if the data size is large or unlimited.
"""
# TODO: remove this:
do_doctest_gettext_workaround()
# implementation inspired by subprocess.check_output() function
if stdin:
if 'input' in kwargs and kwargs['input'] != '-':
raise ValueError(
_("input='-' must be used when stdin is specified"))
if stdin == subprocess.PIPE:
raise ValueError(_("stdin must be string or buffer, not PIPE"))
kwargs['stdin'] = subprocess.PIPE # to be able to send data to stdin
elif 'input' in kwargs and kwargs['input'] == '-':
raise ValueError(_("stdin must be used when input='-'"))
if merge_stderr and not (capture_stdout and capture_stderr):
raise ValueError(
_("You cannot merge stdout and stderr and not capture them"))
if 'stdout' in kwargs:
raise TypeError(
_("stdout argument not allowed, it could be overridden"))
if 'stderr' in kwargs:
raise TypeError(
_("stderr argument not allowed, it could be overridden"))
if capture_stdout:
kwargs['stdout'] = subprocess.PIPE
if capture_stderr:
if merge_stderr:
kwargs['stderr'] = subprocess.STDOUT
else:
kwargs['stderr'] = subprocess.PIPE
process = start_command(module, **kwargs)
# input=None means no stdin (our default)
# for no stdout, output is None which is out interface
# for stderr=STDOUT or no stderr, errors is None
# which is fine for CalledModuleError
output, errors = process.communicate(
input=encode(decode(stdin)) if stdin else None)
returncode = process.poll()
if returncode:
raise CalledModuleError(returncode, module, kwargs, errors)
return decode(output) if output else None
