class Message2Redis(Routine):
def __init__(self, out_key, url, queue, maxlen, *args, **kwargs):
super().__init__(*args, **kwargs)
self.out_key = out_key
self.url = url
self.q_handler = QueueHandler(queue)
self.maxlen = maxlen
self.msg_handler = None
def main_logic(self, *args, **kwargs):
msg = self.q_handler.non_blocking_get()
if msg:
msg.record_exit(self.component_name, self.logger)
encoded_msg = message_encode(msg)
self.msg_handler.send(self.out_key, encoded_msg)
return True
else:
return False
def setup(self, *args, **kwargs):
self.msg_handler = RedisHandler(self.url, self.maxlen)
self.msg_handler.connect()
def cleanup(self, *args, **kwargs):
self.msg_handler.close()
class Message2Redis(Routine):
def __init__(self, out_key, url, queue, maxlen, *args, **kwargs):
super().__init__(*args, **kwargs)
self.out_key = out_key
self.url = url
self.queue = queue
self.maxlen = maxlen
self.msg_handler = None
def main_logic(self, *args, **kwargs):
try:
msg = self.queue.get(block=False)
msg.record_exit(self.component_name, self.logger)
encoded_msg = message_encode(msg)
self.msg_handler.send(encoded_msg, self.out_key)
time.sleep(0)
return True
except Empty:
time.sleep(0) # yield the control of the thread
return False
def setup(self, *args, **kwargs):
self.msg_handler = RedisHandler(self.url, self.maxlen)
self.msg_handler.connect()
def cleanup(self, *args, **kwargs):
self.msg_handler.close()
def setup(self, *args, **kwargs):
self.msg_handler = RedisHandler(self.url)
if self.most_recent:
self.read_method = self.msg_handler.read_most_recent_msg
else:
self.read_method = self.msg_handler.read_next_msg
self.msg_handler.connect()
class MessageFromRedis(Routine):
def __init__(self, in_key, url, queue, most_recent=True, *args, **kwargs):
super().__init__(*args, **kwargs)
self.in_key = in_key
self.url = url
self.q_handler = QueueHandler(queue)
self.msg_handler = None
self.most_recent = most_recent
self.read_method = None
self.flip = False
self.negative = False
def main_logic(self, *args, **kwargs):
encoded_msg = self.read_method(self.in_key)
if encoded_msg:
msg = message_decode(encoded_msg)
msg.record_entry(self.component_name, self.logger)
success = self.q_handler.deque_non_blocking_put(msg)
return success
else:
time.sleep(0)
return None
def setup(self, *args, **kwargs):
self.msg_handler = RedisHandler(self.url)
if self.most_recent:
self.read_method = self.msg_handler.read_most_recent_msg
else:
self.read_method = self.msg_handler.read_next_msg
self.msg_handler.connect()
def cleanup(self, *args, **kwargs):
self.msg_handler.close()
class MessageFromRedis(Routine):
routine_type = RoutineTypes.INPUT
def __init__(self, redis_read_key, message_queue, *args, **kwargs):
super().__init__(*args, **kwargs)
self.redis_read_key = redis_read_key
self.url = urlparse(os.environ.get('REDIS_URL', "redis://127.0.0.1:6379"))
self.message_queue = message_queue
self.msg_handler = None
self.flip = False
self.negative = False
def main_logic(self, *args, **kwargs):
encoded_msg = self.msg_handler.read_most_recent_msg(self.redis_read_key)
if encoded_msg:
msg = message_decode(encoded_msg)
msg.record_entry(self.component_name, self.logger)
try:
self.message_queue.put(msg, block=False)
return True
except Full:
try:
self.message_queue.get(block=False)
except Empty:
pass
finally:
self.message_queue.put(msg, block=False)
return True
else:
time.sleep(0)
return False
def setup(self, *args, **kwargs):
self.msg_handler = RedisHandler(self.url)
def cleanup(self, *args, **kwargs):
self.msg_handler.close()
@staticmethod
def get_constructor_parameters():
dicts = Routine.get_constructor_parameters()
dicts.update({
"redis_read_key": "String",
"message_queue": "QueueOut"
})
return dicts
def does_routine_use_queue(self, queue):
return self.message_queue == queue
class MetaAndFrameFromRedis(Routine):
def __init__(self, in_key_meta, in_key_im, url, queue, *args, **kwargs):
super().__init__(*args, **kwargs)
self.in_key_meta = in_key_meta
self.in_key_im = in_key_im
self.url = url
self.queue = queue
self.msg_handler = None
self.flip = False
self.negative = False
def receive_msg(self, in_key):
encoded_msg = self.msg_handler.receive(in_key)
if not encoded_msg:
return None
msg = message_decode(encoded_msg)
msg.record_entry(self.component_name, self.logger)
return msg
def main_logic(self, *args, **kwargs):
pred_msg = self.receive_msg(self.in_key_meta)
frame_msg = self.receive_msg(self.in_key_im)
if frame_msg:
arr = frame_msg.get_payload()
if self.flip:
arr = cv2.flip(arr, 1)
if self.negative:
arr = 255 - arr
try:
self.queue.get(block=False)
except Empty:
pass
frame_msg.update_payload(arr)
self.queue.put((frame_msg, pred_msg))
return True
else:
time.sleep(0)
return False
def setup(self, *args, **kwargs):
self.msg_handler = RedisHandler(self.url)
def cleanup(self, *args, **kwargs):
self.msg_handler.close()
class MetaAndFrameFromRedis(Routine):
def __init__(self, in_key_meta, in_key_im, url, queue, *args, **kwargs):
super().__init__(*args, **kwargs)
self.in_key_meta = in_key_meta
self.in_key_im = in_key_im
self.url = url
self.q_handler = QueueHandler(queue)
self.msg_handler = None
self.flip = False
self.negative = False
def receive_msg(self, in_key, most_recent=True):
if most_recent:
encoded_msg = self.msg_handler.read_most_recent_msg(in_key)
else:
encoded_msg = self.msg_handler.receive(in_key)
if not encoded_msg:
return None
msg = message_decode(encoded_msg)
msg.record_entry(self.component_name, self.logger)
return msg
def main_logic(self, *args, **kwargs):
pred_msg = self.receive_msg(self.in_key_meta, most_recent=False)
frame_msg = self.receive_msg(self.in_key_im, most_recent=True)
if frame_msg:
arr = frame_msg.get_payload()
if self.flip:
arr = cv2.flip(arr, 1)
if self.negative:
arr = 255 - arr
frame_msg.update_payload(arr)
success = self.q_handler.deque_non_blocking_put(
(frame_msg, pred_msg))
return success
else:
time.sleep(0)
return False
def setup(self, *args, **kwargs):
self.msg_handler = RedisHandler(self.url)
def cleanup(self, *args, **kwargs):
self.msg_handler.close()
class MessageToRedis(Routine):
routine_type = RoutineTypes.OUTPUT
def __init__(self, redis_send_key, message_queue, max_stream_length, *args,
**kwargs):
super().__init__(*args, **kwargs)
self.redis_send_key = redis_send_key
self.url = urlparse(
os.environ.get('REDIS_URL', "redis://127.0.0.1:6379"))
self.message_queue = message_queue
self.max_stream_length = max_stream_length
self.msg_handler = None
def main_logic(self, *args, **kwargs):
try:
msg = self.message_queue.get(block=False)
msg.record_exit(self.component_name, self.logger)
encoded_msg = message_encode(msg, generator=self.generator)
self.msg_handler.send(self.redis_send_key, encoded_msg)
time.sleep(0)
return True
except Empty:
time.sleep(0) # yield the control of the thread
return False
def setup(self, *args, **kwargs):
self.msg_handler = RedisHandler(self.url, self.max_stream_length)
self.msg_handler.connect()
def cleanup(self, *args, **kwargs):
self.msg_handler.close()
@staticmethod
def get_constructor_parameters():
dicts = Routine.get_constructor_parameters()
dicts.update({
"redis_send_key": "String",
"message_queue": "QueueIn",
"max_stream_length": "Integer"
})
return dicts
def does_routine_use_queue(self, queue):
return self.message_queue == queue
class MessageFromRedis(Routine):
def __init__(self, in_key, url, queue, *args, **kwargs):
super().__init__(*args, **kwargs)
self.in_key = in_key
self.url = url
self.queue = queue
self.msg_handler = None
self.flip = False
self.negative = False
def main_logic(self, *args, **kwargs):
encoded_msg = self.msg_handler.receive(self.in_key)
if encoded_msg:
msg = message_decode(encoded_msg)
msg.record_entry(self.component_name, self.logger)
try:
self.queue.put(msg, block=False)
return True
except Full:
try:
self.queue.get(block=False)
except Empty:
pass
finally:
self.queue.put(msg, block=False)
return True
else:
time.sleep(0)
return False
def setup(self, *args, **kwargs):
self.msg_handler = RedisHandler(self.url)
self.msg_handler.connect()
def cleanup(self, *args, **kwargs):
self.msg_handler.close()
def setup(self, *args, **kwargs):
self.msg_handler = RedisHandler(self.url)
def setup(self, *args, **kwargs):
self.msg_handler = RedisHandler(self.url, self.maxlen)
self.msg_handler.connect()
def setup(self, *args, **kwargs):
self.msg_handler = RedisHandler(self.url, self.max_stream_length)
self.msg_handler.connect()
class MetaAndFrameFromRedisClassification(Routine):
routine_type = RoutineTypes.INPUT
def __init__(self, redis_read_meta_key, redis_read_image_key,
image_meta_queue, *args, **kwargs):
super().__init__(*args, **kwargs)
self.redis_read_meta_key = redis_read_meta_key
self.redis_read_image_key = redis_read_image_key
self.url = urlparse(
os.environ.get('REDIS_URL', "redis://127.0.0.1:6379"))
self.image_meta_queue = image_meta_queue
self.msg_handler = None
self.flip = False
self.negative = False
def receive_msg(self, in_key, most_recent=True):
if most_recent:
encoded_msg = self.msg_handler.read_most_recent_msg(in_key)
else:
encoded_msg = self.msg_handler.receive(in_key)
if not encoded_msg:
return None
msg = message_decode(encoded_msg)
msg.record_entry(self.component_name, self.logger)
return msg
def main_logic(self, *args, **kwargs):
pred_msg = self.receive_msg(self.redis_read_meta_key,
most_recent=False)
frame_msg = self.receive_msg(self.redis_read_image_key)
if frame_msg:
arr = frame_msg.get_payload()
if self.flip:
arr = cv2.flip(arr, 1)
if self.negative:
arr = 255 - arr
try:
self.image_meta_queue.get(block=False)
except Empty:
pass
frame_msg.update_payload(arr)
self.image_meta_queue.put((frame_msg, pred_msg))
return True
else:
time.sleep(0)
return False
def setup(self, *args, **kwargs):
self.msg_handler = RedisHandler(self.url)
def cleanup(self, *args, **kwargs):
self.msg_handler.close()
@staticmethod
def get_constructor_parameters():
dicts = Routine.get_constructor_parameters()
dicts.update({
"redis_read_meta_key": "String",
"redis_read_image_key": "String",
"image_meta_queue": "QueueOut",
})
return dicts
def does_routine_use_queue(self, queue):
return self.image_meta_queue == queue
def redis_handler():
redis_handler = RedisHandler(urlparse("redis://127.0.0.1:6379"))
yield redis_handler
redis_handler.conn.delete(key)
redis_handler.close()