本文整理汇总了Python中redis.StrictRedis.ltrim方法的典型用法代码示例。如果您正苦于以下问题:Python StrictRedis.ltrim方法的具体用法?Python StrictRedis.ltrim怎么用?Python StrictRedis.ltrim使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类redis.StrictRedis
的用法示例。
在下文中一共展示了StrictRedis.ltrim方法的5个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: update_status
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import ltrim [as 别名]
def update_status(msg, **redis_kwargs):
""" Updated Redis with a message, prefix it with the current timestamp.
Keyword args are passed directly to redis.StrictRedis().
"""
pid = getpid()
red = StrictRedis(**redis_kwargs)
key = 'pid-%d-statuses' % pid
msg = '%.6f %s' % (time(), msg)
red.lpush(key, msg)
red.expire(key, 60 * 60)
red.ltrim(key, 0, _keep)
示例2: RedisDatabaseManager
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import ltrim [as 别名]
class RedisDatabaseManager(object):
redisHandler = None
# initialization, establish connection to redis server
#
# @param host string host of the redis server
# @param port int port of the redis server
# @param db int database you want to use in redis server
def __init__(self, host, port, db):
self.redisHandler = StrictRedis(host=host, port=port, db=db)
# create deadLinks, unvisistedLinks, visitedLinks in redis
self.redisHandler.ltrim('deadLinks', -1, 0)
self.redisHandler.ltrim('unvisitedLinks', -1, 0)
self.redisHandler.ltrim('visitedLinks', -1, 0)
# createDeadLinks
# create a record in deadLinks list
#
# @param url string
# @return boolean
def createDeadLinks(self, url):
pass
示例3: KeyValueStore
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import ltrim [as 别名]
class KeyValueStore(object):
def __init__(self):
self.data = StrictRedis(host = settings.redis.server.host, port = settings.redis.server.port)
log.debug("Connected to REDIS(%s, %s)" % (settings.redis.server.host, settings.redis.server.port))
def _get_value(self, key):
return self.data.get(key)
def _set_value(self, key, value, seconds=None):
self.data.set(key, value)
if seconds is not None:
self.data.expire(key, seconds)
def _delete_key(self, key):
self.data.delete(key)
def _search_keys(self, pattern):
return self.data.keys(pattern)
def _get_model(self, model_pf, model_id):
value = self._get_value(model_pf+model_id)
if value is None:
return None
return Struct(loads(self._get_value(model_pf+model_id)))
def _set_model(self, model_pf, model_id, model_value, seconds=None):
self._set_value(model_pf+model_id, dumps(model_value, default=datetime_serializer), seconds)
def _list_model(self, model_pf):
return [Struct(loads(self._get_value(key))) for key in self._search_keys(model_pf+'*')]
def _get_list_models(self, list_pf, list_id):
return [Struct(loads(value)) for value in self.data.lrange(list_pf+list_id, 0, -1)]
def _get_list_scalars(self, list_pf, list_id):
return [value for value in self.data.lrange(list_pf+list_id, 0, -1)]
def _pop_list_scalars(self, list_pf, list_id):
scalars = []
scalar = True
while scalar:
scalar=self.data.lpop(list_pf+list_id)
if scalar:
scalars += [scalar]
return scalars
def _push_list(self, list_pf, list_id, model_value, trim_count):
if not isinstance(model_value, unicode):
model_value = dumps(model_value)
self.data.lpush(list_pf+list_id, model_value)
self.data.ltrim(list_pf+list_id, 0, MAX_STAT_ITEMS-1)
# Devices
def get_device(self, mac_address):
return self._get_model(DEVICE_PF, mac_address.replace(":","").upper())
def set_device(self, mac_address, device):
self._set_model(DEVICE_PF, mac_address.replace(":","").upper(), device)
def delete_device(self, mac_address):
self._delete_key(DEVICE_PF+mac_address.replace(":","").upper())
self._delete_key(ASSETLIST_PF+mac_address.replace(":","").upper())
def list_devices(self):
return self._list_model(DEVICE_PF)
# Assets
def get_asset(self, guid):
return self._get_model(ASSET_PF, guid)
def set_asset(self, guid, asset):
self._set_model(ASSET_PF, guid, asset)
def delete_asset(self, guid):
self._delete_key(ASSET_PF+guid)
def list_assets(self):
return self._list_model(ASSET_PF)
# Playlists
def get_playlist(self, name):
return self._get_model(PLAYLIST_PF, name)
def set_playlist(self, name, playlist):
self._set_model(PLAYLIST_PF, name, playlist)
def delete_playlist(self, name):
self._delete_key(PLAYLIST_PF+name)
def list_playlists(self):
return self._list_model(PLAYLIST_PF)
# Stats
#.........这里部分代码省略.........
示例4: Zone
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import ltrim [as 别名]
#.........这里部分代码省略.........
f.write(snapshot)
f.close()
shutil.move(f.name, self.snapshot_path)
os._exit(os.EX_OK)
def _import_subclasses(self, module_name, parent_class):
module = importlib.import_module(module_name)
return {
cls.__name__: cls
for name, cls in inspect.getmembers(module)
if inspect.isclass(cls) and issubclass(cls, parent_class)
}
def load_modules(self):
sys.path.append(self.world_path)
self.components = self._import_subclasses(self.config['world']['components'], Component)
self.modes = self._import_subclasses(self.config['world']['modes'], Mode)
log.debug('Loaded %s component(s) and %s mode(s).' % (
len(self.components), len(self.modes)
))
def start(self):
try:
self.redis.ping()
except ConnectionError as e:
fatal("Redis error: %s" % e.message)
self.running = True
log.info('Listening.')
# Clear any existing tick events
self.redis.ltrim(self.tick_key, 0, 0)
try:
while self.running:
self.process_one_event()
except Exception as e:
log.critical(traceback.format_exc())
except BaseException as e:
pass
finally:
self.save_snapshot()
def stop(self):
self.running = False
def start_ticker(self):
log.info('Ticking every %ss.' % self.tick_interval)
tock = False
while True:
log.debug('Tock.' if tock else 'Tick.')
# TODO: timestamp here instead of True, for debugging?
self.redis.rpush(self.tick_key, True)
sleep(self.tick_interval)
tock = not tock
def send_message(self, entity_id, message):
self.redis.publish(self.messages_key(entity_id), message)
def listen(self, entity_id):
subscription = self.subscribe(entity_id)
for message in subscription.listen():
yield message['data']
# TODO: Leaky abstraction :\
示例5: RedisTimeline
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import ltrim [as 别名]
class RedisTimeline(object):
_redis = None
def __init__(self, **kwargs):
"""
Creates Redis object with key ``timelines:<id>``.
"""
name = kwargs.pop('name')
prefix = kwargs.pop('prefix', "timelines")
sep = kwargs.pop('sep', ":")
self.name = "%s%s%s" % (prefix, sep, name)
# Default to uncapped length
self.max_length = kwargs.pop("max_length", 0)
if self._redis is None:
url = kwargs.get('url', None)
if url is not None:
self._redis = StrictRedis().from_url(url)
else:
self._redis = StrictRedis(**kwargs)
def push(self, value):
"""
Adds the value to the front of the list and trim if the
max length != 0. Returns the value.
"""
self._redis.lpush(self.name, value)
if self.max_length > 0:
self._redis.ltrim(self.name, 0, self.max_length-1)
return value
def range(self, count=0, **kwargs):
"""
Returns a range values from the front of the list to the limit.
"""
if count is 0:
# No count, check for offset/limit
offset = kwargs.get('offset', 0)
limit = kwargs.get('limit', -1)
else:
# If there's a count, default to offset 0
offset = 0
limit = count
if limit is 1:
# Get range of length 1 using LRANGE <timeline> <limit> <limit>
limit = offset
elif limit > 0:
limit = offset+limit - 1
return self._redis.lrange(self.name, offset, limit)
def count(self):
"""
Uses Redis LLEN to get the length of the timeline.
"""
return self._redis.llen(self.name)
@property
def length(self):
"""
Access the length (count) as a property.
"""
return self.count()