permit usage of liste as key

synergine2/share.py

 import pickle
 import typing
 
+import collections
 import redis
 
 from synergine2.exceptions import SynergineException
         self._data[key] = value
         self._modified_keys.add(key)
 
-    def get(self, key) -> typing.Any:
+    def get(self, *key_args: typing.Union[str, float, int]) -> typing.Any:
+        key = '_'.join([str(v) for v in key_args])
+
         if key not in self._data:
             b_value = self._r.get(key)
             if b_value is None:
 
     def create(
         self,
-        key: str,
-        value,
+        key_args: typing.Union[str, typing.List[typing.Union[str, int, float]]],
+        value: typing.Any,
         indexes: typing.List[SharedDataIndex]=None,
     ):
+        key = key_args
+        if not isinstance(key, str):
+            key = '_'.join(key_args)
         indexes = indexes or []
 
         def get_key(obj):

tests/test_share.py

         shared = SharedDataManager()
 
         class Foo(object):
+            counter = shared.create('counter', value=0)
+
+        foo = Foo()
+        foo.counter = 42
+
+        assert shared.get('counter') == 42
+
+        foo.counter = 48
+
+        assert shared.get('counter') == 48
+
+    def test_default_value(self):
+        shared = SharedDataManager()
+
+        class Foo(object):
             counter = shared.create('counter', 0)
 
         foo = Foo()
 
         class Foo(object):
             counter = shared.create(
-                '{id}_counter',
-                0,
+                ['{id}', 'counter'],
+                value=0,
                 indexes=[],
             )
 
         foo = Foo()
         foo.counter = 42
 
-        assert shared.get('{}_counter'.format(foo.id)) == 42
+        assert shared.get(foo.id, 'counter') == 42
 
         foo.counter = 48
 
-        assert shared.get('{}_counter'.format(foo.id)) == 48
+        assert shared.get(foo.id, 'counter') == 48
 
     def test_multiple_uses(self):
         shared = SharedDataManager()