Ejemplo n.º 1
0
    def test_learn_multi_user(self):
        client_context1 = ClientContext(TestClient(), "testid")
        client_context1.bot = Bot(BotConfiguration())
        client_context1.brain = client_context1.bot.brain

        template = ET.fromstring("""
			<template>
				<learn>
				    <category>
				        <pattern>HELLO THERE ONE</pattern>
				        <template>HIYA ONE</template>
				    </category>
				</learn>
			</template>
			""")

        ast = self._graph.parse_template_expression(template)

        learn_node = ast.children[0]

        learn_node.resolve(client_context1)

        response = client_context1.bot.ask_question(client_context1, "HELLO THERE ONE")
        self.assertEqual("HIYA ONE", response)

        client_context2 = ClientContext(TestClient(), "testid")
        client_context2.bot = Bot(BotConfiguration())
        client_context2.brain = client_context2.bot.brain

        template = ET.fromstring("""
			<template>
				<learn>
				    <category>
				        <pattern>HELLO THERE TWO</pattern>
				        <template>HIYA TWO</template>
				    </category>
				</learn>
			</template>
			""")

        ast = self._graph.parse_template_expression(template)

        learn_node = ast.children[0]

        learn_node.resolve(client_context2)

        response = client_context2.bot.ask_question(client_context2, "HELLO THERE TWO")
        self.assertEqual("HIYA TWO", response)

        # Now try and ask each others questions

        response = client_context1.bot.ask_question(client_context1, "HELLO THERE TWO")
        self.assertEqual("", response)

        response = client_context2.bot.ask_question(client_context2, "HELLO THERE ONE")
        self.assertEqual("", response)
Ejemplo n.º 2
0
    def test_remove_html(self):
        processor = RemoveHTMLPostProcessor()

        context = ClientContext(TestClient(), "testid")

        result = processor.process(context, "Hello World")
        self.assertIsNotNone(result)
        self.assertEqual("Hello World", result)

        result = processor.process(context, "Hello  <br/> World")
        self.assertIsNotNone(result)
        if os.name == 'posix':
            self.assertEqual("Hello\nWorld", result)
        elif os.name == 'nt':
            self.assertEqual("Hello\r\nWorld", result)
        else:
            raise Exception("Unknown os [%s]" % os.name)

        result = processor.process(context, "Hello <br /> World")
        self.assertIsNotNone(result)
        if os.name == 'posix':
            self.assertEqual("Hello\nWorld", result)
        elif os.name == 'nt':
            self.assertEqual("Hello\r\nWorld", result)
        else:
            raise Exception("Unknown os [%s]" % os.name)
Ejemplo n.º 3
0
    def test_merge_chinese(self):
        processor = MergeChinesePostProcessor()

        context = ClientContext(TestClient(), "testid")

        result = processor.process(context, "Hello")
        self.assertIsNotNone(result)
        self.assertEqual("Hello", result)

        result = processor.process(context, "Hello World")
        self.assertIsNotNone(result)
        self.assertEqual("Hello World", result)

        result = processor.process(context, "你 好")
        self.assertIsNotNone(result)
        self.assertEqual("你好", result)

        result = processor.process(context, "问 你 好")
        self.assertIsNotNone(result)
        self.assertEqual("问你好", result)

        result = processor.process(context, "XX 你 好")
        self.assertIsNotNone(result)
        self.assertEqual("XX 你好", result)

        result = processor.process(context, "XX 你 好 YY")
        self.assertIsNotNone(result)
        self.assertEqual("XX 你好 YY", result)
Ejemplo n.º 4
0
    def test_format_numbers(self):
        processor = FormatNumbersPostProcessor()

        context = ClientContext(TestClient(), "testid")

        result = processor.process(context, "23")
        self.assertIsNotNone(result)
        self.assertEqual("23", result)

        result = processor.process(context, "23.45")
        self.assertIsNotNone(result)
        self.assertEqual("23.45", result)

        result = processor.process(context, "23. 45")
        self.assertIsNotNone(result)
        self.assertEqual("23.45", result)

        result = processor.process(context, "23 . 45")
        self.assertIsNotNone(result)
        self.assertEqual("23.45", result)

        result = processor.process(context, "23,450")
        self.assertIsNotNone(result)
        self.assertEqual("23,450", result)

        result = processor.process(context, "23, 450")
        self.assertIsNotNone(result)
        self.assertEqual("23,450", result)

        result = processor.process(context, "23, 450, 000")
        self.assertIsNotNone(result)
        self.assertEqual("23,450,000", result)
Ejemplo n.º 5
0
    def setUp(self):

        self._client_context = ClientContext(TestClient(), "testid")
        self._client_context.bot = Bot(BotConfiguration())
        self._client_context.brain = self._client_context.bot.brain

        self._graph = self._client_context.bot.brain.aiml_parser.template_parser

        self.test_sentence = Sentence(self._client_context.brain.nlp.tokenizer,
                                      "test sentence")

        test_node = PatternOneOrMoreWildCardNode("*")

        self.test_sentence._matched_context = MatchContext(
            max_search_depth=100,
            max_search_timeout=-1,
            tokenizer=self._client_context.brain.nlp.tokenizer)
        self.test_sentence._matched_context._matched_nodes = [
            Match(Match.WORD, test_node, 'one'),
            Match(Match.WORD, test_node, 'two'),
            Match(Match.WORD, test_node, 'three'),
            Match(Match.WORD, test_node, 'four'),
            Match(Match.WORD, test_node, 'five'),
            Match(Match.WORD, test_node, 'six'),
            Match(Match.TOPIC, test_node, '*'),
            Match(Match.THAT, test_node, '*')
        ]

        conversation = self._client_context.bot.get_conversation(
            self._client_context)
        question = Question.create_from_sentence(self.test_sentence)
        conversation._questions.append(question)
Ejemplo n.º 6
0
    def test_to_upper(self):
        processor = ToUpperPreProcessor()

        context = ClientContext(TestClient(), "testid")

        result = processor.process(context, "Hello")
        self.assertIsNotNone(result)
        self.assertEqual("HELLO", result)
Ejemplo n.º 7
0
 def test_init_with_bot_brain(self):
     client = MockClient("clientid")
     bot = MockBot("botid", None)
     brain = MockBrain("brainid")
     context = ClientContext(client, "testid")
     context.bot = bot
     context.brain = brain
     self.assertEquals("[clientid] [testid] [botid] [brainid] [0]",
                       str(context))
Ejemplo n.º 8
0
    def create_client_context(self, userid, load_variables=True):
        client_context = ClientContext(self, userid)
        client_context.bot = self._bot_factory.select_bot()

        #TODO: here is where we need to load in variables
        client_context.brain = client_context.bot.brain
        if load_variables:
            client_context.brain._load_variables(client_context)
        return client_context
Ejemplo n.º 9
0
    def test_demojize(self):
        processor = EmojizePreProcessor()

        context = ClientContext(TestClient(), "TestUser")

        self.assertEqual("Python is 👍",
                         processor.process(context, 'Python is :thumbs_up:'))
        self.assertEqual("Python is 👍",
                         processor.process(context, 'Python is :thumbsup:'))
Ejemplo n.º 10
0
    def test_format_punctuation(self):
        processor = FormatPunctuationProcessor()

        context = ClientContext(TestClient(), "testid")

        result = processor.process(context, 'Hello " World "')
        self.assertIsNotNone(result)
        self.assertEqual('Hello "World"', result)

        result = processor.process(context, '"Hello World"')
        self.assertIsNotNone(result)
        self.assertEqual('"Hello World"', result)

        result = processor.process(context, "' Hello World '")
        self.assertIsNotNone(result)
        self.assertEqual("'Hello World'", result)

        result = processor.process(context, '" Hello World "')
        self.assertIsNotNone(result)
        self.assertEqual('"Hello World"', result)

        result = processor.process(context, '"This" and "That"')
        self.assertIsNotNone(result)
        self.assertEqual('"This" and "That"', result)

        result = processor.process(context, "Hello World .")
        self.assertIsNotNone(result)
        self.assertEqual("Hello World.", result)

        result = processor.process(context, "Hello World ,")
        self.assertIsNotNone(result)
        self.assertEqual("Hello World,", result)

        result = processor.process(context, "Hello World :")
        self.assertIsNotNone(result)
        self.assertEqual("Hello World:", result)

        result = processor.process(context, "Hello World ;")
        self.assertIsNotNone(result)
        self.assertEqual("Hello World;", result)

        result = processor.process(context, "Hello World ?")
        self.assertIsNotNone(result)
        self.assertEqual("Hello World?", result)

        result = processor.process(context, "Hello World !")
        self.assertIsNotNone(result)
        self.assertEqual("Hello World!", result)

        result = processor.process(context, "Hello World . This is it.")
        self.assertIsNotNone(result)
        self.assertEqual("Hello World. This is it.", result)

        result = processor.process(context, "Hello World . 23.45.")
        self.assertIsNotNone(result)
        self.assertEqual("Hello World. 23.45.", result)
Ejemplo n.º 11
0
    def test_normalize(self):
        processor = NormalizePreProcessor()

        context = ClientContext(TestClient(), "testid")
        context.bot = self.bot
        context.brain = self.bot.brain

        result = processor.process(context, "Hello")
        self.assertIsNotNone(result)
        self.assertEqual("Hello", result)
Ejemplo n.º 12
0
    def test_authenticator_with_empty_config(self):
        client_context = ClientContext(TestClient(), "console")
        client_context.bot = Bot(BotConfiguration())
        client_context.bot.configuration.conversations._max_histories = 3
        client_context.brain = client_context.bot.brain

        service = Authenticator(BrainSecurityConfiguration("authentication"))
        self.assertIsNotNone(service)
        self.assertIsNotNone(service.configuration)
        self.assertIsNone(service.get_default_denied_srai())
        self.assertFalse(service.authenticate(client_context))
Ejemplo n.º 13
0
    def test_remove_punctuation(self):
        processor = RemovePunctuationPreProcessor()

        context = ClientContext(TestClient(), "testid")

        result = processor.process(context, "Hello!")
        self.assertIsNotNone(result)
        self.assertEqual("Hello", result)

        result = processor.process(context, "$100")
        self.assertIsNotNone(result)
        self.assertEqual("$100", result)
Ejemplo n.º 14
0
    def test_conversation(self):

        client_context = ClientContext(TestClient(), "testid")
        client_context.bot = Bot(BotConfiguration())
        client_context.bot.configuration.conversations._max_histories = 3
        client_context.brain = client_context.bot.brain

        conversation = Conversation(client_context)
        self.assertIsNotNone(conversation)
        self.assertEqual(0, len(conversation._questions))
        self.assertEqual(3, conversation._max_histories)
        self.assertEqual(1, len(conversation._properties))

        with self.assertRaises(Exception):
            conversation.current_question()
        with self.assertRaises(Exception):
            conversation.previous_nth_question(0)

        question1 = Question.create_from_text(
            client_context.brain.nlp.tokenizer, "Hello There")
        conversation.record_question(question1)
        self.assertEqual(question1, conversation.current_question())
        with self.assertRaises(Exception):
            conversation.previous_nth_question(1)

        question2 = Question.create_from_text(
            client_context.brain.nlp.tokenizer, "Hello There Again")
        conversation.record_question(question2)
        self.assertEqual(question2, conversation.current_question())
        self.assertEqual(question1, conversation.previous_nth_question(1))
        with self.assertRaises(Exception):
            conversation.previous_nth_question(3)

        question3 = Question.create_from_text(
            client_context.brain.nlp.tokenizer, "Hello There Again Again")
        conversation.record_question(question3)
        self.assertEqual(question3, conversation.current_question())
        self.assertEqual(question2, conversation.previous_nth_question(1))
        with self.assertRaises(Exception):
            conversation.previous_nth_question(4)

        # Max Histories for this test is 3
        # Therefore we should see the first question, pop of the stack

        question4 = Question.create_from_text(
            client_context.brain.nlp.tokenizer,
            "Hello There Again Again Again")
        conversation.record_question(question4)
        self.assertEqual(question4, conversation.current_question())
        self.assertEqual(question3, conversation.previous_nth_question(1))
        with self.assertRaises(Exception):
            conversation.previous_nth_question(5)
Ejemplo n.º 15
0
    def test_denormalize(self):
        processor = DenormalizePostProcessor ()

        context = ClientContext(TestClient(), "testid")
        context.bot = self.bot
        context.brain = self.bot.brain
        result = processor.process(context, "Hello")
        self.assertIsNotNone(result)
        self.assertEqual("Hello", result)

        result = processor.process(context, "hello dot com")
        self.assertIsNotNone(result)
        self.assertEqual("hello.com", result)
Ejemplo n.º 16
0
    def test_get_initial_question_initial_question_srai_match(self):

        bot_config = BotConfiguration()
        self.assertIsNotNone(bot_config)

        bot = MockBot(bot_config)
        self.assertIsNotNone(bot)

        client_context2 = ClientContext(TestClient(), "testid2")
        client_context2._bot = bot
        client_context2._brain = MockBrain(bot, bot.configuration.brain_config[0])
        client_context2._brain._response = "Y DEFAULT RESPONSE"

        self.assertEquals("Y DEFAULT RESPONSE", bot.get_initial_question(client_context2))
Ejemplo n.º 17
0
    def test_service(self):
        client_context = ClientContext(TestClient(), "unknown")
        client_context.bot = Bot(BotConfiguration())
        client_context.bot.configuration.conversations._max_histories = 3
        client_context.brain = client_context.bot.brain

        service = BasicPassThroughAuthenticationService(
            BrainServiceConfiguration("authentication"))
        self.assertIsNotNone(service)
        self.assertIsNotNone(service.configuration)
        client_context._userid = "console"
        self.assertTrue(service.authenticate(client_context))
        client_context._userid = "anyone"
        self.assertTrue(service.authenticate(client_context))
Ejemplo n.º 18
0
    def test_get_default_response_default_response_srai_match(self):

        bot_config = BotConfiguration()
        self.assertIsNotNone(bot_config)

        bot_config.default_response_srai = "YDEFAULTRESPONSE"
        bot_config.default_response = "Default response!"

        bot = MockBot(bot_config)
        self.assertIsNotNone(bot)

        client_context2 = ClientContext(TestClient(), "testid2")
        client_context2._bot = bot
        client_context2._brain = MockBrain(bot, bot.configuration.brain_config[0])
        client_context2._brain._response = "Y DEFAULT RESPONSE"

        response = bot.get_default_response(client_context2)
        self.assertIsNotNone(response)
        self.assertEquals("Y DEFAULT RESPONSE", response)
Ejemplo n.º 19
0
    def test_max_recursion(self):
        client = MockClient("clientid")
        bot_config = MockBotConfiguration(1, 1)
        bot = MockBot("botid", bot_config)
        brain = MockBrain("brainid")
        context = ClientContext(client, "testid")
        context.bot = bot
        context.brain = brain
        self.assertEquals("[clientid] [testid] [botid] [brainid] [0]",
                          str(context))

        context.mark_question_start("question1")

        context.check_max_recursion()

        context.mark_question_start("question2")

        with self.assertRaises(Exception):
            context.check_max_recursion()
Ejemplo n.º 20
0
    def test_learn_simple(self):
        
        client_context1 = ClientContext(TestClient(), "testid")
        client_context1.bot = Bot(BotConfiguration())
        client_context1.brain = client_context1.bot.brain

        template = ET.fromstring("""
			<template>
				<learn>
				    <category>
				        <pattern>HELLO <eval>WORLD</eval> <iset>THERE, NOW</iset></pattern>
				        <template>HIYA</template>
				    </category>
				</learn>
			</template>
			""")

        ast = self._graph.parse_template_expression(template)
        self.assertIsNotNone(ast)
        self.assertIsInstance(ast, TemplateNode)
        self.assertIsNotNone(ast.children)
        self.assertEqual(len(ast.children), 1)

        learn_node = ast.children[0]
        self.assertIsNotNone(learn_node)
        self.assertIsInstance(learn_node, TemplateLearnNode)
        self.assertEqual(1, len(learn_node.children))
        self.assertIsInstance(learn_node.children[0], LearnCategory)
        self.assertIsNotNone(learn_node.children[0].pattern)
        self.assertIsInstance(learn_node.children[0].pattern, ET.Element)
        self.assertIsNotNone(learn_node.children[0].topic)
        self.assertIsInstance(learn_node.children[0].topic, ET.Element)
        self.assertIsNotNone(learn_node.children[0].that)
        self.assertIsInstance(learn_node.children[0].that, ET.Element)
        self.assertIsNotNone(learn_node.children[0].template)
        self.assertIsInstance(learn_node.children[0].template, TemplateNode)

        resolved = learn_node.resolve(client_context1)
        self.assertEqual(resolved, "")

        response = client_context1.bot.ask_question(client_context1, "HELLO WORLD THERE")
        self.assertEqual("HIYA", response)
Ejemplo n.º 21
0
    def test_remove_multi_spaces(self):
        processor = RemoveMultiSpacePostProcessor()

        context = ClientContext(TestClient(), "testid")
        
        result = processor.process(context, "Hello World")
        self.assertIsNotNone(result)
        self.assertEqual("Hello World", result)

        result = processor.process(context, "Hello World ")
        self.assertIsNotNone(result)
        self.assertEqual("Hello World", result)

        result = processor.process(context, " Hello World")
        self.assertIsNotNone(result)
        self.assertEqual("Hello World", result)

        result = processor.process(context, " Hello  World ")
        self.assertIsNotNone(result)
        self.assertEqual("Hello World", result)
Ejemplo n.º 22
0
    def post_process(self, output_str):
        context = ClientContext(TestClient(), "testid")

        context.bot = Bot(config=BotConfiguration())
        context.brain = context.bot.brain
        context.bot.brain.denormals.process_splits([" dot com ", ".com"])
        context.bot.brain.denormals.process_splits([" atsign ", "@"])
        denormalize = DenormalizePostProcessor()
        punctuation = FormatPunctuationProcessor()
        numbers = FormatNumbersPostProcessor()
        multispaces = RemoveMultiSpacePostProcessor()
        emojize = EmojizePreProcessor()

        output_str = denormalize.process(context, output_str)
        output_str = punctuation.process(context, output_str)
        output_str = numbers.process(context, output_str)
        output_str = multispaces.process(context, output_str)
        output_str = emojize.process(context, output_str)

        return output_str
Ejemplo n.º 23
0
    def test_format_message_with_client_context(self):

        client = TestClient()

        bot_config = BotConfiguration()
        bot_config._section_name = "testbot"
        bot = Bot(bot_config, client)

        brain_config = BrainConfiguration()
        brain_config._section_name = "testbrain"
        brain = Brain(bot, brain_config)

        client_context = ClientContext(client, "testuser")
        client_context._bot = bot
        client_context._brain = brain

        msg = YLogger.format_message(client_context, "Test Message")
        self.assertIsNotNone(msg)
        self.assertEquals(
            "[testclient] [testbot] [testbrain] [testuser] - Test Message",
            msg)
Ejemplo n.º 24
0
    def test_pre_cleanup(self):

        context = ClientContext(TestClient(), "testid")
        context.bot = Bot(config=BotConfiguration())
        context.brain = context.bot.brain
        test_str = "This is my Location!"

        punctuation_processor = RemovePunctuationPreProcessor()
        test_str = punctuation_processor.process(context, test_str)
        self.assertEqual("This is my Location", test_str)

        normalize_processor = NormalizePreProcessor()
        test_str = normalize_processor.process(context, test_str)
        self.assertEqual("This is my Location", test_str)

        toupper_processor = ToUpperPreProcessor()
        test_str = toupper_processor.process(context, test_str)
        self.assertEqual("THIS IS MY LOCATION", test_str)

        demojize_processpr = DemojizePreProcessor()
        test_str = demojize_processpr.process(context, test_str)
        self.assertEqual(test_str, test_str)
Ejemplo n.º 25
0
    def test_bot_with_conversation(self):
        
        bot = Bot(BotConfiguration())
        self.assertIsNotNone(bot)

        self.assertFalse(bot.has_conversation(self._client_context))

        response = bot.ask_question(self._client_context, "hello")
        self.assertIsNotNone(response)
        self.assertTrue(bot.has_conversation(self._client_context))

        response = bot.ask_question(self._client_context, "hello")
        self.assertIsNotNone(response)
        self.assertTrue(bot.has_conversation(self._client_context))

        client_context2 = ClientContext(TestClient(), "testid2")
        client_context2._bot = bot
        client_context2._brain = self._client_context.bot.brain

        response = bot.ask_question(client_context2, "hello")
        self.assertIsNotNone(response)
        self.assertTrue(bot.has_conversation(client_context2))
Ejemplo n.º 26
0
    def test_format_console(self):
        processor = ConsoleFormatPostProcessor()

        context = ClientContext(TestClient(), "testid")
        result = processor.process(context, "Hello World")
        self.assertIsNotNone(result)
        self.assertEqual("Hello World", result)

        result = processor.process(
            context,
            "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Rationis enim perfectio est virtus; Sed quid attinet de rebus tam apertis plura requirere?"
        )
        self.assertIsNotNone(result)
        if os.name == 'posix':
            self.assertEqual(
                "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Rationis enim perfectio\nest virtus; Sed quid attinet de rebus tam apertis plura requirere?",
                result)
        elif os.name == 'nt':
            self.assertEqual(
                "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Rationis enim perfectio\r\nest virtus; Sed quid attinet de rebus tam apertis plura requirere?",
                result)
        else:
            raise Exception("Unknown os [%s]" % os.name)
Ejemplo n.º 27
0
    def test_question(self):
        client = MockClient("clientid")
        bot = MockBot("botid", None)
        brain = MockBrain("brainid")
        context = ClientContext(client, "testid")
        context.bot = bot
        context.brain = brain
        self.assertEquals("[clientid] [testid] [botid] [brainid] [0]",
                          str(context))

        context.mark_question_start("question")

        self.assertEquals("[clientid] [testid] [botid] [brainid] [1]",
                          str(context))

        context.mark_question_start("question")

        self.assertEquals("[clientid] [testid] [botid] [brainid] [2]",
                          str(context))

        context.reset_question()

        self.assertEquals("[clientid] [testid] [botid] [brainid] [0]",
                          str(context))
Ejemplo n.º 28
0
    def test_demojize(self):
        processor = DemojizePreProcessor()

        context = ClientContext(TestClient(), "testid")

        self.assertEqual("Python is :thumbs_up:", processor.process(context, 'Python is 👍'))
Ejemplo n.º 29
0
 def setUp(self):
     self._client_context = ClientContext(TestClient(), "testid")
Ejemplo n.º 30
0
 def setUp(self):
     self._client_context = ClientContext(TestClient(), "unknown")
     self._client_context.bot = Bot(BotConfiguration())
     self._client_context.bot.configuration.conversations._max_histories = 3
     self._client_context.brain = self._client_context.bot.brain