Ejemplo n.º 1
0
def test_extract_sentiment():
    print("Testing extract_sentiment() functionality...")
    chatbot = Chatbot(False)
    if assertEquals(
            chatbot.extract_sentiment("I like \"Titanic (1997)\"."), 1,
            "Incorrect output for extract_sentiment(\'I like \"Titanic (1997)\".\')"
    ) and assertEquals(
            chatbot.extract_sentiment("I saw \"Titanic (1997)\"."), 0,
            "Incorrect output for extract_sentiment(\'I saw  \"Titanic (1997)\".\')"
    ) and assertEquals(
            chatbot.extract_sentiment("I didn't enjoy \"Titanic (1997)\"."),
            -1,
            "Incorrect output for extract_sentiment(\'I didn't enjoy  \"Titanic (1997)\"\'.)"
    ) and assertEquals(
            chatbot.extract_sentiment("I saw \"Titanic (1997)\"."), 0,
            "Incorrect output for extract_sentiment(\'I saw  \"Titanic (1997)\"\'.)"
    ) and assertEquals(
            chatbot.extract_sentiment(
                " \"Titanic (1997)\" started out terrible, but the ending was totally great and I loved it!"
            ), 1,
            "Incorrect output for extract_sentiment(\" \"Titanic (1997)\" started out terrible, but the ending was totally great and I loved it!\'.\")"
    ) and assertEquals(
            chatbot.extract_sentiment(
                "I loved \"10 Things I Hate About You\""), 1,
            "Incorrect output for extract_sentiment(\'I loved  \"10 Things I Hate About You\"\')"
    ) and assertEquals(
            chatbot.extract_sentiment(
                "I saw \"The Notebook\" and it was great!"), 1,
            "Incorrect output for extract_sentiment(\'I saw \"The Notebook\" and it was great!\')"
    ):
        print('extract_sentiment() sanity check passed!')
    print()
Ejemplo n.º 2
0
def test_find_movies_by_title():
    print("Testing find_movies_by_title() functionality...")
    chatbot = Chatbot(False)
    if assertListEquals(
            chatbot.find_movies_by_title("The American President"),
        [
            10
        ], "Incorrect output for find_movies_by_title('The American President')."
    ) and assertListEquals(
            chatbot.find_movies_by_title("An American in Paris (1951)"),
        [
            721
        ], "Incorrect output for find_movies_by_title('An American in Paris (1951)')."
    ) and assertListEquals(
            chatbot.find_movies_by_title("Titanic"), [1359, 2716],
            "Incorrect output for find_movies_by_title('Titanic').",
            orderMatters=False
    ) and assertListEquals(
            chatbot.find_movies_by_title("The Notebook"), [5448],
            "Incorrect output for find_movies_by_title('The Notebook')."
    ) and assertListEquals(
            chatbot.find_movies_by_title("Titanic (1997)"),
        [1359],
            "Incorrect output for find_movies_by_title('Titanic (1997)').",
    ) and assertListEquals(
            chatbot.find_movies_by_title("There is no title here!"), [],
            "Incorrect output for find_movies_by_title('There is no title here!')."
    ):
        print('find_movies_by_title() sanity check passed!')
    print()
Ejemplo n.º 3
0
def test():
    dataset = CornellMovieDialogs(data_directory="data/",
                                  vocabulary_size=20000)
    if not os.path.exists("data/cleaned"):
        dataset.make_conversations()
    else:
        dataset.load()

    bot = Chatbot(sequence_length=20,
                  hidden_size=256,
                  vocabulary_size=dataset.vocabulary_size)
    bot.load("models/checkpoints/checkpoint.h5")
    while True:
        print(">>>", end="")
        sentence = raw_input()
        sentence = dataset.clean(sentence)
        sentence = dataset.encode_sequence(sentence)
        sentence = sequence.pad_sequences([sentence],
                                          maxlen=bot.sequence_length)
        for t in [.7, .8, .9]:
            response = bot.respond(sentence, temperature=t)
            print(response)
            response = dataset.decode_sequence(response)
            start_index = response.index(
                "START") + 1 if "START" in response else 0
            end_index = response.index("END") if "END" in response else len(
                response)
            response = response[start_index:end_index]
            print(" ".join(response))
Ejemplo n.º 4
0
def main(args):
    # Configure Logger
    level = 'NOTSET'
    if args.verbose:
        level = 'DEBUG'
    logger = get_logger(name="main", level=level)
    logger.info("Starting Tissegram")

    # Get Config
    logger.info("Get Config")
    config = configparser.ConfigParser()
    config.read(args.conf)

    logger.info("Init database module")
    db = DataBase(ip=config['Database']['ip'],
                  port=config['Database']['port'],
                  database=config['Database']['database'],
                  username=config['Database']['username'],
                  password=config['Database']['password'])

    logger.info("Init transport module")
    transport = PublicTransport(token=config['Tisseo']['token'])

    logger.info("Init bot module")
    bot = Chatbot(token=config['Telegram']['token'],
                  webhook_ip=config['Telegram']['webhook'],
                  db=db,
                  transport=transport)

    logger.info("Start thread")
    threading.Thread(target=bot.run, kwargs=dict(host='localhost',
                                                 port=5001)).start()
Ejemplo n.º 5
0
    def test_chatbot(self):
        bot = Chatbot()

        for test_case in self.chatbot_funtranslate_test:
            with mock.patch('requests.get', self.mocked_funtranslate_get):
                bot_response = bot.translate(test_case[KEY_INPUT])

                self.assertEqual(test_case[KEY_EXPECTED], bot_response)

        for test_case in self.chatbot_joke_test:
            with mock.patch('requests.get', self.mocked_joke_get):
                bot_response = bot.joke()

                self.assertEqual(test_case[KEY_EXPECTED], bot_response)

        for test_case in self.chatbot_randcase_test:
            with mock.patch('chatbot.choice', self.mocked_random_choice):
                bot_response = bot.randcase(test_case[KEY_INPUT])

                self.assertEqual(test_case[KEY_EXPECTED], bot_response)

        for test_case in self.chatbot_translate_from_process_test:
            with mock.patch('requests.get', self.mocked_funtranslate_get):
                bot_response = bot.process(test_case[KEY_INPUT])

                self.assertEqual(test_case[KEY_EXPECTED], bot_response)

        for test_case in self.create_message_test:
            model = Message(test_case[KEY_INPUT]['username'],
                            test_case[KEY_INPUT]['userimage'],
                            test_case[KEY_INPUT]['userkey'],
                            test_case[KEY_INPUT]['message'])
Ejemplo n.º 6
0
def test_find_movies_closest_to_title():
    print("Testing find_movies_closest_to_title() functionality...")
    chatbot = Chatbot(True)

    misspelled = "Sleeping Beaty"

    if assertListEquals(
            chatbot.find_movies_closest_to_title(misspelled,
                                                 max_distance=3), [1656],
            "Incorrect output for test_find_movies_closest_to_title('{}', max_distance={})"
            .format(misspelled, 3),
            orderMatters=False
    ) and assertListEquals(
            chatbot.find_movies_closest_to_title(
                "Te", max_distance=3), [8082, 4511, 1664],
            "Incorrect output for test_find_movies_closest_to_title('{}', max_distance={})"
            .format("Te", 3),
            orderMatters=False
    ) and assertListEquals(
            chatbot.find_movies_closest_to_title("BAT-MAAAN",
                                                 max_distance=3), [524, 5743],
            "Incorrect output for test_find_movies_closest_to_title('{}', max_distance={})"
            .format("BAT-MAAAN", 3),
            orderMatters=False
    ) and assertListEquals(
            chatbot.find_movies_closest_to_title("Blargdeblargh",
                                                 max_distance=4), [],
            "Incorrect output for test_find_movies_closest_to_title('{}', max_distance={})"
            .format("Blargdeblargh", 4),
            orderMatters=False):
        print('find_movies_closest_to_title() sanity check passed!')
    print()
    return True
Ejemplo n.º 7
0
def test_disambiguate():
    print("Testing disambiguate() functionality...")
    chatbot = Chatbot(True)

    # clarification = "2"
    # candidates = [3812, 4325, 5399, 6294, 6735, 7274, 7670, 7842]
    # if assertListEquals(
    #     chatbot.disambiguate(clarification, candidates),
    #     [4325],
    #     "Incorrect output for disambiguate('{}', {})".format(clarification, candidates),
    #     orderMatters=False
    # ):

    # clarification = "Sorcerer's Stone"
    # candidates = [3812, 4325, 5399, 6294, 6735, 7274, 7670, 7842]
    # if assertListEquals(
    #     chatbot.disambiguate(clarification, candidates),
    #     [3812],
    #     "Incorrect output for disambiguate('{}', {})".format(clarification, candidates),
    #     orderMatters=False
    # ):

    clarification = "1997"
    candidates = [1359, 2716]
    if assertListEquals(
        chatbot.disambiguate(clarification, candidates),
        [1359],
        "Incorrect output for disambiguate('{}', {})".format(clarification, candidates),
        orderMatters=False
    ):
        print('disambiguate() sanity check passed!')
    print()
    return True
Ejemplo n.º 8
0
def index():

    chatbot_label = "Hallo. Worüber wollen Sie sprechen?"

    # Listen
    zufallsantworten = [
        "Oh wirklich...", "Interessant", "Das kann man so sehen.",
        "Ich verstehe..."
    ]
    reaktionen = {
        "hallo": "aber hallo",
        "geht": "Was verstehst Du darunter",
        "schmeckt": "Ich habe keinen Geschmackssinn"
    }

    if request.method == 'POST':
        chatbot_input = request.form['chatbot_input']
        if not chatbot_input:
            flash('Ohne Frage kann ich nicht antworten!')
        else:
            bot = Chatbot(reaktionen, zufallsantworten)
            bot.set_Message(chatbot_input)
            chatbot_label = bot.get_response()

    return render_template('chatbot.html', chatbot_label=chatbot_label)
Ejemplo n.º 9
0
class Assistente(Screen):
    bot = Chatbot('Pedro')

    def mensagem(self,msg,*args):
        self.ids.box.add_widget(Mensagem(text=msg))
        frase = self.bot.escuta(frase=msg)
        self.resp = self.bot.pensa(frase)
        self.bot.fala(self.resp)
        self.respWidget = Mensagem(text='Typing...')
        self.ids.box.add_widget(self.respWidget)
        self.ids.texto.text = ''
        Clock.schedule_once(self.responder,1)

    def responder(self,*args):
        self.respWidget.text = self.resp 
        tts.speak(self.resp)

    def escuta(self,*args):
        if self.ids.mic.background_normal == 'mic.png':
            self.ids.mic.background_normal = ''
            stt.start()
            Clock.schedule_interval(self.checar,1/5)
        else:
            self.ids.mic.background_normal = 'mic.png'
            stt.stop()

    def checar(self,*args):
        if not stt.listening:
            self.ids.mic.background_normal = 'mic.png'
            stt.stop()
            Clock.unschedule(self.checar)
            frase = ''.join(stt.results)
            if frase:
                self.mensagem(frase)
Ejemplo n.º 10
0
def test_extract_titles():
    print("Testing extract_titles() functionality...")
    chatbot = Chatbot(False)

    # add more test cases here!!!
    test_cases = [
        ('I liked "The Notebook"', ["The Notebook"]),
        ('You are a great bot!', []),
        ('I enjoyed "Titanic (1997)" and "Scream 2 (1997)"',
         ["Titanic (1997)", "Scream 2 (1997)"]),
    ]

    tests_passed = True
    for input_text, expected_output in test_cases:
        if not assert_list_equals(
                chatbot.extract_titles(chatbot.preprocess(input_text)),
                expected_output,
                "Incorrect output for extract_titles("
                "chatbot.preprocess('{}')).".format(
                    input_text),
                orderMatters=False
        ):
            tests_passed = False
    if tests_passed:
        print('extract_titles() sanity check passed!')
    print()
def main():
    """
    Main loop for the command line interface.
    """
    (options, args) = PARSER.parse_args()
    # Configure logging
    logging.basicConfig(filename=options.log_filename, level=logging.DEBUG,
        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
    logging.getLogger('py4j.java_gateway').setLevel(logging.INFO)
    # These imports are performed after the logging setup because basicConfig
    # will not work if other modules call logging functions before it's called.
    from chatbot import Chatbot
    from database import Database
    # Setup the database
    db = Database(options.database_url)
    # Setup the chatbot
    logger = logging.getLogger('chatbot')
    bot = Chatbot(db, logger)
    greeting = bot.get_greeting()

    print greeting
    while 1:
        # Chatbot instances should not call exit() themselves.
        # If they need to exit, they should signal so, not exit
        # themselves.
        PROMPT = bot.prompt # prompt from chatbot, shows mode: creative/regular
        try:
            user_input = raw_input(PROMPT)
        except EOFError:
            return
        bot_output = bot.handle_input(user_input)
        print bot_output
Ejemplo n.º 12
0
def test_extract_sentiment_for_movies():
    print("Testing test_extract_sentiment_for_movies() functionality...")
    chatbot = Chatbot(True)

    # add more test cases here!!!
    test_cases = [
        ('I liked both "I, Robot" and "Ex Machina".', [("I, Robot", 1),
                                                       ("Ex Machina", 1)]),
        ('I liked "I, Robot" but not "Ex Machina".', [("I, Robot", 1),
                                                      ("Ex Machina", -1)]),
        ('I didn\'t like either "I, Robot" or "Ex Machina".',
         [("I, Robot", -1), ("Ex Machina", -1)]),
        ('I liked "Titanic (1997)", but "Ex Machina" was not good.',
         [("Titanic (1997)", 1), ("Ex Machina", -1)]),
    ]

    tests_passed = True
    for input_text, expected_output in test_cases:
        if not assertListEquals(
                chatbot.extract_sentiment_for_movies(
                    chatbot.preprocess(input_text)),
                expected_output,
                "Incorrect output for extract_sentiment_for_movies(chatbot.preprocess('{}'))."
                .format(input_text),
                orderMatters=False):
            tests_passed = False
    if tests_passed:
        print('extract_sentiment_for_movies() sanity check passed!')
    print()
Ejemplo n.º 13
0
def test_find_movies_closest_to_title():
    print("Testing find_movies_closest_to_title() functionality...")
    chatbot = Chatbot(True)

    # add more test cases here!!!
    test_cases = [
        ('Sleeping Beaty', [1656]),
        ('Te', [8082, 4511, 1664]),
        ('BAT-MAAAN', [524, 5743]),
        ('Blargdeblargh', []),
    ]

    tests_passed = True
    for input_text, expected_output in test_cases:
        if not assertListEquals(
                chatbot.find_movies_closest_to_title(
                    chatbot.preprocess(input_text)),
                expected_output,
                "Incorrect output for find_movies_closest_to_title(chatbot.preprocess('{}'))."
                .format(input_text),
                orderMatters=False):
            tests_passed = False
    if tests_passed:
        print('find_movies_closest_to_title() sanity check passed!')
    print()
    return True
Ejemplo n.º 14
0
def test_find_movies_closest_to_title():
    print("Testing find_movies_closest_to_title() functionality...")
    chatbot = Chatbot(True)

    # add more test cases here!!!
    test_cases = [('Sleeping Beaty', [1656]), ('Te', [8082, 4511, 1664]),
                  ('BAT-MAAAN', [524, 5743]), ('Blargdeblargh', []),
                  ('The Notebok', [5448]),
                  ('An Awfully Big Advventuree', [127]),
                  ('An Amrican in Paris', [721]),
                  ('The Cellloid Closet', [516]), ('Titanc', [2716, 1359])]

    tests_passed = True
    for input_text, expected_output in test_cases:
        if not assert_list_equals(
                chatbot.find_movies_closest_to_title(input_text),
                expected_output,
                "Incorrect output for find_movies_closest_to_title("
                "chatbot.preprocess('{}')).".format(input_text),
                orderMatters=False):
            tests_passed = False
    if tests_passed:
        print('find_movies_closest_to_title() sanity check passed!')
    print()
    return True
Ejemplo n.º 15
0
def test_extract_sentiment():
    print("Testing extract_sentiment() functionality...")
    chatbot = Chatbot(False)

    # add more test cases here!!!
    test_cases = [
        ('I like "Titanic (1997)".', 1),
        ('I saw "Titanic (1997)".', 0),
        ('I didn\'t enjoy "Titanic (1997)".', -1),
        ('I didn\'t really like "Titanic (1997)".', -1),
        ('I never liked "Titanic (1997)".', -1),
        ('I really enjoyed "Titanic (1997)".', 1),
        ('"Titanic (1997)" started out terrible, but the ending was totally great and I loved it!',
         1),
        ('I loved "10 Things I Hate About You"', 1),
    ]

    tests_passed = True
    for input_text, expected_output in test_cases:
        if not assertEquals(
                chatbot.extract_sentiment(
                    chatbot.preprocess(input_text)), expected_output,
                "Incorrect output for extract_sentiment(chatbot.preprocess('{}'))."
                .format(input_text)):
            tests_passed = False
    if tests_passed:
        print('extract_sentiment() sanity check passed!')
    print()
Ejemplo n.º 16
0
def test_find_movies_by_title():
    print("Testing find_movies_by_title() functionality...")
    chatbot = Chatbot(False)

    # add more test cases here!!!
    test_cases = [
        ('The American President', [10]),
        ('Titanic', [1359, 2716]),
        ('Titanic (1997)', [1359]),
        ('An American in Paris (1951)', [721]),
        ('The Notebook (1220)', []),
        ('Scream', [1142]),
    ]

    tests_passed = True
    for input_text, expected_output in test_cases:
        if not assert_list_equals(
                chatbot.find_movies_by_title(input_text),
                expected_output,
                "Incorrect output for find_movies_by_title('{}').".format(
                    input_text),
                orderMatters=False
        ):
            tests_passed = False
    if tests_passed:
        print('find_movies_by_title() sanity check passed!')
    print()
Ejemplo n.º 17
0
def test_disambiguate_complex():
    print("Testing complex disambiguate() functionality...")
    chatbot = Chatbot(True)

    # add more test cases here!!!
    test_cases = [
        ('2', [8082, 4511, 1664], [4511]),
        ('most recent', [524, 5743], [1524]),
        ('the Goblet of Fire one',
         [3812, 4325, 5399, 6294, 6735, 7274, 7670, 7842], [6294]),
        ('the second one', [3812, 6294, 4325, 5399, 6735, 7274, 7670,
                            7842], [6294]),
    ]

    tests_passed = True
    for clarification, candidates, expected_output in test_cases:
        if not assertListEquals(
                chatbot.disambiguate(clarification, candidates),
                expected_output,
                "Incorrect output for complex disambiguate('{}', {})".format(
                    clarification, candidates),
                orderMatters=False):
            tests_passed = False
    if tests_passed:
        print('complex disambiguate() sanity check passed!')
    print()
    return True
Ejemplo n.º 18
0
def getResponse(input_statement):
    from chatbot import Chatbot
    bot = Chatbot()

    with open(answers_json) as ans:
        ans_json = json.load(ans)

    input_statement = re.sub(r'[^a-zA-Z0-9-:.@/ ]', '',
                             input_statement).strip()
    input_statement = ' '.join(input_statement.split())

    bucket, sub_bucket, _, _ = extract_buckets(input_statement.lower())
    reply = bot.get_response(input_statement)
    print("reply ---- {}".format(reply))

    if bucket and sub_bucket:
        reply = reply
    elif bucket and not sub_bucket:
        reply = reply
    elif not bucket and sub_bucket:
        reply = ""
    else:
        reply = ""

    reply = str(reply)
    if not reply:
        suggestions = ""
    else:
        suggestions = ans_json[reply]["category"]
    replyJson = {"suggestions": suggestions}
    return replyJson
Ejemplo n.º 19
0
def ask():

    data = request.get_json()

    if not data:
        return jsonify({"message": "No payload received"}), 400
    if ("message" not in data):
        return jsonify({"message": "please specify a message"}), 400

    if ("current_context" not in data):
        current_context = None
    else:
        current_context = data["current_context"]

    chatbot = Chatbot(sensitivity=0.4)
    chatbot.load()
    '''
    chatbot.add_action("NutrizionistaCittaIntent", search_nutritionists)
    chatbot.add_action("DietistaCittaIntent", search_dietisti)
    chatbot.add_action("DietologoCittaIntent", search_dietologi)
    '''
    answer = chatbot.ask(data["message"],
                         current_context=current_context,
                         return_proba=True)

    return jsonify({
        "answer": str(answer[0]),
        "new_context": str(answer[1]),
        "probability": str(answer[2])
    }), 200
Ejemplo n.º 20
0
def test_extract_titles_creative():
    print("Testing [CREATIVE MODE] extract_titles() functionality...")
    chatbot = Chatbot(True)
    if assertListEquals(
            chatbot.extract_titles('I liked The Notebook!'),
        [
            "The Notebook"
        ], "Incorrect output for [CREATIVE] extract_titles('I liked The Notebook')."
    ) and assertListEquals(
            chatbot.extract_titles(
                'I thought 10 things i hate about you was great'),
        ["10 things i hate about you", "10", "hate"],
            "Incorrect output for [CREATIVE] extract_titles('I thought 10 things i hate about you was great').",
            orderMatters=False
    ) and assertListEquals(
            chatbot.extract_titles('I like \"Harry Potter\"'),
        [
            "Harry Potter"
        ], "Incorrect output for [CREATIVE] extract_titles('I like \"Harry Potter\"')."
    ) and assertListEquals(
            chatbot.extract_titles('I liked Scream 2!'),
        ["Scream", "Scream 2"],
            "Incorrect output for [CREATIVE] extract_titles('I liked Scream 2').",
            orderMatters=False
    ) and assertListEquals(
            chatbot.extract_titles(
                'I liked "Titanic" and 10 things i hate about you...'),
        ["Titanic", "10 things i hate about you", "10", "hate"],
            "Incorrect output for [CREATIVE] extract_titles('I liked \"Titanic\" and 10 things i hate about you').",
            orderMatters=False
    ) and assertListEquals(
            chatbot.extract_titles('I liked Se7en, 10 things i hate about you, La guerre du feu, The Return of Godzilla, and I, Robot!'
                                   ), [
                                       "10",
                                       "hate", "Se7en", "10 things i hate about you",
                                       "La guerre du feu", "I, Robot",
                                       "The Return of Godzilla", "The Return",
                                       "Godzilla"
                                   ],
            "Incorrect output for [CREATIVE] extract_titles('I liked Se7en, 10 things i hate about you, La guerre du feu, The Return of Godzilla, and I, Robot!').",
            orderMatters=False
    ) and assertListEquals(
            chatbot
            .extract_titles('I liked "Home Alone 3"'), ["Home Alone 3"],
            "Incorrect output for [CREATIVE] extract_titles('I liked \"Home Alone 3\").",
            orderMatters=False
    ) and assertListEquals(
            chatbot.
            extract_titles('I liked happy feet'
                           ),
        ["happy", "happy feet"],
            "Incorrect output for [CREATIVE] extract_titles('I liked happy feet).",
            orderMatters=False
    ) and assertListEquals(
            chatbot
            .extract_titles('I liked \"Happy Feet\"'), ["Happy Feet"],
            "Incorrect output for [CREATIVE] extract_titles('I liked \"Happy Feet\").",
            orderMatters=False):
        print('[CREATIVE MODE] extract_titles() sanity check passed!')
    print()
Ejemplo n.º 21
0
def main():
    chatbot = Chatbot()

    print('BOT: Olá querido usuário!')
    print(
        'BOT: Fico a disposição para responder perguntas sobre mercado, saúde, tecnologia e telefonia.'
    )
    print('BOT: Diga tchau quando encerrar!')

    stop = False

    while not stop:
        user_request = input('Pergunta: ')
        user_request = user_request.lower()

        if user_request != 'tchau':
            if user_request == 'obrigado' or user_request == 'muito obrigado':
                stop = True
                print("BOT: Não há de quê!")
            else:
                if chatbot.greeting(user_request) != '':
                    print("BOT:", chatbot.greeting(user_request))
                else:
                    print("BOT: Pensando...")
                    start_time = time.perf_counter()
                    response = chatbot.response(user_request)
                    end_time = time.perf_counter()
                    print("BOT:", response)
                    print('[{:.1f} segundos]'.format(end_time - start_time))
        else:
            stop = True
            print("BOT: Até mais!")
Ejemplo n.º 22
0
def test_recommend():
    print("Testing recommend() functionality...")
    chatbot = Chatbot(False)

    user_ratings = np.array([1, -1, 0, 0, 0, 0])
    all_ratings = np.array([
        [1, 1, 1, 0],
        [1, -1, 0, -1],
        [1, 1, 1, 0],
        [0, 1, 1, -1],
        [0, -1, 1, -1],
        [-1, -1, -1, 0],
    ])
    small_recommendations = chatbot.recommend(user_ratings, all_ratings, 2)
    user_ratings = np.zeros(9125)
    user_ratings[[8514, 7953, 6979, 7890]] = 1
    user_ratings[[7369, 8726]] = -1
    recommendations = chatbot.recommend(user_ratings, chatbot.ratings, k=5)

    test_cases = [
        (small_recommendations, [2, 3]),
        (recommendations, [8582, 8596, 8786, 8309, 8637]),
    ]

    tests_passed = True
    for i, (recs, expected_output) in enumerate(test_cases):
        if not assertListEquals(
                recs,
                expected_output,
                "Test case #{} for recommender tests failed".format(i),
        ):
            tests_passed = False
    if tests_passed:
        print('recommend() sanity check passed!')
    print()
Ejemplo n.º 23
0
def test_disambiguate():
    print("Testing disambiguate() functionality...")
    chatbot = Chatbot(True)

    # add more test cases here!!!
    test_cases = [
        ('1997', [1359, 2716], [1359]),
        ('2', [1142, 1357, 2629, 546], [1357]),
        ('Sorcerer\'s Stone', [3812, 4325, 5399, 6294, 6735, 7274, 7670,
                               7842], [3812]),
    ]

    tests_passed = True
    for clarification, candidates, expected_output in test_cases:
        if not assertListEquals(
                chatbot.disambiguate(clarification, candidates),
                expected_output,
                "Incorrect output for disambiguate('{}', {})".format(
                    clarification, candidates),
                orderMatters=False):
            tests_passed = False
    if tests_passed:
        print('disambiguate() sanity check passed!')
    print()
    return True
Ejemplo n.º 24
0
def main():
    # initialise the bot
    bot = Bot(cache_path=True)
    # search the friend with name
    my_friend = bot.friends().search("旋潇")[0]
    chatbot = Chatbot()

    # sent a start message
    my_friend.send('Hello! This is the chatbot')

    # reply the message send by my_friend
    @bot.register(my_friend)
    def reply_my_friend(msg):
        state = MAIN
        pending = None

        print(chatbot.get_intent(msg.text))
        state, pending, final_response, message_intent = chatbot.send_message(
            state, pending, msg.text)
        msg.reply(final_response)
        # send_figure
        if message_intent == 'clear_historical_data' or message_intent == 'add_historical_data':
            msg.reply_image('result.png')

        return None

    embed()
Ejemplo n.º 25
0
def test_binarize():
    print("Testing binarize() functionality...")
    chatbot = Chatbot(False)
    if assertNumpyArrayEquals(
            chatbot.binarize(np.array([[1, 2.5, 5, 0]])),
            np.array([[-1., -1., 1., 0.]]),
            "Incorrect output for binarize(np.array([[1, 2.5, 5, 0]]))."):
        print("binarize() sanity check passed!")
    print()
Ejemplo n.º 26
0
def handle_message(event):
    #print("Handle: reply_token: " + event.reply_token + ", message: " + event.message.text)
    tokenID = "{}".format(event.reply_token)
    content = "{}".format(event.message.text)
    print("line_message : ", content)
    if content != "":
        from chatbot import Chatbot
        chat = Chatbot(content)
        ##        print("hi",chat)
        line_bot.reply_message(tokenID, TextSendMessage(text=chat))
Ejemplo n.º 27
0
    def __init__(self, creative=False):
        super().__init__()

        self.chatbot = Chatbot(creative=creative)
        self.name = self.chatbot.name
        self.bot_prompt = '\001\033[96m\002%s> \001\033[0m\002' % self.name

        self.greeting = self.chatbot.greeting()
        self.intro = self.chatbot.intro() + '\n' + self.bot_prompt + self.greeting
        self.debug = False
Ejemplo n.º 28
0
 def reply_messages(msg):
     print(msg)
     sender = msg.sender
     global chatbots
     if sender in chatbots:
         sender.send(chatbots[sender].respond(msg.text))
     else:
         chatbot = Chatbot(interpreter)
         chatbots[sender] = chatbot
         sender.send(chatbot.greet())
Ejemplo n.º 29
0
class Assistente(Screen):
    bot = Chatbot('Pedro')

    def mensagem(self, msg, *args):
        self.ids.box.add_widget(Tarefa(text=msg))
        frase = self.bot.escuta(frase=msg)
        resp = self.bot.pensa(frase)
        self.bot.fala(resp)
        self.ids.box.add_widget(Tarefa(text=resp))
        self.ids.texto.text = ''
Ejemplo n.º 30
0
def main(room_id):
    chatbot = Chatbot(decrypt='caird')
    chatbot.login()
    chatbot.joinRoom(room_id, ignore_msgs)

    for msg in get_msg():
        chatbot.rooms_joined[0].sendMessage(msg)

    chatbot.leaveAllRooms()
    return