dynamic editable ring + wrong .ring -> .rope

ring/django.py

@@ -78,7 +78,7 @@ class CachePageUserInterface(fbase.BaseUserInterface):
 
     @property
     def middleware(self):
-        return self.ring.storage.backend
+        return self.rope.storage.backend
 
     @fbase.interface_attrs(
         transform_args=transform_cache_page_args,
@@ -123,7 +123,7 @@ def get(self, wire, request, *args, **kwargs):
         #    result = middleware.process_view(request, view_func, args, kwargs)
         #    if result is not None:
         #        return result
-        return self.ring.miss_value
+        return self.rope.miss_value
 
     @fbase.interface_attrs(
         transform_args=transform_cache_page_args, return_annotation=None)

ring/func/asyncio.py

@@ -120,13 +120,13 @@ class CommonMixinStorage(fbase.BaseStorage):  # Working only as mixin
     @asyncio.coroutine
     def get(self, key):
         value = yield from self.get_value(key)
-        return self.ring.coder.decode(value)
+        return self.rope.decode(value)
 
     @asyncio.coroutine
     def set(self, key, value, expire=...):
         if expire is ...:
-            expire = self.ring.expire_default
-        encoded = self.ring.coder.encode(value)
+            expire = self.rope.expire_default
+        encoded = self.rope.encode(value)
         result = yield from self.set_value(key, encoded, expire)
         return result
 
@@ -143,7 +143,7 @@ def has(self, key):
     @asyncio.coroutine
     def touch(self, key, expire=...):
         if expire is ...:
-            expire = self.ring.expire_default
+            expire = self.rope.expire_default
         result = yield from self.touch_value(key, expire)
         return result
 
@@ -162,54 +162,54 @@ class CacheUserInterface(fbase.BaseUserInterface):
     def get(self, wire, **kwargs):
         key = self.key(wire, **kwargs)
         try:
-            result = yield from self.ring.storage.get(key)
+            result = yield from self.rope.storage.get(key)
         except fbase.NotFound:
-            result = self.ring.miss_value
+            result = self.rope.miss_value
         return result
 
     @fbase.interface_attrs(transform_args=fbase.transform_kwargs_only)
     @asyncio.coroutine
     def update(self, wire, **kwargs):
         key = self.key(wire, **kwargs)
         result = yield from self.execute(wire, **kwargs)
-        yield from self.ring.storage.set(key, result)
+        yield from self.rope.storage.set(key, result)
         return result
 
     @fbase.interface_attrs(transform_args=fbase.transform_kwargs_only)
     @asyncio.coroutine
     def get_or_update(self, wire, **kwargs):
         key = self.key(wire, **kwargs)
         try:
-            result = yield from self.ring.storage.get(key)
+            result = yield from self.rope.storage.get(key)
         except fbase.NotFound:
             result = yield from self.execute(wire, **kwargs)
-            yield from self.ring.storage.set(key, result)
+            yield from self.rope.storage.set(key, result)
         return result
 
     @fbase.interface_attrs(
         transform_args=(fbase.transform_kwargs_only, {'prefix_count': 1}),
         return_annotation=None)
     def set(self, wire, _value, **kwargs):
         key = self.key(wire, **kwargs)
-        return self.ring.storage.set(key, _value)
+        return self.rope.storage.set(key, _value)
 
     @fbase.interface_attrs(
         transform_args=fbase.transform_kwargs_only, return_annotation=None)
     def delete(self, wire, **kwargs):
         key = self.key(wire, **kwargs)
-        return self.ring.storage.delete(key)
+        return self.rope.storage.delete(key)
 
     @fbase.interface_attrs(
         transform_args=fbase.transform_kwargs_only, return_annotation=bool)
     def has(self, wire, **kwargs):
         key = self.key(wire, **kwargs)
-        return self.ring.storage.has(key)
+        return self.rope.storage.has(key)
 
     @fbase.interface_attrs(
         transform_args=fbase.transform_kwargs_only, return_annotation=None)
     def touch(self, wire, **kwargs):
         key = self.key(wire, **kwargs)
-        return self.ring.storage.touch(key)
+        return self.rope.storage.touch(key)
 
 
 class BulkInterfaceMixin(fbase.AbstractBulkUserInterfaceMixin):
@@ -229,16 +229,16 @@ def execute_many(self, wire, *args_list):
         return_annotation=lambda a: List[Optional[a.get('return', Any)]])
     def get_many(self, wire, *args_list):
         keys = self.key_many(wire, *args_list)
-        return self.ring.storage.get_many(
-            keys, miss_value=self.ring.miss_value)
+        return self.rope.storage.get_many(
+            keys, miss_value=self.rope.miss_value)
 
     @fbase.interface_attrs(
         return_annotation=lambda a: List[a.get('return', Any)])
     @asyncio.coroutine
     def update_many(self, wire, *args_list):
         keys = self.key_many(wire, *args_list)
         values = yield from self.execute_many(wire, *args_list)
-        yield from self.ring.storage.set_many(keys, values)
+        yield from self.rope.storage.set_many(keys, values)
         return values
 
     @fbase.interface_attrs(
@@ -247,7 +247,7 @@ def update_many(self, wire, *args_list):
     def get_or_update_many(self, wire, *args_list):
         keys = self.key_many(wire, *args_list)
         miss_value = object()
-        results = yield from self.ring.storage.get_many(
+        results = yield from self.rope.storage.get_many(
             keys, miss_value=miss_value)
 
         miss_indices = []
@@ -260,7 +260,7 @@ def get_or_update_many(self, wire, *args_list):
         new_results = yield from asyncio.gather(*(
             fbase.execute_bulk_item(wire, args_list[i]) for i in miss_indices))
         new_keys = [keys[i] for i in miss_indices]
-        yield from self.ring.storage.set_many(new_keys, new_results)
+        yield from self.rope.storage.set_many(new_keys, new_results)
 
         for new_i, old_i in enumerate(miss_indices):
             results[old_i] = new_results[new_i]
@@ -269,22 +269,22 @@ def get_or_update_many(self, wire, *args_list):
     @fbase.interface_attrs(return_annotation=None)
     def set_many(self, wire, args_list, value_list):
         keys = self.key_many(wire, *args_list)
-        return self.ring.storage.set_many(keys, value_list)
+        return self.rope.storage.set_many(keys, value_list)
 
     @fbase.interface_attrs(return_annotation=None)
     def delete_many(self, wire, *args_list):
         keys = self.key_many(wire, *args_list)
-        return self.ring.storage.delete_many(keys)
+        return self.rope.storage.delete_many(keys)
 
     @fbase.interface_attrs(return_annotation=None)
     def has_many(self, wire, *args_list):
         keys = self.key_many(wire, *args_list)
-        return self.ring.storage.has_many(keys)
+        return self.rope.storage.has_many(keys)
 
     @fbase.interface_attrs(return_annotation=None)
     def touch_many(self, wire, *args_list):
         keys = self.key_many(wire, *args_list)
-        return self.ring.storage.touch_many(keys)
+        return self.rope.storage.touch_many(keys)
 
 
 class BulkStorageMixin(object):
@@ -294,16 +294,16 @@ def get_many(self, keys, miss_value):
         """Get and return values for the given key."""
         values = yield from self.get_many_values(keys)
         results = [
-            self.ring.coder.decode(v) if v is not fbase.NotFound else miss_value  # noqa
+            self.rope.decode(v) if v is not fbase.NotFound else miss_value  # noqa
             for v in values]
         return results
 
     def set_many(self, keys, values, expire=Ellipsis):
         """Set values for the given keys."""
         if expire is Ellipsis:
-            expire = self.ring.expire_default
+            expire = self.rope.expire_default
         return self.set_many_values(
-            keys, [self.ring.coder.encode(v) for v in values], expire)
+            keys, [self.rope.encode(v) for v in values], expire)
 
     def delete_many(self, keys):
         """Delete values for the given keys."""
@@ -316,7 +316,7 @@ def has_many(self, keys):
     def touch_many(self, keys, expire=Ellipsis):
         """Touch values for the given keys."""
         if expire is Ellipsis:
-            expire = self.ring.expire_default
+            expire = self.rope.expire_default
         return self.touch_many_values(keys, expire)
 
 

ring/func/base.py

@@ -116,7 +116,7 @@ def create_key_builder(
     key_generator = CallableKey(
         c, format_prefix=key_prefix, ignorable_keys=ignorable_keys)
 
-    def compose_key(bound_args, kwargs):
+    def compose_key(*bound_args, **kwargs):
         full_kwargs = kwargs.copy()
         for i, prearg in enumerate(bound_args):
             full_kwargs[c.parameters[i].name] = bound_args[i]
@@ -228,8 +228,8 @@ class BaseUserInterface(object):
         :func:`ring.func.base.transform_kwargs_only`
     """
 
-    def __init__(self, ring):
-        self.ring = ring
+    def __init__(self, rope):
+        self.rope = rope
 
     @interface_attrs(
         transform_args=transform_kwargs_only, return_annotation=str)
@@ -240,7 +240,7 @@ def key(self, wire, **kwargs):
         :return: The composed key with given arguments.
         :rtype: str
         """
-        return self.ring.compose_key(wire._bound_objects, kwargs)
+        return self.rope.compose_key(*wire._bound_objects, **kwargs)
 
     @interface_attrs(transform_args=transform_kwargs_only)
     def execute(self, wire, **kwargs):
@@ -487,15 +487,19 @@ def touch_many(self, wire, *args_list):  # pragma: no cover
 
 class RingWire(Wire):
 
-    __slots__ = ('encode', 'decode', 'storage')
+    __slots__ = ('storage', )
 
     def __init__(self, rope, *args, **kwargs):
         super(RingWire, self).__init__(rope, *args, **kwargs)
 
-        self.encode = rope.coder.encode
-        self.decode = rope.coder.decode
         self.storage = rope.storage
 
+    def encode(self, v):
+        return self._rope.encode(v)
+
+    def decode(self, v):
+        return self._rope.decode(v)
+
     def _merge_args(self, args, kwargs):
         """Create a fake kwargs object by merging actual arguments.
 
@@ -515,6 +519,21 @@ def run(self, action, *args, **kwargs):
         return attr(*args, **kwargs)
 
 
+class PublicRing(object):
+
+    def __init__(self, rope):
+        self._rope = rope
+
+    def key(self, func):
+        self._rope.compose_key = func
+
+    def encode(self, func):
+        self._rope.encode = func
+
+    def decode(self, func):
+        self._rope.decode = func
+
+
 def factory(
         storage_backend,  # actual storage
         key_prefix,  # manual key prefix
@@ -605,6 +624,11 @@ def __init__(self, *args, **kwargs):
                 self.compose_key = create_key_builder(
                     self.callable, _key_prefix, _ignorable_keys,
                     encoding=key_encoding, key_refactor=key_refactor)
+                self.compose_key.ignorable_keys = _ignorable_keys
+                self.encode = self.coder.encode
+                self.decode = self.coder.decode
+
+                self.ring = PublicRing(self)
 
         func = f if type(f) is types.FunctionType else f.__func__  # noqa
         interface_keys = tuple(k for k in dir(user_interface) if k[0] != '_')
@@ -698,8 +722,8 @@ class BaseStorage(object):
     are mandatory; Otherwise not.
     """
 
-    def __init__(self, ring, backend):
-        self.ring = ring
+    def __init__(self, rope, backend):
+        self.rope = rope
         self.backend = backend
 
     @abc.abstractmethod
@@ -733,12 +757,12 @@ class CommonMixinStorage(BaseStorage):
 
     def get(self, key):
         value = self.get_value(key)
-        return self.ring.coder.decode(value)
+        return self.rope.decode(value)
 
     def set(self, key, value, expire=Ellipsis):
         if expire is Ellipsis:
-            expire = self.ring.expire_default
-        encoded = self.ring.coder.encode(value)
+            expire = self.rope.expire_default
+        encoded = self.rope.encode(value)
         result = self.set_value(key, encoded, expire)
         return result
 
@@ -752,7 +776,7 @@ def has(self, key):
 
     def touch(self, key, expire=Ellipsis):
         if expire is Ellipsis:
-            expire = self.ring.expire_default
+            expire = self.rope.expire_default
         result = self.touch_value(key, expire)
         return result