From d7d08dc759d643fd10d4d3cf273cdac36d32ed99 Mon Sep 17 00:00:00 2001 From: Kenneth Reitz Date: Sun, 10 Apr 2011 20:12:16 -0400 Subject: [PATCH] redi.s! --- redi/core.py | 6 +-- redi/db.py | 5 ++- redi/ext.py | 82 +++++++++++++++++++++++------------ redi/models.py | 113 +++++++++++++++++++++++++++++++++++++++++++------ 4 files changed, 160 insertions(+), 46 deletions(-) diff --git a/redi/core.py b/redi/core.py index 1c682cb..3f84210 100644 --- a/redi/core.py +++ b/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) \ No newline at end of file diff --git a/redi/db.py b/redi/db.py index 36d14fd..fc50655 100644 --- a/redi/db.py +++ b/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: diff --git a/redi/ext.py b/redi/ext.py index 2e91983..ccea081 100644 --- a/redi/ext.py +++ b/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 diff --git a/redi/models.py b/redi/models.py index af0dde0..0c5d868 100644 --- a/redi/models.py +++ b/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 ''.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 +} +