def __init__(self, content, id):
self.content = content
self.interseting_input = {}
self.reset_intersting_input()
lgm = common_utils.SingletonRotateLoggerManager()
self.logger = lgm.create_logger(logger_name="session_contents" +
str(id))
self.start_order = \
StartOrder(self.content, self.interseting_input)
self.cancel_order = \
CancelOrder(self.content, self.interseting_input)
self.make_purchase_list = \
MakePurchaseList(self.content, self.interseting_input)
self.additional_purchase_list = \
AdditionalPucharseList(self.content, self.interseting_input)
self.add_phone_before_complete_order = \
AddPhoneBeforeCompleteOrder(self.content, self.interseting_input)
self.complete_order = CompleteOrder(self.content,
self.interseting_input)
self.start_order.add_next_states([self.make_purchase_list])
self.cancel_order.add_next_states([self.start_order])
self.make_purchase_list.add_next_states(
[self.add_phone_before_complete_order, self.cancel_order])
self.add_phone_before_complete_order.add_next_states(
[self.additional_purchase_list, self.cancel_order])
self.additional_purchase_list.add_next_states(
[self.add_phone_before_complete_order, self.cancel_order])
self.complete_order.add_next_states([self.start_order])
self.transition_to(self.start_order)
def __init__(self, redponder_ids, response_listeners):
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
lgm = common_utils.SingletonRotateLoggerManager()
self.logger = lgm.create_logger("responder manager")
self.redponder_ids = redponder_ids
self.responder_queues = {}
self.responders_coros = {}
self.o2o_working_coros_name_and_id = common_utils.one_to_one_dict()
self.unused_coros_names = set(redponder_ids)
self.logger.info(self.unused_coros_names)
self.response_listeners = response_listeners
self.logic_manager = SessionResposeLogicManager(redponder_ids)
list_of_resters = [
lambda name=name: self.make_coro_ready_for_new_session(name)
for name in self.redponder_ids]
for name, reset_me in zip(self.redponder_ids, list_of_resters):
self.set_responder_queue(name, asyncio.Queue())
self.set_responder_coro(
name, message_responder(
name,
self.get_responder_queue(name),
self.get_response_logic(name),
self.response_listeners,
reset_me))
self.loop.create_task(main_coroutine(self, self.redponder_ids))
def __init__(self, content, name="", sessionsee_name=""):
self.name = name
lgm = common_utils.SingletonRotateLoggerManager()
self.logger = lgm.create_logger(logger_name='-'.join(("session_logic",
self.name)))
self.contet = content
self.reset(sessionsee_name)
self._current_state = None
self._new_state = None
async def main_coroutine(manager, redponder_ids):
lgm = common_utils.SingletonRotateLoggerManager()
logger = lgm.create_logger("main_coroutine ")
logger.info("main_coroutine wait for all responder to finish")
await asyncio.gather(*manager.get_responder_coros())
logger.info("main_coroutine all responder to finished")
for task in asyncio.Task.all_tasks():
task.cancel()
def __init__(self, *args, post_callback_list=[], **kwargs):
super(TelegramBot, self).__init__()
lgm = common_utils.SingletonRotateLoggerManager()
self.logger = lgm.create_logger(logger_name="bot")
self.post_callback_list = []
self.post_callback_list.append(print)
self.post_callback_list.extend(post_callback_list)
self.logger.info("call back list is " + str(self.post_callback_list))
self.route('/', callback=self._post_handler, method="POST")
async def message_responder(
name, queue, session_logic, response_listeners, reset_me):
lgm = common_utils.SingletonRotateLoggerManager()
logger = lgm.create_logger(f"message responder {name}")
while True:
# Get a "work item" out of the queue.
new_msg = {}
logger.info(f'waiting for queue to fill')
timeout_duration_sec = TIMEOUT_SEC
if not session_logic.session_started():
timeout_duration_sec = None
logger.info(f'update timeout to {timeout_duration_sec} in coro {name}')
try:
queue_output = dict()
await asyncio.wait_for(
get_new_value_from_queue(queue, queue_output),
timeout=timeout_duration_sec)
new_msg = queue_output["content"]
logger.info(queue_output)
logger.info(new_msg)
except asyncio.TimeoutError:
session_logic.reset()
reset_me()
logger.info(
f"""
Responder reseted because of time out,after {
timeout_duration_sec}""")
continue
logger.info("new msg")
response_content = session_logic.process_message(new_msg)
response = {"chat_id": new_msg["id"], "text": response_content}
logger.info(response)
for response_listener in response_listeners:
response_listener(response)
# Notify the queue that the "work item" has been processed.
queue.task_done()
logger.info("new msg processes")
def create_session_fiber_manager(manager):
manager.start()
def run_ngrok():
ngrok_starter.run_ngrok()
def return_on_key_press():
input("Press Enter to end \n")
if __name__ == "__main__":
lgm = common_utils.SingletonRotateLoggerManager()
logger = lgm.create_logger()
logger.info("before creating thread")
ngrok_thread = threading.Thread(target=run_ngrok, daemon=True)
key_press_thread = threading.Thread(
target=return_on_key_press, daemon=True)
telegram_listener = telegram_bot.TelegramBot()
response_listeners = telegram_listener.get_response_handlers()
redponder_ids = [f"{num}" for num in range(NUM_OF_RESPONDERS)]
manager = ResponderManager(redponder_ids, response_listeners)
fiber_manager_thread = threading.Thread(
target=create_session_fiber_manager, args=(manager,), daemon=True)