trjhtr

I'm making a sort of a user interface for a telegram bot and my idea was to use State design pattern for making sort of a wizard for all the process, with user inputting data in each step or pressing /skip for skipping a single step or /cancel for ending everything.

It's working pretty well. I put the states/steps in a list so I can always get to the next one easily by a common method in the parent. Every state is a Borg, so I can instantiate a state everywhere and will always have the same values and methods.

I also made a Singleton class named Progress for putting all the input in the wizard process so I can store it and send it altogether at the end. I know you can use modules in Python as singleton, but I'm more used to this and I prefer not polluting the namespace. I also think this is easier for testing and using.

Being a Python beginner, I'm proud with this code, but I think it has some code smells and it can be improved in terms of design and best practices. I also made it for a single user, but haven't tested two persons accessing the bot simultaneously. I'd like to restrict transitions among states too.

step_states.py:

from abc import ABCMeta, abstractmethod
from telegram import InlineKeyboardButton, InlineKeyboardMarkup, ReplyKeyboardRemove
from telegram.ext import ConversationHandler
from my_package.amazon.search_indexes import SEARCH_INDEXES
from environments import get_blogs

OK = 'OK'
CANCEL = 'CANCEL'
DELETE = 'DELETE'


class StepState(metaclass=ABCMeta):
 """
 This is a Borg class which shares state and methods so all the instances created for it are different references
 but containing the same values. This is also true for children of the same class, so:

 Children1() == Children1() # False, because references are different, but the values are the same.
 Also if you change one, you change the other
 Children1() == Children2() # False, references are different and you can change anyone without affecting the other
 """
 states = 
 name = "state" # This is not used yet. Thinking of deleting it everywhere
 allowed = # This is not used, but could be interesting to allow only some transitions. Just a sketch

 # State is a Borg design pattern class
 __shared_state = 

 def __init__(self):
 self.__dict__ = self.__shared_state

 def __eq__(self, other):
 return self.__hash__() == other.__hash__()

 def message(self, update):
 """
 Returns the object holding the info coming from Telegram with the methods for replying and looking into this info
 :param update: the Telegram update, probably a text message
 :return: the update or query object
 """
 if update.callback_query:
 return update.callback_query.message
 else:
 return update.message

 def draw_ui(self, bot, update):
 """
 Draws the UI in Telegram (usually a custom keyboard) for the user to input data
 :param bot: the Telegram bot
 :param update: the Telegram update, probably a text message
 """
 pass

 @abstractmethod
 def handle(self, bot=None, update=None):
 """
 Handles all the input info into the Progress object and transitions to the next state
 :param bot: the Telegram bot
 :param update: the Telegram update, probably a text message
 """
 self.progress = Progress()
 # TODO How to make cancel() common to all states
 #query = update.callback_query
 #if query.data == CANCEL:
 # return cancel(bot, update)

 def next_state(self, new_state=None):
 """
 Inherited method which decides to move to the next state, or to the specified state if any
 :param new_state: the next state, if any
 :return: the next state
 """
 # TODO Check if the transition is allowed?
 if new_state is None:
 default_next_state_index = (self.index + 1) % len(self.states)
 next_new_state = self.states[default_next_state_index]
 # TODO logging
 logger.info('Current state:', self, ' => switched to new state', next_new_state)
 return next_new_state
 else:
 return new_state

 @property
 def index(self):
 """
 Returns the index of this state within the list with all states
 :return: the index as an int
 """
 return StepState.states.index(self)

 def __hash__(self):
 return hash(self.__class__.name)

 def __str__(self):
 return self.__class__.name


class NoneState(StepState):
 name = 'NoneState'

 def draw_ui(self, bot, update):
 pass

 def handle(self, bot=None, update=None):
 pass


class DepState(StepState):
 name = 'DepState'

 def draw_ui(self, bot, update):
 reply_keyboard = [
 ]
 num_cols = 3
 current_row = 

 # Think of SEARCH_INDEXES as a list with objects having two strings: spanish_description and browse_node_id
 for dep in SEARCH_INDEXES:
 current_row.append(InlineKeyboardButton(dep.spanish_desc,
 callback_data="=".format(dep.browse_node_id, dep.spanish_desc)))
 if len(current_row) >= num_cols:
 reply_keyboard.append(current_row)
 current_row = 
 reply_markup = InlineKeyboardMarkup(reply_keyboard)

 self.message(update).reply_text('Enter the department or /cancel', reply_markup=reply_markup)

 def handle(self, bot=None, update=None):
 super().handle()
 query = update.callback_query
 if query.data:
 current_input_dep, text = query.data.split('=')
 bot.edit_message_text(text="Departament chosen: ".format(text), chat_id=query.message.chat_id,
 message_id=query.message.message_id)

 # We optionally log anything

 Progress().input_dep = current_input_dep

 Progress().next_state()
 Progress().state.draw_ui(bot, update)

 return Progress().state


class NodeState(StepState):
 name = 'NodeState'

 def draw_ui(self, bot, update):
 reply_keyboard = [
 [InlineKeyboardButton(str(number), callback_data=str(number)) for number in range(5)],
 [InlineKeyboardButton(str(number), callback_data=str(number)) for number in range(5, 10)],
 [InlineKeyboardButton('Accept', callback_data=OK),
 InlineKeyboardButton('Cancel', callback_data=CANCEL)],
 ]
 reply_markup = InlineKeyboardMarkup(reply_keyboard)
 self.message(update).reply_text('Input numbers for the node or /cancel', reply_markup=reply_markup)
 # We get the reference to the message we will use to update the value and set into Progress
 Progress().tracking_message = self.message(update).reply_text("Typed data : ".format(''))

 def handle(self, bot=None, update=None):
 super().handle()
 query = update.callback_query
 if query.data == OK:
 # TODO Validate input data
 #logger.info('Input data: '.format(self.progress.input_node))
 bot.edit_message_text(text="Chosen node: ".format(self.progress.input_node), chat_id=query.message.chat_id,
 message_id=query.message.message_id)

 bot.delete_message(chat_id=Progress().tracking_message.chat_id,
 message_id=Progress().tracking_message.message_id)

 Progress().next_state()
 Progress().state.draw_ui(bot, update)

 return Progress().state
 else:
 if not self.progress.input_node:
 self.progress.input_node = ''
 if query.data == DELETE:
 if len(self.progress.input_node):
 self.progress.input_node = self.progress.input_node[:-1]
 else:
 self.progress.input_node += query.data

 # We update the output so the user sees if he types correctly
 bot.edit_message_text(text="Input data: ".format(self.progress.input_node),
 chat_id=query.message.chat_id,
 message_id=Progress().tracking_message.message_id)


class BlogState(StepState):
 name = 'BlogState'

 def draw_ui(self, bot, update):

 reply_keyboard = [
 [InlineKeyboardButton(blog, callback_data='='.format(blog, bid)) for blog, bid in get_blogs().items()]
 ]
 reply_markup = InlineKeyboardMarkup(reply_keyboard)
 self.message(update).reply_text('Choose an option, /skip or /cancel', reply_markup=reply_markup)

 def handle(self, bot=None, update=None):
 super().handle()
 query = update.callback_query
 if query.data:
 bname, bid = query.data.split('=')
 bot.edit_message_text(text="Chosen option: ".format(bname), chat_id=query.message.chat_id,
 message_id=query.message.message_id)

 # We optionally log anything

 # We text the user the requirements for next state
 # query.message.reply_text('Departamento elegido. ', reply_markup=ReplyKeyboardRemove())

 Progress().input_blog = (bname,bid)

 Progress().next_state()
 Progress().state.draw_ui(bot, update)

 return Progress().state


class StartTimeState(StepState):
 name = 'StartTimeState'

 def draw_ui(self, bot, update):
 reply_keyboard = [
 [InlineKeyboardButton('Delete', callback_data=DELETE)],
 [InlineKeyboardButton(str(number), callback_data=str(number)) for number in range(5)],
 [InlineKeyboardButton(str(number), callback_data=str(number)) for number in range(5, 10)],
 [InlineKeyboardButton(':', callback_data=':')],
 [InlineKeyboardButton('Accept', callback_data=OK),
 InlineKeyboardButton('Cancel', callback_data=CANCEL)],
 ]
 reply_markup = InlineKeyboardMarkup(reply_keyboard)
 self.message(update).reply_text('Input start time or /cancel', reply_markup=reply_markup)
 # We get the reference to the message we will use to update the value and set into Progress
 Progress().tracking_message = self.message(update).reply_text("Start time: ".format(''))

 def handle(self, bot=None, update=None):
 super().handle()
 query = update.callback_query
 if query.data == OK:
 # TODO Validate input data
 #logger.info('Intpu data: '.format(self.progress.input_start_time))
 bot.delete_message(chat_id=query.message.chat_id, message_id=query.message.message_id)
 #bot.edit_message_text(text="Input start time: ".format(self.progress.input_start_time),chat_id=query.message.chat_id,message_id=query.message.message_id)

 #bot.delete_message(chat_id=Progress().tracking_message.chat_id,message_id=Progress().tracking_message.message_id)

 Progress().next_state()
 Progress().state.draw_ui(bot, update)

 return Progress().state
 else:
 if not self.progress.input_start_time:
 self.progress.input_start_time = ''
 if query.data == DELETE:
 if len(self.progress.input_start_time):
 self.progress.input_start_time = self.progress.input_start_time[:-1]
 else:
 self.progress.input_start_time += query.data

 # We update the output so the user sees if he types correctly
 bot.edit_message_text(text="Start time: ".format(self.progress.input_start_time),
 chat_id=query.message.chat_id,
 message_id=Progress().tracking_message.message_id)


# ... more states
# ... more and more states
# ...and so on, you can imagine


class KeywordsState(StepState):
 name = 'KeywordsState'

 def draw_ui(self, bot, update):
 self.message(update).reply_text('Enter keywords', reply_markup=ReplyKeyboardRemove())

 def handle(self, bot=None, update=None):
 #logger.info("Keywords: %s", update.message.text)
 # TODO Store in a variable or similar the keywords
 update.message.reply_text(
 'Thanks. The keywods are: '.format(update.message.text))

 Progress().next_state()
 Progress().state.draw_ui(bot, update)

 return Progress().state


class ConfirmState(StepState):
 name = 'ConfirmState'

 def draw_ui(self, bot, update):
 self.message(update).reply_text('Confirm all this info: !s'.format(Progress()))
 reply_keyboard = [
 [InlineKeyboardButton('Accept', callback_data=OK),
 InlineKeyboardButton('Cancel', callback_data=CANCEL)],
 ]
 reply_markup = InlineKeyboardMarkup(reply_keyboard)
 self.message(update).reply_text('Accep or cancel (/cancel)', reply_markup=reply_markup)

 def handle(self, bot=None, update=None):
 query = update.callback_query
 self.message(update).reply_text('Finalizado')

 # Se lanza el procesamiento
 # Se resetea el progreso
 self.progress.clear()
 Progress().next_state(NoneState())
 return ConversationHandler.END


# This is important. It's intended for setting the steps in an ordered-sorted way
StepState.states = [NoneState(), DepState(), NodeState(), BlogState(), IntervalState(), StartTimeState(), EndTimeState(), RepeatsState(), LabelsState(), KeywordsState(), ConfirmState()]


class Progress(object):
 """
 This singleton class contains the whole information collected along all the wizard process
 """
 __instance = None

 def __new__(cls):
 if Progress.__instance is None:
 Progress.__instance = object.__new__(cls)
 Progress.__instance.input_blog = None
 Progress.__instance.state = NoneState()
 Progress.__instance.tracking_message = None
 Progress.__instance.input_dep = None
 Progress.__instance.input_node = None
 Progress.__instance.input_minutes = None
 Progress.__instance.input_start_time = None
 Progress.__instance.input_end_time = None
 return Progress.__instance

 def clear(self):
 """
 Resets the progress
 """
 self.input_blog = None
 self.state = NoneState()
 self.tracking_message = None
 self.input_dep = None
 self.input_node = None
 self.input_minutes = None
 self.input_start_time = None
 self.input_end_time = None

 def next_state(self, new_state=None):
 """
 Moves to the next state or to the specified state if any
 :param new_state: the next state to move to
 :return: the next state, already set to the Progress object
 """
 if new_state is not None:
 if self.state:
 self.state = self.state.next_state(new_state)
 else:
 self.state = NoneState
 #logger('Couldnt go to next state')
 else:
 self.state = self.state.next_state()

 def __str__(self):
 return ': dep=, node=, start=,end='.format(self.__class__.__name__, self.input_dep, self.input_node, self.input_start_time, self.input_end_time)

Now we use the previous code here:

bot_prototype:

#!/usr/bin/python3

from telegram import ReplyKeyboardMarkup, ReplyKeyboardRemove
from telegram.ext import (Updater, Filters, RegexHandler, CommandHandler,
 CallbackQueryHandler, ConversationHandler, MessageHandler)

from my_package.step_states import DepState, NodeState, StartTimeState, EndTimeState, KeywordsState, ConfirmState, 
 BlogState, IntervalState
from my_package.step_states import Progress
from environments import get_bot_token

import logging

logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
 level=logging.INFO)
logger = logging.getLogger(__name__)

OK = 'OK'
CANCEL = 'CANCEL'
DELETE = 'DELETE'

# Updater is telegram code and the bot_token is an id string
updater = Updater(get_bot_token())


def start(bot, update):
 """
 Starts the wizard planning process
 :param bot: the Telegram bot
 :param update: the Telegram update, probably a text message
 :return: the state for the ConversationHandler
 """
 p = Progress()

 p.next_state()
 p.state.draw_ui(bot, update)

 return p.state


def error(bot, update, error):
 """
 Logs errors
 :param bot: the Telegram bot
 :param update: the Telegram update, probably a text message
 """
 logger.error('Update "%s" caused error "%s"', update, error) 


def skip(bot, update):
 """
 Skips this step in the wizard process
 :param bot: the Telegram bot
 :param update: the Telegram update, probably a text message
 :return: the next state skipping the present one
 """
 user = update.message.from_user
 logger.info("%s skipped a step.", user.first_name)
 update.message.reply_text("Skipping steps is not supported yet. Process is done")

 # If we don't cancel at the end, we should remove any keyboard which could be present

 # TODO Right now we don't accept skips and we cancel everything.
 # TODO In the future, we will look at present state and choose the next state
 return cancel(bot, update)


def cancel(bot, update):
 """
 Cancels the whole wizard process
 :param bot: the Telegram bot
 :param update: the Telegram update, probably a text message
 :return: the END state for he ConversationHandler
 """
 Progress().clear()

 user = update.message.from_user
 logger.info(" cancelled the process.".format(user.first_name))
 update.message.reply_text('Process ended.', reply_markup=ReplyKeyboardRemove())

 return ConversationHandler.END


def main():
 global updater

 dp = updater.dispatcher

 # Add conversation handler with the states
 # The telegram conversation handler needs a list of handlers with function so it can execute desired code in each state/step
 conv_handler = ConversationHandler(
 entry_points=[ CommandHandler('start', start) ],

 states=
 DepState(): [CallbackQueryHandler(DepState().handle), CommandHandler('skip', skip)],
 NodeState(): [CallbackQueryHandler(NodeState().handle), CommandHandler('skip', skip)],
 BlogState(): [CallbackQueryHandler(BlogState().handle), CommandHandler('skip', skip)],
 IntervalState(): [CallbackQueryHandler(IntervalState().handle), CommandHandler('skip', skip)],
 StartTimeState(): [CallbackQueryHandler(StartTimeState().handle), CommandHandler('skip', skip)],
 EndTimeState(): [CallbackQueryHandler(EndTimeState().handle), CommandHandler('skip', skip)],
 KeywordsState(): [MessageHandler(Filters.text, KeywordsState().handle), CommandHandler('skip', skip)],
 ConfirmState(): [CallbackQueryHandler(ConfirmState().handle)],
 ,
 fallbacks=[CommandHandler('cancel', cancel)]
 )

 dp.add_handler(conv_handler)

 # dp.add_handler(CallbackQueryHandler(button_callback))
 updater.dispatcher.add_error_handler(error)

 # Start the Bot
 updater.start_polling()

 # Run the bot until you press Ctrl-C or the process receives SIGINT,
 # SIGTERM or SIGABRT. This should be used most of the time, since
 # start_polling() is non-blocking and will stop the bot gracefully.
 updater.idle()


if __name__ == '__main__':
 main()

I mainly decoupled the states from the bots putting a handler_list method inside each state.

Briefly I comment some suggestions and good points Gareeth Reese made:

1. Cutting source code lines to 80 chars. Still pending. I'm doing it the next time I post
   


2. The use of self.states and the index method to choose a next state is inefficient (proportional to number of states). The antipattern here is over-encapsulation, the co-ordination needs to be handled at a higher level,for example in a state machine class like your Progress class. Still pending
   


3. 
   

   The data structure that's needed is a mapping from state to next state, for example, in the Progress class you could have:

   
   
   

   _state_order = [NoneState(), DepState(), NodeState(), ...]
   _next_state = dict(zip(_state_order[:-1], _state_order[1:]))
   

   
   

and then in the Progress.next_state method you'd write:

self.state = self._next_state[self.state]

4. 
   

   The message method is only used in the context

   
   
   

   self.message(update).reply_text(...)
   

   
   

The duplicated code could be eliminated like this:

def reply_text(self, update, *args, *kwargs):
"""Reply to a Telegram update ..."""
 if update.callback_query:
 message = update.callback_query.message
 else:
 message = update.message
 message.reply_text(*args, **kwargs)

And since this does not use self, it does not need to be a method on a class, it could be a @staticmethod or, better, an ordinary function. Tried it but some parameter was giving an error

5. Borg pattern is unnecessary and its machinery can be dropped from the StepState class. Still thinking about it




6. After removing all these attributes and methods, the only attribute remaining is progress. This is only used in the handle method, and so it would make sense to pass it as a parameter to that method and avoid the need for the attribute. Still thinking about it



7. 
   

   Still pending as well. After removing the progress attribute, none of the remaining methods use self, so there's no need to create state objects, you can just use the state classes as namespaces for the draw_ui and handle functions:

   
   
   

   _state_order = [NoneState, DepState, NodeState, ...]
   

   
   

I evolved a little bit the code until I came to this below. I know that many changes are still pending and DRY principle is broken, but the main things are done:

step_states:

class StepState(metaclass=ABCMeta):
 """
 This is a Borg class which shares state and methods so all the instances created for it are different references
 but containing the same values. This is also true for children of the same class, so:

 Children1() == Children1() # False, because references are different, but the values are the same.
 Also if you change one, you change the other
 Children1() == Children2() # False, references are different and you can change anyone without affecting others
 """
 states = 

 # State is a Borg design pattern class
 __shared_state = 

 def __init__(self):
 self.__dict__ = self.__shared_state


 @staticmethod
 def message(update):
 """
 Returns the object holding the info coming from Telegram with the methods for replying
 and looking into this info
 :param update: the Telegram update, probably a text message
 :return: the update or query object
 """
 if update.callback_query:
 return update.callback_query.message
 else:
 return update.message

 @abstractmethod
 def draw_ui(self, bot, update):
 """
 Draws the UI in Telegram (usually a custom keyboard) for the user to input data
 :param bot: the Telegram bot
 :param update: the Telegram update, probably a text message
 """
 pass

 @abstractmethod
 def handle(self, bot=None, update=None):
 """
 Handles all the input info into the Progress object and transitions to the next state
 :param bot: the Telegram bot
 :param update: the Telegram update, probably a text message
 """
 logger.info('Handling state in parent'.format(self.__class__.__name__))
 self.progress = Progress()
 if update and update.callback_query:
 query = update.callback_query
 if query.data == CANCEL:
 return self.cancel(bot, update)

 @abstractmethod
 def handler_list(self):
 """
 Returns the list with the handlers for managing the events for this state
 Example: return [ CallbackQueryHandler(callbackFunc), CommandHandler('cmd', commandFunc)]

 Will apply the callbackFunc for managing a query-like update, but if not,
 will try to apply commandFunc for an incoming command /cmd
 :return: the handlers list
 """
 pass

 def next_state(self, new_state=None):
 """
 Inherited method which decides to move to the next state, or to the specified state if any
 :param new_state: the next state, if any
 :return: the next state
 """
 # TODO Check if the transition is allowed?
 next_new_state = None
 if new_state is None:
 default_next_state_index = (self.index + 1) % len(self.states)
 next_new_state = self.states[default_next_state_index]
 else:
 next_new_state = new_state
 logger.info('Actual state: => switched to new state '.format(self, next_new_state))
 return next_new_state

 @staticmethod
 def skip(bot, update):
 """
 Skips this step in the wizard process
 :param bot: the Telegram bot
 :param update: the Telegram update, probably a text message
 :return: the next state skipping the present one
 """
 logger.info('Skipping state '.format(Progress().state))
 update.message.reply_text("Se salta este paso.")

 # If we don't cancel at the end, we should remove any keyboard which could be present

 Progress().next_state()
 Progress().state.draw_ui(bot, update)

 return Progress().state

 @staticmethod
 def cancel(bot, update):
 """
 Cancels the whole wizard process
 :param bot: the Telegram bot
 :param update: the Telegram update, probably a text message
 :return: the END state for he ConversationHandler
 """
 Progress().clear()

 user = StepState.message(update).from_user
 logger.info(" canceled the process.".format(user.first_name))
 StepState.message(update).reply_text('Proceso finalizado.', reply_markup=ReplyKeyboardRemove())

 return ConversationHandler.END

 def validate_input(self, input_data):
 """
 Validates the input data for this step/state
 :param input_data: the input data
 :return: True if input data is valid, otherwise False
 """
 return True

 @property
 def index(self):
 """
 Returns the index of this state within the list with all states
 :return: the index as an int
 """
 return StepState.states.index(self)

 def __eq__(self, other):
 return self.__hash__() == other.__hash__()

 def __hash__(self):
 return hash(self.__class__.__name__)

 def __str__(self):
 return self.__class__.__name__


class DepState(StepState):
 def draw_ui(self, bot, update):
 reply_keyboard = [
 ]
 num_cols = 3
 current_row = 

 # Think of SEARCH_INDEXES as a list with objects having two strings: spanish_description and browse_node_id
 for dep in SEARCH_INDEXES:
 current_row.append(InlineKeyboardButton(dep.spanish_desc,
 callback_data="=".format(dep.browse_node_id, dep.spanish_desc)))
 if len(current_row) >= num_cols:
 reply_keyboard.append(current_row)
 current_row = 
 reply_markup = InlineKeyboardMarkup(reply_keyboard)

 self.message(update).reply_text('Enter the *departament*, do /skip or /cancel',
 parse_mode='Markdown', reply_markup=reply_markup)

 def handle(self, bot=None, update=None):
 parent_result = super().handle(bot, update)
 if parent_result is not None:
 return parent_result
 query = update.callback_query
 if query.data:
 current_input_dep, text = query.data.split('=')
 bot.edit_message_text(text="Departament chosen: ".format(text), chat_id=query.message.chat_id,
 message_id=query.message.message_id)

 # We optionally log anything

 Progress().input_dep = current_input_dep

 Progress().next_state()
 Progress().state.draw_ui(bot, update)

 return Progress().state

class NodeState(StepState):
 def draw_ui(self, bot, update):
 reply_keyboard = [
 [InlineKeyboardButton('Delete', callback_data=DELETE)],
 [InlineKeyboardButton(str(number), callback_data=str(number)) for number in range(5)],
 [InlineKeyboardButton(str(number), callback_data=str(number)) for number in range(5, 10)],
 [InlineKeyboardButton('Accept', callback_data=OK),
 InlineKeyboardButton('Cancel', callback_data=CANCEL)],
 ]
 reply_markup = InlineKeyboardMarkup(reply_keyboard)
 self.message(update).reply_text('Input numbers for the node, do /skip or /cancel',
 parse_mode='Markdown', reply_markup=reply_markup)
 # We get the reference to the message we will use to update the value and set into Progress
 Progress().tracking_message = self.message(update).reply_text("Typed data : ".format(''))

 def handle(self, bot=None, update=None):
 parent_result = super().handle(bot, update)
 if parent_result is not None:
 return parent_result
 query = update.callback_query
 if hasattr(query, 'data'):
 if query.data == OK:
 if self.validate_input(self.progress.input_node):
 bot.edit_message_text(text="Chosen node: ".format(self.progress.input_node),
 chat_id=query.message.chat_id, message_id=query.message.message_id)

 bot.delete_message(chat_id=Progress().tracking_message.chat_id,
 message_id=Progress().tracking_message.message_id)
 Progress().next_state()
 else:
 no_keywords = self.progress.input_keywords is None or not self.progress.input_keywords.strip()

 if self.progress.input_node:
 self.message(update).reply_text('Not allowed value')
 self.progress.input_node = ''
 elif no_keywords:
 # If there are no keywords, then the node is mandatory
 self.message(update).reply_text('This input is mandatory. Enter an allowed value')
 Progress().next_state(self)

 Progress().state.draw_ui(bot, update)
 return Progress().state
 else:
 if not self.progress.input_node:
 self.progress.input_node = ''

 if query.data == DELETE:
 if len(self.progress.input_node):
 self.progress.input_node = self.progress.input_node[:-1]
 else:
 self.progress.input_node += query.data

 # We update the output so the user sees if he types correctly
 bot.edit_message_text(text="Input data: ".format(self.progress.input_node),
 chat_id=query.message.chat_id,
 message_id=Progress().tracking_message.message_id)
 else:
 if update.message.text and self.validate_input(update.message.text):
 self.progress.input_node = update.message.text
 Progress().next_state()
 Progress().state.draw_ui(bot, update)
 elif not self.validate_input(update.message.text):
 self.message(update).reply_text('Valor no admitido')
 self.message(update).reply_text('Este dato es obligatorio. Introduzca un valor valido')
 self.progress.input_node = ''
 Progress().next_state(self)
 Progress().state.draw_ui(bot, update)
 return Progress().state

 @staticmethod
 def skip(bot, update):
 logger.info('Skipping state '.format(Progress().state))

 # If we don't cancel at the end, we should remove any keyboard which could be present
 if Progress().input_keywords is None or not Progress().input_keywords.strip():
 update.message.reply_text('Este dato es obligatorio. Introduzca un valor valido')
 else:
 Progress().input_node = ''
 Progress().next_state()
 update.message.reply_text("Se salta este paso.")

 Progress().state.draw_ui(bot, update)
 return Progress().state

 def validate_input(self, input_data):
 data = input_data
 if type(input_data) is str:
 data = int(data.strip())

 response = requests.get('https://www.amazon.es/exec/obidos/tg/browse/-/'.format(data))
 return response.status_code == 200

 def handler_list(self):
 return [RegexHandler('^(d+)$', self.handle),
 CallbackQueryHandler(self.handle), CommandHandler('skip', self.skip)]


class BlogState(StepState):
 def draw_ui(self, bot, update):

 reply_keyboard = [
 [InlineKeyboardButton(blog, callback_data='='.format(blog, bid)) for blog, bid in sorted(get_blogs().items())]
 ]
 reply_markup = InlineKeyboardMarkup(reply_keyboard)
 self.message(update).reply_text('Choose an option, /skip or /cancel', parse_mode='Markdown',reply_markup=reply_markup)

 def handle(self, bot=None, update=None):
 parent_result = super().handle(bot, update)
 if parent_result is not None:
 return parent_result
 query = update.callback_query
 if query.data:
 bname, bid = query.data.split('=')
 bot.edit_message_text(text="Chosen option: ".format(bname), chat_id=query.message.chat_id,
 message_id=query.message.message_id)

 # We optionally log anything

 # We text the user the requirements for next state
 # query.message.reply_text('Departamento elegido. ', reply_markup=ReplyKeyboardRemove())

 Progress().input_blog = (bname,bid)

 if bname == 'xxx':
 Progress().input_dep = HEALTH.browse_node_id
 Progress().next_state(KeywordsState())
 elif bname == 'books':
 Progress().input_dep = BOOKS.browse_node_id
 Progress().next_state(KeywordsState())
 else:
 Progress().next_state()

 Progress().state.draw_ui(bot, update)

 return Progress().state

 def handler_list(self):
 return [CallbackQueryHandler(self.handle), CommandHandler('skip', self.skip)]


class StartTimeState(StepState):
 def draw_ui(self, bot, update):
 reply_keyboard = [
 [InlineKeyboardButton('Delete', callback_data=DELETE)],
 [InlineKeyboardButton(str(number), callback_data=str(number)) for number in range(5)],
 [InlineKeyboardButton(str(number), callback_data=str(number)) for number in range(5, 10)],
 [InlineKeyboardButton(':', callback_data=':')],
 [InlineKeyboardButton('Accept', callback_data=OK),
 InlineKeyboardButton('Cancel', callback_data=CANCEL)],
 ]
 reply_markup = InlineKeyboardMarkup(reply_keyboard)
 self.message(update).reply_text('Input start time or /cancel', 
 parse_mode='Markdown', reply_markup=reply_markup)
 # We get the reference to the message we will use to update the value and set into Progress
 Progress().tracking_message = self.message(update).reply_text("Start time: ".format(''))

 def handle(self, bot=None, update=None):
 parent_result = super().handle(bot, update)
 if parent_result is not None:
 return parent_result
 query = update.callback_query

 if hasattr(query, 'data'):
 if query.data == OK:
 bot.delete_message(chat_id=query.message.chat_id, message_id=query.message.message_id)

 Progress().next_state()
 Progress().state.draw_ui(bot, update)

 return Progress().state
 else:
 if not self.progress.input_start_time:
 self.progress.input_start_time = ''
 if query.data == DELETE:
 if len(self.progress.input_start_time):
 self.progress.input_start_time = self.progress.input_start_time[:-1]
 else:
 self.progress.input_start_time += query.data

 # We update the output so the user sees if he types correctly
 bot.edit_message_text(text="Start time: ".format(self.progress.input_start_time),
 chat_id=query.message.chat_id,
 message_id=Progress().tracking_message.message_id)
 else:
 if update.message.text and self.validate_input(update.message.text):
 self.progress.input_start_time = update.message.text
 Progress().next_state()
 Progress().state.draw_ui(bot, update)
 elif not self.validate_input(update.message.text):
 self.message(update).reply_text('Valor no admitido')
 self.message(update).reply_text('Este dato es obligatorio. Introduzca un valor valido')
 self.progress.input_start_time = ''
 Progress().next_state(self)
 Progress().state.draw_ui(bot, update)
 return Progress().state

 def handler_list(self):
 return [RegexHandler(TIME_REGEX, self.handle),
 CallbackQueryHandler(self.handle), CommandHandler('skip', self.skip)]


# ... more states
# ... more and more states
# ...and so on, you can imagine


class KeywordsState(StepState):
 name = 'KeywordsState'

 def draw_ui(self, bot, update):
 self.message(update).reply_text('Enter keywords', parse_mode='Markdown', 
 reply_markup=ReplyKeyboardRemove())

 def handle(self, bot=None, update=None):
 parent_result = super().handle(bot, update)
 if parent_result is not None:
 return parent_result

 keywords = update.message.text.strip()

 if keywords:
 Progress().input_keywords = keywords
 update.message.reply_text('Thanks. The keywords are: '.format(keywords))
 # When SearchIndex equals All, BrowseNode cannot be present
 if Progress().input_dep is None:
 Progress().next_state(StartTimeState())
 else:
 Progress().next_state()
 else:
 update.message.reply_text('No ha introducido palabras. Introdúzcalas, haga /skip o /cancel')
 Progress().next_state(self)

 Progress().state.draw_ui(bot, update)

 return Progress().state

 @staticmethod
 def skip(bot, update):
 logger.info('Skipping state '.format(Progress().state))

 # If we don't cancel at the end, we should remove any keyboard which could be present
 if Progress().input_dep is None:
 update.message.reply_text('Este dato es obligatorio. Introduzca un valor valido')
 else:
 Progress().input_keywords = None
 Progress().next_state()
 update.message.reply_text("Skipping this step.")

 Progress().state.draw_ui(bot, update)
 return Progress().state

 def handler_list(self):
 return [MessageHandler(Filters.text, self.handle), CommandHandler('skip', self.skip)]

class ConfirmState(StepState):

 def draw_ui(self, bot, update):
 self.message(update).reply_text('Confirm all this info: !s'.format(Progress()))
 reply_keyboard = [
 [InlineKeyboardButton('Accept', callback_data=OK),
 InlineKeyboardButton('Cancel', callback_data=CANCEL)],
 ]
 reply_markup = InlineKeyboardMarkup(reply_keyboard)
 self.message(update).reply_text('Accept or cancel (/cancel)', reply_markup=reply_markup)

 # This returns a generator with a data list to consume
 self.generator = search_asins(Progress().input_dep, Progress().input_node, Progress().input_keywords)

 def handle(self, bot=None, update=None):
 parent_result = super().handle(bot, update)
 if parent_result is not None:
 return parent_result
 # OK granted, CANCEL is managed in parent
 query = update.callback_query

 # We finished with the wizard and launch everything
 # Launching stuff here...
 # ...

 # Progress should be reset
 self.progress.clear()
 Progress().next_state(NoneState())
 return ConversationHandler.END

 def handler_list(self):
 return [CallbackQueryHandler(self.handle)]


# This is intended for setting the steps in an ordered-sorted way
StepState.states = [
 NoneState(), BlogState(), DepState(), KeywordsState(), NodeState(), StartTimeState(),
 IntervalState(), EndTimeState(), RepeatsState(), ConfirmState()
]


class Progress(object):
 """
 This singleton class contains the whole information collected along all the wizard process
 """
 __instance = None

 def __new__(cls):
 if Progress.__instance is None:
 Progress.__instance = object.__new__(cls)
 Progress.__instance.input_blog = None
 Progress.__instance.state = NoneState()
 Progress.__instance.tracking_message = None
 Progress.__instance.input_dep = None
 Progress.__instance.input_node = None
 Progress.__instance.input_minutes = '60'
 Progress.__instance.input_start_time = None
 Progress.__instance.input_end_time = None
 Progress.__instance.input_keywords = None
 Progress.__instance.input_repeats = None
 return Progress.__instance

 def clear(self):
 """
 Resets the progress
 """
 self.input_blog = None
 self.state = NoneState()
 self.tracking_message = None
 self.input_dep = None
 self.input_node = None
 self.input_minutes = '60'
 self.input_start_time = None
 self.input_end_time = None
 self.input_keywords = None

 def next_state(self, new_state=None):
 """
 Moves to the next state or to the specified state if any
 :param new_state: the next state to move to
 :return: the next state, already set to the Progress object
 """
 if new_state is not None:
 if self.state:
 self.state = self.state.next_state(new_state)
 else:
 self.state = NoneState
 logger.info("It was impossible o move to the next state")
 else:
 self.state = self.state.next_state()

 def __str__(self):
 return ": blog=, dep=, node=, start=, " 
 "interval=', end=, repeats=, keywords=".format(self.__class__.__name__,self.input_blog[0],self.input_dep,self.input_node,self.input_start_time,self.input_minutes,self.input_end_time,self.input_repeats,self.input_keywords)

bot.py:

#!/usr/bin/python3

from telegram.ext import (Updater, Filters, CommandHandler, ConversationHandler, MessageHandler)

from my_package.step_states import Progress, StepState
from environments import get_bot_token, getLogger

# Enable logging
logger = getLogger(__name__)

updater = Updater(get_bot_token())


def start(bot, update):
 """
 Sends a message when the command /start is issued.
 :param bot: the bot
 :param update: the update info from Telegram for this command
 """
 update.message.reply_text('Bot started')

def error(bot, update, error):
 """
 Logs errors
 :param bot: the Telegram bot
 :param update: the Telegram update, probably a text message
 """
 logger.error('Update "%s" caused error "%s"', update, error) 


def restricted(my_handler):
 """
 Decorates a handler for restricting its use
 :param my_handler: the handler to be restricted
 :return: the restricted handler
 """
 @wraps(my_handler)
 def wrapped(bot, update, *args, **kwargs):
 user_id, user_name = update.effective_user.id, update.effective_user.first_name
 if user_id not in get_allowed_users():
 update.message.reply_text("Unauthorized access con id .n".format(user_name, user_id))
 return
 logger.info('Entering '.format(my_handler.__name__))
 return my_handler(bot, update, *args, **kwargs)
 return wrapped


@restricted
def plan(bot, update): #, blog_id=get_blog_id(), interval=60, dep_param_id=None):
 """
 Starts the wizard for scheduling item posts
 :param bot: the bot
 :param update: the update info from Telegram for this command
 """
 p = Progress()

 p.next_state()
 p.state.draw_ui(bot, update)

 return p.state


def main():
 """Start the bot."""
 # Create the EventHandler and pass it your bot's token.
 global updater

 # Get the dispatcher to register handlers
 dp = updater.dispatcher

 # on different commands - answer in Telegram
 dp.add_handler(CommandHandler('start', start))

 # Add conversation handler with the states
 # The telegram conversation handler needs a handler_list with functions
 # so it can execute desired code in each state/step
 conv_handler = ConversationHandler(
 entry_points=[CommandHandler('plan', plan)],
 # We enter all the states and all the configured handlers for each state
 states=state: state.handler_list() for state in StepState.states,
 fallbacks=[CommandHandler('cancel', StepState.cancel)]
 )

 dp.add_handler(conv_handler)

 # log all errors
 dp.add_error_handler(error)

 # Start the Bot
 updater.start_polling()

 # Run the bot until you press Ctrl-C or the process receives SIGINT,
 # SIGTERM or SIGABRT. This should be used most of the time, since
 # start_polling() is non-blocking and will stop the bot gracefully.
 updater.idle()


if __name__ == '__main__':
 main()