def init(self, bot: ChatbotEngine):
        """
        Initialize chatbot engine

        :param bot:
        :return:
        """
        self.bot = bot
        self.logger = DotFlow2LoggerAdapter(logging.getLogger('df2_ext.csMatch'), self, self.bot, '$chatscriptMatch')
        bot.register_dotflow2_function('chatscriptMatch', {'object': self, 'method': 'chatscriptMatch', 'cost': 0, 'register_enabled': False})
Exemple #2
0
    def init(self, bot: ChatbotEngine):
        """
        Initialize extension

        :param bot:
        :return:
        """
        self.bot = bot
        self.logger = DotFlow2LoggerAdapter(logging.getLogger('df2_ext.ssent_an'), self, self.bot, '$simpleSentimentAnalysis')
        bot.register_dotflow2_function('simpleSentimentAnalysis', {'object': self, 'method': 'df2_simpleSentimentAnalysis', 'cost': 0.5, 'register_enabled': True})
Exemple #3
0
def test_commands():
    """Create bot."""
    bot = create_test_bot(None, "flow")
    request = ChatbotEngine.create_request(":unknown_command", "joe", '7', '1')
    response = bot.get_response(request)
    assert response["output"]["text"].startswith('Unknown command.')
    request = ChatbotEngine.create_request(":help", "joe", '7', '1')
    response = bot.get_response(request)
    assert response["output"]["text"].startswith('Commands:')
    request = ChatbotEngine.create_request(":reset all", "joe", '7', '1')
    response = bot.get_response(request)
    assert response["output"]["text"].startswith('User data')
Exemple #4
0
    def rest(bot_id):  # pylint: disable=W0612
        """
        Telegram webhook endpoint.
        """
        logger.debug(f'Received a Telegram webhook request for botid {bot_id}')

        try:
            params = request.get_json(force=True)
            org_id = 1

            # checks if bot is telegram enabled
            # if not, it delete the webhook and throw an exception
            enabled = webhook_check(bot_id)
            if enabled:
                dotbot = telegram.dotdb.find_dotbot_by_container_id(
                    bot_id).dotbot
                token = dotbot['channels']['telegram']['token']
                telegram.set_api_token(token)

                user_id = telegram.get_user_id(params)
                telegram_recv = telegram.get_message(params)
                bbot_request = telegram.to_bbot_request(telegram_recv)

                bbot = create_bot(config, dotbot)
                req = ChatbotEngine.create_request(bbot_request, user_id,
                                                   bot_id, org_id)
                bbot_response = bbot.get_response(req)

                telegram.send_response(bbot_response)
        except Exception as e:
            print("type error: " + str(e))
            print(traceback.format_exc())

        # be sure to respond 200 code. telegram will keep sending it if doesnt get it
        return jsonify(success=True)
Exemple #5
0
    def rest():  # pylint: disable=W0612
        try:
            params = request.get_json(force=True)
            logger.debug("Received request:" + str(params))
            user_id = params['userId']
            bot_id = params['botId']
            org_id = params['orgId']
            input_params = params['input']
            # if 'runBot' in params:
            #    run_bot = params['runBot']
            dotbotContainer = restful.dotdb.find_dotbot_by_container_id(bot_id)
            if not dotbotContainer:
                raise Exception('Bot not found')
            bot = create_bot(config, dotbotContainer.dotbot)
            input_text = ""
            #for input_type, input_value in input_params.items():
            # bot.get_response(input_type, input_value)
            #    _ = input_type
            #    input_text = input_text + input_value
            req = ChatbotEngine.create_request(input_params, user_id, bot_id,
                                               org_id)
            response = bot.get_response(req)
        except Exception as e:
            response = {'error': {'message': str(e)}}

        logger.debug("Response: " + str(response))
        return json.dumps(response)
Exemple #6
0
def test_socket_error():
    """Test socket error."""
    bot = create_test_bot(None, "chatscript")
    bot.port = 0
    request = ChatbotEngine.create_request("", "Joe")
    response = bot.get_response(request)
    assert not response
Exemple #7
0
    def get_response(self, request: dict) ->dict:
        """
        Return a response based on the input data.

        :param request: A dictionary with input data.
        :return: A response to the input data.
        """
        return ChatbotEngine.create_response("dummy")
Exemple #8
0
    def init(self, bot: ChatbotEngine):
        """

        :param bot:
        :return:
        """
        self.bot = bot
        self.logger = DotFlow2LoggerAdapter(
            logging.getLogger('df2_ext.weather'), self, self.bot, '$weather')
        bot.register_dotflow2_function('weather', {
            'object': self,
            'method': 'df2_weather'
        })
        bot.register_template_function('weather', {
            'object': self,
            'method': 'df2_weather'
        })
Exemple #9
0
def test_create_bot():
    """Create bot."""
    bot = create_test_bot(None, "chatscript")
    assert bot.host
    assert bot.port
    request = ChatbotEngine.create_request("Hello", "Joe")
    response = bot.get_response(request)
    assert response["output"]["text"]
Exemple #10
0
    def init(self, core: ChatbotEngine):
        """

        :param bot:
        :return:
        """
        self.core = core
        self.logger = BBotLoggerAdapter(
            logging.getLogger('core_ext.send_email'), self, self.core,
            '$sendEmail')
        core.register_function(
            'sendEmail', {
                'object': self,
                'method': 'sendEmail',
                'cost': 0.001,
                'register_enabled': True
            })
Exemple #11
0
    def process(self):
        """
        @TODO this will be called from a pubsub event, so args might change
        Call to fallback bots defined in dotbot when the main bot has a no match o
        or when it doesnt answer or has an invalid response
        @TODO this might be replaced by a conditional pipeline

        :param bot:
        :param response:
        :return:
        """
        if not self.core.bot.is_fallback and (self.core.response.get('noMatch')
                                              or
                                              self.core.response.get('error')):
            self.logger.debug(
                'Bot engine has a no match. Looking fallback bots')

            # try import bots
            fbbs = self.core.dotbot.get('fallbackBots', [])
            for bot_name in fbbs:
                self.logger.debug(f'Trying with bot {bot_name}')
                bot_dotbot_container = self.core.dotdb.find_dotbot_by_idname(
                    bot_name)
                if not bot_dotbot_container:
                    raise Exception(f'Fallback bot not found {bot_name}')
                else:
                    bot_dotbot = bot_dotbot_container.dotbot

                config_path = os.path.abspath(
                    os.path.dirname(__file__) + "/../instance")
                config = load_configuration(config_path, "BBOT_ENV")
                bbot = create_bot(config, bot_dotbot)
                bbot.is_fallback = True
                req = ChatbotEngine.create_request(core.request['input'],
                                                   core.user_id, 1, 1)
                fallback_response = bbot.get_response(req)
                if fallback_response.get('error'):
                    self.logger.error(
                        'Fallback bot returned an invalid response. Discarding.'
                    )
                    continue
                if not fallback_response.get('noMatch'):
                    self.logger.debug(
                        'Fallback bot has a response. Returning this to channel.'
                    )
                    self.core.response = fallback_response
                    return
            if fbbs:
                self.logger.debug(
                    'Fallback bot don\'t have a response either. Sending original main bot response if any'
                )
            else:
                self.logger.debug(
                    'No fallback defined for this bot. Sending original main bot response if any'
                )

        self.logger.debug('Bot responded with a match. No fallback needed.')
        return
Exemple #12
0
    def init(self, bot: ChatbotEngine):
        """

        :param bot:
        :return:
        """
        self.bot = bot
        self.logger = DotFlow2LoggerAdapter(
            logging.getLogger('df2_ext.ssent_an'), self, self.bot,
            '$simpleSentimentAnalysis')
        bot.register_dotflow2_function('simpleSentimentAnalysis', {
            'object': self,
            'method': 'df2_simpleSentimentAnalysis'
        })
        bot.register_template_function('simpleSentimentAnalysis', {
            'object': self,
            'method': 'df2_simpleSentimentAnalysis'
        })
Exemple #13
0
    def init(self, bot: ChatbotEngine):

        self.bot = bot
        self.logger = DotFlow2LoggerAdapter(logging.getLogger('df2_ext.core'),
                                            self, self.bot, 'DF2CoreFnc')

        self.functions = [
            'input', 'eq', 'gt', 'lt', 'gte', 'lte', 'code', 'goto', 'return',
            'set', 'get', 'regexMatch', 'and', 'or'
        ]

        for f in self.functions:
            bot.register_dotflow2_function(
                f, {
                    'object': self,
                    'method': 'df2_' + f,
                    'cost': 0,
                    'register_enabled': False
                })
Exemple #14
0
    def init(self, bot: ChatbotEngine):
        """
        Initializes extension

        :param bot:
        :return:
        """
        self.bot = bot
        self.logger = DotFlow2LoggerAdapter(
            logging.getLogger('df2_ext.r_output'), self, self.bot,
            'Output Response Ext')

        for f in self.functions:
            bot.register_dotflow2_function(f, {
                'object': self,
                'method': 'df2_' + f
            })
            bot.register_template_function(f, {
                'object': self,
                'method': 'df2_' + f
            })
Exemple #15
0
def test_create_bot():
    """Create bot."""
    config_settings = \
    {
        "bbot": {
            "default_chatbot_engine": "dummy",
            "chatbot_engines": {
                "dummy": {
                    "plugin_class": "tests.bbot.test_core.DummyEngine",
                    "name": "engine",
                    "loader": {
                        "plugin_class": "tests.bbot.test_core.DummyPlugin",
                        "name": "loader"
                    },
                    "extensions": {
                        "dummy_plugin_1": {
                            "plugin_class": "tests.bbot.test_core.DummyPlugin",
                            "name": "extension 1"
                        },
                        "dummy_plugin_2": {
                            "plugin_class": "tests.bbot.test_core.DummyPlugin",
                            "name": "extension 2"
                        }
                    }
                }
            }
        },
        "logging": {
            "version": 1
        }
    }
    bot = create_test_bot(config_settings)
    info = config_settings["bbot"]["chatbot_engines"]["dummy"]
    assert bot.name == info["name"]
    assert bot.loader.name == info["loader"]["name"]
    assert bot.extensions["dummy_plugin_2"].name == \
           info["extensions"]["dummy_plugin_2"]["name"]
    request = ChatbotEngine.create_request("dummy", "Joe")
    response = bot.get_response(request)
    assert response['output']['text'] == "dummy"
Exemple #16
0
    print("Usage: make console user_id bot_id org_id\n")
    sys.exit(255)

print("Type \"quit\" or \"bye\" to leave chat\n\n")

user_id, bot_id, org_id, debug = sys.argv[1:]

dotbotContainer = console.dotdb.find_dotbot_by_idname(bot_id)
if not dotbotContainer:
    raise Exception('Couldn\'t find the bot')

while True:
    input_text = input("You: ")
    if input_text.lower() in ["!quit", "!bye"]:
        print("BBot: Bye!\n")
        sys.exit(0)

    bot = create_bot(
        config, dotbotContainer.dotbot
    )  # create new bot each volley to get same behavior as others stateless channels
    request = ChatbotEngine.create_request({'text': input_text}, user_id,
                                           bot_id, org_id)
    response = bot.get_response(request)

    if debug == 'debug':
        print('Debug: ' + str(response))

    for r in response['output']:
        if r.get('text'):
            print(bot.dotbot['name'].capitalize() + ': ' + str(r['text']))