################################
# Py4j.py
# more info here: https://www.py4j.org/
# Py4J enables Python programs running in a Python interpreter to dynamically access
# Java objects in a Java Virtual Machine.
# Methods are called as if the Java objects resided in the Python interpreter and
# Java collections can be accessed through standard Python collection methods.
# Py4J also enables Java programs to call back Python objects. Py4J is distributed under the BSD license
# Python 2.7 -to- 3.x is supported
# In your python 3.x project
# pip install py4j
# you have full access to mrl instance that's running
# the gateway
import sys
import json
from abc import ABC, abstractmethod
from py4j.java_collections import JavaObject, JavaClass
from py4j.java_gateway import JavaGateway, CallbackServerParameters, GatewayParameters
class Service(ABC):
def __init__(self, name):
self.java_object = runtime.start(name, self.getType())
def __getattr__(self, attr):
# Delegate attribute access to the underlying Java object
return getattr(self.java_object, attr)
def __str__(self):
# Delegate string representation to the underlying Java object
return str(self.java_object)
def subscribe(self, event):
print("subscribe")
self.java_object.subscribe(event)
@abstractmethod
def getType(self):
pass
class NeoPixel(Service):
def __init__(self, name):
super().__init__(name)
def getType(self):
return "NeoPixel"
def onFlash(self):
print("onFlash")
class InMoov2(Service):
def __init__(self, name):
super().__init__(name)
self.subscribe('onStateChange')
def getType(self):
return "InMoov2"
def onOnStateChange(self, state):
print("onOnStateChange")
print(state)
print(state.get('last'))
print(state.get('current'))
print(state.get('event'))
# TODO dynamically add classes that you don't bother to check in
# class Runtime(Service):
# def __init__(self, name):
# super().__init__(name)
# FIXME - REMOVE THIS - DO NOT SET ANY GLOBALS !!!!
runtime = None
# TODO - rename to mrl_lib ?
# e.g.
# mrl = mrl_lib.connect("localhost", 1099)
# i01 = InMoov("i01", mrl)
# or
# runtime = mrl_lib.connect("localhost", 1099) # JVM connection Py4j instance needed for a gateway
# runtime.start("i01", "InMoov2") # starts Java service
# runtime.start("nativePythonService", "NativePythonClass") # starts Python service no gateway needed
class MessageHandler(object):
"""
The class responsible for receiving and processing Py4j messages,
including handling `invoke()` and `exec()` requests. Class
must be initialized and then the `setName()` method must be invoked before
the Java and Python sides can talk correctly.
"""
def __init__(self):
global runtime
# initializing stdout and stderr
print("initializing")
self.name = None
self.stdout = sys.stdout
self.stderr = sys.stderr
sys.stdout = self
sys.stderr = self
self.gateway = JavaGateway(callback_server_parameters=CallbackServerParameters(),
python_server_entry_point=self,
gateway_parameters=GatewayParameters(auto_convert=True))
self.runtime = self.gateway.jvm.org.myrobotlab.service.Runtime.getInstance()
# FIXME - REMOVE THIS - DO NOT SET ANY GLOBALS !!!!
runtime = self.runtime
self.py4j = None # need to wait until name is set
print("initialized ... waiting for name to be set")
def construct_runtime(self):
"""
Constructs a new Runtime instance and returns it.
"""
jvm_runtime = self.gateway.jvm.org.myrobotlab.service.Runtime.getInstance()
# Define class attributes and methods as dictionaries
class_attributes = {
'x': 0,
'y': 0,
'move': lambda self, dx, dy: setattr(self, 'x', self.x + dx) or setattr(self, 'y', self.y + dy),
'get_position': lambda self: (self.x, self.y),
}
# Create the class dynamically using the type() function
MyDynamicClass = type('MyDynamicClass', (object,), class_attributes)
# Create an instance of the dynamically created class
obj = MyDynamicClass()
return self.runtime
# Define the callback function
def handle_connection_break(self):
# Add your custom logic here to handle the connection break
print("Connection with Java gateway was lost or terminated.")
print("goodbye.")
sys.exit(1)
def write(self,string):
if (self.py4j):
self.py4j.handleStdOut(string)
def flush(self):
pass
def setName(self, name):
"""
Called after initialization completed in order
for this Python side handler to know how to contact the Java-side
service.
:param name: Name of the Java-side Py4j service this script is linked to, preferably as a full name.
:type name: str
"""
print("name set to", name)
self.name = name
self.py4j = self.runtime.getService(name)
print(self.runtime.getUptime())
print("python started", sys.version)
print("runtime attached", self.runtime.getVersion())
print("reference to runtime")
# TODO print env vars PYTHONPATH etc
return name
def getRuntime(self):
return self.runtime
def exec(self, code):
"""
Executes Python code in the global namespace.
All exceptions are caught and printed so that the
Python subprocess doesn't crash.
:param code: The Python code to execute.
:type code: str
"""
try:
# Restricts the exec() to the global namespace,
# so the code is executed as if it were the top level of a module
exec(code, globals())
except Exception as e:
print(e)
def send(self, json_msg):
msg = json.loads(json_msg)
if msg.get("data") is None or msg.get("data") == []:
globals()[msg.get("method")]()
else:
globals()[msg.get("method")](*msg.get("data"))
# equivalent to JS onMessage
def invoke(self, method, data=None):
"""
Invoke a function from the global namespace with the given parameters.
:param method: The name of the function to invoke.
:type method: str
:param data: The parameters to pass to the function, defaulting to
no parameters.
:type data: Iterable
"""
# convert to list
# params = list(data) not necessary will always be a json string
# Lookup the method in the global namespace
# Much much faster than using eval()
# data should be None or always a list of params
if data is None:
globals()[method]()
else:
# one shot json decode
params = json.loads(data)
globals()[method](*params)
def shutdown(self):
"""
Shutdown the Py4j gateway
:return:
"""
self.gateway.shutdown()
def convert_array(self, array):
"""
Utility method used by Py4j to convert arrays of Java objects
into equivalent Python lists.
:param array: The array to convert
:return: The converted array
"""
result = []
for item in array:
if isinstance(item, JavaObject):
item_class = item.getClass()
if item_class == JavaClass.forName("java.lang.String"):
result.append(str(item))
elif item_class == JavaClass.forName("java.lang.Integer"):
result.append(int(item))
elif item_class == JavaClass.forName("java.lang.Double"):
result.append(float(item))
elif item_class == JavaClass.forName("java.lang.Boolean"):
result.append(bool(item))
elif item_class == JavaClass.forName("java.lang.Long"):
result.append(int(item))
elif item_class == JavaClass.forName("java.lang.Short"):
result.append(int(item))
elif item_class == JavaClass.forName("java.lang.Float"):
result.append(float(item))
elif item_class == JavaClass.forName("java.lang.Byte"):
result.append(int(item))
else:
raise ValueError("Unsupported type: {}".format(item_class))
else:
raise ValueError("Unsupported type: {}".format(type(item)))
return result
class Java:
implements = ['org.myrobotlab.framework.interfaces.Invoker']
handler = MessageHandler()
if len(sys.argv) > 1:
handler.setName(sys.argv[1])
else:
raise RuntimeError("This script requires the full name of the Py4j service as its first command-line argument")