Merge pull request #3 from dawagner/fix-autocompletion

Use namedtuple instead of the custom DotDict

Author: engbergandreas

example/example.py

@@ -19,7 +19,7 @@ async def scaleEarth(value):
 
     property = "Scene.Earth.Scale.Scale"
     data = await os.getProperty(property)
-    data = os.toDotDict(data)
+    data = os.toNamedTuple(data)
 
     print(f"Current scale value: {data.Value}")
     os.setProperty(property, value)
@@ -33,15 +33,15 @@ async def subscribeToEarthScaleUpdates():
     while i < 3:
         print("Waiting for Earth scale update...")
         result = await os.nextValue(subscription)
-        dic = os.toDotDict(result)
+        dic = os.toNamedTuple(result)
         print(f"{dic.Description.Identifier} changed to {dic.Value}")
         i += 1
     subscription.cancel()
 
     ## Or using async for loop
     # async for future in subscription.iterator():
     #     result = await future
-    #     dic = api.toDotDict(result)
+    #     dic = api.toNamedTuple(result)
     #     print(f"{dic.Description.Identifier} changed to {dic.Value}")
     #     if i > 3:
     #         subscription.cancel()
@@ -166,4 +166,4 @@ async def mainLoop():
 
 loop = asyncio.new_event_loop()
 loop.run_until_complete(mainLoop())
-loop.run_forever()
+loop.run_forever()

src/openspace/__init__.py

@@ -1,3 +1,3 @@
-from .src.api import Api, DotDict
+from .src.api import Api
 
-__version__ = "0.1.2"
+__version__ = "0.1.2"

src/openspace/src/api.py

@@ -3,32 +3,8 @@
 from traceback import print_exc
 from .topic import Topic
 from .socketwrapper import SocketWrapper
-from typing import Callable
-
-class DotDict(dict):
-    """ A dictionary subclass supporting dot.notation.
-
-    Example usage:
-        `foo = DotDict({'bar': 'baz'})`\n
-        `print(foo.bar)` output 'baz'
-
-    Set attributes:
-        `foo.bar = 'foo'`
-
-    Delete attributes:
-        `del foo.bar`
-
-    Convert a `Dict` to a `DotDict` using `DotDict(dict)`. However, it does not convert
-    nested dictionaries. Instead use `OpenSpaceApi.toDotDict()`
-        `foo = {"bar": "baz"}`\n
-        `foo = DotDict(foo)` """
-
-    __getattr__ = dict.__getitem__
-    __setattr__ = dict.__setitem__
-    __delattr__ = dict.__delitem__
-
-    def __dir__(self):
-        return dir(dict) + list(self.keys())
+from typing import Callable, NamedTuple
+from collections import namedtuple
 
 class Api:
     """ Construct an instance of the OpenSpace API. \n
@@ -346,7 +322,7 @@ async def executeLuaFunction(self, function: str, args, getReturnValue = True):
         else:
             topic.cancel()
 
-    async def library(self, multiReturn: bool) -> DotDict:
+    async def library(self, multiReturn: bool) -> NamedTuple:
         """ 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
@@ -395,16 +371,20 @@ async def fun(*args):
                 else:
                     subPyLibrary[func['name']] = generateAsyncSingleRetFunction(fullFunctionName)
 
-        return self.toDotDict(pyLibrary)
+        return self.toNamedTuple(pyLibrary, libraryName)
 
-    def toDotDict(self, dictionary: dict) -> DotDict:
-        """ Recursively converts a `dictionary` to a `DotDict`. """
+    def toNamedTuple(self, content: dict, name: str = "namedtuple") -> NamedTuple:
+        """ Recursively converts a `dictionary` to a `namedtuple`. """
 
-        for k, v in dictionary.items():
+        T = namedtuple(name, content.keys())
+        values = []
+        for k, v in content.items():
             if isinstance(v, dict):
-                dictionary[k] = self.toDotDict(v)
+                values.append(self.toNamedTuple(v, k))
+            else:
+                values.append(v)
 
-        return DotDict(dictionary)
+        return T(*values)
 
     async def singleReturnLibrary(self):
         """ Get an object representing the OpenSpace lua library. \n
@@ -418,4 +398,4 @@ async def multiReturnLibrary(self):
         :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(True)