def process_ended(self, reason):
log.warning(f"renderer | process ended: {reason}")
if not self.terminated:
# Clear the filename on crash so it works when reset
#self.document = None
self.restart()
log.warning("renderer | stdout closed")
def refresh_view(self, change):
""" Refresh the compiled view object.
This method will (re)compile the view for the given view text
and update the 'compiled_view' attribute. If a compiled model
is available and the view has a member named 'model', the model
will be applied to the view.
"""
viewer = self.workbench.get_plugin('declaracad.viewer')
doc = self.active_document
try:
ast = parse(doc.source, filename=doc.name)
code = EnamlCompiler.compile(ast, doc.name)
module = ModuleType('__main__')
module.__file__ = doc.name
namespace = module.__dict__
with enaml.imports():
exec_(code, namespace)
assembly = namespace.get('Assembly', lambda: None)()
viewer.parts = [assembly] if assembly else []
except Exception as e:
errors = doc.errors[:]
log.warning(traceback.format_exc())
tb = traceback.format_exc().strip().split("\n")
print(tb[-3])
m = re.search(r'File "(.+)", line (\d+),', tb[-3])
if m:
errors.append("{}:{}: {}".format(m.group(1), m.group(2),
tb[-1]))
doc.errors = errors
viewer.parts = []
def data_received(self, data):
line = data.decode()
try:
response = jsonpickle.loads(line)
# log.debug(f"viewer | resp | {response}")
except Exception as e:
log.debug(f"viewer | out | {line.rstrip()}")
response = {}
doc = self.document
if not isinstance(response, dict):
log.debug(f"viewer | out | {response.rstrip()}")
return
#: Special case for startup
response_id = response.get('id')
if response_id == 'window_id':
self.window_id = response['result']
self.restarts = 0 # Clear the restart count
return
elif response_id == 'keep_alive':
return
elif response_id == 'invoke_command':
command_id = response.get('command_id')
parameters = response.get('parameters', {})
log.debug(f"viewer | out | {command_id}({parameters})")
self.plugin.workbench.invoke_command(command_id, parameters)
elif response_id == 'render_error':
if doc:
doc.errors.extend(response['error']['message'].split("\n"))
return
elif response_id == 'render_success':
if doc:
doc.errors = []
return
elif response_id == 'capture_output':
# Script output capture it
if doc:
doc.output = response['result'].split("\n")
return
elif response_id == 'shape_selection':
#: TODO: Do something with this?
if doc:
doc.output.append(str(response['result']))
return
elif response_id is not None:
# Lookup the deferred object that should be stored for this id
# when it is called and invoke the callback or errback based on the
# result
d = self._responses.get(response_id)
if d is not None:
del self._responses[response_id]
try:
error = response.get('error')
if error is not None:
if doc:
doc.errors.extend(
error.get('message', '').split("\n"))
d.add_done_callback(error)
else:
d.add_done_callback(response.get('result'))
return
except Exception as e:
log.warning("RPC response not properly handled!")
log.exception(e)
else:
log.warning("Got unexpected reply")
# else we got a response from something else, possibly an error?
if 'error' in response and doc:
doc.errors.extend(response['error'].get('message', '').split("\n"))
doc.output.append(line)
elif 'message' in response and doc:
doc.output.extend(response['message'].split("\n"))
elif doc:
# Append to output
doc.output.extend(line.split("\n"))
def processEnded(self, reason):
super(ViewerProcess, self).processEnded(reason)
log.warning(f"renderer | process ended: {reason}")
def errConnectionLost(self):
log.warning("renderer | stderr closed")
def outConnectionLost(self):
if not self.terminated:
# Clear the filename on crash so it works when reset
#self.document = None
self.restart()
log.warning("renderer | stdout closed")
def inConnectionLost(self):
log.warning("renderer | stdio closed (we probably did it)")
def outConnectionLost(self):
if not self.terminated:
self.restart()
log.warning("renderer | stdout closed")
