redi.s!

redi/core.py

@@ -7,7 +7,6 @@ redi.core
 This module contains the primary interface for redi.
 
 Simple, eh?
-
 """
 
 
@@ -21,7 +20,7 @@ def key(key, redis=config.redis, default=None):
     exists.
     """
 
-    return ext.auto_type(
+    return models.auto_type(
         utils.compress_key(key), redis=config.redis, default=default
 )
 
@@ -57,4 +56,5 @@ def list(key, redis=config.redis):
 
     return models.RedisList(utils.compress_key(key), redis=config.redis)
 
-
+# REDI.S!
+s = ext.Objectify(rootkeys=ext.root_keys(), redis=config.redis)

redi/db.py

@@ -12,14 +12,15 @@ from . import config
 
 
 def flush(redis=None):
-    """Flushes Redis database."""
+    """Flushes active Redis database."""
 
     if redis is None:
         redis = config.redis
 
     return redis.flushdb()
 
-def keys(search, redis=None):
+
+def keys(search='*', redis=None):
     """Flushes Redis database."""
 
     if redis is None:

redi/ext.py

@@ -11,7 +11,7 @@ This module contains extra stuff.
 
 from . import config
 from . import models
-from .utils import is_collection, compress_key
+from .utils import is_collection, compress_key, expand_key
 
 
 TYPE_MAP = {
@@ -33,40 +33,66 @@ TYPE_MAP = {
 
 
 
-def auto_type(key, redis=None, default=None):
-    """Returns datatype instance"""
+def root_keys(redis=config.redis):
 
-    if redis is None:
-        redis = config.redis
+    keys = []
 
-    key = compress_key(key)
 
-    if redis.exists(key):
+    for key in map(expand_key, redis.keys('*')):
+        if len(key) < 2:
+            keys.append(key)
 
-        datatype = redis.type(key)
+    return keys
 
-        if datatype == 'string':
-            test_string = models.RedisString(key, redis=redis).data
 
-            if isinstance(test_string, dict):
-                datatype = 'dict-string'
-            elif isinstance(test_string, list):
-                datatype = 'list-string'
-            elif isinstance(test_string, basestring):
-                datatype = 'string'
-            elif isinstance(test_string, int):
-                datatype = 'string'
-            elif isinstance(test_string, float):
-                datatype = 'string'
+class Objectify(object):
+    """Objects out of NOTHING!"""
+
+    def __init__(self, rootkeys, redis=config.redis):
+        super(Objectify, self).__init__()
+
+        self.redis = redis
+        self.rootkeys = rootkeys
+
+        self.update()
+
+
+    def __repr__(self):
+        return repr(self.dict)
+
+
+    def __getitem__(self, key):
+        return getattr(self, key, None)
+
+    @property
+    def dict(self):
+        d = self.__dict__
+        del d['redis']
+
+        return d
+
+    def items(self):
+        """Returns items within object."""
+        return self.dict.items()
+
+
+    def keys(self):
+        """Returns keys within object."""
+        return self.dict.keys()
+
+
+    def update(self):
+        for key in self.rootkeys:
+            self.__dict__[key[-1]] = (
+                models.auto_type(key[-1], redis=self.redis, o=True)
+            )
+
+        # keys = []
+
+        # for key in self.redis.keys('*'):
+        #     keys.append(key)
+        # print keys
 
-        return TYPE_MAP.get(datatype)(key, redis=redis)
 
-    else:
-        if default:
-            try:
-                return TYPE_MAP.get(default)(key, redis=redis)
-            except KeyError:
-                raise ValueError('Provide a valid default redis type.')
 
-        return None
 

redi/models.py

@@ -13,11 +13,15 @@ import uuid
 
 from operator import itemgetter
 from UserDict import DictMixin
-
 from . import config
+
 from .utils import ListMixin, is_collection, compress_key, expand_key
 
-from clint.textui import colored
+
+
+
+
+
 
 
 
@@ -25,9 +29,11 @@ from clint.textui import colored
 class RedisKey(object):
     """Contains methods that can be applied to any Redis key."""
 
-    def __init__(self, key, redis=None):
+    def __init__(self, key, redis=None, o=False):
+        super(RedisKey, self).__init__()
 
         self.key = key
+        self._o = o
 
         if redis is None:
             self.redis = config.redis
@@ -39,11 +45,25 @@ class RedisKey(object):
     def __repr__(self):
         return '<redis-key {0}>'.format(self.key)
 
+    @property
+    def _(self):
+        return 'hi'
 
     def delete(self):
         """Removes this key from Redis."""
         return self.redis.delete(self.key)
 
+    def __getattribute__(self, key):
+
+        if key not in ('_o', 'children', 'key', 'redis'):
+            if self._o:
+                if key in self.children:
+
+                    key = compress_key(expand_key(self.key) + [key])
+
+                    return auto_type(key, redis=self.redis, o=True)
+
+        return object.__getattribute__(self, key)
 
     def expire(self, s):
         """Expires this key from Redis in given seconds."""
@@ -74,7 +94,12 @@ class RedisKey(object):
 
         namespace = compress_key(expand_key(self.key) + ['*'])
 
-        return self.redis.keys(namespace)
+        keys = []
+
+        for key in self.redis.keys(namespace):
+            keys.append(expand_key(key)[-1])
+
+        return keys
 
 
     @property
@@ -89,7 +114,10 @@ class RedisKey(object):
         keys.remove(self.key)
 
         for key in self.children:
-            keys.remove(key)
+            try:
+                keys.remove(key)
+            except ValueError:
+                pass
 
 
         return keys
@@ -146,8 +174,8 @@ class RedisKey(object):
 class RedisString(RedisKey):
     """Redis String interface."""
 
-    def __init__(self, key, redis=None):
-        super(RedisString, self).__init__(key, redis=redis)
+    def __init__(self, key, redis=None, o=False):
+        super(RedisString, self).__init__(key, redis=redis, o=o)
 
         self.key = key
 
@@ -207,8 +235,8 @@ class RedisListString(RedisString, ListMixin):
     """Redis value of awesomeness."""
 
 
-    def __init__(self, key, redis):
-        super(RedisListString, self).__init__(key, redis=redis)
+    def __init__(self, key, redis, o=False):
+        super(RedisListString, self).__init__(key, redis=redis, o=o)
         self.key = key
 
 
@@ -246,8 +274,8 @@ class RedisDictString(RedisString, DictMixin):
     """Redis value of awesomeness."""
 
 
-    def __init__(self, key, redis):
-        super(RedisDictString, self).__init__(key, redis=redis)
+    def __init__(self, key, redis, o=False):
+        super(RedisDictString, self).__init__(key, redis=redis, o=o)
         self.key = key
 
 
@@ -267,8 +295,8 @@ class RedisDictString(RedisString, DictMixin):
 class RedisList(RedisKey):
     """Redis list of awesomeness."""
 
-    def __init__(self, key, redis):
-        super(RedisList, self).__init__(key, redis=redis)
+    def __init__(self, key, redis, o=False):
+        super(RedisList, self).__init__(key, redis=redis, o=o)
         self.key = key
 
 
@@ -528,3 +556,62 @@ class SubDict(DictMixin):
 
     def keys(self):
         return self.data.keys()
+
+
+
+def auto_type(key, redis=None, default=None, o=True):
+    """Returns datatype instance"""
+
+    if redis is None:
+        redis = config.redis
+
+    key = compress_key(key)
+
+    if redis.exists(key):
+
+        datatype = redis.type(key)
+
+        if datatype == 'string':
+            test_string = RedisString(key, redis=redis).data
+
+            if isinstance(test_string, dict):
+                datatype = 'dict-string'
+            elif isinstance(test_string, list):
+                datatype = 'list-string'
+            elif isinstance(test_string, basestring):
+                datatype = 'string'
+            elif isinstance(test_string, int):
+                datatype = 'string'
+            elif isinstance(test_string, float):
+                datatype = 'string'
+
+        return TYPE_MAP.get(datatype)(key, redis=redis, o=o)
+
+    else:
+        if default:
+            try:
+                return TYPE_MAP.get(default)(key, redis=redis, o=o)
+            except KeyError:
+                raise ValueError('Provide a valid default redis type.')
+
+        return None
+
+
+
+TYPE_MAP = {
+    'string': RedisString,
+    'value': RedisString,
+
+    'liststring': RedisListString,
+    'list-string': RedisListString,
+    'stringlist': RedisListString,
+    'string-list': RedisListString,
+
+    'dictstring': RedisDictString,
+    'dict-string': RedisDictString,
+    'stringdict': RedisDictString,
+    'string-dict': RedisDictString,
+
+    'list': RedisList
+}
+