botbuilder-python | Microsoft Bot Framework provides what you need to build | Bot library

from botbuilder.core import ActivityHandler, TurnContext, MessageFactory, IntentScore, ConversationState, UserState
from botbuilder.schema import ChannelAccount,Attachment
from botbuilder.ai.luis import LuisApplication,LuisPredictionOptions,LuisRecognizer
from botbuilder.ai.qna import QnAMakerEndpoint,QnAMakerOptions,QnAMaker
from typing import List
import os
import json
import os.path
from usecases import SimpleUseCase
import requests

from botbuilder.dialogs import Dialog, DialogSet, DialogTurnStatus
from helpers.dialog_helper import DialogHelper
from dialogs import UserProfileDialog



class Bot(ActivityHandler):

    def __init__(
        self,
        conversation_state: ConversationState,
        user_state: UserState
        # dialog: Dialog,
    ):
        if conversation_state is None:
            raise TypeError(
                "[DialogBot]: Missing parameter. conversation_state is required but None was given"
            )
        if user_state is None:
            raise TypeError(
                "[DialogBot]: Missing parameter. user_state is required but None was given"
            )
        # if dialog is None:
        #     raise Exception("[DialogBot]: Missing parameter. dialog is required")

        self.conversation_state = conversation_state
        self.user_state = user_state
        # self.dialog = dialog###Change based on dialog

        luisApp = LuisApplication("","","https://abcd.cognitiveservices.azure.com/")
        luisOptions = LuisPredictionOptions(include_all_intents=True,include_instance_data=True)
        self.LuisRecog = LuisRecognizer(luisApp,luisOptions)
        self.qnaMaker = QnAMaker(QnAMakerEndpoint("","",""))        
    

    async def on_members_added_activity(
        self, members_added: List[ChannelAccount], turn_context: TurnContext
    ):
        for member in members_added:
            # Greet anyone that was not the target (recipient) of this message.
            # To learn more about Adaptive Cards, see https://aka.ms/msbot-adaptivecards for more details.
            if member.id != turn_context.activity.recipient.id:
                welcome_card = self.create_adaptive_card_attachment()
                response = MessageFactory.attachment(welcome_card)
                await turn_context.send_activity(response)

    # Load attachment from file.
    def create_adaptive_card_attachment(self):
        relative_path = os.path.abspath(os.path.dirname(__file__))
        path = os.path.join(relative_path, "cards/welcomeCard.json")
        with open(path) as in_file:
            card = json.load(in_file)

        return Attachment(
            content_type="application/vnd.microsoft.card.adaptive", content=card
        )

    async def greetings(self,turn_context):
        await turn_context.send_activity(MessageFactory.text("from inside greetings"))

    async def on_turn(self, turn_context: TurnContext):
        await super().on_turn(turn_context)

        # Save any state changes that might have ocurred during the turn.
        await self.conversation_state.save_changes(turn_context)
        await self.user_state.save_changes(turn_context)


    async def on_message_activity(self, turn_context: TurnContext):
        luisResult = await self.LuisRecog.recognize(turn_context) 
        print(luisResult.get_top_scoring_intent())
        intent = LuisRecognizer.top_intent(luisResult,min_score=0.40)

        if turn_context.activity.text.lower() == 'hi':
            await self.greetings(turn_context)
            await turn_context.send_activity(MessageFactory.text("message sent from send greetings.."))
        else:
### Here I want to be able to understand if there is any dialog that is already present on the dialog stack and 
### the dialog id. If we can get that details, I can then call the run_dialog method with the  dialog id 
### instead of routing the request based on the intent. Without knowing if a dialog is already 
### running, every input from user is again processed which is not desired.
            if intent == 'UserProfileIntent':
                await DialogHelper.run_dialog(UserProfileDialog(self.user_state),turn_context,self.conversation_state.create_property("DialogState"))
            else:
                answers = await self..get_answers(turn_context)                
                await turn_context.send_activity(MessageFactory.text(answers[0].answer))

                

from botbuilder.dialogs import (
    ComponentDialog,
    WaterfallDialog,
    WaterfallStepContext,
    DialogTurnResult,
)
from botbuilder.dialogs.prompts import (
    TextPrompt,
    NumberPrompt,
    ChoicePrompt,
    ConfirmPrompt,
    AttachmentPrompt,
    PromptOptions,
    PromptValidatorContext,
)
from botbuilder.dialogs.choices import Choice
from botbuilder.core import MessageFactory, UserState
from dialogs import NameDialog,UserProfileDialog,QADialog
from botbuilder.ai.qna import QnAMaker,QnAMakerEndpoint
import json

class MainDialog(ComponentDialog):
    def __init__(self, luis, intent, recognizer_result,user_state, turn_context):
        super(MainDialog, self).__init__(MainDialog.__name__)

        self.luis = luis
        self.intent = intent
        self.recognizer_result = recognizer_result
        self.user_state = user_state
        self.turn_context = turn_context

        self.add_dialog(NameDialog(self.user_state))
        self.add_dialog(UserProfileDialog(self.user_state))
        self.add_dialog(QADialog(self.user_state))
        self.add_dialog(
            WaterfallDialog(
                "main_dialog_id", [self.main_step]
            )
        )

        self.initial_dialog_id = "main_dialog_id"

    async def main_step(self, step_context: WaterfallStepContext) -> DialogTurnResult:
        # dialog_detail = self.luis.get_entities(self.intent, self.recognizer_result)
        if self.intent == "name":
            return await step_context.begin_dialog(NameDialog.__name__)
        elif self.intent == "place":
            return await step_context.begin_dialog(UserProfileDialog.__name__)
        elif self.intent == "AGE":
            entities = None
            if self.recognizer_result.entities is not None:
                entities = json.dumps(self.recognizer_result.entities.get("number"))
            return await step_context.begin_dialog(NameDialog.__name__,entities[0])
            # await self.turn_context.send_activity(MessageFactory.text("age intent"))
        elif self.intent == "None":                                    
     ###This part ends up in error even though I close the dialog immediately after sending the answer and I'm not sure if it's the right way to do it.        
            answers = await QnAMaker(QnAMakerEndpoint("","","")).get_answers(self.turn_context)
            if answers and len(answers) > 0:
                await self.turn_context.send_activity(MessageFactory.text(answers[0].answer))
            else:
                await self.turn_context.send_activity(MessageFactory.text("Sorry I cant help you with that !!"))

            await step_context.end_dialog()

from botbuilder.core import ActivityHandler, TurnContext, MessageFactory, IntentScore, ConversationState, UserState, StatePropertyAccessor
from botbuilder.schema import ChannelAccount,Attachment
from botbuilder.ai.luis import LuisApplication,LuisPredictionOptions,LuisRecognizer
from botbuilder.ai.qna import QnAMakerEndpoint,QnAMakerOptions,QnAMaker
from typing import List
import os
import json
import os.path
from usecases import SimpleUseCase
import requests

from botbuilder.dialogs import Dialog, DialogSet, DialogTurnStatus, DialogContext
from helpers.dialog_helper import DialogHelper
from dialogs import UserProfileDialog,NameDialog,MainDialog



class Bot(ActivityHandler):

    def __init__(
        self,
        conversation_state: ConversationState,
        user_state: UserState
        # dialog: Dialog,
    ):
        if conversation_state is None:
            raise TypeError(
                "[DialogBot]: Missing parameter. conversation_state is required but None was given"
            )
        if user_state is None:
            raise TypeError(
                "[DialogBot]: Missing parameter. user_state is required but None was given"
            )
        # if dialog is None:
        #     raise Exception("[DialogBot]: Missing parameter. dialog is required")

        self.conversation_state = conversation_state
        self.user_state = user_state
        # self.dialog = dialog###Change based on dialog

        luisApp = LuisApplication("","","")
        luisOptions = LuisPredictionOptions(include_all_intents=True,include_instance_data=True)
        self.LuisRecog = LuisRecognizer(luisApp,luisOptions)
      

    async def on_members_added_activity(
        self, members_added: List[ChannelAccount], turn_context: TurnContext
    ):
        for member in members_added:
            # Greet anyone that was not the target (recipient) of this message.
            # To learn more about Adaptive Cards, see https://aka.ms/msbot-adaptivecards for more details.
            if member.id != turn_context.activity.recipient.id:
                welcome_card = self.create_adaptive_card_attachment()
                response = MessageFactory.attachment(welcome_card)
                await turn_context.send_activity(response)

    # Load attachment from file.
    def create_adaptive_card_attachment(self):
        relative_path = os.path.abspath(os.path.dirname(__file__))
        path = os.path.join(relative_path, "cards/welcomeCard.json")
        with open(path) as in_file:
            card = json.load(in_file)

        return Attachment(
            content_type="application/vnd.microsoft.card.adaptive", content=card
        )

    async def greetings(self,turn_context):
        await turn_context.send_activity(MessageFactory.text("from inside greetings"))

    async def on_turn(self, turn_context: TurnContext):
        await super().on_turn(turn_context)

        # Save any state changes that might have ocurred during the turn.
        await self.conversation_state.save_changes(turn_context)
        await self.user_state.save_changes(turn_context)


    async def on_message_activity(self, turn_context: TurnContext):
        luisResult = await self.LuisRecog.recognize(turn_context) 
        print(luisResult.get_top_scoring_intent())
        intent = LuisRecognizer.top_intent(luisResult,min_score=0.40)


        if turn_context.activity.text.lower() == 'hi':
            await self.greetings(turn_context)
            await turn_context.send_activity(MessageFactory.text("message sent from send greetings.."))
        else:
            # if intent != "None":
            dialog = MainDialog(self.LuisRecog, intent, luisResult,self.user_state,turn_context)
            await DialogHelper.run_dialog(dialog,turn_context,self.conversation_state.create_property("DialogState"))

                

import os
from typing import List
import json

from azure.cognitiveservices.language.luis.runtime.models import LuisResult, IntentModel

from botbuilder.ai.luis import LuisApplication, LuisRecognizer, LuisPredictionOptions
from botbuilder.ai.qna import QnAMaker, QnAMakerEndpoint
from botbuilder.core import ActivityHandler, TurnContext, RecognizerResult, MessageFactory, UserState, ConversationState
from botbuilder.schema import ChannelAccount, Attachment

from config import DefaultConfig

from helpers.luis_helper import LuisDispatchResult
from helpers.dialog_helper import DialogHelper
from dialogs import NameDialog,UserProfileDialog,QADialog

class DispatchBot(ActivityHandler):
    def __init__(self, config: DefaultConfig,
                 conversation_state: ConversationState,
                 user_state: UserState):
        self.qna_maker = QnAMaker(
            QnAMakerEndpoint(
                knowledge_base_id=config.QNA_KNOWLEDGEBASE_ID,
                endpoint_key=config.QNA_ENDPOINT_KEY,
                host=config.QNA_ENDPOINT_HOST,
            )
        )

        # If the includeApiResults parameter is set to true, as shown below, the full response
        # from the LUIS api will be made available in the properties  of the RecognizerResult
        self.dialog_started = False
        self.app_id = config.LUIS_APP_ID
        self.api_key = config.LUIS_API_KEY
        self.host = "https://" + config.LUIS_API_HOST_NAME
        self.user_state = user_state
        self.conversation_state = conversation_state

        luis_application = LuisApplication(
            config.LUIS_APP_ID,
            config.LUIS_API_KEY,
            "https://" + config.LUIS_API_HOST_NAME,
        )
        luis_options = LuisPredictionOptions(
            include_all_intents=True, include_instance_data=True
        )
        self.recognizer = LuisRecognizer(luis_application, luis_options, True)

    async def on_members_added_activity(
        self, members_added: List[ChannelAccount], turn_context: TurnContext
    ):
        for member in members_added:
            # Greet anyone that was not the target (recipient) of this message.
            # To learn more about Adaptive Cards, see https://aka.ms/msbot-adaptivecards for more details.
            if member.id != turn_context.activity.recipient.id:
                welcome_card = self.create_adaptive_card_attachment()
                response = MessageFactory.attachment(welcome_card)
                await turn_context.send_activity(response)

    # Load attachment from file.
    def create_adaptive_card_attachment(self):
        relative_path = os.path.abspath(os.path.dirname(__file__))
        path = os.path.join(relative_path, "cards/welcomeCard.json")
        with open(path) as in_file:
            card = json.load(in_file)

        return Attachment(
            content_type="application/vnd.microsoft.card.adaptive", content=card
        )



    async def on_message_activity(self, turn_context: TurnContext):
        # First, we use the dispatch model to determine which cognitive service (LUIS or QnA) to use.
        # recognizer_result = await self.recognizer.recognize(turn_context)
        # Top intent tell us which cognitive service to use.
        # intent = LuisRecognizer.top_intent(recognizer_result)
        topIntent,childIntent,childEntities = LuisDispatchResult().getLuisDispatchResult(self.app_id,self.api_key,self.host,turn_context.activity.text)

        # Next, we call the dispatcher with the top intent.
        await self._dispatch_to_top_intent(turn_context, topIntent,childIntent,childEntities)

    async def _dispatch_to_top_intent(
        self, turn_context: TurnContext, topIntent,childIntent,childEntities
    ):
        if topIntent == "l_myluisapp":
            await self._process_luis_queries(
                turn_context, childIntent,childEntities
            )
        elif topIntent == "q_mybotqna":
            await self._process_sample_qna(turn_context)
        else:
            await turn_context.send_activity(f"Dispatch unrecognized intent: {topIntent}.")

    async def _process_luis_queries(
        self, turn_context: TurnContext, childIntent,childEntities
    ):
        await turn_context.send_activity(
            f"LUIS intent selected {childIntent}."
        )

        await turn_context.send_activity(
            f"LUIS entities: {childEntities}."
        )
        
            
        if childIntent == "name":
            self.dialog_started = True
            dialog = NameDialog(self.user_state)
            await DialogHelper.run_dialog(dialog,turn_context,self.conversation_state.create_property("DialogState"))
        elif childIntent == "place":
            self.dialog_started = True
            dialog = UserProfileDialog(self.user_state)
            await DialogHelper.run_dialog(dialog,turn_context,self.conversation_state.create_property("DialogState"))
        elif childIntent == "AGE":
            self.dialog_started = True
            dialog = NameDialog(self.user_state)
            await DialogHelper.run_dialog(dialog,turn_context,self.conversation_state.create_property("DialogState"))
        else:
            await turn_context.send_activity(MessageFactory.text("No suitable intent detected"))


    async def _process_sample_qna(self, turn_context: TurnContext):
        results = await self.qna_maker.get_answers(turn_context)
        if results:
            await turn_context.send_activity(results[0].answer)
        else:
            await turn_context.send_activity(
                "Sorry, could not find an answer in the Q and A system."
            )