| ############################################################################### |
| # Copyright (c) 2016 Kichwa Coders and others. |
| # All rights reserved. This program and the accompanying materials |
| # are made available under the terms of the Eclipse Public License v2.0 |
| # which accompanies this distribution, and is available at |
| # https://www.eclipse.org/legal/epl-2.0/ |
| # |
| # Contributors: |
| # Jonah Graham (Kichwa Coders) - initial API and implementation |
| ############################################################################### |
| import sys as _pyease_sys |
| if __name__ == '__main__': |
| # To be able to import all the py4j and related items, we need to add to the PYTHONPATH |
| # all the correct paths. Because we may be launched with -E, the command line provides |
| # all the paths to what we need. |
| # sys.argv[1] - required - the port to conenct o |
| # sys.argv[2:] - optional - paths to prepend on sys.path |
| _pyease_sys.path[0:0] = _pyease_sys.argv[2:] |
| |
| import code as _pyease_code |
| import os as _pyease_os |
| import py4j |
| from py4j.clientserver import ClientServer as _pyease_ClientServer |
| from py4j.clientserver import JavaParameters as _pyease_JavaParameters |
| from py4j.clientserver import PythonParameters as _pyease_PythonParameters |
| from py4j.java_collections import MapConverter as _pyease_MapConverter |
| from py4j.java_collections import ListConverter as _pyease_ListConverter |
| from py4j.java_collections import SetConverter as _pyease_SetConverter |
| from py4j.java_gateway import JavaObject as _pyease_JavaObject |
| from py4j.java_gateway import JavaClass as _pyease_JavaClass |
| from py4j.protocol import Py4JJavaError as _pyease_Py4JJavaError |
| import threading as _pyease_threading |
| import __main__ |
| import ast as _pyease_ast |
| try: |
| from six import integer_types as _pyease_integer_types |
| from six import string_types as _pyease_string_types |
| except ImportError: |
| if _pyease_sys.version_info.major == 2: |
| _pyease_integer_types = (int, long) |
| _pyease_string_types = (basestring,) |
| else: |
| _pyease_integer_types = (int,) |
| _pyease_string_types = (str,) |
| |
| # builtins used to set global variables |
| try: |
| # Python 3.* |
| import builtins as _pyease_builtins |
| except ImportError: |
| # Python 2.* |
| _pyease_builtins = __builtins__ |
| |
| |
| def _pyease_patch_builtins(name, value): |
| ''' |
| Patches Python builtins to make given value available as a builtin |
| Python object in all modules. |
| |
| :param name: Name of the builtin |
| :type name: str |
| :param value: Value for the builtin |
| :type value: object |
| ''' |
| _pyease_builtins.__dict__.update({name: value}) |
| |
| |
| # To ease some debugging of the py4j engine itself it is useful to turn logging on, |
| # uncomment the following lines for one way to do that |
| # import logging |
| # logger = logging.getLogger("py4j") |
| # logger.setLevel(logging.DEBUG) |
| # logger.addHandler(logging.StreamHandler()) |
| def convert_value( |
| value, |
| gw=None, |
| integer_types=_pyease_integer_types, |
| string_types=_pyease_string_types, |
| dict_types=dict, |
| list_types=list, |
| set_types=set): |
| ''' |
| Tries to convert the given value using different strategies. |
| |
| Used because default py4j converters have some issues with e.g. |
| nested collections. |
| |
| :param value: Value to be converted. |
| :param gw: py4j gateway necessary for converters. |
| ''' |
| if not gw: |
| gw = gateway._gateway_client |
| |
| # None will be mapped to Java null |
| if value is None: |
| return value |
| |
| # Integers can be send directly |
| if isinstance(value, integer_types): |
| if (value > java.lang.Long.MAX_VALUE) or (value < java.lang.Long.MIN_VALUE): |
| return java.math.BigInteger(str(value)) |
| |
| return value |
| |
| # Floats can be send directly |
| if isinstance(value, float): |
| return value |
| |
| # Strings can be send directly |
| if isinstance(value, string_types): |
| return value |
| |
| # Recursively check collections |
| if isinstance(value, dict_types): |
| return _pyease_MapConverter().convert({ |
| convert_value(k, gw): convert_value(v, gw) |
| for k, v in value.items() |
| }, gw) |
| if isinstance(value, list_types): |
| return _pyease_ListConverter().convert([ |
| convert_value(v, gw) for v in value |
| ], gw) |
| if isinstance(value, set_types): |
| return _pyease_SetConverter().convert({ |
| convert_value(v, gw) for v in value |
| }, gw) |
| |
| # Try registered converters |
| for converter in gw.converters: |
| if converter.can_convert(value): |
| try: |
| return converter.convert(value, gw) |
| except Exception: |
| # TODO: Actually find out what this might throw |
| pass |
| |
| # Issues with marshalling Java class objects |
| if isinstance(value, _pyease_JavaClass): |
| return repr(value) |
| |
| # Check if we have a Java object |
| if isinstance(value, _pyease_JavaObject): |
| return value |
| |
| # Check if we implement a Java interface |
| if hasattr(value, 'Java') and hasattr(getattr(value, 'Java'), 'implements'): |
| if hasattr(value, '_get_obj_id'): |
| if callable(value._get_obj_id): |
| return value |
| else: |
| # Issue with invalid implementations |
| if hasattr(value, 'toString'): |
| return value |
| |
| # Last resort use string representation |
| return repr(value) |
| |
| convert_value.__ease__ = True |
| |
| class _pyease_EaseInteractiveConsole(_pyease_code.InteractiveConsole): |
| ''' |
| Extension to standard InteractiveConsole so we can handle and capture |
| error output better |
| ''' |
| |
| def __init__(self, engine, *args, **kwargs): |
| _pyease_code.InteractiveConsole.__init__(self, *args, **kwargs) |
| self.engine = engine |
| |
| def write(self, data): |
| # Python 3 write the whole error in one write, Python 2 does multiple writes |
| if self.engine.except_data is None: |
| self.engine.except_data = [data] |
| else: |
| self.engine.except_data.append(data) |
| |
| def runcode(self, code, filename=None): |
| filename = filename or '<...>' |
| try: |
| # If we have compiled code we cannot use AST |
| if isinstance(code, _pyease_string_types): |
| # Parse code input |
| tree = _pyease_ast.parse(code) |
| |
| # Check if we have multiline statement |
| if len(tree.body) > 1: |
| module = _pyease_ast.Module(tree.body[:-1], type_ignores=[]) |
| compiled = compile(module, filename, 'exec') |
| exec(compiled, self.locals) |
| |
| # Check if at least one line given |
| if len(tree.body): |
| if isinstance(tree.body[-1], _pyease_ast.Expr): |
| # Only expressions can be evaluated |
| expression = _pyease_ast.Expression(tree.body[-1].value) |
| compiled = compile(expression, filename, 'eval') |
| result = eval(compiled, self.locals) |
| return result, False |
| else: |
| module = _pyease_ast.Module([tree.body[-1]], type_ignores=[]) |
| compiled = compile(module, filename, 'exec') |
| exec(compiled, self.locals) |
| else: |
| exec(code, self.locals) |
| |
| except SystemExit: |
| raise |
| except _pyease_Py4JJavaError as e: |
| if isinstance(e.java_exception, _pyease_JavaObject): |
| # Skip self.showtraceback/self.write as we can get |
| # a Java exception instance already |
| self.engine.except_data = e.java_exception |
| else: |
| # No java exception here, fallback to normal case |
| self.showtraceback() |
| except Exception: |
| # create information that will end up in a |
| # ScriptExecutionException |
| self.showtraceback() |
| |
| def push(self, cmd, filename=None): |
| return _pyease_code.InteractiveConsole.push(self, cmd) |
| |
| |
| # Sentinel object for no result (different than None) |
| _pyease_NO_RESULT = object() |
| |
| |
| class _pyease_InteractiveReturn(object): |
| ''' |
| Instance of Java's IInteractiveReturn. |
| This class encapsulates the return state from the |
| ScriptEngineExecute.executeInteractive() method |
| ''' |
| |
| def __init__(self, gateway_client, display_data=None, except_data=None, result=_pyease_NO_RESULT): |
| self.gateway_client = gateway_client |
| self.display_data = display_data |
| self.except_data = except_data |
| self.result = result |
| |
| def getException(self): |
| data = self.except_data |
| if data is None: |
| return None |
| if isinstance(data, _pyease_JavaObject): |
| return data |
| return "".join(data) |
| |
| def getResult(self): |
| # Check if we did not receive result |
| if self.result is _pyease_NO_RESULT: |
| data = self.display_data |
| else: |
| data = self.result |
| |
| # Use conversion just to be sure |
| return convert_value(data, self.gateway_client) |
| |
| class Java: |
| implements = ['org.eclipse.ease.lang.python.py4j.internal.IInteractiveReturn'] |
| |
| |
| class _pyease_ScriptEngineExecute(object): |
| ''' |
| Instance of Java's IPythonSideEngine. |
| This class is the main class of the Python side. |
| ''' |
| |
| def __init__(self): |
| self.shutdown_event = _pyease_threading.Event() |
| |
| def set_gateway(self, gateway): |
| self.gateway = gateway |
| self.locals = __main__.__dict__ |
| self.interp = _pyease_EaseInteractiveConsole(self, self.locals) |
| # Provide most common top level pacakage names in the namespace |
| # so that code like "java.lang.String()" can work. |
| # for other names, jvm.<package name> should be used |
| self.locals['java'] = gateway.jvm.java |
| _pyease_patch_builtins('java', gateway.jvm.java) |
| |
| self.locals['javax'] = gateway.jvm.javax |
| _pyease_patch_builtins('javax', gateway.jvm.javax) |
| |
| self.locals['org'] = gateway.jvm.org |
| _pyease_patch_builtins('org', gateway.jvm.org) |
| |
| self.locals['com'] = gateway.jvm.com |
| _pyease_patch_builtins('com', gateway.jvm.com) |
| |
| self.locals['net'] = gateway.jvm.net |
| _pyease_patch_builtins('net', gateway.jvm.net) |
| |
| self.locals['jvm'] = gateway.jvm |
| _pyease_patch_builtins('jvm', gateway.jvm.jvm) |
| |
| self.locals['gateway'] = gateway |
| _pyease_patch_builtins('gateway', gateway) |
| |
| self.locals['py4j'] = py4j |
| _pyease_patch_builtins('py4j', py4j) |
| |
| _pyease_sys.displayhook = self.displayhook |
| self.display_data = None |
| self.except_data = None |
| |
| def displayhook(self, data): |
| self.display_data = data |
| if data is not None: |
| self.locals['_'] = data |
| |
| def executeCommon(self, code_text, code_exec, filename=None): |
| self.display_data = None |
| self.except_data = None |
| execution_result = code_exec(code_text, filename) |
| |
| # Check if we received a tuple, meaning that we are in script mode |
| if isinstance(execution_result, tuple) and len(execution_result) == 2: |
| result, needMore = execution_result |
| else: |
| # Set result to NO_RESULT to distinguish from None result |
| result = _pyease_NO_RESULT |
| needMore = execution_result |
| |
| if needMore: |
| # TODO, need to handle this with prompts, this message |
| # is a workaround |
| return _pyease_InteractiveReturn(self.gateway._gateway_client, display_data="... - more input required to complete statement") |
| else: |
| display_data = self.display_data |
| except_data = self.except_data |
| self.display_data = None |
| self.except_data = None |
| return _pyease_InteractiveReturn(self.gateway._gateway_client, display_data=display_data, except_data=except_data, result=result) |
| |
| def executeScript(self, code_text, filename=None): |
| return self.executeCommon(code_text, self.interp.runcode, filename) |
| |
| def executeInteractive(self, code_text): |
| return self.executeCommon(code_text, self.interp.push) |
| |
| def internalGetVariable(self, name): |
| return convert_value(self.locals.get(name), self.gateway._gateway_client) |
| |
| def internalGetVariables(self): |
| # Filter out data we do not want |
| filtered = { |
| k: convert_value(v, self.gateway._gateway_client) |
| for k, v in self.locals.items() |
| if k.startswith('__EASE') or ((not k.startswith('__')) and (not k.startswith('_pyease_')) and (not v.__class__.__module__.startswith('py4j.')) and (not hasattr(v, '__ease__')) and (not v.__class__.__name__ == 'module')) |
| } |
| |
| return _pyease_MapConverter().convert(filtered, self.gateway._gateway_client) |
| |
| def internalHasVariable(self, name): |
| return name in self.locals |
| |
| def internalSetVariable(self, name, content): |
| self.locals[name] = content |
| _pyease_builtins.__dict__.update({name: content}) |
| |
| def teardownEngine(self): |
| self.shutdown_event.set() |
| |
| def wait_on_shutdown(self): |
| self.shutdown_event.wait() |
| |
| def addSearchPath(self, path): |
| _pyease_sys.path.append(path) |
| |
| class Java: |
| implements = ['org.eclipse.ease.lang.python.py4j.internal.IPythonSideEngine'] |
| |
| |
| def _pyease_watchdog(engine): |
| # Read from the parent process until EOF, EOF indicates the |
| # parent process has terminated |
| try: |
| _pyease_sys.stdin.read() |
| except: |
| pass |
| |
| # shutdown the engine |
| engine.teardownEngine() |
| |
| # Allow some time for the shutdown to be clean, but |
| # fallback to a hard exit if that fails |
| timer = _pyease_threading.Timer(10.0, _pyease_os._exit, (1,)) |
| timer.setDaemon(True) |
| timer.start() |
| |
| |
| def _pyease_main(argv): |
| port = int(argv[1]) |
| engine = _pyease_ScriptEngineExecute() |
| # Bug 517528: Disable memory management until Py4J #275 is resolved |
| enable_memory_management = False |
| java_params = _pyease_JavaParameters(auto_convert=True, port=port, |
| enable_memory_management=enable_memory_management) |
| gateway = _pyease_ClientServer(java_parameters=java_params, |
| python_parameters=_pyease_PythonParameters(port=0), |
| python_server_entry_point=engine) |
| # retrieve the port on which the python callback server was bound to. |
| python_port = gateway.get_callback_server().get_listening_port() |
| engine.set_gateway(gateway) |
| |
| # tell Java that we are up and running and where to direct |
| # calls to python to. |
| gateway.entry_point.pythonStartupComplete(python_port, engine) |
| |
| # start a watchdog on stdin to make sure we terminate |
| thread = _pyease_threading.Thread(target=_pyease_watchdog, args=(engine,)) |
| thread.setDaemon(True) |
| thread.start() |
| |
| # now wait until we have a request for shutdown |
| engine.wait_on_shutdown() |
| |
| gateway.shutdown_callback_server() |
| gateway.shutdown() |
| |
| |
| if __name__ == '__main__': |
| # Will be patched via builtins |
| gateway = None |
| _pyease_main(_pyease_sys.argv) |
