Python StrictRedis.llen方法代码示例

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import llen [as 别名]
class Worker(object):
    def __init__(self, queue_name=None, from_queue=None, host='127.0.0.1', port=6379, db=0, prefix='easy_jobs:queue:'):
        self.queue_name = queue_name
        self.from_queue = from_queue
        self.outputs = ['results']

        if from_queue:
            self.connection = self.from_queue.connection
            self.key = self.from_queue.key
        else:
            self.key = '%s%s' % (prefix, queue_name)
            self.connection = StrictRedis(host=host, port=port, db=db)

    def start(self, once=False, threaded=False):
        jobs = self.connection.llen(self.key)

        while jobs > 0:
            pickled = self.connection.rpop(self.key)

            if pickled:
                un_pickled = loads(pickled)
                instance = un_pickled['foo']
                args = un_pickled['args']
                kwargs = un_pickled['kwargs']
                p = Process(target=instance, args=args, kwargs=kwargs)
                p.start()

                if not threaded:
                    p.join()
            jobs = self.connection.llen(self.key) if not once else -1

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import llen [as 别名]
class Repository:

    def __init__(self, host, port):
        self.r = StrictRedis(host=host, port=port)

# store dictionary
#    redis.hmset(hkey, dict_to_store)
# retrieve dictionary
#    redis.hmget(hkey)
# lists
#    redis.lappend(hkey, string)
#    redis.llen

    def get_item(self, key_store, index):
        length = self.r.llen(key_store)
        if length == 0:
            return None
        if index >= length:
            raise Exception('Index out of range.')
        item_json = self.r.lindex(key_store, length - (index + 1))
        item_dict = json.loads(item_json)
        return item_dict

    def append_item(self, key_store, item):
        item_json = json.dumps(item)
        if not self.r.lpush(key_store, item_json):
            raise Exception('Unable to write key_store: [%s]' % item_json)

    def fetch_all(self, key_store):
        q = []
        length = self.r.llen(key_store)
        for i in range(length):
            item_json = self.r.lindex(key_store, length - (i + 1))
            item_dict = json.loads(item_json)
            q.append(item_dict)
        return q

    def set(self, key_store, list):
        self.r.delete(key_store)
        for item_dict in list:
            item_json = json.dumps(item_dict)
            if not self.r.lpush(key_store, item_json):
                raise Exception('Unable to write key_store: [%s]' % item_json)

    def delete(self, key_store):
        self.r.delete(key_store)

    def info(self):
        return self.r.info()

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import llen [as 别名]
class JSONRedisBackend(BaseBackend):

    def __init__(self):
        self.redis = StrictRedis()

    def serialize(self, value):
        return json.dumps(value)

    def deserialize(self, value):
        return value and json.loads(value) or None

    def get(self, key):
        value = self.redis.get(key)
        result = self.deserialize(value)
        return result

    def set(self, key, value):
        product = self.serialize(value)
        return self.redis.set(key, product)

    def rpush(self, key, value):
        product = self.serialize(value)
        return self.redis.rpush(key, product)

    def lpush(self, key, value):
        product = self.serialize(value)
        return self.redis.lpush(key, product)

    def lpop(self, key):
        value = self.redis.lpop(key)
        result = self.deserialize(value)
        return result

    def llen(self, key):
        return self.redis.llen(key)

    def rpop(self, key):
        value = self.redis.rpop(key)
        result = self.deserialize(value)
        return result

    def report_steps(self, name, consumers, producers):
        pipeline = self.redis.pipeline()
        producers_key = ':'.join([name, 'producers'])
        consumers_key = ':'.join([name, 'consumers'])

        for consumer in consumers:
            pipeline.sadd(consumers_key, consumer)

        for producer in producers:
            pipeline.sadd(producers_key, producer)

        pipeline.smembers(consumers_key)
        pipeline.smembers(producers_key)

        result = pipeline.execute()
        all_consumers = result[-2]
        all_producers = result[-1]

        return all_consumers, all_producers

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import llen [as 别名]
class DbRedis(Db):
    def __init__(self):
        super().__init__()
        self.redis = StrictRedis(**dbSettings)

    def generateKey(self):
        return self.redis.incr("id")

    def store(self, key, objSerial):
        self.redis.setex(key, TTL, objSerial)

    def retrieve(self, key):
        return self.redis.get(key)

    def lenList(self, name):
        return self.redis.llen(name)

    def listAppend(self, name, val):
        self.redis.lpush(name, val)

    def listPopLeft(self, name):
        return self.redis.lpop(name)

    def retrieveList(self, name):
        return self.redis.lrange(name, 0, -1)

    def removeFromList(self, name, item):
        self.redis.lrem(name, item, 0)

    def keyExists(self, key):
        return self.redis.exists(key)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import llen [as 别名]
class RedisQueue():
    def __init__(self):
        """
        初始化Redis
        """
        self.db = StrictRedis(host=REDIS_HOST, port=REDIS_PORT, password=REDIS_PASSWORD)

    def add(self, request):
        """
        向队列添加序列化后的Request
        :param request: 请求对象
        :return: 添加结果
        """
        if isinstance(request, WeixinRequset):
            return self.db.rpush(REDIS_KEY, dumps(request))
        return False

    def pop(self):
        """
        取出下一个Request并反序列化
        :return: Request or None
        """
        if self.db.llen(REDIS_KEY):
            return loads(self.db.lpop(REDIS_KEY))
        else:
            return False

    def clear(self):
        self.db.delete(REDIS_KEY)

    def empty(self):
        """
        检查是否为空
        :return:
        """
        return self.db.llen(REDIS_KEY) == 0

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import llen [as 别名]
class VisualDebugger:

    def __init__(self):
        self.available_buckets = config["visual_debugger"]["available_buckets"]
        self.bucket_generator = itertools.cycle(self.available_buckets)

        self.redis_client = StrictRedis(**config["redis"])
        self.clear_image_data()

    def store_image_data(self, image_data, image_shape, bucket="debug"):
        self.redis_client.lpush(f"{config['visual_debugger']['redis_key_prefix']}:{bucket}:SHAPE", pickle.dumps(image_shape))
        self.redis_client.lpush(f"{config['visual_debugger']['redis_key_prefix']}:{bucket}", image_data.tobytes())

    def retrieve_image_data(self):
        bucket = next(self.bucket_generator)
        bucket_key = f"{config['visual_debugger']['redis_key_prefix']}:{bucket}"

        response = self.redis_client.rpop(bucket_key)

        if response is not None:
            bucket = bucket_key.split(":")[-1]

            image_shape = self.redis_client.rpop(f"{config['visual_debugger']['redis_key_prefix']}:{bucket}:SHAPE")
            image_shape = pickle.loads(image_shape)

            image_data = np.fromstring(response, dtype="uint8").reshape(image_shape)

            return bucket, image_data

        return None

    def save_image_data(self, bucket, image_data):
        if bucket in self.available_buckets:
            if image_data.dtype == "bool" or (image_data.dtype == "uint8" and 1 in np.unique(image_data)):
                image_data = image_data.astype("uint8") * 255

            skimage.io.imsave(f"{bucket}.png", image_data)

    def clear_image_data(self):
        visual_debugger_keys = self.redis_client.keys(f"{config['visual_debugger']['redis_key_prefix']}*")

        for key in visual_debugger_keys:
            self.redis_client.delete(key.decode("utf-8"))

    def get_bucket_queue_length(self, bucket):
        return self.redis_client.llen(f"{config['visual_debugger']['redis_key_prefix']}:{bucket}")

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import llen [as 别名]
class QueueClient(object):
    """Interface to a Redis queue/hashmap combo for managing account sync
    allocation.
    """

    # Lua scripts for atomic assignment and conflict-free unassignment.
    ASSIGN = """
    local k = redis.call('RPOP', KEYS[1])
    if k then
        local s = redis.call('HSETNX', KEYS[2], k, ARGV[1])
        if s then
            return k
        end
    end"""

    UNASSIGN = """
    if redis.call('HGET', KEYS[1], KEYS[2]) == ARGV[1] then
        return redis.call('HDEL', KEYS[1], KEYS[2])
    else
        return 0
    end
    """

    def __init__(self, zone):
        self.zone = zone
        redis_host = config["ACCOUNT_QUEUE_REDIS_HOSTNAME"]
        redis_db = config["ACCOUNT_QUEUE_REDIS_DB"]
        self.redis = StrictRedis(
            host=redis_host, db=redis_db, socket_connect_timeout=SOCKET_CONNECT_TIMEOUT, socket_timeout=SOCKET_TIMEOUT
        )

    def all(self):
        """
        Returns all keys being tracked (either pending in the queue, or
        already assigned).
        """
        p = self.redis.pipeline(transaction=True)
        p.hgetall(self._hash)
        p.lrange(self._queue, 0, -1)
        unassigned, assigned = p.execute()
        return {int(k) for k in itertools.chain(unassigned, assigned)}

    def assigned(self):
        """
        Returns a dictionary of all currently assigned key/value pairs (keys
        are coerced to integers).
        """
        return {int(k): v for k, v in self.redis.hgetall(self._hash).items()}

    def enqueue(self, key):
        """
        Adds a new key onto the pending queue.
        """
        self.redis.lpush(self._queue, key)

    def claim_next(self, value):
        """
        Pulls the next key off of the pending queue (if any exists), and sets
        it to `value` in the hash. Returns None if the queue is empty or if the
        key is already present in the hash; otherwise returns the key.
        """
        s = self.redis.register_script(self.ASSIGN)
        return s(keys=[self._queue, self._hash], args=[value])

    def unassign(self, key, value):
        """
        Removes `key` from the hash, if and only if it is present and set to
        `value` (to prevent removing a key actually assigned to someone else).
        """
        s = self.redis.register_script(self.UNASSIGN)
        return s(keys=[self._hash, key], args=[value])

    def qsize(self):
        """
        Returns current length of the queue.
        """
        return self.redis.llen(self._queue)

    @property
    def _queue(self):
        return "unassigned_{}".format(self.zone)

    @property
    def _hash(self):
        return "assigned_{}".format(self.zone)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import llen [as 别名]
class RedisQueue(object):
    _cli = None
    _connection_parameters = dict()
    _queue = None

    logger = getLogger()

    def __init__(self, **kwargs):
        self._queue = kwargs.pop('queue', None)
        self._connection_parameters.update(kwargs)

    def connect(self, **kwargs):
        if self._cli and not kwargs:
            return self

        self._queue = kwargs.pop('queue') if kwargs.get('queue') else self._queue
        self._connection_parameters.update(kwargs)

        if not self._connection_parameters:
            raise QueueConnectionError

        self._cli = StrictRedis(**self._connection_parameters)
        return self

    def put(self, message, **kwargs):
        self.connect() if not self._cli else None
        queue = kwargs.pop('queue') if kwargs.get('queue') else self._queue
        publisher = kwargs.pop('publisher') if kwargs.get('publisher') else 'default'

        pipe = self._cli.pipeline()
        return pipe.lpush(queue, dumps(message)).publish(publisher, queue).execute()

    def get(self, **kwargs):
        self.connect() if not self._cli else None
        queue = kwargs.pop('queue') if kwargs.get('queue') else self._queue
        timeout = kwargs.pop('timeout') if isinstance(kwargs.get('timeout'), int) else 1

        try:
            return loads(self._cli.brpop(queue, timeout)[1])
        except TypeError:
            return None
        except ValueError:
            return None

    def length(self, queue=None):
        self.connect() if not self._cli else None
        queue = queue if queue else self._queue

        return self._cli.llen('{0}'.format(queue))

    @property
    def queue(self):
        return self._queue

    @queue.setter
    def queue(self, value):
        self._queue = value

    @queue.deleter
    def queue(self):
        self._queue = None

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import llen [as 别名]
class TaskTest(TestCase):
    def setUp(self):
        self.redis = StrictRedis(**settings.REDISES['default'])
        self.job_changes_pool_key = 'queue_job_changes'
        self.job_sync = JobSync(self.redis)

    def tearDown(self):
        Task.objects.all().delete()
        #self.redis.delete('active_jobs_pool')
        self.redis.delete(self.job_changes_pool_key)
        self.redis.delete('job_stats.1')

    def testAddJob(self):
        task = self.generateTask()
        task.run_time = '{"days":0, "hours":0, "minutes":10, "seconds":0}'
        task.save()
        self.assertTrue(task.id > 0)

        job = task.getJob()
        now = Task.objects.now()
        self.assertTrue(job.compute_next_run_time(now) is not None)
        self.assertEqual(600, job.trigger.interval_length)
        self.assertEqual(task.run_entry, job.func)

        self.assertEqual(1, self.redis.llen(self.job_changes_pool_key))

    def testGetJob(self):
        task = self.generateTask()
        task.save()
        job = task.getJob()
        self.assertEqual(task.id, job.id)
        self.assertEqual(task.name, job.name)
        self.assertEqual(task.run_entry, job.func)
        self.assertEqual(str(task.getTrigger()), str(job.trigger))

    def testDelete(self):
        task = self.generateTask()
        task.active = 1
        task.save()
        now = Task.objects.now()
        job_id, change_type, job = self.job_sync.pop(now)
        self.assertEqual(task.id, job_id)
        self.assertEqual('add', change_type)

        task_id = task.id
        task.delete()
        job_id, change_type, job = self.job_sync.pop(now)
        self.assertEqual(task_id, job_id)
        self.assertEqual('remove', change_type)

    def testUpdate(self):
        task = self.generateTask()
        task.save()
        now = Task.objects.now()
        job_id, change_type, job = self.job_sync.pop(now)
        task.run_time = '2013-09-10 00:00:00'
        task.type = 'date'
        task.save()
        job_id, change_type, job = self.job_sync.pop(now)
        self.assertEqual(task.id, job_id)
        self.assertEqual('update', change_type)

    def testEnable(self):
        task = self.generateTask()
        task.active = 0
        task.save()
        self.assertEqual(0, self.job_sync.count())
        task.disable()
        self.assertEqual(0, self.job_sync.count())

        task.enable()
        now = Task.objects.now()
        job_id, change_type, job = self.job_sync.pop(now)
        self.assertEqual(task.id, job_id)
        self.assertEqual('add', change_type)

    def generateTask(self):
        task = Task()
        task.name = 'Task1'
        task.run_time = '{"days":0, "hours":0, "minutes":10, "seconds":0}'
        task.run_entry = 'http://baidu.com'
        task.run_method = 'post'
        task.active = 1
        return task

    def testDisable(self):
        task = self.generateTask()
        task.active = 1
        task.save()

        now = Task.objects.now()
        job_id, change_type, job = self.job_sync.pop(now)
        self.assertEqual(task.id, job_id)
        self.assertEqual('add', change_type)

        task.enable()
        self.assertEqual(0, self.job_sync.count())

        task.disable()
        job_id, change_type, job = self.job_sync.pop(now)
#.........这里部分代码省略.........

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import llen [as 别名]
class RedisHelper:
    prefix = "bc:chart:cache"

    def __init__(self, host=None, port=None, prefix=None):
        # 这里读取redis配置信息，用到了conf.py里面的函数
        self._host = host
        self._port = int(port)
        self._redis = StrictRedis(host=self._host, port=self._port)

    def gen_key(self, chart_id):
        return "%s:%s" % (self.prefix, chart_id)

    def put(self, chart_id, data, expire=2000):
        key = self.gen_key(chart_id)
        self._redis.set(key, dumps(data))
        self._redis.expire(key, expire)
        return True

    def delete(self, chart_id):
        key = self.gen_key(chart_id)
        self._redis.delete(key)

    def deleteN(self, chart_id):
        key = self.gen_key(chart_id)
        keys = self._redis.keys("%s*" % key)
        for k in keys:
            self._redis.delete(k)

    def get(self, chart_id):
        key = self.gen_key(chart_id)
        data = self._redis.get(key)
        return {} if not data else loads(data)

    def hset(self, key, field, value):
        self._redis.hset(key, field, value)

    def hmget(self, key, fields):
        return self._redis.hmget(key, fields)

    def flush(self):
        keys = self._redis.keys("%s*" % self.prefix)
        pipe = self._redis.pipeline()
        for key in keys:
            pipe.delete(key)
        pipe.execute()

    # the type of value is list
    def list_push(self, key, data):
        return self._redis.rpush(key, dumps(data))
    # pop the head element of the list

    def list_pop(self, key):
        return self._redis.lpop(key)

    # pop all elements of the list
    def list_all_pop(self, key):
        while True:
            if self.list_size(key) == 0:
                self._redis.delete(key)
                break
            res = self._redis.lpop(key)
            if res:
                yield loads(res)

    # the length of list
    def list_size(self, key):
        return self._redis.llen(key)

    @property
    def redis(self):
        return self._redis

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import llen [as 别名]
class JSONRedisBackend(BaseBackend):
    def initialize(self):
        conf = env.get_uri("LINEUP_REDIS_URI")

        self.redis = StrictRedis(
            db=conf.username or 0,
            host=conf.host,
            port=conf.port,
            # using `path` as password to support the URI like:
            # redis://[email protected]:port/veryverylongpasswordhash
            password=conf.path,
        )

    def serialize(self, value):
        return json.dumps(value, default=bytes)

    def deserialize(self, value):
        return value and json.loads(value) or None

    # read operations
    @io_operation
    def get(self, key):
        value = self.redis.get(key)
        result = self.deserialize(value)
        return result

    @io_operation
    def lpop(self, key):
        value = self.redis.lpop(key)
        result = self.deserialize(value)
        return result

    @io_operation
    def llen(self, key):
        return self.redis.llen(key)

    @io_operation
    def lrange(self, key, start, stop):
        return map(self.deserialize, self.redis.lrange(key, start, stop))

    @io_operation
    def rpop(self, key):
        value = self.redis.rpop(key)
        result = self.deserialize(value)
        return result

    # Write operations
    @io_operation
    def set(self, key, value):
        product = self.serialize(value)
        return self.redis.set(key, product)

    @io_operation
    def rpush(self, key, value):
        product = self.serialize(value)
        return self.redis.rpush(key, product)

    @io_operation
    def lpush(self, key, value):
        product = self.serialize(value)
        return self.redis.lpush(key, product)

    # Pipeline operations
    @io_operation
    def report_steps(self, name, consumers, producers):
        pipeline = self.redis.pipeline()
        producers_key = ':'.join([name, 'producers'])
        consumers_key = ':'.join([name, 'consumers'])

        for consumer in consumers:
            pipeline.sadd(consumers_key, consumer)

        for producer in producers:
            pipeline.sadd(producers_key, producer)

        pipeline.smembers(consumers_key)
        pipeline.smembers(producers_key)

        result = pipeline.execute()
        all_consumers = result[-2]
        all_producers = result[-1]

        return all_consumers, all_producers

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import llen [as 别名]
            del post['uid']

            # Look up the `username` for the `user_id` and attach this to the
            # post. We now store this de-normalized to reduce reads
            post['username'] = \
                r.hget(USER.format(post.get('user_id')), 'username')

            # `pid` becomes `_id`
            post_id = post.get('pid')
            post['_id'] = post_id
            del post['pid']

            # Get the count of comments for the post and add the new key
            # This is now de-normalized
            post['comment_count'] = \
                r.llen(POST_COMMENTS.format(post_id))

            post['created'] = float(post.get('created'))
            post['score'] = int(post.get('score'))

            if m.pjuu.posts.insert(post):
                r.delete(POST.format(post_id))
                r.delete(POST_COMMENTS.format(post_id))

    # Convert all comments to become posts.
    # DUPLICATES CAN HAPPEN HERE AND ARE EXPECTED. COMMENTS WHICH COLLIDE WILL
    # BE GIVEN A NEW `_id`.
    # There is a duplication of code here but as its a script I want
    # readability to be a priority (this could brick some installations).
    for key in r.keys('{comment:*}'):
        if COMMENT_RE.match(key) is not None:

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import llen [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()

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import llen [as 别名]
class Game(offshoot.Pluggable):

    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.config = config.get(f"{self.__class__.__name__}Plugin")

        self.platform = kwargs.get("platform")

        self.window_id = None
        self.window_name = kwargs.get("window_name")
        self.window_geometry = None

        self.is_launched = False

        self.frame_grabber_process = None
        self.game_frame_limiter = GameFrameLimiter(fps=self.config.get("fps", 4))

        self.sprites = self._discover_sprites()

        self.redis_client = StrictRedis(**config["redis"])

        self.kwargs = kwargs

    @property
    @offshoot.forbidden
    def game_launcher(self):
        return self.game_launchers.get(self.platform)

    @property
    @offshoot.forbidden
    def game_launchers(self):
        return {
            "steam": SteamGameLauncher
        }

    @property
    @offshoot.expected
    def screen_regions(self):
        raise NotImplementedError()

    @property
    @offshoot.forbidden
    def is_focused(self):
        focused_window_id = subprocess.check_output(shlex.split("xdotool getwindowfocus")).decode("utf-8").strip()
        return focused_window_id == self.window_id

    @offshoot.forbidden
    def launch(self, dry_run=False):
        self.before_launch()

        if not dry_run:
            self.game_launcher().launch(**self.kwargs)

        self.after_launch()

    def before_launch(self):
        pass

    def after_launch(self):
        self.is_launched = True

        time.sleep(5)

        self.window_id = subprocess.check_output(shlex.split(f"xdotool search --name \"{self.window_name}\"")).decode("utf-8").strip()

        subprocess.call(shlex.split(f"xdotool windowmove {self.window_id} 0 0"))
        subprocess.call(shlex.split(f"xdotool windowactivate {self.window_id}"))

        self.window_geometry = self.extract_window_geometry()
        print(self.window_geometry)

    def play(self, game_agent_class_name=None):
        if not self.is_launched:
            raise GameError(f"Game '{self.__class__.__name__}' is not running...")

        game_agent_class = offshoot.discover("GameAgent").get(game_agent_class_name)

        if game_agent_class is None:
            raise GameError("The provided Game Agent class name does not map to an existing class...")

        game_agent = game_agent_class(
            game=self,
            input_controller=InputController(game_window_id=self.window_id)
        )

        self.start_frame_grabber()
        self.redis_client.delete(config["frame_grabber"]["redis_key"])

        while self.redis_client.llen(config["frame_grabber"]["redis_key"]) == 0:
            time.sleep(0.1)

        subprocess.call(shlex.split(f"xdotool windowactivate {self.window_id}"))

        while True:
            self.game_frame_limiter.start()

            game_frame = self.grab_latest_frame()
            try:
                if self.is_focused:
                    game_agent.on_game_frame(game_frame)
#.........这里部分代码省略.........

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import llen [as 别名]
    sys.exit(0)


if __name__ == "__main__":
    signal.signal(signal.SIGTERM, sigterm_handler)
    r = False
    while not r:
        try:
            r = StrictRedis(host="inbox-redis", port=6379, db=0)
        except:
            print("Waiting for redis...")
            time.sleep(2)

    last_check = None
    last_count = 0

    try:
        while True:
            count = r.llen("incoming_urls")
            if last_check is not None:
                print("Queue size: %d" % count)
                if count > last_count:
                    diff = count - last_count
                    if diff > QUEUE_GROWTH_THRESHOLD:
                        print("Queue growth of %d exceeds limit. Need to do something." % diff)
            last_count = count
            last_check = time.time()
            time.sleep(INTERVAL_SECONDS)
    finally:
        print("Exiting")