Пример #1
0
    def _load_bot_configurations(self, configuration_file, section, bot_root,
                                 subs):
        bots = configuration_file.get_section("bots", section)
        if bots is not None:
            bot_keys = configuration_file.get_keys(bots)
            first = True
            for name in bot_keys:
                if first is True:
                    self._bot_configs.clear()
                    first = False
                bot_config = configuration_file.get_section(name, bots)
                config = BotConfiguration(name)
                config.load_configuration_section(configuration_file,
                                                  bot_config,
                                                  bot_root,
                                                  subs=subs)
                self._bot_configs.append(config)

        if len(self._bot_configs) == 0:
            YLogger.warning(
                self,
                "No bot name defined for client [%s], defaulting to 'bot'.",
                self.section_name)
            self._bot_configs.append(BotConfiguration("bot"))
            self._bot_configs[0].configurations.append(
                BrainConfiguration("brain"))

        self._bot_selector = configuration_file.get_option(
            section,
            "bot_selector",
            missing_value="programy.clients.botfactory.DefaultBotSelector",
            subs=subs)
Пример #2
0
    def test_with_data_single_bot(self):
        yaml = YamlConfigurationFile()
        self.assertIsNotNone(yaml)
        yaml.load_from_text(
            """
        bot:
          bot_root: .
          default_response: Sorry, I don't have an answer for that!
          default_response_srai: 'YEMPTY'
          exit_response: 'So long, and thanks for the fish!'
          exit_response_srai: 'YEXITRESPONSE'
          initial_question: 'Hi, how can I help you today?'
          initial_question_srai: 'YINITIALQUESTION'
          empty_string: 'YEMPTY'
          override_properties: true
          max_question_recursion: 100
          max_question_timeout: 60
          max_search_depth: 100
          max_search_timeout: 60
          tab_parse_output: true
          spelling:
            classname: programy.spelling.norvig.NorvigSpellingChecker
            alphabet: ABCDEFGHIJKLMNOPQRSTUVWXYZ
            check_before: true
            check_and_retry: true
          conversations:
            max_histories: 100
            restore_last_topic: true
            initial_topic: '*'
            empty_on_start: true
            multi_client: false
          splitter:
            classname: programy.dialog.splitter.regex.RegexSentenceSplitter
            split_chars: '[:;,.?!]'
          joiner:
            classname: programy.dialog.joiner.joiner.SentenceJoiner
            join_chars: .?!
            terminator: .
          from_translator:
            classname: programy.nlp.translate.textblob_translator.TextBlobTranslator
            from: en
            to: fr
          to_translator:
            classname: programy.nlp.translate.textblob_translator.TextBlobTranslator
            from: en
            to: fr
          sentiment:
            classname: programy.nlp.sentiment.textblob_sentiment.TextBlobSentimentAnalyser
            scores: programy.nlp.sentiment.scores.SentimentScores
          brains:
            brain:
              overrides:
                allow_system_aiml: true
                allow_learn_aiml: true
                allow_learnf_aiml: true
              defaults:
                default_get: unknown
                default_property: unknown
                default_map: unknown
              binaries:
                save_binary: true
                load_binary: true
                load_aiml_on_binary_fail: true
              braintree:
                create: true
                save_as_user: system
              services:
                REST:
                  classname: programy.services.rest.GenericRESTService
                  method: GET
                  host: 0.0.0.0
                  port: 8080
                Pannous:
                  classname: programy.services.pannous.PannousService
                  url: http://weannie.pannous.com/api
                Pandora:
                  classname: programy.services.pandora.PandoraService
                  url: http://www.pandorabots.com/pandora/talk-xml
                Wikipedia:
                  classname: programy.services.wikipediaservice.WikipediaService
                DuckDuckGo:
                  classname: programy.services.duckduckgo.DuckDuckGoService
                  url: http://api.duckduckgo.com
                OPENCHAT:
                  classname: programy.services.openchat.openchat.service.OpenChatRESTService
                  url: http://localhost:8090
              openchatbots:
                openchatbots: {}
                protocols:
                - http
                domains: []
              security:
                authentication:
                  classname: programy.security.authenticate.passthrough.BasicPassThroughAuthenticationService
                  denied_srai: AUTHENTICATION_FAILED
                  denied_text: Access Denied!
                authorisation:
                  classname: programy.security.authorise.usergroupsauthorisor.BasicUserGroupAuthorisationService
                  denied_srai: AUTHORISATION_FAILED
                  denied_text: Access Denied!
                account_linker:
                  classname: programy.security.linking.accountlinker.BasicAccountLinkerService
                  denied_srai: ACCOUNT_LINKING_FAILED
                  denied_text: Unable to link accounts!
              dynamic:
                sets:
                  NUMBER: programy.dynamic.sets.numeric.IsNumeric
                  ROMAN: programy.dynamic.sets.roman.IsRomanNumeral
                  STOPWORD: programy.dynamic.sets.stopword.IsStopWord
                  SYNSETS: programy.dynamic.sets.synsets.IsSynset
                maps:
                  ROMANTODDEC: programy.dynamic.maps.roman.MapRomanToDecimal
                  DECTOROMAN: programy.dynamic.maps.roman.MapDecimalToRoman
                  LEMMATIZE: programy.dynamic.maps.lemmatize.LemmatizeMap
                  STEMMER: programy.dynamic.maps.stemmer.StemmerMap
                variables:
                  GETTIME: programy.dynamic.variables.datetime.GetTime
              tokenizer:
                classname: programy.dialog.tokenizer.tokenizer.Tokenizer
                split_chars: ' '
              debugfiles:
                save_errors: false
                save_duplicates: false
          brain_selector: programy.brainfactory.DefaultBrainSelector
        """, ConsoleConfiguration(), ".")

        bot_section = yaml.get_section("bot")

        bot_config = BotConfiguration()
        bot_config.load_configuration_section(yaml, bot_section, ".")

        license_keys = LicenseKeys()
        bot_config.check_for_license_keys(license_keys)

        self.assertEqual("Hi, how can I help you today?",
                         bot_config.initial_question)
        self.assertEqual("YINITIALQUESTION", bot_config.initial_question_srai)
        self.assertEqual("Sorry, I don't have an answer for that!",
                         bot_config.default_response)
        self.assertEqual("YEMPTY", bot_config.default_response_srai)
        self.assertEqual("So long, and thanks for the fish!",
                         bot_config.exit_response)
        self.assertEqual("YEXITRESPONSE", bot_config.exit_response_srai)
        self.assertEqual("YEMPTY", bot_config.empty_string)
        self.assertEqual(bot_config.max_question_recursion, 100)
        self.assertEqual(bot_config.max_question_timeout, 60)
        self.assertEqual(bot_config.max_search_depth, 100)
        self.assertEqual(bot_config.max_search_timeout, 60)
        self.assertTrue(bot_config.override_properties)

        self.assertIsNotNone(bot_config.spelling)
        self.assertEqual(bot_config.spelling.section_name, "spelling")
        self.assertEqual(bot_config.spelling.classname,
                         "programy.spelling.norvig.NorvigSpellingChecker")
        self.assertTrue(bot_config.spelling.check_before)
        self.assertTrue(bot_config.spelling.check_and_retry)

        self.assertIsNotNone(bot_config.splitter)
        self.assertEqual(
            "programy.dialog.splitter.regex.RegexSentenceSplitter",
            bot_config.splitter.classname)
        self.assertEqual('[:;,.?!]', bot_config.splitter.split_chars)

        self.assertIsNotNone(bot_config.joiner)
        self.assertEqual("programy.dialog.joiner.joiner.SentenceJoiner",
                         bot_config.joiner.classname)
        self.assertEqual('.?!', bot_config.joiner.join_chars)

        self.assertIsNotNone(bot_config.conversations)
        self.assertIsNotNone(bot_config.conversations.max_histories, 100)
        self.assertIsNotNone(bot_config.conversations.restore_last_topic,
                             False)
        self.assertIsNotNone(bot_config.conversations.initial_topic, "TOPIC1")
        self.assertIsNotNone(bot_config.conversations.empty_on_start, False)

        self.assertEqual(
            "programy.nlp.translate.textblob_translator.TextBlobTranslator",
            bot_config.from_translator.classname)
        self.assertEqual("fr", bot_config.from_translator.to_lang)
        self.assertEqual("en", bot_config.from_translator.from_lang)

        self.assertEqual(
            "programy.nlp.translate.textblob_translator.TextBlobTranslator",
            bot_config.to_translator.classname)
        self.assertEqual("fr", bot_config.to_translator.to_lang)
        self.assertEqual("en", bot_config.to_translator.from_lang)

        self.assertEqual(
            "programy.nlp.sentiment.textblob_sentiment.TextBlobSentimentAnalyser",
            bot_config.sentiment_analyser.classname)
        self.assertEqual("programy.nlp.sentiment.scores.SentimentScores",
                         bot_config.sentiment_analyser.scores)

        self.assertEqual("programy.brainfactory.DefaultBrainSelector",
                         bot_config.brain_selector)
        self.assertEqual(1, len(bot_config.configurations))
        BrainConfigurationTests.assert_brain_config(
            self, bot_config.configurations[0])