Merge pull request #6 from dawagner/sync-api-example

Author: engbergandreas

example/sync-example.py

@@ -0,0 +1,29 @@
+import asyncio
+import openspace
+
+# This is an example of how to make synchronous calls to the API
+# This is not so useful in scripts but has its use in interactive shells, instead of prepending
+# every call with `await`.
+
+ADDRESS = 'localhost'
+PORT = 4681
+# Create an OpenSpaceApi instance with the OpenSpace address and port
+api = openspace.Api(ADDRESS, PORT)
+
+# You might want to handle this differently according to your environment or use-case.
+# For instance, this works in a regular python shell or in IPython but `python3 -m asyncio` is
+# different.
+loop = asyncio.new_event_loop()
+def sync_wrapper(f, *args, **kwargs):
+    return loop.run_until_complete(f(*args, **kwargs))
+
+# warning: all async calls must be performed on the same loop
+
+loop.run_until_complete(api.connect())
+sync_os = loop.run_until_complete(api.singleReturnLibrary(sync_wrapper))
+
+# Calls to methods of `sync_os` will block until the call is made and a result is returned:
+sync_os.printInfo("foo")
+print(sync_os.propertyValue("Scene.Earth.Scale.Scale"))
+
+api.disconnect()

src/openspace/src/api.py

@@ -3,9 +3,25 @@
 from traceback import print_exc
 from .topic import Topic
 from .socketwrapper import SocketWrapper
+from functools import partial
 from typing import Callable, NamedTuple
 from collections import namedtuple
 
+
+def toNamedTuple(content: dict, name: str = "namedtuple") -> NamedTuple:
+    """ Recursively converts a `dictionary` to a `namedtuple`. """
+
+    T = namedtuple(name, content.keys())
+    values = []
+    for k, v in content.items():
+        if isinstance(v, dict):
+            values.append(toNamedTuple(v, k))
+        else:
+            values.append(v)
+
+    return T(*values)
+
+
 class Api:
     """ Construct an instance of the OpenSpace API. \n
     :param socket - An instance of SocketWrapper.
@@ -322,32 +338,19 @@ async def executeLuaFunction(self, function: str, args, getReturnValue = True):
         else:
             topic.cancel()
 
-    async def library(self, multiReturn: bool) -> NamedTuple:
+    async def library(self, wrapper: None|Callable = None) -> dict:
         """ Get an object representing the OpenSpace lua libarary. \n
-        :param multiReturn - whether the library should return the raw lua tables.
-        If this value is true, the 1-indexed lua table will be returned as a dict
-        If the value is false, then only the first return value will be returned. \n
+        :param wrapper: if set, wraps all API calls (may be used to make them synchronous)
         :return - The lua library, mapped to async python functions. """
 
-        def generateAsyncMultiRetFunction(functionName):
-            async def fun(*args):
-                try:
-                    return await self.executeLuaFunction(functionName, args)
-                except Exception as e:
-                    print("Lua exception error: \n", e)
-
-            return fun
-
-        def generateAsyncSingleRetFunction(functionName):
-            async def fun(*args):
-                try:
-                    luaTable = await self.executeLuaFunction(functionName, args)
-                    if luaTable:
-                        return luaTable['1']
-                    return None
-                except Exception as e:
-                    print("Lua exception error: \n", e)
-            return fun
+        async def async_lua_call(functionName, *args):
+            try:
+                luaTable = await self.executeLuaFunction(functionName, args)
+                if luaTable:
+                    return luaTable['1']
+                return None
+            except Exception as e:
+                print("Lua exception error: \n", e)
 
         docs = await self.getDocumentation('lua')
 
@@ -366,36 +369,18 @@ async def fun(*args):
                 _lib = '' if subPyLibrary == pyLibrary else libraryName + '.'
                 fullFunctionName = 'openspace.' + _lib + func['name']
 
-                if multiReturn:
-                    subPyLibrary[func['name']] = generateAsyncMultiRetFunction(fullFunctionName)
-                else:
-                    subPyLibrary[func['name']] = generateAsyncSingleRetFunction(fullFunctionName)
-
-        return self.toNamedTuple(pyLibrary, libraryName)
-
-    def toNamedTuple(self, content: dict, name: str = "namedtuple") -> NamedTuple:
-        """ Recursively converts a `dictionary` to a `namedtuple`. """
+                lua_call = partial(async_lua_call, fullFunctionName)
+                if wrapper is not None:
+                    lua_call = partial(wrapper, lua_call)
+                subPyLibrary[func['name']] = lua_call
 
-        T = namedtuple(name, content.keys())
-        values = []
-        for k, v in content.items():
-            if isinstance(v, dict):
-                values.append(self.toNamedTuple(v, k))
-            else:
-                values.append(v)
-
-        return T(*values)
+        return toNamedTuple(pyLibrary, libraryName)
 
-    async def singleReturnLibrary(self):
+    async def singleReturnLibrary(self, wrapper=None):
         """ Get an object representing the OpenSpace lua library. \n
+        (deprecated. Use library() instead)
+        :param wrapper: if set, wraps all API calls (may be used to make them synchronous)
         :return - The lua library, mapped to async python functions. This method only
         returns the first return value. """
 
-        return await self.library(False)
-
-    async def multiReturnLibrary(self):
-        """ Get an object representing the OpenSpace lua library. \n
-        :return - The lua library, mapped to async python functions. The values returned
-        by the async functions will be the entire lua tables, with 1-indexed values. """
-
-        return await self.library(True)
+        return await self.library(wrapper)

src/openspace/src/socketwrapper.py

@@ -56,7 +56,7 @@ async def _handle_receive(self):
     async def connect(self):
         self._client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         self._client.setblocking(False)
-        self._loop = asyncio.get_event_loop()
+        self._loop = asyncio.get_running_loop()
         try:
             await self._loop.sock_connect(self._client, (self._address, self._port))
             self._disconnecting = False