rasa-pro 3.11.5__py3-none-any.whl → 3.12.0__py3-none-any.whl

rasa/core/channels/voice_stream/voice_channel.py

@@ -1,32 +1,26 @@
 import asyncio
-import structlog
 import copy
 from dataclasses import asdict, dataclass
 from typing import Any, AsyncIterator, Awaitable, Callable, Dict, List, Optional, Tuple
 
-from rasa.core.channels.voice_stream.util import generate_silence
-from rasa.shared.core.constants import SLOT_SILENCE_TIMEOUT
-from rasa.shared.utils.common import (
-    class_from_module_path,
-    mark_as_beta_feature,
-)
-from rasa.shared.utils.cli import print_error_and_exit
-
+import structlog
+from sanic import Websocket  # type: ignore
 from sanic.exceptions import ServerError, WebsocketClosed
 
 from rasa.core.channels import InputChannel, OutputChannel, UserMessage
-from rasa.core.channels.voice_ready.utils import CallParameters
-from rasa.core.channels.voice_ready.utils import validate_voice_license_scope
+from rasa.core.channels.voice_ready.utils import (
+    CallParameters,
+    validate_voice_license_scope,
+)
 from rasa.core.channels.voice_stream.asr.asr_engine import ASREngine
 from rasa.core.channels.voice_stream.asr.asr_event import (
     ASREvent,
     NewTranscript,
     UserIsSpeaking,
+    UserSilence,
 )
-from sanic import Websocket  # type: ignore
-
-from rasa.core.channels.voice_stream.asr.deepgram import DeepgramASR
 from rasa.core.channels.voice_stream.asr.azure import AzureASR
+from rasa.core.channels.voice_stream.asr.deepgram import DeepgramASR
 from rasa.core.channels.voice_stream.audio_bytes import HERTZ, RasaAudioBytes
 from rasa.core.channels.voice_stream.call_state import (
     CallState,
@@ -34,9 +28,16 @@ from rasa.core.channels.voice_stream.call_state import (
     call_state,
 )
 from rasa.core.channels.voice_stream.tts.azure import AzureTTS
-from rasa.core.channels.voice_stream.tts.tts_engine import TTSEngine, TTSError
 from rasa.core.channels.voice_stream.tts.cartesia import CartesiaTTS
 from rasa.core.channels.voice_stream.tts.tts_cache import TTSCache
+from rasa.core.channels.voice_stream.tts.tts_engine import TTSEngine, TTSError
+from rasa.core.channels.voice_stream.util import generate_silence
+from rasa.shared.core.constants import SLOT_SILENCE_TIMEOUT
+from rasa.shared.utils.cli import print_error_and_exit
+from rasa.shared.utils.common import (
+    class_from_module_path,
+    mark_as_beta_feature,
+)
 from rasa.utils.io import remove_emojis
 
 logger = structlog.get_logger(__name__)
@@ -120,13 +121,14 @@ class VoiceOutputChannel(OutputChannel):
         voice_websocket: Websocket,
         tts_engine: TTSEngine,
         tts_cache: TTSCache,
+        min_buffer_size: int = 0,
     ):
         super().__init__()
         self.voice_websocket = voice_websocket
         self.tts_engine = tts_engine
         self.tts_cache = tts_cache
-
         self.latest_message_id: Optional[str] = None
+        self.min_buffer_size = min_buffer_size
 
     def rasa_audio_bytes_to_channel_bytes(
         self, rasa_audio_bytes: RasaAudioBytes
@@ -148,6 +150,19 @@ class VoiceOutputChannel(OutputChannel):
         await self.voice_websocket.send(marker_message)
         self.latest_message_id = mark_id
 
+    async def send_start_marker(self, recipient_id: str) -> None:
+        """Send a marker message before the first audio chunk."""
+        # Default implementation uses the generic marker message
+        await self.send_marker_message(recipient_id)
+
+    async def send_intermediate_marker(self, recipient_id: str) -> None:
+        """Send a marker message during audio streaming."""
+        await self.send_marker_message(recipient_id)
+
+    async def send_end_marker(self, recipient_id: str) -> None:
+        """Send a marker message after the last audio chunk."""
+        await self.send_marker_message(recipient_id)
+
     def update_silence_timeout(self) -> None:
         """Updates the silence timeout for the session."""
         if self.tracker_state:
@@ -173,6 +188,14 @@ class VoiceOutputChannel(OutputChannel):
         cached_audio_bytes = self.tts_cache.get(text)
         collected_audio_bytes = RasaAudioBytes(b"")
         seconds_marker = -1
+        last_sent_offset = 0
+
+        # Send start marker before first chunk
+        try:
+            await self.send_start_marker(recipient_id)
+        except (WebsocketClosed, ServerError):
+            call_state.connection_failed = True  # type: ignore[attr-defined]
+
         if cached_audio_bytes:
             audio_stream = self.chunk_audio(cached_audio_bytes)
         else:
@@ -185,19 +208,40 @@ class VoiceOutputChannel(OutputChannel):
                 audio_stream = self.chunk_audio(generate_silence())
 
         async for audio_bytes in audio_stream:
-            try:
-                await self.send_audio_bytes(recipient_id, audio_bytes)
-                full_seconds_of_audio = len(collected_audio_bytes) // HERTZ
-                if full_seconds_of_audio > seconds_marker:
-                    await self.send_marker_message(recipient_id)
-                    seconds_marker = full_seconds_of_audio
+            collected_audio_bytes = RasaAudioBytes(collected_audio_bytes + audio_bytes)
 
+            # Check if we have enough new bytes to send
+            current_buffer_size = len(collected_audio_bytes) - last_sent_offset
+            should_send = current_buffer_size >= self.min_buffer_size
+
+            if should_send:
+                try:
+                    # Send only the new bytes since last send
+                    new_bytes = RasaAudioBytes(collected_audio_bytes[last_sent_offset:])
+                    await self.send_audio_bytes(recipient_id, new_bytes)
+                    last_sent_offset = len(collected_audio_bytes)
+
+                    full_seconds_of_audio = len(collected_audio_bytes) // HERTZ
+                    if full_seconds_of_audio > seconds_marker:
+                        await self.send_intermediate_marker(recipient_id)
+                        seconds_marker = full_seconds_of_audio
+
+                except (WebsocketClosed, ServerError):
+                    # ignore sending error, and keep collecting and caching audio bytes
+                    call_state.connection_failed = True  # type: ignore[attr-defined]
+
+        # Send any remaining audio not yet sent
+        remaining_bytes = len(collected_audio_bytes) - last_sent_offset
+        if remaining_bytes > 0:
+            try:
+                new_bytes = RasaAudioBytes(collected_audio_bytes[last_sent_offset:])
+                await self.send_audio_bytes(recipient_id, new_bytes)
             except (WebsocketClosed, ServerError):
-                # ignore sending error, and keep collecting and caching audio bytes
+                # ignore sending error
                 call_state.connection_failed = True  # type: ignore[attr-defined]
-            collected_audio_bytes = RasaAudioBytes(collected_audio_bytes + audio_bytes)
+
         try:
-            await self.send_marker_message(recipient_id)
+            await self.send_end_marker(recipient_id)
         except (WebsocketClosed, ServerError):
             # ignore sending error
             pass
@@ -244,13 +288,7 @@ class VoiceInputChannel(InputChannel):
         self.monitor_silence = monitor_silence
         self.tts_cache = TTSCache(tts_config.get("cache_size", 1000))
 
-    async def handle_silence_timeout(
-        self,
-        voice_websocket: Websocket,
-        on_new_message: Callable[[UserMessage], Awaitable[Any]],
-        tts_engine: TTSEngine,
-        call_parameters: CallParameters,
-    ) -> None:
+    async def monitor_silence_timeout(self, asr_event_queue: asyncio.Queue) -> None:
         timeout = call_state.silence_timeout
         if not timeout:
             return
@@ -258,16 +296,8 @@ class VoiceInputChannel(InputChannel):
             return
         logger.debug("voice_channel.silence_timeout_watch_started", timeout=timeout)
         await asyncio.sleep(timeout)
+        await asr_event_queue.put(UserSilence())
         logger.debug("voice_channel.silence_timeout_tripped")
-        output_channel = self.create_output_channel(voice_websocket, tts_engine)
-        message = UserMessage(
-            "/silence_timeout",
-            output_channel,
-            call_parameters.stream_id,
-            input_channel=self.name(),
-            metadata=asdict(call_parameters),
-        )
-        await on_new_message(message)
 
     @staticmethod
     def _cancel_silence_timeout_watcher() -> None:
@@ -315,6 +345,7 @@ class VoiceInputChannel(InputChannel):
     def map_input_message(
         self,
         message: Any,
+        ws: Websocket,
     ) -> VoiceChannelAction:
         """Map a channel input message to a voice channel action."""
         raise NotImplementedError
@@ -328,6 +359,7 @@ class VoiceInputChannel(InputChannel):
         _call_state.set(CallState())
         asr_engine = asr_engine_from_config(self.asr_config)
         tts_engine = tts_engine_from_config(self.tts_config)
+        asr_event_queue: asyncio.Queue = asyncio.Queue()
         await asr_engine.connect()
 
         call_parameters = await self.collect_call_parameters(channel_websocket)
@@ -340,7 +372,7 @@ class VoiceInputChannel(InputChannel):
         async def consume_audio_bytes() -> None:
             async for message in channel_websocket:
                 is_bot_speaking_before = call_state.is_bot_speaking
-                channel_action = self.map_input_message(message)
+                channel_action = self.map_input_message(message, channel_websocket)
                 is_bot_speaking_after = call_state.is_bot_speaking
 
                 if not is_bot_speaking_before and is_bot_speaking_after:
@@ -354,12 +386,7 @@ class VoiceInputChannel(InputChannel):
                     self._cancel_silence_timeout_watcher()
                     call_state.silence_timeout_watcher = (  # type: ignore[attr-defined]
                         asyncio.create_task(
-                            self.handle_silence_timeout(
-                                channel_websocket,
-                                on_new_message,
-                                tts_engine,
-                                call_parameters,
-                            )
+                            self.monitor_silence_timeout(asr_event_queue)
                         )
                     )
                 if isinstance(channel_action, NewAudioAction):
@@ -368,8 +395,13 @@ class VoiceInputChannel(InputChannel):
                     # end stream event came from the other side
                     break
 
-        async def consume_asr_events() -> None:
+        async def receive_asr_events() -> None:
             async for event in asr_engine.stream_asr_events():
+                await asr_event_queue.put(event)
+
+        async def handle_asr_events() -> None:
+            while True:
+                event = await asr_event_queue.get()
                 await self.handle_asr_event(
                     event,
                     channel_websocket,
@@ -378,16 +410,18 @@ class VoiceInputChannel(InputChannel):
                     call_parameters,
                 )
 
-        audio_forwarding_task = asyncio.create_task(consume_audio_bytes())
-        asr_event_task = asyncio.create_task(consume_asr_events())
+        tasks = [
+            asyncio.create_task(consume_audio_bytes()),
+            asyncio.create_task(receive_asr_events()),
+            asyncio.create_task(handle_asr_events()),
+        ]
         await asyncio.wait(
-            [audio_forwarding_task, asr_event_task],
+            tasks,
             return_when=asyncio.FIRST_COMPLETED,
         )
-        if not audio_forwarding_task.done():
-            audio_forwarding_task.cancel()
-        if not asr_event_task.done():
-            asr_event_task.cancel()
+        for task in tasks:
+            if not task.done():
+                task.cancel()
         await tts_engine.close_connection()
         await asr_engine.close_connection()
         await channel_websocket.close()
@@ -425,3 +459,13 @@ class VoiceInputChannel(InputChannel):
         elif isinstance(e, UserIsSpeaking):
             self._cancel_silence_timeout_watcher()
             call_state.is_user_speaking = True  # type: ignore[attr-defined]
+        elif isinstance(e, UserSilence):
+            output_channel = self.create_output_channel(voice_websocket, tts_engine)
+            message = UserMessage(
+                "/silence_timeout",
+                output_channel,
+                call_parameters.stream_id,
+                input_channel=self.name(),
+                metadata=asdict(call_parameters),
+            )
+            await on_new_message(message)

rasa/core/channels/webexteams.py

@@ -1,13 +1,12 @@
 import logging
+from typing import Any, Awaitable, Callable, Dict, Optional, Text
+
 from sanic import Blueprint, response
 from sanic.request import Request
-from typing import Text, Optional, Dict, Any, Callable, Awaitable
-
 from sanic.response import HTTPResponse
 from webexteamssdk import WebexTeamsAPI, Webhook
 
-from rasa.core.channels.channel import InputChannel
-from rasa.core.channels.channel import UserMessage, OutputChannel
+from rasa.core.channels.channel import InputChannel, OutputChannel, UserMessage
 
 logger = logging.getLogger(__name__)
 

rasa/core/constants.py

@@ -110,3 +110,5 @@ UTTER_SOURCE_METADATA_KEY = "utter_source"
 DOMAIN_GROUND_TRUTH_METADATA_KEY = "domain_ground_truth"
 ACTIVE_FLOW_METADATA_KEY = "active_flow"
 STEP_ID_METADATA_KEY = "step_id"
+KEY_IS_CALM_SYSTEM = "is_calm_system"
+KEY_IS_COEXISTENCE_ASSISTANT = "is_coexistence_assistant"

rasa/core/evaluation/marker.py

@@ -1,13 +1,14 @@
-from rasa.shared.core.domain import Domain
-from typing import Optional, Text, List
+import logging
+from typing import List, Optional, Text
+
 from rasa.core.evaluation.marker_base import (
-    OperatorMarker,
     ConditionMarker,
-    MarkerRegistry,
     Marker,
+    MarkerRegistry,
+    OperatorMarker,
 )
-from rasa.shared.core.events import ActionExecuted, SlotSet, UserUttered, Event
-import logging
+from rasa.shared.core.domain import Domain
+from rasa.shared.core.events import ActionExecuted, Event, SlotSet, UserUttered
 
 logger = logging.getLogger(__name__)
 

rasa/core/evaluation/marker_base.py

@@ -1,42 +1,41 @@
 from __future__ import annotations
+
+import csv
+import logging
 import os
+import os.path
 from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from pathlib import Path
 from typing import (
+    TYPE_CHECKING,
+    Any,
+    AsyncIterator,
     Dict,
     Iterator,
+    List,
     Optional,
     Set,
     Text,
-    List,
     Tuple,
     Type,
     TypeVar,
-    TYPE_CHECKING,
     Union,
-    Any,
-    AsyncIterator,
 )
 
-from pathlib import Path
-from dataclasses import dataclass
-
 import rasa.shared.core.constants
 import rasa.shared.nlu.constants
-import rasa.shared.utils.io
 import rasa.shared.utils.common
-from rasa.shared.data import is_likely_yaml_file
-from rasa.shared.exceptions import InvalidConfigException, RasaException
-from rasa.shared.core.events import ActionExecuted, UserUttered, Event
+import rasa.shared.utils.io
 from rasa import telemetry
+from rasa.shared.constants import DOCS_URL_MARKERS
 from rasa.shared.core.domain import Domain
+from rasa.shared.core.events import ActionExecuted, Event, UserUttered
 from rasa.shared.core.trackers import DialogueStateTracker
+from rasa.shared.data import is_likely_yaml_file
+from rasa.shared.exceptions import InvalidConfigException, RasaException
 from rasa.shared.utils.yaml import read_yaml_file
 from rasa.utils.io import WriteRow
-from rasa.shared.constants import DOCS_URL_MARKERS
-
-import logging
-import csv
-import os.path
 
 if TYPE_CHECKING:
     from rasa.core.evaluation.marker import OrMarker

rasa/core/evaluation/marker_stats.py

@@ -1,14 +1,13 @@
 from __future__ import annotations
-from typing import Dict, Text, Union, List, Tuple
 
-from rasa.utils.io import WriteRow
-from pathlib import Path
 import csv
+from pathlib import Path
+from typing import Dict, List, Text, Tuple, Union
 
 import numpy as np
 
-
 from rasa.core.evaluation.marker_base import EventMetaData
+from rasa.utils.io import WriteRow
 
 
 def compute_statistics(

rasa/core/evaluation/marker_tracker_loader.py

@@ -1,9 +1,10 @@
 import random
-from rasa.shared.exceptions import RasaException
-from rasa.shared.core.trackers import DialogueStateTracker
-from typing import Any, Iterable, List, Text, Optional, AsyncIterator
-from rasa.core.tracker_store import TrackerStore
+from typing import Any, AsyncIterator, Iterable, List, Optional, Text
+
 import rasa.shared.utils.io
+from rasa.core.tracker_store import TrackerStore
+from rasa.shared.core.trackers import DialogueStateTracker
+from rasa.shared.exceptions import RasaException
 
 STRATEGY_ALL = "all"
 STRATEGY_FIRST_N = "first_n"

rasa/core/exporter.py

@@ -1,7 +1,7 @@
+import datetime
 import logging
 import uuid
-import datetime
-from typing import AsyncIterator, Text, Optional, List, Set, Dict, Any
+from typing import Any, AsyncIterator, Dict, List, Optional, Set, Text
 
 from tqdm import tqdm
 
@@ -11,12 +11,12 @@ from rasa.core.brokers.broker import EventBroker
 from rasa.core.brokers.pika import PikaEventBroker
 from rasa.core.constants import RASA_EXPORT_PROCESS_ID_HEADER_NAME
 from rasa.core.tracker_store import TrackerStore
-from rasa.shared.core.trackers import EventVerbosity
 from rasa.exceptions import (
-    NoEventsToMigrateError,
     NoConversationsInTrackerStoreError,
+    NoEventsToMigrateError,
     PublishingError,
 )
+from rasa.shared.core.trackers import EventVerbosity
 
 logger = logging.getLogger(__name__)
 

rasa/core/featurizers/precomputation.py

@@ -1,20 +1,20 @@
 from __future__ import annotations
-from typing import Optional, Text, Dict, List, Union, Iterable, Any
-from collections.abc import ValuesView, KeysView
 
-from rasa.engine.graph import GraphComponent
-from rasa.engine.storage.storage import ModelStorage
+from collections.abc import KeysView, ValuesView
+from typing import Any, Dict, Iterable, List, Optional, Text, Union
+
+import rasa.shared.utils.io
+from rasa.engine.graph import ExecutionContext, GraphComponent
 from rasa.engine.storage.resource import Resource
-from rasa.engine.graph import ExecutionContext
+from rasa.engine.storage.storage import ModelStorage
 from rasa.shared.core.domain import Domain, SubState
-from rasa.shared.core.events import ActionExecuted, UserUttered, Event
+from rasa.shared.core.events import ActionExecuted, Event, UserUttered
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.core.training_data.structures import StoryGraph
 from rasa.shared.nlu.constants import ACTION_NAME, ACTION_TEXT, INTENT, TEXT
+from rasa.shared.nlu.training_data.features import Features
 from rasa.shared.nlu.training_data.message import Message
 from rasa.shared.nlu.training_data.training_data import TrainingData
-from rasa.shared.nlu.training_data.features import Features
-import rasa.shared.utils.io
 
 # TODO: make precomputations (MessageContainerForCoreFeaturization) cacheable
 

rasa/core/featurizers/single_state_featurizer.py

@@ -1,5 +1,5 @@
 import logging
-from typing import List, Optional, Dict, Text, Set, Any
+from typing import Any, Dict, List, Optional, Set, Text
 
 import numpy as np
 import scipy.sparse
@@ -8,18 +8,18 @@ from rasa.core.featurizers.precomputation import MessageContainerForCoreFeaturiz
 from rasa.nlu.extractors.extractor import EntityTagSpec
 from rasa.nlu.utils import bilou_utils
 from rasa.nlu.utils.bilou_utils import BILOU_PREFIXES
-from rasa.shared.core.domain import SubState, State, Domain
-from rasa.shared.core.constants import PREVIOUS_ACTION, ACTIVE_LOOP, USER, SLOTS
+from rasa.shared.core.constants import ACTIVE_LOOP, PREVIOUS_ACTION, SLOTS, USER
+from rasa.shared.core.domain import Domain, State, SubState
 from rasa.shared.core.trackers import is_prev_action_listen_in_state
 from rasa.shared.nlu.constants import (
+    ACTION_NAME,
+    ACTION_TEXT,
     ENTITIES,
+    ENTITY_ATTRIBUTE_TYPE,
+    ENTITY_TAGS,
     FEATURE_TYPE_SENTENCE,
-    ACTION_TEXT,
-    ACTION_NAME,
     INTENT,
     NO_ENTITY_TAG,
-    ENTITY_ATTRIBUTE_TYPE,
-    ENTITY_TAGS,
     TEXT,
 )
 from rasa.shared.nlu.training_data.features import Features

rasa/core/featurizers/tracker_featurizers.py

@@ -5,20 +5,20 @@ from abc import abstractmethod
 from collections import defaultdict
 from pathlib import Path
 from typing import (
-    Tuple,
+    Any,
+    Callable,
+    ClassVar,
+    DefaultDict,
+    Dict,
+    Iterator,
     List,
     Optional,
-    Dict,
+    Set,
     Text,
+    Tuple,
+    Type,
     Union,
-    Any,
-    Iterator,
-    Set,
-    DefaultDict,
     cast,
-    Type,
-    Callable,
-    ClassVar,
 )
 
 import numpy as np
@@ -30,15 +30,15 @@ from rasa.core.exceptions import InvalidTrackerFeaturizerUsageError
 from rasa.core.featurizers.precomputation import MessageContainerForCoreFeaturization
 from rasa.core.featurizers.single_state_featurizer import SingleStateFeaturizer
 from rasa.shared.core.constants import (
-    USER,
     ACTION_UNLIKELY_INTENT_NAME,
     PREVIOUS_ACTION,
+    USER,
 )
-from rasa.shared.core.domain import State, Domain
-from rasa.shared.core.events import Event, ActionExecuted, UserUttered
+from rasa.shared.core.domain import Domain, State
+from rasa.shared.core.events import ActionExecuted, Event, UserUttered
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.exceptions import RasaException
-from rasa.shared.nlu.constants import TEXT, INTENT, ENTITIES, ACTION_NAME
+from rasa.shared.nlu.constants import ACTION_NAME, ENTITIES, INTENT, TEXT
 from rasa.shared.nlu.training_data.features import Features
 from rasa.utils.tensorflow.constants import LABEL_PAD_ID
 from rasa.utils.tensorflow.model_data import ragged_array_to_ndarray

rasa/core/http_interpreter.py

@@ -1,10 +1,9 @@
-import aiohttp
-
 import copy
 import logging
-import structlog
+from typing import Any, Dict, Optional, Text
 
-from typing import Text, Dict, Any, Optional
+import aiohttp
+import structlog
 
 from rasa.core import constants
 from rasa.core.channels import UserMessage

rasa/core/information_retrieval/__init__.py

@@ -1,7 +1,7 @@
 from rasa.core.information_retrieval.information_retrieval import (  # noqa: F401
     InformationRetrieval,
+    InformationRetrievalException,
     SearchResult,
     SearchResultList,
-    InformationRetrievalException,
     create_from_endpoint_config,
 )

rasa/core/information_retrieval/faiss.py

@@ -1,18 +1,18 @@
 from pathlib import Path
-from typing import TYPE_CHECKING, List, Optional, Text, Any, Dict
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Text
 
 import structlog
 from langchain.text_splitter import RecursiveCharacterTextSplitter
-from langchain_community.document_loaders.text import TextLoader
 from langchain_community.document_loaders.directory import DirectoryLoader
+from langchain_community.document_loaders.text import TextLoader
 from langchain_community.vectorstores.faiss import FAISS
-from rasa.utils.endpoints import EndpointConfig
 
 from rasa.core.information_retrieval import (
-    SearchResultList,
     InformationRetrieval,
     InformationRetrievalException,
+    SearchResultList,
 )
+from rasa.utils.endpoints import EndpointConfig
 from rasa.utils.ml_utils import persist_faiss_vector_store
 
 if TYPE_CHECKING:

rasa/core/information_retrieval/information_retrieval.py

@@ -1,13 +1,13 @@
 from __future__ import annotations
 
+import importlib
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, List, Text, Any, Optional
+from typing import TYPE_CHECKING, Any, List, Optional, Text
 
 import structlog
 
 from rasa.shared.exceptions import RasaException
 from rasa.utils.endpoints import EndpointConfig
-import importlib
 
 if TYPE_CHECKING:
     from langchain.schema import Document

rasa/core/information_retrieval/milvus.py

@@ -1,14 +1,14 @@
-from typing import Text, Any, Dict
+from typing import Any, Dict, Text
 
 import structlog
 from langchain_community.vectorstores.milvus import Milvus
-from rasa.utils.endpoints import EndpointConfig
 
 from rasa.core.information_retrieval import (
-    SearchResultList,
     InformationRetrieval,
     InformationRetrievalException,
+    SearchResultList,
 )
+from rasa.utils.endpoints import EndpointConfig
 
 logger = structlog.get_logger()
 

rasa/core/information_retrieval/qdrant.py

@@ -1,16 +1,16 @@
-from typing import Text, Any, Dict
+from typing import Any, Dict, Text
 
 import structlog
 from langchain_community.vectorstores.qdrant import Qdrant
 from pydantic import ValidationError
 from qdrant_client import QdrantClient
-from rasa.utils.endpoints import EndpointConfig
 
 from rasa.core.information_retrieval import (
-    SearchResultList,
     InformationRetrieval,
     InformationRetrievalException,
+    SearchResultList,
 )
+from rasa.utils.endpoints import EndpointConfig
 
 logger = structlog.get_logger()
 

rasa/core/jobs.py

@@ -3,6 +3,7 @@ import logging
 
 from apscheduler.schedulers.asyncio import AsyncIOScheduler
 from pytz import UnknownTimeZoneError, utc
+
 import rasa.shared.utils.io
 
 __scheduler = None