#2725

pending completion

Build # #2725

Build Type

push

python-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/microsoft/botbuilder-python/commit/<a class=hub.com/microsoft/botbuilder-python/commit/a1a348b16bc4f03ce4c89771cac1ac9c1672bbc0">a1a348b16<a href="https://github.com/microsoft/botbuilder-python/commit/a1a348b16bc4f03ce4c89771cac1ac9c1672bbc0">">Merge </a><a class="double-link" href="https://github.com/microsoft/botbuilder-python/commit/<a class="double-link" href="https://github.com/microsoft/botbuilder-python/commit/38fd74ae0d1920790fc9dda8be208a231fa2e5e5">38fd74ae0</a>">38fd74ae0</a><a href="https://github.com/microsoft/botbuilder-python/commit/a1a348b16bc4f03ce4c89771cac1ac9c1672bbc0"> into 9b03fa7c7">9b03fa7c7</a>

Run Details

4 of 4 new or added lines in 2 files covered. (100.0%)

9424 of 13396 relevant lines covered (70.35%)

0.7 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

80.11

/libraries/botbuilder-dialogs/botbuilder/dialogs/dialog_context.py

# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License.

from typing import List, Optional

from botbuilder.core.turn_context import TurnContext
from botbuilder.dialogs.memory import DialogStateManager

from .dialog_event import DialogEvent
from .dialog_events import DialogEvents
from .dialog_set import DialogSet
from .dialog_state import DialogState
from .dialog_turn_status import DialogTurnStatus
from .dialog_turn_result import DialogTurnResult
from .dialog_reason import DialogReason
from .dialog_instance import DialogInstance
from .dialog import Dialog


class DialogContext:
    def __init__(
        self, dialog_set: DialogSet, turn_context: TurnContext, state: DialogState
    ):
        if dialog_set is None:
            raise TypeError("DialogContext(): dialog_set cannot be None.")
        # TODO: Circular dependency with dialog_set: Check type.
        if turn_context is None:
            raise TypeError("DialogContext(): turn_context cannot be None.")
        self._turn_context = turn_context
        self._dialogs = dialog_set
        self._stack = state.dialog_stack
        self.services = {}
        self.parent: DialogContext = None
        self.state = DialogStateManager(self)

    @property
    def dialogs(self) -> DialogSet:
        """Gets the set of dialogs that can be called from this context.

        :param:
        :return DialogSet:
        """
        return self._dialogs

    @property
    def context(self) -> TurnContext:
        """Gets the context for the current turn of conversation.

        :param:
        :return TurnContext:
        """
        return self._turn_context

    @property
    def stack(self) -> List:
        """Gets the current dialog stack.

        :param:
        :return list:
        """
        return self._stack

    @property
    def active_dialog(self):
        """Return the container link in the database.

        :param:
        :return:
        """
        if self._stack:
            return self._stack[0]
        return None

    @property
    def child(self) -> Optional["DialogContext"]:
        """Return the container link in the database.

        :param:
        :return DialogContext:
        """
        # pylint: disable=import-outside-toplevel
        instance = self.active_dialog

        if instance:
            dialog = self.find_dialog_sync(instance.id)

            # This import prevents circular dependency issues
            from .dialog_container import DialogContainer

            if isinstance(dialog, DialogContainer):
                return dialog.create_child_context(self)

        return None

    async def begin_dialog(self, dialog_id: str, options: object = None):
        """
        Pushes a new dialog onto the dialog stack.
        :param dialog_id: ID of the dialog to start
        :param options: (Optional) additional argument(s) to pass to the dialog being started.
        """
        try:
            if not dialog_id:
                raise TypeError("Dialog(): dialog_id cannot be None.")
            # Look up dialog
            dialog = await self.find_dialog(dialog_id)
            if dialog is None:
                raise Exception(
                    "'DialogContext.begin_dialog(): A dialog with an id of '%s' wasn't found."
                    " The dialog must be included in the current or parent DialogSet."
                    " For example, if subclassing a ComponentDialog you can call add_dialog() within your constructor."
                    % dialog_id
                )
            # Push new instance onto stack
            instance = DialogInstance()
            instance.id = dialog_id
            instance.state = {}

            self._stack.insert(0, (instance))

            # Call dialog's begin_dialog() method
            return await dialog.begin_dialog(self, options)
        except Exception as err:
            self.__set_exception_context_data(err)
            raise

    # TODO: Fix options: PromptOptions instead of object
    async def prompt(self, dialog_id: str, options) -> DialogTurnResult:
        """
        Helper function to simplify formatting the options for calling a prompt dialog. This helper will
        take a `PromptOptions` argument and then call.
        :param dialog_id: ID of the prompt to start.
        :param options: Contains a Prompt, potentially a RetryPrompt and if using ChoicePrompt, Choices.
        :return:
        """
        try:
            if not dialog_id:
                raise TypeError("DialogContext.prompt(): dialogId cannot be None.")

            if not options:
                raise TypeError("DialogContext.prompt(): options cannot be None.")

            return await self.begin_dialog(dialog_id, options)
        except Exception as err:
            self.__set_exception_context_data(err)
            raise

    async def continue_dialog(self):
        """
        Continues execution of the active dialog, if there is one, by passing the context object to
        its `Dialog.continue_dialog()` method. You can check `turn_context.responded` after the call completes
        to determine if a dialog was run and a reply was sent to the user.
        :return:
        """
        try:
            # Check for a dialog on the stack
            if self.active_dialog is not None:
                # Look up dialog
                dialog = await self.find_dialog(self.active_dialog.id)
                if not dialog:
                    raise Exception(
                        "DialogContext.continue_dialog(): Can't continue dialog. "
                        "A dialog with an id of '%s' wasn't found."
                        % self.active_dialog.id
                    )

                # Continue execution of dialog
                return await dialog.continue_dialog(self)

            return DialogTurnResult(DialogTurnStatus.Empty)
        except Exception as err:
            self.__set_exception_context_data(err)
            raise

    # TODO: instance is DialogInstance
    async def end_dialog(self, result: object = None):
        """
        Ends a dialog by popping it off the stack and returns an optional result to the dialog's
        parent. The parent dialog is the dialog that started the dialog being ended via a call to
        either "begin_dialog" or "prompt".
        The parent dialog will have its `Dialog.resume_dialog()` method invoked with any returned
        result. If the parent dialog hasn't implemented a `resume_dialog()` method then it will be
        automatically ended as well and the result passed to its parent. If there are no more
        parent dialogs on the stack then processing of the turn will end.
        :param result: (Optional) result to pass to the parent dialogs.
        :return:
        """
        try:
            await self.end_active_dialog(DialogReason.EndCalled)

            # Resume previous dialog
            if self.active_dialog is not None:
                # Look up dialog
                dialog = await self.find_dialog(self.active_dialog.id)
                if not dialog:
                    raise Exception(
                        "DialogContext.EndDialogAsync(): Can't resume previous dialog."
                        " A dialog with an id of '%s' wasn't found."
                        % self.active_dialog.id
                    )

                # Return result to previous dialog
                return await dialog.resume_dialog(self, DialogReason.EndCalled, result)

            return DialogTurnResult(DialogTurnStatus.Complete, result)
        except Exception as err:
            self.__set_exception_context_data(err)
            raise

    async def cancel_all_dialogs(
        self,
        cancel_parents: bool = None,
        event_name: str = None,
        event_value: object = None,
    ):
        """
        Deletes any existing dialog stack thus cancelling all dialogs on the stack.
        :param cancel_parents:
        :param event_name:
        :param event_value:
        :return:
        """
        try:
            event_name = event_name or DialogEvents.cancel_dialog
            if self.stack or self.parent:
                # Cancel all local and parent dialogs while checking for interception
                notify = False
                dialog_context = self

                while dialog_context:
                    if dialog_context.stack:
                        # Check to see if the dialog wants to handle the event
                        if notify:
                            event_handled = await dialog_context.emit_event(
                                event_name, event_value, bubble=False, from_leaf=False,
                            )

                            if event_handled:
                                break

                        # End the active dialog
                        await dialog_context.end_active_dialog(
                            DialogReason.CancelCalled
                        )
                    else:
                        dialog_context = (
                            dialog_context.parent if cancel_parents else None
                        )

                    notify = True

                return DialogTurnResult(DialogTurnStatus.Cancelled)

            # Stack was empty and no parent
            return DialogTurnResult(DialogTurnStatus.Empty)
        except Exception as err:
            self.__set_exception_context_data(err)
            raise

    async def find_dialog(self, dialog_id: str) -> Dialog:
        """
        If the dialog cannot be found within the current `DialogSet`, the parent `DialogContext`
        will be searched if there is one.
        :param dialog_id: ID of the dialog to search for.
        :return:
        """
        try:
            dialog = await self.dialogs.find(dialog_id)

            if dialog is None and self.parent is not None:
                dialog = await self.parent.find_dialog(dialog_id)
            return dialog
        except Exception as err:
            self.__set_exception_context_data(err)
            raise

    def find_dialog_sync(self, dialog_id: str) -> Dialog:
        """
        If the dialog cannot be found within the current `DialogSet`, the parent `DialogContext`
        will be searched if there is one.
        :param dialog_id: ID of the dialog to search for.
        :return:
        """
        dialog = self.dialogs.find_dialog(dialog_id)

        if dialog is None and self.parent is not None:
            dialog = self.parent.find_dialog_sync(dialog_id)
        return dialog

    async def replace_dialog(
        self, dialog_id: str, options: object = None
    ) -> DialogTurnResult:
        """
        Ends the active dialog and starts a new dialog in its place. This is particularly useful
        for creating loops or redirecting to another dialog.
        :param dialog_id: ID of the dialog to search for.
        :param options: (Optional) additional argument(s) to pass to the new dialog.
        :return:
        """
        try:
            # End the current dialog and giving the reason.
            await self.end_active_dialog(DialogReason.ReplaceCalled)

            # Start replacement dialog
            return await self.begin_dialog(dialog_id, options)
        except Exception as err:
            self.__set_exception_context_data(err)
            raise

    async def reprompt_dialog(self):
        """
        Calls reprompt on the currently active dialog, if there is one. Used with Prompts that have a reprompt behavior.
        :return:
        """
        try:
            # Check for a dialog on the stack
            if self.active_dialog is not None:
                # Look up dialog
                dialog = await self.find_dialog(self.active_dialog.id)
                if not dialog:
                    raise Exception(
                        "DialogSet.reprompt_dialog(): Can't find A dialog with an id of '%s'."
                        % self.active_dialog.id
                    )

                # Ask dialog to re-prompt if supported
                await dialog.reprompt_dialog(self.context, self.active_dialog)
        except Exception as err:
            self.__set_exception_context_data(err)
            raise

    async def end_active_dialog(self, reason: DialogReason):
        instance = self.active_dialog
        if instance is not None:
            # Look up dialog
            dialog = await self.find_dialog(instance.id)
            if dialog is not None:
                # Notify dialog of end
                await dialog.end_dialog(self.context, instance, reason)

            # Pop dialog off stack
            self._stack.pop(0)

    async def emit_event(
        self,
        name: str,
        value: object = None,
        bubble: bool = True,
        from_leaf: bool = False,
    ) -> bool:
        """
        Searches for a dialog with a given ID.
        Emits a named event for the current dialog, or someone who started it, to handle.
        :param name: Name of the event to raise.
        :param value: Value to send along with the event.
        :param bubble: Flag to control whether the event should be bubbled to its parent if not handled locally.
        Defaults to a value of `True`.
        :param from_leaf: Whether the event is emitted from a leaf node.
        :param cancellationToken: The cancellation token.
        :return: True if the event was handled.
        """
        try:
            # Initialize event
            dialog_event = DialogEvent(bubble=bubble, name=name, value=value,)

            dialog_context = self

            # Find starting dialog
            if from_leaf:
                while True:
                    child_dc = dialog_context.child

                    if child_dc:
                        dialog_context = child_dc
                    else:
                        break

            # Dispatch to active dialog first
            instance = dialog_context.active_dialog

            if instance:
                dialog = await dialog_context.find_dialog(instance.id)

                if dialog:
                    return await dialog.on_dialog_event(dialog_context, dialog_event)

            return False
        except Exception as err:
            self.__set_exception_context_data(err)
            raise

    def __set_exception_context_data(self, exception: Exception):
        if not hasattr(exception, "data"):
            exception.data = {}

        if not type(self).__name__ in exception.data:
            stack = []
            current_dc = self

            while current_dc is not None:
                stack = stack + [x.id for x in current_dc.stack]
                current_dc = current_dc.parent

            exception.data[type(self).__name__] = {
                "active_dialog": None
                if self.active_dialog is None
                else self.active_dialog.id,
                "parent": None if self.parent is None else self.parent.active_dialog.id,
                "stack": self.stack,
            }

1	# Copyright (c) Microsoft Corporation. All rights reserved.
2	# Licensed under the MIT License.
3
4	from typing import List, Optional	1✔
5
6	from botbuilder.core.turn_context import TurnContext	1✔
7	from botbuilder.dialogs.memory import DialogStateManager	1✔
8
9	from .dialog_event import DialogEvent	1✔
10	from .dialog_events import DialogEvents	1✔
11	from .dialog_set import DialogSet	1✔
12	from .dialog_state import DialogState	1✔
13	from .dialog_turn_status import DialogTurnStatus	1✔
14	from .dialog_turn_result import DialogTurnResult	1✔
15	from .dialog_reason import DialogReason	1✔
16	from .dialog_instance import DialogInstance	1✔
17	from .dialog import Dialog	1✔
18
19
20	class DialogContext:	1✔
21	def __init__(	1✔
22	self, dialog_set: DialogSet, turn_context: TurnContext, state: DialogState
23	):
24	if dialog_set is None:	1✔
25	raise TypeError("DialogContext(): dialog_set cannot be None.")	×
26	# TODO: Circular dependency with dialog_set: Check type.
27	if turn_context is None:	1✔
28	raise TypeError("DialogContext(): turn_context cannot be None.")	×
29	self._turn_context = turn_context	1✔
30	self._dialogs = dialog_set	1✔
31	self._stack = state.dialog_stack	1✔
32	self.services = {}	1✔
33	self.parent: DialogContext = None	1✔
34	self.state = DialogStateManager(self)	1✔
35
36	@property	1✔
37	def dialogs(self) -> DialogSet:	1✔
38	"""Gets the set of dialogs that can be called from this context.
39
40	:param:
41	:return DialogSet:
42	"""
43	return self._dialogs	1✔
44
45	@property	1✔
46	def context(self) -> TurnContext:	1✔
47	"""Gets the context for the current turn of conversation.
48
49	:param:
50	:return TurnContext:
51	"""
52	return self._turn_context	1✔
53
54	@property	1✔
55	def stack(self) -> List:	1✔
56	"""Gets the current dialog stack.
57
58	:param:
59	:return list:
60	"""
61	return self._stack	1✔
62
63	@property	1✔
64	def active_dialog(self):
65	"""Return the container link in the database.
66
67	:param:
68	:return:
69	"""
70	if self._stack:	1✔
71	return self._stack[0]	1✔
72	return None	1✔
73
74	@property	1✔
75	def child(self) -> Optional["DialogContext"]:	1✔
76	"""Return the container link in the database.
77
78	:param:
79	:return DialogContext:
80	"""
81	# pylint: disable=import-outside-toplevel
82	instance = self.active_dialog	1✔
83
84	if instance:	1✔
85	dialog = self.find_dialog_sync(instance.id)	1✔
86
87	# This import prevents circular dependency issues
88	from .dialog_container import DialogContainer	1✔
89
90	if isinstance(dialog, DialogContainer):	1✔
91	return dialog.create_child_context(self)	1✔
92
93	return None	1✔
94
95	async def begin_dialog(self, dialog_id: str, options: object = None):	1✔
96	"""
97	Pushes a new dialog onto the dialog stack.
98	:param dialog_id: ID of the dialog to start
99	:param options: (Optional) additional argument(s) to pass to the dialog being started.
100	"""
101	try:	1✔
102	if not dialog_id:	1✔
103	raise TypeError("Dialog(): dialog_id cannot be None.")	×
104	# Look up dialog
105	dialog = await self.find_dialog(dialog_id)	1✔
106	if dialog is None:	1✔
107	raise Exception(	1✔
108	"'DialogContext.begin_dialog(): A dialog with an id of '%s' wasn't found."
109	" The dialog must be included in the current or parent DialogSet."
110	" For example, if subclassing a ComponentDialog you can call add_dialog() within your constructor."
111	% dialog_id
112	)
113	# Push new instance onto stack
114	instance = DialogInstance()	1✔
115	instance.id = dialog_id	1✔
116	instance.state = {}	1✔
117
118	self._stack.insert(0, (instance))	1✔
119
120	# Call dialog's begin_dialog() method
121	return await dialog.begin_dialog(self, options)	1✔
122	except Exception as err:	1✔
123	self.__set_exception_context_data(err)	1✔
124	raise	1✔
125
126	# TODO: Fix options: PromptOptions instead of object
127	async def prompt(self, dialog_id: str, options) -> DialogTurnResult:	1✔
128	"""
129	Helper function to simplify formatting the options for calling a prompt dialog. This helper will
130	take a `PromptOptions` argument and then call.
131	:param dialog_id: ID of the prompt to start.
132	:param options: Contains a Prompt, potentially a RetryPrompt and if using ChoicePrompt, Choices.
133	:return:
134	"""
135	try:	1✔
136	if not dialog_id:	1✔
137	raise TypeError("DialogContext.prompt(): dialogId cannot be None.")	×
138
139	if not options:	1✔
140	raise TypeError("DialogContext.prompt(): options cannot be None.")	×
141
142	return await self.begin_dialog(dialog_id, options)	1✔
143	except Exception as err:	1✔
144	self.__set_exception_context_data(err)	1✔
145	raise	1✔
146
147	async def continue_dialog(self):	1✔
148	"""
149	Continues execution of the active dialog, if there is one, by passing the context object to
150	its `Dialog.continue_dialog()` method. You can check `turn_context.responded` after the call completes
151	to determine if a dialog was run and a reply was sent to the user.
152	:return:
153	"""
154	try:	1✔
155	# Check for a dialog on the stack
156	if self.active_dialog is not None:	1✔
157	# Look up dialog
158	dialog = await self.find_dialog(self.active_dialog.id)	1✔
159	if not dialog:	1✔
160	raise Exception(	×
161	"DialogContext.continue_dialog(): Can't continue dialog. "
162	"A dialog with an id of '%s' wasn't found."
163	% self.active_dialog.id
164	)
165
166	# Continue execution of dialog
167	return await dialog.continue_dialog(self)	1✔
168
169	return DialogTurnResult(DialogTurnStatus.Empty)	1✔
170	except Exception as err:	×
171	self.__set_exception_context_data(err)	×
172	raise	×
173
174	# TODO: instance is DialogInstance
175	async def end_dialog(self, result: object = None):	1✔
176	"""
177	Ends a dialog by popping it off the stack and returns an optional result to the dialog's
178	parent. The parent dialog is the dialog that started the dialog being ended via a call to
179	either "begin_dialog" or "prompt".
180	The parent dialog will have its `Dialog.resume_dialog()` method invoked with any returned
181	result. If the parent dialog hasn't implemented a `resume_dialog()` method then it will be
182	automatically ended as well and the result passed to its parent. If there are no more
183	parent dialogs on the stack then processing of the turn will end.
184	:param result: (Optional) result to pass to the parent dialogs.
185	:return:
186	"""
187	try:	1✔
188	await self.end_active_dialog(DialogReason.EndCalled)	1✔
189
190	# Resume previous dialog
191	if self.active_dialog is not None:	1✔
192	# Look up dialog
193	dialog = await self.find_dialog(self.active_dialog.id)	1✔
194	if not dialog:	1✔
195	raise Exception(	×
196	"DialogContext.EndDialogAsync(): Can't resume previous dialog."
197	" A dialog with an id of '%s' wasn't found."
198	% self.active_dialog.id
199	)
200
201	# Return result to previous dialog
202	return await dialog.resume_dialog(self, DialogReason.EndCalled, result)	1✔
203
204	return DialogTurnResult(DialogTurnStatus.Complete, result)	1✔
205	except Exception as err:	×
206	self.__set_exception_context_data(err)	×
207	raise	×
208
209	async def cancel_all_dialogs(	1✔
210	self,
211	cancel_parents: bool = None,
212	event_name: str = None,
213	event_value: object = None,
214	):
215	"""
216	Deletes any existing dialog stack thus cancelling all dialogs on the stack.
217	:param cancel_parents:
218	:param event_name:
219	:param event_value:
220	:return:
221	"""
222	try:	1✔
223	event_name = event_name or DialogEvents.cancel_dialog	1✔
224	if self.stack or self.parent:	1✔
225	# Cancel all local and parent dialogs while checking for interception
226	notify = False	1✔
227	dialog_context = self	1✔
228
229	while dialog_context:	1✔
230	if dialog_context.stack:	1✔
231	# Check to see if the dialog wants to handle the event
232	if notify:	1✔
233	event_handled = await dialog_context.emit_event(	1✔
234	event_name, event_value, bubble=False, from_leaf=False,
235	)
236
237	if event_handled:	1✔
238	break	×
239
240	# End the active dialog
241	await dialog_context.end_active_dialog(	1✔
242	DialogReason.CancelCalled
243	)
244	else:
245	dialog_context = (	1✔
246	dialog_context.parent if cancel_parents else None
247	)
248
249	notify = True	1✔
250
251	return DialogTurnResult(DialogTurnStatus.Cancelled)	1✔
252
253	# Stack was empty and no parent
254	return DialogTurnResult(DialogTurnStatus.Empty)	×
255	except Exception as err:	×
256	self.__set_exception_context_data(err)	×
257	raise	×
258
259	async def find_dialog(self, dialog_id: str) -> Dialog:	1✔
260	"""
261	If the dialog cannot be found within the current `DialogSet`, the parent `DialogContext`
262	will be searched if there is one.
263	:param dialog_id: ID of the dialog to search for.
264	:return:
265	"""
266	try:	1✔
267	dialog = await self.dialogs.find(dialog_id)	1✔
268
269	if dialog is None and self.parent is not None:	1✔
270	dialog = await self.parent.find_dialog(dialog_id)	×
271	return dialog	1✔
272	except Exception as err:	×
273	self.__set_exception_context_data(err)	×
274	raise	×
275
276	def find_dialog_sync(self, dialog_id: str) -> Dialog:	1✔
277	"""
278	If the dialog cannot be found within the current `DialogSet`, the parent `DialogContext`
279	will be searched if there is one.
280	:param dialog_id: ID of the dialog to search for.
281	:return:
282	"""
283	dialog = self.dialogs.find_dialog(dialog_id)	1✔
284
285	if dialog is None and self.parent is not None:	1✔
286	dialog = self.parent.find_dialog_sync(dialog_id)	×
287	return dialog	1✔
288
289	async def replace_dialog(	1✔
290	self, dialog_id: str, options: object = None
291	) -> DialogTurnResult:
292	"""
293	Ends the active dialog and starts a new dialog in its place. This is particularly useful
294	for creating loops or redirecting to another dialog.
295	:param dialog_id: ID of the dialog to search for.
296	:param options: (Optional) additional argument(s) to pass to the new dialog.
297	:return:
298	"""
299	try:	1✔
300	# End the current dialog and giving the reason.
301	await self.end_active_dialog(DialogReason.ReplaceCalled)	1✔
302
303	# Start replacement dialog
304	return await self.begin_dialog(dialog_id, options)	1✔
305	except Exception as err:	1✔
306	self.__set_exception_context_data(err)	1✔
307	raise	1✔
308
309	async def reprompt_dialog(self):	1✔
310	"""
311	Calls reprompt on the currently active dialog, if there is one. Used with Prompts that have a reprompt behavior.
312	:return:
313	"""
314	try:	1✔
315	# Check for a dialog on the stack
316	if self.active_dialog is not None:	1✔
317	# Look up dialog
318	dialog = await self.find_dialog(self.active_dialog.id)	1✔
319	if not dialog:	1✔
320	raise Exception(	×
321	"DialogSet.reprompt_dialog(): Can't find A dialog with an id of '%s'."
322	% self.active_dialog.id
323	)
324
325	# Ask dialog to re-prompt if supported
326	await dialog.reprompt_dialog(self.context, self.active_dialog)	1✔
327	except Exception as err:	×
328	self.__set_exception_context_data(err)	×
329	raise	×
330
331	async def end_active_dialog(self, reason: DialogReason):	1✔
332	instance = self.active_dialog	1✔
333	if instance is not None:	1✔
334	# Look up dialog
335	dialog = await self.find_dialog(instance.id)	1✔
336	if dialog is not None:	1✔
337	# Notify dialog of end
338	await dialog.end_dialog(self.context, instance, reason)	1✔
339
340	# Pop dialog off stack
341	self._stack.pop(0)	1✔
342
343	async def emit_event(	1✔
344	self,
345	name: str,
346	value: object = None,
347	bubble: bool = True,
348	from_leaf: bool = False,
349	) -> bool:
350	"""
351	Searches for a dialog with a given ID.
352	Emits a named event for the current dialog, or someone who started it, to handle.
353	:param name: Name of the event to raise.
354	:param value: Value to send along with the event.
355	:param bubble: Flag to control whether the event should be bubbled to its parent if not handled locally.
356	Defaults to a value of `True`.
357	:param from_leaf: Whether the event is emitted from a leaf node.
358	:param cancellationToken: The cancellation token.
359	:return: True if the event was handled.
360	"""
361	try:	1✔
362	# Initialize event
363	dialog_event = DialogEvent(bubble=bubble, name=name, value=value,)	1✔
364
365	dialog_context = self	1✔
366
367	# Find starting dialog
368	if from_leaf:	1✔
369	while True:	×
370	child_dc = dialog_context.child	×
371
372	if child_dc:	×
373	dialog_context = child_dc	×
374	else:
375	break	×
376
377	# Dispatch to active dialog first
378	instance = dialog_context.active_dialog	1✔
379
380	if instance:	1✔
381	dialog = await dialog_context.find_dialog(instance.id)	1✔
382
383	if dialog:	1✔
384	return await dialog.on_dialog_event(dialog_context, dialog_event)	1✔
385
386	return False	×
387	except Exception as err:	×
388	self.__set_exception_context_data(err)	×
389	raise	×
390
391	def __set_exception_context_data(self, exception: Exception):	1✔
392	if not hasattr(exception, "data"):	1✔
393	exception.data = {}	1✔
394
395	if not type(self).__name__ in exception.data:	1✔
396	stack = []	1✔
397	current_dc = self	1✔
398
399	while current_dc is not None:	1✔
400	stack = stack + [x.id for x in current_dc.stack]	1✔
401	current_dc = current_dc.parent	1✔
402
403	exception.data[type(self).__name__] = {	1✔
404	"active_dialog": None
405	if self.active_dialog is None
406	else self.active_dialog.id,
407	"parent": None if self.parent is None else self.parent.active_dialog.id,
408	"stack": self.stack,
409	}

microsoft / botbuilder-python / #2725

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous