Repository: RasaHQ/rasa
Pull request: Change `TrainingDataImporter` to be sync
**Proposed changes**:
- fix #9131 

**Status (please check what you already did)**:
- [ ] added some tests for the functionality
- [ ] updated the documentation
- [ ] updated the changelog (please check [changelog](https://github.com/RasaHQ/rasa/tree/main/changelog) for instructions)
- [x] reformat files using `black` (please check [Readme](https://github.com/RasaHQ/rasa#code-style) for instructions)


Problem statement:
Change `TrainingDataImporter` to be sync
**Description of Problem**:
Currently our `TrainingDataImporter` interface (and implementations) has a lot of `async` methods.
This will make integrating it into the new graph architecture difficult + we don't actually make sure of any async IO calls (as far as I'm aware).

**Overview of the Solution**:
We need to make all the methods in the importer classes normal, not `async` methods.

**Definition of Done**:
- [ ] Change all the interface and all importers to have only `sync` methods.
- [ ] Update the related tests to also not be `async`.
- [ ] Docs/migration guide for custom importers.

Hints from issue discussion:

Commit message: Updated docs

Patch to review:
diff --git a/changelog/9131.misc.md b/changelog/9131.misc.md
new file mode 100644
index 000000000000..6e5e79ee4df1
--- /dev/null
+++ b/changelog/9131.misc.md
@@ -0,0 +1 @@
+Change `TrainingDataImporter` to be sync.
\ No newline at end of file
diff --git a/docs/docs/migration-guide.mdx b/docs/docs/migration-guide.mdx
index 299581ed3b4d..db5500336172 100644
--- a/docs/docs/migration-guide.mdx
+++ b/docs/docs/migration-guide.mdx
@@ -10,6 +10,63 @@ description: |
 This page contains information about changes between major versions and
 how you can migrate from one version to another.
 
+## Rasa 2.x to 3.0
+
+### Training data
+
+`TrainingDataImporter` and all its implementations are updated to contain only synchronous methods.
+If you have a custom data importer or rely on some functions provided by `TrainingDataImporter`, you need
+to update your implementation and function calls.
+
+For example, this is how the data loading should look like in Rasa 3.0:
+
+```python
+from typing import Text
+from rasa.shared.importers.importer import TrainingDataImporter
+
+def load_data(domain_path: Text, config_path: Text):
+    file_importer = TrainingDataImporter.load_from_config(
+        config_path, domain_path
+    )
+    # note that all the functions below were async before:
+    config = file_importer.get_config()
+    domain = file_importer.get_domain()
+    stories = file_importer.get_stories()
+    nlu_data = file_importer.get_nlu_data()
+```
+
+Since any custom importer implements `TrainingDataImporter`, you should update your custom
+importer to contain only sync methods as well:
+
+```python
+from typing import Dict, Text
+
+from rasa.shared.core.domain import Domain
+from rasa.shared.importers.importer import TrainingDataImporter
+
+
+class MyImporter(TrainingDataImporter):
+    """Example partial implementation of a custom importer component."""
+
+    # this function was async before
+    def get_domain(self) -> Domain:
+        path_to_domain_file = self._custom_get_domain_file()
+        return Domain.load(path_to_domain_file)
+
+    def _custom_get_domain_file(self) -> Text:
+        pass
+
+    # this function was also async before
+    def get_config(self) -> Dict:
+        path_to_config = self._custom_get_config_file()
+        return rasa.utils.io.read_config_file(path_to_config)
+
+    def _custom_get_config_file(self) -> Text:
+        pass
+
+    # ...
+```
+
 ## Rasa 2.7 to 2.8
 
 :::caution
diff --git a/docs/docs/training-data-importers.mdx b/docs/docs/training-data-importers.mdx
index 9de5bb540099..b8b4862997d2 100644
--- a/docs/docs/training-data-importers.mdx
+++ b/docs/docs/training-data-importers.mdx
@@ -33,6 +33,13 @@ importers:
 The `name` key is used to determine which importer should be loaded. Any extra
 parameters are passed as constructor arguments to the loaded importer.
 
+:::note
+`TrainingDataImporter` and its subclasses contain no async methods since Rasa 3.0.
+In order to migrate your custom importers and make them work with Rasa 3.0, you also need to
+replace your async methods with synchronised ones.
+Please see the [migration guide](migration-guide.mdx#rasa-2x-to-30) for more information.
+:::
+
 :::tip
 You can specify multiple importers. Rasa will automatically merge their results.
 
@@ -172,14 +179,14 @@ class MyImporter(TrainingDataImporter):
 
         pass
 
-    async def get_domain(self) -> Domain:
+    def get_domain(self) -> Domain:
         path_to_domain_file = self._custom_get_domain_file()
         return Domain.load(path_to_domain_file)
 
     def _custom_get_domain_file(self) -> Text:
         pass
 
-    async def get_stories(
+    def get_stories(
         self,
         interpreter: "NaturalLanguageInterpreter" = RegexInterpreter(),
         template_variables: Optional[Dict] = None,
@@ -191,19 +198,19 @@ class MyImporter(TrainingDataImporter):
         )
 
         path_to_stories = self._custom_get_story_file()
-        return YAMLStoryReader.read_from_file(path_to_stories, await self.get_domain())
+        return YAMLStoryReader.read_from_file(path_to_stories, self.get_domain())
 
     def _custom_get_story_file(self) -> Text:
         pass
 
-    async def get_config(self) -> Dict:
+    def get_config(self) -> Dict:
         path_to_config = self._custom_get_config_file()
         return rasa.utils.io.read_config_file(path_to_config)
 
     def _custom_get_config_file(self) -> Text:
         pass
 
-    async def get_nlu_data(self, language: Optional[Text] = "en") -> TrainingData:
+    def get_nlu_data(self, language: Optional[Text] = "en") -> TrainingData:
         from rasa.shared.nlu.training_data import loading
 
         path_to_nlu_file = self._custom_get_nlu_file()
diff --git a/rasa/api.py b/rasa/api.py
index a9d9ae10e49b..be57c2b2343d 100644
--- a/rasa/api.py
+++ b/rasa/api.py
@@ -142,14 +142,10 @@ def test(
         additional_arguments: additional arguments for the test call
     """
     from rasa.model_testing import test_core
-    import rasa.utils.common
     from rasa.model_testing import test_nlu
 
     if additional_arguments is None:
         additional_arguments = {}
 
     test_core(model, stories, output, additional_arguments)
-
-    rasa.utils.common.run_in_loop(
-        test_nlu(model, nlu_data, output, additional_arguments)
-    )
+    test_nlu(model, nlu_data, output, additional_arguments)
diff --git a/rasa/cli/data.py b/rasa/cli/data.py
index 8ed2f585fc09..27b8e37fb5b5 100644
--- a/rasa/cli/data.py
+++ b/rasa/cli/data.py
@@ -245,7 +245,7 @@ def validate_files(args: argparse.Namespace, stories_only: bool = False) -> None
         domain_path=args.domain, training_data_paths=args.data, config_file=config,
     )
 
-    validator = rasa.utils.common.run_in_loop(Validator.from_importer(file_importer))
+    validator = Validator.from_importer(file_importer)
 
     if stories_only:
         all_good = _validate_story_structure(validator, args)
diff --git a/rasa/cli/interactive.py b/rasa/cli/interactive.py
index b8bac9312a11..62997abf317c 100644
--- a/rasa/cli/interactive.py
+++ b/rasa/cli/interactive.py
@@ -58,7 +58,7 @@ def interactive(args: argparse.Namespace) -> None:
     )
 
     if args.model is None:
-        story_graph = rasa.utils.common.run_in_loop(file_importer.get_stories())
+        story_graph = file_importer.get_stories()
         if not story_graph or story_graph.is_empty():
             rasa.shared.utils.cli.print_error_and_exit(
                 "Could not run interactive learning without either core "
diff --git a/rasa/cli/test.py b/rasa/cli/test.py
index 9eaf6a50f18b..04ee71f23961 100644
--- a/rasa/cli/test.py
+++ b/rasa/cli/test.py
@@ -184,7 +184,7 @@ async def run_nlu_test_async(
     test_data_importer = TrainingDataImporter.load_from_dict(
         training_data_paths=[data_path], domain_path=DEFAULT_DOMAIN_PATH,
     )
-    nlu_data = await test_data_importer.get_nlu_data()
+    nlu_data = test_data_importer.get_nlu_data()
 
     output = output_dir or DEFAULT_RESULTS_PATH
     all_args["errors"] = not no_errors
@@ -226,14 +226,14 @@ async def run_nlu_test_async(
         )
         config_importer = TrainingDataImporter.load_from_dict(config_path=config)
 
-        config_dict = await config_importer.get_config()
+        config_dict = config_importer.get_config()
         perform_nlu_cross_validation(config_dict, nlu_data, output, all_args)
     else:
         model_path = rasa.cli.utils.get_validated_path(
             models_path, "model", DEFAULT_MODELS_PATH
         )
 
-        await test_nlu(model_path, data_path, output, all_args)
+        test_nlu(model_path, data_path, output, all_args)
 
 
 def run_nlu_test(args: argparse.Namespace) -> None:
diff --git a/rasa/core/agent.py b/rasa/core/agent.py
index ab5f0b81adb7..1d0bedabbf07 100644
--- a/rasa/core/agent.py
+++ b/rasa/core/agent.py
@@ -701,7 +701,7 @@ def has_max_history_featurizer(policy: Policy) -> bool:
                 return False
         return True
 
-    async def load_data(
+    def load_data(
         self,
         training_resource: Union[Text, TrainingDataImporter],
         remove_duplicates: bool = True,
@@ -733,7 +733,7 @@ async def load_data(
                 f"at least maximum max_history."
             )
 
-        return await training.load_data(
+        return training.load_data(
             training_resource,
             self.domain,
             remove_duplicates,
@@ -832,7 +832,7 @@ async def visualize(
         # largest value from any policy
         max_history = max_history or self._max_history()
 
-        story_steps = await loading.load_data_from_resource(resource_name, self.domain)
+        story_steps = loading.load_data_from_resource(resource_name, self.domain)
         await visualize_stories(
             story_steps,
             self.domain,
diff --git a/rasa/core/test.py b/rasa/core/test.py
index 6a5d445f5dbd..5f77d21a6917 100644
--- a/rasa/core/test.py
+++ b/rasa/core/test.py
@@ -405,7 +405,7 @@ def as_story_string(self, e2e: bool = True) -> Text:
         )
 
 
-async def _create_data_generator(
+def _create_data_generator(
     resource_name: Text,
     agent: "Agent",
     max_stories: Optional[int] = None,
@@ -428,9 +428,9 @@ async def _create_data_generator(
         training_data_paths=[resource_name], domain_path=domain_path
     )
     if use_conversation_test_files:
-        story_graph = await test_data_importer.get_conversation_tests()
+        story_graph = test_data_importer.get_conversation_tests()
     else:
-        story_graph = await test_data_importer.get_stories()
+        story_graph = test_data_importer.get_stories()
 
     return TrainingDataGenerator(
         story_graph,
@@ -1017,7 +1017,7 @@ async def test(
     """
     from rasa.model_testing import get_evaluation_metrics
 
-    generator = await _create_data_generator(stories, agent, max_stories, e2e)
+    generator = _create_data_generator(stories, agent, max_stories, e2e)
     completed_trackers = generator.generate_story_trackers()
 
     story_evaluation, _, entity_results = await _collect_story_predictions(
@@ -1246,7 +1246,7 @@ async def _evaluate_core_model(
     logger.info(f"Evaluating model '{model}'")
 
     agent = Agent.load(model)
-    generator = await _create_data_generator(
+    generator = _create_data_generator(
         stories_file, agent, use_conversation_test_files=use_conversation_test_files
     )
     completed_trackers = generator.generate_story_trackers()
diff --git a/rasa/core/train.py b/rasa/core/train.py
index cd94ef568c44..7f4d1d0d81a4 100644
--- a/rasa/core/train.py
+++ b/rasa/core/train.py
@@ -1,5 +1,4 @@
 import argparse
-import asyncio
 import logging
 import os
 import tempfile
@@ -21,7 +20,7 @@
 logger = logging.getLogger(__name__)
 
 
-async def train(
+def train(
     domain_file: Union[Domain, Text],
     training_resource: Union[Text, "TrainingDataImporter"],
     output_path: Text,
@@ -32,6 +31,7 @@ async def train(
     additional_arguments: Optional[Dict] = None,
     model_to_finetune: Optional["Agent"] = None,
 ) -> "Agent":
+    """Trains the model."""
     from rasa.core import config, utils
     from rasa.core.utils import AvailableEndpoints
     from rasa.core.agent import Agent
@@ -62,7 +62,7 @@ async def train(
             "debug_plots",
         },
     )
-    training_data = await agent.load_data(
+    training_data = agent.load_data(
         training_resource, exclusion_percentage=exclusion_percentage, **data_load_args
     )
     if model_to_finetune:
@@ -108,17 +108,15 @@ async def train_comparison_models(
                 )
 
                 with TempDirectoryPath(tempfile.mkdtemp()) as train_path:
-                    _, new_fingerprint = await asyncio.gather(
-                        train(
-                            domain,
-                            file_importer,
-                            train_path,
-                            policy_config=policy_config,
-                            exclusion_percentage=percentage,
-                            additional_arguments=additional_arguments,
-                        ),
-                        model.model_fingerprint(file_importer),
+                    train(
+                        domain,
+                        file_importer,
+                        train_path,
+                        policy_config=policy_config,
+                        exclusion_percentage=percentage,
+                        additional_arguments=additional_arguments,
                     )
+                    new_fingerprint = model.model_fingerprint(file_importer)
 
                     output_dir = os.path.join(output_path, "run_" + str(r + 1))
                     model_name = config_name + PERCENTAGE_KEY + str(percentage)
@@ -130,12 +128,12 @@ async def train_comparison_models(
                     )
 
 
-async def get_no_of_stories(story_file: Text, domain: Text) -> int:
+def get_no_of_stories(story_file: Text, domain: Text) -> int:
     """Get number of stories in a file."""
     from rasa.shared.core.domain import Domain
     from rasa.shared.core.training_data import loading
 
-    stories = await loading.load_data_from_files([story_file], Domain.load(domain))
+    stories = loading.load_data_from_files([story_file], Domain.load(domain))
     return len(stories)
 
 
@@ -144,18 +142,16 @@ async def do_compare_training(
     story_file: Text,
     additional_arguments: Optional[Dict] = None,
 ) -> None:
-    _, no_stories = await asyncio.gather(
-        train_comparison_models(
-            story_file=story_file,
-            domain=args.domain,
-            output_path=args.out,
-            exclusion_percentages=args.percentages,
-            policy_configs=args.config,
-            runs=args.runs,
-            additional_arguments=additional_arguments,
-        ),
-        get_no_of_stories(args.stories, args.domain),
+    await train_comparison_models(
+        story_file=story_file,
+        domain=args.domain,
+        output_path=args.out,
+        exclusion_percentages=args.percentages,
+        policy_configs=args.config,
+        runs=args.runs,
+        additional_arguments=additional_arguments,
     )
+    no_stories = get_no_of_stories(args.stories, args.domain)
 
     # store the list of the number of stories present at each exclusion
     # percentage
diff --git a/rasa/core/training/__init__.py b/rasa/core/training/__init__.py
index fd0518f333d7..6fa63360b541 100644
--- a/rasa/core/training/__init__.py
+++ b/rasa/core/training/__init__.py
@@ -7,7 +7,7 @@
     from rasa.shared.importers.importer import TrainingDataImporter
 
 
-async def extract_story_graph(
+def extract_story_graph(
     resource_name: Text,
     domain: "Domain",
     use_e2e: bool = False,
@@ -28,7 +28,7 @@ async def extract_story_graph(
     from rasa.shared.core.training_data.structures import StoryGraph
     import rasa.shared.core.training_data.loading as core_loading
 
-    story_steps = await core_loading.load_data_from_resource(
+    story_steps = core_loading.load_data_from_resource(
         resource_name,
         domain,
         use_e2e=use_e2e,
@@ -37,7 +37,7 @@ async def extract_story_graph(
     return StoryGraph(story_steps)
 
 
-async def load_data(
+def load_data(
     resource_name: Union[Text, "TrainingDataImporter"],
     domain: "Domain",
     remove_duplicates: bool = True,
@@ -76,11 +76,9 @@ async def load_data(
 
     if resource_name:
         if isinstance(resource_name, TrainingDataImporter):
-            graph = await resource_name.get_stories(
-                exclusion_percentage=exclusion_percentage
-            )
+            graph = resource_name.get_stories(exclusion_percentage=exclusion_percentage)
         else:
-            graph = await extract_story_graph(
+            graph = extract_story_graph(
                 resource_name, domain, exclusion_percentage=exclusion_percentage
             )
 
diff --git a/rasa/core/training/interactive.py b/rasa/core/training/interactive.py
index 6adfbe7a9ccd..46d918dd0b7f 100644
--- a/rasa/core/training/interactive.py
+++ b/rasa/core/training/interactive.py
@@ -1490,7 +1490,7 @@ async def record_messages(
         num_messages = 0
 
         if not skip_visualization:
-            events_including_current_user_id = await _get_tracker_events_to_plot(
+            events_including_current_user_id = _get_tracker_events_to_plot(
                 domain, file_importer, conversation_id
             )
 
@@ -1555,10 +1555,10 @@ async def record_messages(
         raise
 
 
-async def _get_tracker_events_to_plot(
+def _get_tracker_events_to_plot(
     domain: Dict[Text, Any], file_importer: TrainingDataImporter, conversation_id: Text
 ) -> List[Union[Text, Deque[Event]]]:
-    training_trackers = await _get_training_trackers(file_importer, domain)
+    training_trackers = _get_training_trackers(file_importer, domain)
     number_of_trackers = len(training_trackers)
     if number_of_trackers > MAX_NUMBER_OF_TRAINING_STORIES_FOR_VISUALIZATION:
         rasa.shared.utils.cli.print_warning(
@@ -1576,12 +1576,12 @@ async def _get_tracker_events_to_plot(
     return training_data_events + [conversation_id]
 
 
-async def _get_training_trackers(
+def _get_training_trackers(
     file_importer: TrainingDataImporter, domain: Dict[str, Any]
 ) -> List[TrackerWithCachedStates]:
     from rasa.core import training
 
-    return await training.load_data(
+    return training.load_data(
         file_importer,
         Domain.from_dict(domain),
         augmentation_factor=0,
diff --git a/rasa/model.py b/rasa/model.py
index 393ec37cca75..d8a5d90b1fd2 100644
--- a/rasa/model.py
+++ b/rasa/model.py
@@ -329,7 +329,7 @@ def project_fingerprint() -> Optional[Text]:
         return None
 
 
-async def model_fingerprint(file_importer: "TrainingDataImporter") -> Fingerprint:
+def model_fingerprint(file_importer: "TrainingDataImporter") -> Fingerprint:
     """Create a model fingerprint from its used configuration and training data.
 
     Args:
@@ -341,10 +341,10 @@ async def model_fingerprint(file_importer: "TrainingDataImporter") -> Fingerprin
     """
     import time
 
-    config = await file_importer.get_config()
-    domain = await file_importer.get_domain()
-    stories = await file_importer.get_stories()
-    nlu_data = await file_importer.get_nlu_data()
+    config = file_importer.get_config()
+    domain = file_importer.get_domain()
+    stories = file_importer.get_stories()
+    nlu_data = file_importer.get_nlu_data()
 
     responses = domain.responses
 
@@ -615,7 +615,7 @@ def package_model(
     return output_directory
 
 
-async def update_model_with_new_domain(
+def update_model_with_new_domain(
     importer: "TrainingDataImporter", unpacked_model_path: Union[Path, Text]
 ) -> None:
     """Overwrites the domain of an unpacked model with a new domain.
@@ -625,7 +625,7 @@ async def update_model_with_new_domain(
         unpacked_model_path: Path to the unpacked model.
     """
     model_path = Path(unpacked_model_path) / DEFAULT_CORE_SUBDIRECTORY_NAME
-    domain = await importer.get_domain()
+    domain = importer.get_domain()
     domain.persist(model_path / DEFAULT_DOMAIN_PATH)
 
 
diff --git a/rasa/model_testing.py b/rasa/model_testing.py
index ee60ed25cfc8..909c9a2ee697 100644
--- a/rasa/model_testing.py
+++ b/rasa/model_testing.py
@@ -187,7 +187,7 @@ def test_core(
     )
 
 
-async def test_nlu(
+def test_nlu(
     model: Optional[Text],
     nlu_data: Optional[Text],
     output_directory: Text = DEFAULT_RESULTS_PATH,
@@ -214,9 +214,7 @@ async def test_nlu(
         kwargs = rasa.shared.utils.common.minimal_kwargs(
             additional_arguments, run_evaluation, ["data_path", "model"]
         )
-        await run_evaluation(
-            nlu_data, nlu_model, output_directory=output_directory, **kwargs
-        )
+        run_evaluation(nlu_data, nlu_model, output_directory=output_directory, **kwargs)
     else:
         rasa.shared.utils.cli.print_error(
             "Could not find any model. Use 'rasa train nlu' to train a "
diff --git a/rasa/model_training.py b/rasa/model_training.py
index 2c9930f2150f..bf8520f078b9 100644
--- a/rasa/model_training.py
+++ b/rasa/model_training.py
@@ -1,4 +1,3 @@
-import asyncio
 import os
 import tempfile
 from contextlib import ExitStack
@@ -93,7 +92,7 @@ async def train_async(
         config, domain, training_files
     )
     with TempDirectoryPath(tempfile.mkdtemp()) as train_path:
-        domain = await file_importer.get_domain()
+        domain = file_importer.get_domain()
 
         if domain.is_empty():
             nlu_model = await handle_domain_if_not_exists(
@@ -207,11 +206,10 @@ async def _train_async_internal(
     Returns:
         An instance of `TrainingResult`.
     """
-    stories, nlu_data = await asyncio.gather(
-        file_importer.get_stories(), file_importer.get_nlu_data()
-    )
+    stories = file_importer.get_stories()
+    nlu_data = file_importer.get_nlu_data()
 
-    new_fingerprint = await model.model_fingerprint(file_importer)
+    new_fingerprint = model.model_fingerprint(file_importer)
     old_model = model.get_latest_model(output_path)
 
     if dry_run:
@@ -253,7 +251,7 @@ async def _train_async_internal(
         rasa.shared.utils.cli.print_warning(
             "No NLU data present. Just a Rasa Core model will be trained."
         )
-        trained_model = await _train_core_with_validated_data(
+        trained_model = _train_core_with_validated_data(
             file_importer,
             output=output_path,
             fixed_model_name=fixed_model_name,
@@ -264,7 +262,7 @@ async def _train_async_internal(
 
         return TrainingResult(model=trained_model)
 
-    new_fingerprint = await model.model_fingerprint(file_importer)
+    new_fingerprint = model.model_fingerprint(file_importer)
     old_model = model.get_latest_model(output_path)
 
     if not force_training:
@@ -278,7 +276,7 @@ async def _train_async_internal(
         fingerprint_comparison = FingerprintComparisonResult(force_training=True)
 
     if not old_model or fingerprint_comparison.is_training_required():
-        async with telemetry.track_model_training(
+        with telemetry.track_model_training(
             file_importer, model_type="rasa",
         ):
             await _do_training(
@@ -345,7 +343,7 @@ async def _do_training(
         )
 
     if fingerprint_comparison_result.should_retrain_core():
-        await _train_core_with_validated_data(
+        _train_core_with_validated_data(
             file_importer,
             output=output_path,
             train_path=train_path,
@@ -363,7 +361,7 @@ async def _do_training(
             "the updated responses will be created.",
             color=rasa.shared.utils.io.bcolors.OKBLUE,
         )
-        await model.update_model_with_new_domain(file_importer, train_path)
+        model.update_model_with_new_domain(file_importer, train_path)
     else:
         rasa.shared.utils.cli.print_color(
             "Core stories/configuration did not change. No need to retrain Core model.",
@@ -401,32 +399,6 @@ def train_core(
     additional_arguments: Optional[Dict] = None,
     model_to_finetune: Optional[Text] = None,
     finetuning_epoch_fraction: float = 1.0,
-) -> Optional[Text]:
-    return rasa.utils.common.run_in_loop(
-        train_core_async(
-            domain=domain,
-            config=config,
-            stories=stories,
-            output=output,
-            train_path=train_path,
-            fixed_model_name=fixed_model_name,
-            additional_arguments=additional_arguments,
-            model_to_finetune=model_to_finetune,
-            finetuning_epoch_fraction=finetuning_epoch_fraction,
-        )
-    )
-
-
-async def train_core_async(
-    domain: Union[Domain, Text],
-    config: Text,
-    stories: Text,
-    output: Text,
-    train_path: Optional[Text] = None,
-    fixed_model_name: Optional[Text] = None,
-    additional_arguments: Optional[Dict] = None,
-    model_to_finetune: Optional[Text] = None,
-    finetuning_epoch_fraction: float = 1.0,
 ) -> Optional[Text]:
     """Trains a Core model.
 
@@ -452,11 +424,9 @@ async def train_core_async(
     file_importer = TrainingDataImporter.load_core_importer_from_config(
         config, domain, [stories]
     )
-    stories, nlu_data, domain = await asyncio.gather(
-        file_importer.get_stories(),
-        file_importer.get_nlu_data(),
-        file_importer.get_domain(),
-    )
+    stories = file_importer.get_stories()
+    nlu_data = file_importer.get_nlu_data()
+    domain = file_importer.get_domain()
 
     if nlu_data.has_e2e_examples():
         rasa.shared.utils.cli.print_error(
@@ -480,7 +450,7 @@ async def train_core_async(
         )
         return None
 
-    return await _train_core_with_validated_data(
+    return _train_core_with_validated_data(
         file_importer,
         output=output,
         train_path=train_path,
@@ -491,7 +461,7 @@ async def train_core_async(
     )
 
 
-async def _train_core_with_validated_data(
+def _train_core_with_validated_data(
     file_importer: TrainingDataImporter,
     output: Text,
     train_path: Optional[Text] = None,
@@ -516,15 +486,14 @@ async def _train_core_with_validated_data(
         rasa.shared.utils.cli.print_color(
             "Training Core model...", color=rasa.shared.utils.io.bcolors.OKBLUE
         )
-        domain, config = await asyncio.gather(
-            file_importer.get_domain(), file_importer.get_config()
-        )
+        domain = file_importer.get_domain()
+        config = file_importer.get_config()
 
         if model_to_finetune:
             rasa.shared.utils.common.mark_as_experimental_feature(
                 "Incremental Training feature"
             )
-            model_to_finetune = await _core_model_for_finetuning(
+            model_to_finetune = _core_model_for_finetuning(
                 model_to_finetune,
                 file_importer=file_importer,
                 finetuning_epoch_fraction=finetuning_epoch_fraction,
@@ -537,12 +506,12 @@ async def _train_core_with_validated_data(
                     f"model within the directory '{output}'."
                 )
 
-        async with telemetry.track_model_training(
+        with telemetry.track_model_training(
             file_importer,
             model_type="core",
             is_finetuning=model_to_finetune is not None,
         ):
-            await rasa.core.train.train(
+            rasa.core.train.train(
                 domain_file=domain,
                 training_resource=file_importer,
                 output_path=os.path.join(_train_path, DEFAULT_CORE_SUBDIRECTORY_NAME),
@@ -557,7 +526,7 @@ async def _train_core_with_validated_data(
 
         if train_path is None:
             # Only Core was trained.
-            new_fingerprint = await model.model_fingerprint(file_importer)
+            new_fingerprint = model.model_fingerprint(file_importer)
             return model.package_model(
                 fingerprint=new_fingerprint,
                 output_directory=output,
@@ -569,7 +538,7 @@ async def _train_core_with_validated_data(
     return _train_path
 
 
-async def _core_model_for_finetuning(
+def _core_model_for_finetuning(
     model_to_finetune: Text,
     file_importer: TrainingDataImporter,
     finetuning_epoch_fraction: float = 1.0,
@@ -583,14 +552,14 @@ async def _core_model_for_finetuning(
     )
 
     with model.unpack_model(path_to_archive) as unpacked:
-        new_fingerprint = await model.model_fingerprint(file_importer)
+        new_fingerprint = model.model_fingerprint(file_importer)
         old_fingerprint = model.fingerprint_from_path(unpacked)
         if not model.can_finetune(old_fingerprint, new_fingerprint, core=True):
             rasa.shared.utils.cli.print_error_and_exit(
                 "Core model can not be finetuned."
             )
 
-        config = await file_importer.get_config()
+        config = file_importer.get_config()
         agent = Agent.load(
             unpacked,
             new_config=config,
@@ -680,7 +649,7 @@ async def train_nlu_async(
         config, domain, training_data_paths=[nlu_data]
     )
 
-    training_data = await file_importer.get_nlu_data()
+    training_data = file_importer.get_nlu_data()
     if training_data.contains_no_pure_nlu_data():
         rasa.shared.utils.cli.print_error(
             f"Path '{nlu_data}' doesn't contain valid NLU data in it. "
@@ -724,7 +693,7 @@ async def _train_nlu_with_validated_data(
         else:
             # Otherwise, create a temp train path and clean it up on exit.
             _train_path = stack.enter_context(TempDirectoryPath(tempfile.mkdtemp()))
-        config = await file_importer.get_config()
+        config = file_importer.get_config()
         rasa.shared.utils.cli.print_color(
             "Training NLU model...", color=rasa.shared.utils.io.bcolors.OKBLUE
         )
@@ -733,7 +702,7 @@ async def _train_nlu_with_validated_data(
             rasa.shared.utils.common.mark_as_experimental_feature(
                 "Incremental Training feature"
             )
-            model_to_finetune = await _nlu_model_for_finetuning(
+            model_to_finetune = _nlu_model_for_finetuning(
                 model_to_finetune,
                 file_importer,
                 finetuning_epoch_fraction,
@@ -746,7 +715,7 @@ async def _train_nlu_with_validated_data(
                     f"model within the directory '{output}'."
                 )
 
-        async with telemetry.track_model_training(
+        with telemetry.track_model_training(
             file_importer,
             model_type="nlu",
             is_finetuning=model_to_finetune is not None,
@@ -766,7 +735,7 @@ async def _train_nlu_with_validated_data(
 
         if train_path is None:
             # Only NLU was trained
-            new_fingerprint = await model.model_fingerprint(file_importer)
+            new_fingerprint = model.model_fingerprint(file_importer)
 
             return model.package_model(
                 fingerprint=new_fingerprint,
@@ -779,7 +748,7 @@ async def _train_nlu_with_validated_data(
     return _train_path
 
 
-async def _nlu_model_for_finetuning(
+def _nlu_model_for_finetuning(
     model_to_finetune: Text,
     file_importer: TrainingDataImporter,
     finetuning_epoch_fraction: float = 1.0,
@@ -795,7 +764,7 @@ async def _nlu_model_for_finetuning(
     )
     with model.unpack_model(path_to_archive) as unpacked:
         _, old_nlu = model.get_model_subdirectories(unpacked)
-        new_fingerprint = await model.model_fingerprint(file_importer)
+        new_fingerprint = model.model_fingerprint(file_importer)
         old_fingerprint = model.fingerprint_from_path(unpacked)
         if not model.can_finetune(
             old_fingerprint,
@@ -807,7 +776,7 @@ async def _nlu_model_for_finetuning(
                 "NLU model can not be finetuned."
             )
 
-        config = await file_importer.get_config()
+        config = file_importer.get_config()
         loaded_model_to_finetune = Interpreter.load(
             old_nlu,
             new_config=config,
diff --git a/rasa/nlu/test.py b/rasa/nlu/test.py
index e5549d1932c0..a5dc71cc1d29 100644
--- a/rasa/nlu/test.py
+++ b/rasa/nlu/test.py
@@ -1409,7 +1409,7 @@ def remove_pretrained_extractors(pipeline: List[Component]) -> List[Component]:
     return pipeline
 
 
-async def run_evaluation(
+def run_evaluation(
     data_path: Text,
     model_path: Text,
     output_directory: Optional[Text] = None,
@@ -1446,7 +1446,7 @@ async def run_evaluation(
     test_data_importer = TrainingDataImporter.load_from_dict(
         training_data_paths=[data_path], domain_path=DEFAULT_DOMAIN_PATH,
     )
-    test_data = await test_data_importer.get_nlu_data()
+    test_data = test_data_importer.get_nlu_data()
 
     result: Dict[Text, Optional[Dict]] = {
         "intent_evaluation": None,
@@ -1908,7 +1908,7 @@ async def compare_nlu(
                 model_path = os.path.join(get_model(model_path), "nlu")
 
                 output_path = os.path.join(model_output_path, f"{model_name}_report")
-                result = await run_evaluation(
+                result = run_evaluation(
                     test_path, model_path, output_directory=output_path, errors=True
                 )
 
diff --git a/rasa/nlu/train.py b/rasa/nlu/train.py
index 0798aa655654..44f9eb175a02 100644
--- a/rasa/nlu/train.py
+++ b/rasa/nlu/train.py
@@ -106,7 +106,7 @@ async def train(
             training_data_endpoint, nlu_config.language
         )
     elif isinstance(data, TrainingDataImporter):
-        training_data = await data.get_nlu_data(nlu_config.language)
+        training_data = data.get_nlu_data(nlu_config.language)
     else:
         training_data = load_data(data, nlu_config.language)
 
diff --git a/rasa/server.py b/rasa/server.py
index c3c6d4331090..3cfaf46a8b8e 100644
--- a/rasa/server.py
+++ b/rasa/server.py
@@ -1229,7 +1229,7 @@ async def _evaluate_model_using_test_set(
                 HTTPStatus.CONFLICT, "Conflict", "Missing NLU model directory.",
             )
 
-        return await rasa.nlu.test.run_evaluation(
+        return rasa.nlu.test.run_evaluation(
             data_path, nlu_model, disable_plotting=True, report_as_dict=True
         )
 
@@ -1238,8 +1238,8 @@ async def _cross_validate(data_file: Text, config_file: Text, folds: int) -> Dic
         importer = TrainingDataImporter.load_from_dict(
             config=None, config_path=config_file, training_data_paths=[data_file]
         )
-        config = await importer.get_config()
-        nlu_data = await importer.get_nlu_data()
+        config = importer.get_config()
+        nlu_data = importer.get_nlu_data()
 
         evaluations = rasa.nlu.test.cross_validate(
             data=nlu_data,
diff --git a/rasa/shared/core/training_data/loading.py b/rasa/shared/core/training_data/loading.py
index f7834eea5732..1910169be75f 100644
--- a/rasa/shared/core/training_data/loading.py
+++ b/rasa/shared/core/training_data/loading.py
@@ -52,7 +52,7 @@ def _guess_reader(
     )
 
 
-async def load_data_from_resource(
+def load_data_from_resource(
     resource: Union[Text],
     domain: Domain,
     template_variables: Optional[Dict] = None,
@@ -75,7 +75,7 @@ async def load_data_from_resource(
     if not os.path.exists(resource):
         raise ValueError(f"Resource '{resource}' does not exist.")
 
-    return await load_data_from_files(
+    return load_data_from_files(
         rasa.shared.utils.io.list_files(resource),
         domain,
         template_variables,
@@ -84,7 +84,7 @@ async def load_data_from_resource(
     )
 
 
-async def load_data_from_files(
+def load_data_from_files(
     story_files: List[Text],
     domain: Domain,
     template_variables: Optional[Dict] = None,
diff --git a/rasa/shared/importers/importer.py b/rasa/shared/importers/importer.py
index 1f45c2ba84a5..37767bbef311 100644
--- a/rasa/shared/importers/importer.py
+++ b/rasa/shared/importers/importer.py
@@ -1,4 +1,3 @@
-import asyncio
 from functools import reduce
 from typing import Text, Optional, List, Dict, Set, Any, Tuple
 import logging
@@ -23,7 +22,7 @@
 class TrainingDataImporter:
     """Common interface for different mechanisms to load training data."""
 
-    async def get_domain(self) -> Domain:
+    def get_domain(self) -> Domain:
         """Retrieves the domain of the bot.
 
         Returns:
@@ -31,7 +30,7 @@ async def get_domain(self) -> Domain:
         """
         raise NotImplementedError()
 
-    async def get_stories(
+    def get_stories(
         self,
         template_variables: Optional[Dict] = None,
         use_e2e: bool = False,
@@ -51,15 +50,15 @@ async def get_stories(
         # TODO: Drop `use_e2e` in Rasa Open Source 3.0.0 when removing Markdown support
         raise NotImplementedError()
 
-    async def get_conversation_tests(self) -> StoryGraph:
+    def get_conversation_tests(self) -> StoryGraph:
         """Retrieves end-to-end conversation stories for testing.
 
         Returns:
             `StoryGraph` containing all loaded stories.
         """
-        return await self.get_stories(use_e2e=True)
+        return self.get_stories(use_e2e=True)
 
-    async def get_config(self) -> Dict:
+    def get_config(self) -> Dict:
         """Retrieves the configuration that should be used for the training.
 
         Returns:
@@ -67,7 +66,7 @@ async def get_config(self) -> Dict:
         """
         raise NotImplementedError()
 
-    async def get_nlu_data(self, language: Optional[Text] = "en") -> TrainingData:
+    def get_nlu_data(self, language: Optional[Text] = "en") -> TrainingData:
         """Retrieves the NLU training data that should be used for training.
 
         Args:
@@ -76,7 +75,6 @@ async def get_nlu_data(self, language: Optional[Text] = "en") -> TrainingData:
         Returns:
             Loaded NLU `TrainingData`.
         """
-
         raise NotImplementedError()
 
     @staticmethod
@@ -201,13 +199,14 @@ class NluDataImporter(TrainingDataImporter):
     """Importer that skips any Core-related file reading."""
 
     def __init__(self, actual_importer: TrainingDataImporter):
+        """Initializes the NLUDataImporter."""
         self._importer = actual_importer
 
-    async def get_domain(self) -> Domain:
+    def get_domain(self) -> Domain:
         """Retrieves model domain (see parent class for full docstring)."""
         return Domain.empty()
 
-    async def get_stories(
+    def get_stories(
         self,
         template_variables: Optional[Dict] = None,
         use_e2e: bool = False,
@@ -216,17 +215,17 @@ async def get_stories(
         """Retrieves training stories / rules (see parent class for full docstring)."""
         return StoryGraph([])
 
-    async def get_conversation_tests(self) -> StoryGraph:
+    def get_conversation_tests(self) -> StoryGraph:
         """Retrieves conversation test stories (see parent class for full docstring)."""
         return StoryGraph([])
 
-    async def get_config(self) -> Dict:
+    def get_config(self) -> Dict:
         """Retrieves model config (see parent class for full docstring)."""
-        return await self._importer.get_config()
+        return self._importer.get_config()
 
-    async def get_nlu_data(self, language: Optional[Text] = "en") -> TrainingData:
+    def get_nlu_data(self, language: Optional[Text] = "en") -> TrainingData:
         """Retrieves NLU training data (see parent class for full docstring)."""
-        return await self._importer.get_nlu_data(language)
+        return self._importer.get_nlu_data(language)
 
 
 class CombinedDataImporter(TrainingDataImporter):
@@ -240,25 +239,23 @@ def __init__(self, importers: List[TrainingDataImporter]):
         self._importers = importers
 
     @rasa.shared.utils.common.cached_method
-    async def get_config(self) -> Dict:
+    def get_config(self) -> Dict:
         """Retrieves model config (see parent class for full docstring)."""
         configs = [importer.get_config() for importer in self._importers]
-        configs = await asyncio.gather(*configs)
 
         return reduce(lambda merged, other: {**merged, **(other or {})}, configs, {})
 
     @rasa.shared.utils.common.cached_method
-    async def get_domain(self) -> Domain:
+    def get_domain(self) -> Domain:
         """Retrieves model domain (see parent class for full docstring)."""
         domains = [importer.get_domain() for importer in self._importers]
-        domains = await asyncio.gather(*domains)
 
         return reduce(
             lambda merged, other: merged.merge(other), domains, Domain.empty()
         )
 
     @rasa.shared.utils.common.cached_method
-    async def get_stories(
+    def get_stories(
         self,
         template_variables: Optional[Dict] = None,
         use_e2e: bool = False,
@@ -269,27 +266,24 @@ async def get_stories(
             importer.get_stories(template_variables, use_e2e, exclusion_percentage)
             for importer in self._importers
         ]
-        stories = await asyncio.gather(*stories)
 
         return reduce(
             lambda merged, other: merged.merge(other), stories, StoryGraph([])
         )
 
     @rasa.shared.utils.common.cached_method
-    async def get_conversation_tests(self) -> StoryGraph:
+    def get_conversation_tests(self) -> StoryGraph:
         """Retrieves conversation test stories (see parent class for full docstring)."""
         stories = [importer.get_conversation_tests() for importer in self._importers]
-        stories = await asyncio.gather(*stories)
 
         return reduce(
             lambda merged, other: merged.merge(other), stories, StoryGraph([])
         )
 
     @rasa.shared.utils.common.cached_method
-    async def get_nlu_data(self, language: Optional[Text] = "en") -> TrainingData:
+    def get_nlu_data(self, language: Optional[Text] = "en") -> TrainingData:
         """Retrieves NLU training data (see parent class for full docstring)."""
         nlu_data = [importer.get_nlu_data(language) for importer in self._importers]
-        nlu_data = await asyncio.gather(*nlu_data)
 
         return reduce(
             lambda merged, other: merged.merge(other), nlu_data, TrainingData()
@@ -305,18 +299,18 @@ class ResponsesSyncImporter(TrainingDataImporter):
     """
 
     def __init__(self, importer: TrainingDataImporter):
+        """Initializes the ResponsesSyncImporter."""
         self._importer = importer
 
-    async def get_config(self) -> Dict:
+    def get_config(self) -> Dict:
         """Retrieves model config (see parent class for full docstring)."""
-        return await self._importer.get_config()
+        return self._importer.get_config()
 
     @rasa.shared.utils.common.cached_method
-    async def get_domain(self) -> Domain:
+    def get_domain(self) -> Domain:
         """Merge existing domain with properties of retrieval intents in NLU data."""
-
-        existing_domain = await self._importer.get_domain()
-        existing_nlu_data = await self._importer.get_nlu_data()
+        existing_domain = self._importer.get_domain()
+        existing_nlu_data = self._importer.get_nlu_data()
 
         # Merge responses from NLU data with responses in the domain.
         # If NLU data has any retrieval intents, then add corresponding
@@ -389,26 +383,26 @@ def _get_domain_with_retrieval_intents(
             {},
         )
 
-    async def get_stories(
+    def get_stories(
         self,
         template_variables: Optional[Dict] = None,
         use_e2e: bool = False,
         exclusion_percentage: Optional[int] = None,
     ) -> StoryGraph:
         """Retrieves training stories / rules (see parent class for full docstring)."""
-        return await self._importer.get_stories(
+        return self._importer.get_stories(
             template_variables, use_e2e, exclusion_percentage
         )
 
-    async def get_conversation_tests(self) -> StoryGraph:
+    def get_conversation_tests(self) -> StoryGraph:
         """Retrieves conversation test stories (see parent class for full docstring)."""
-        return await self._importer.get_conversation_tests()
+        return self._importer.get_conversation_tests()
 
     @rasa.shared.utils.common.cached_method
-    async def get_nlu_data(self, language: Optional[Text] = "en") -> TrainingData:
+    def get_nlu_data(self, language: Optional[Text] = "en") -> TrainingData:
         """Updates NLU data with responses for retrieval intents from domain."""
-        existing_nlu_data = await self._importer.get_nlu_data(language)
-        existing_domain = await self._importer.get_domain()
+        existing_nlu_data = self._importer.get_nlu_data(language)
+        existing_domain = self._importer.get_domain()
 
         return existing_nlu_data.merge(
             self._get_nlu_data_with_responses(
@@ -440,19 +434,19 @@ class E2EImporter(TrainingDataImporter):
     """
 
     def __init__(self, importer: TrainingDataImporter) -> None:
+        """Initializes the E2EImporter."""
         self.importer = importer
 
     @rasa.shared.utils.common.cached_method
-    async def get_domain(self) -> Domain:
+    def get_domain(self) -> Domain:
         """Retrieves model domain (see parent class for full docstring)."""
-        original, e2e_domain = await asyncio.gather(
-            self.importer.get_domain(), self._get_domain_with_e2e_actions()
-        )
+        original = self.importer.get_domain()
+        e2e_domain = self._get_domain_with_e2e_actions()
         return original.merge(e2e_domain)
 
-    async def _get_domain_with_e2e_actions(self) -> Domain:
+    def _get_domain_with_e2e_actions(self) -> Domain:
 
-        stories = await self.get_stories()
+        stories = self.get_stories()
 
         additional_e2e_action_names = set()
         for story_step in stories.story_steps:
@@ -476,7 +470,7 @@ async def _get_domain_with_e2e_actions(self) -> Domain:
             action_texts=additional_e2e_action_names,
         )
 
-    async def get_stories(
+    def get_stories(
         self,
         interpreter: "NaturalLanguageInterpreter" = RegexInterpreter(),
         template_variables: Optional[Dict] = None,
@@ -487,34 +481,33 @@ async def get_stories(
 
         See parent class for details.
         """
-        return await self.importer.get_stories(
+        return self.importer.get_stories(
             template_variables, use_e2e, exclusion_percentage
         )
 
-    async def get_conversation_tests(self) -> StoryGraph:
+    def get_conversation_tests(self) -> StoryGraph:
         """Retrieves conversation test stories (see parent class for full docstring)."""
-        return await self.importer.get_conversation_tests()
+        return self.importer.get_conversation_tests()
 
-    async def get_config(self) -> Dict:
+    def get_config(self) -> Dict:
         """Retrieves model config (see parent class for full docstring)."""
-        return await self.importer.get_config()
+        return self.importer.get_config()
 
     @rasa.shared.utils.common.cached_method
-    async def get_nlu_data(self, language: Optional[Text] = "en") -> TrainingData:
+    def get_nlu_data(self, language: Optional[Text] = "en") -> TrainingData:
         """Retrieves NLU training data (see parent class for full docstring)."""
-        training_datasets = [_additional_training_data_from_default_actions()]
-
-        training_datasets += await asyncio.gather(
+        training_datasets = [
+            _additional_training_data_from_default_actions(),
             self.importer.get_nlu_data(language),
             self._additional_training_data_from_stories(),
-        )
+        ]
 
         return reduce(
             lambda merged, other: merged.merge(other), training_datasets, TrainingData()
         )
 
-    async def _additional_training_data_from_stories(self) -> TrainingData:
-        stories = await self.get_stories()
+    def _additional_training_data_from_stories(self) -> TrainingData:
+        stories = self.get_stories()
 
         utterances, actions = _unique_events_from_stories(stories)
 
diff --git a/rasa/shared/importers/multi_project.py b/rasa/shared/importers/multi_project.py
index 0c54d7b141b1..4885f9ddd47c 100644
--- a/rasa/shared/importers/multi_project.py
+++ b/rasa/shared/importers/multi_project.py
@@ -168,38 +168,38 @@ def _is_in_imported_paths(self, path: Text) -> bool:
             [rasa.shared.utils.io.is_subdirectory(path, i) for i in self._imports]
         )
 
-    async def get_domain(self) -> Domain:
+    def get_domain(self) -> Domain:
         """Retrieves model domain (see parent class for full docstring)."""
         domains = [Domain.load(path) for path in self._domain_paths]
         return reduce(
             lambda merged, other: merged.merge(other), domains, Domain.empty()
         )
 
-    async def get_stories(
+    def get_stories(
         self,
         template_variables: Optional[Dict] = None,
         use_e2e: bool = False,
         exclusion_percentage: Optional[int] = None,
     ) -> StoryGraph:
         """Retrieves training stories / rules (see parent class for full docstring)."""
-        return await utils.story_graph_from_paths(
+        return utils.story_graph_from_paths(
             self._story_paths,
-            await self.get_domain(),
+            self.get_domain(),
             template_variables,
             use_e2e,
             exclusion_percentage,
         )
 
-    async def get_conversation_tests(self) -> StoryGraph:
+    def get_conversation_tests(self) -> StoryGraph:
         """Retrieves conversation test stories (see parent class for full docstring)."""
-        return await utils.story_graph_from_paths(
-            self._e2e_story_paths, await self.get_domain(), use_e2e=True,
+        return utils.story_graph_from_paths(
+            self._e2e_story_paths, self.get_domain(), use_e2e=True,
         )
 
-    async def get_config(self) -> Dict:
+    def get_config(self) -> Dict:
         """Retrieves model config (see parent class for full docstring)."""
         return self.config
 
-    async def get_nlu_data(self, language: Optional[Text] = "en") -> TrainingData:
+    def get_nlu_data(self, language: Optional[Text] = "en") -> TrainingData:
         """Retrieves NLU training data (see parent class for full docstring)."""
         return utils.training_data_from_paths(self._nlu_paths, language)
diff --git a/rasa/shared/importers/rasa.py b/rasa/shared/importers/rasa.py
index 278007316329..fb8542fc995f 100644
--- a/rasa/shared/importers/rasa.py
+++ b/rasa/shared/importers/rasa.py
@@ -39,36 +39,36 @@ def __init__(
 
         self.config = autoconfig.get_configuration(config_file, training_type)
 
-    async def get_config(self) -> Dict:
+    def get_config(self) -> Dict:
         """Retrieves model config (see parent class for full docstring)."""
         return self.config
 
-    async def get_stories(
+    def get_stories(
         self,
         template_variables: Optional[Dict] = None,
         use_e2e: bool = False,
         exclusion_percentage: Optional[int] = None,
     ) -> StoryGraph:
         """Retrieves training stories / rules (see parent class for full docstring)."""
-        return await utils.story_graph_from_paths(
+        return utils.story_graph_from_paths(
             self._story_files,
-            await self.get_domain(),
+            self.get_domain(),
             template_variables,
             use_e2e,
             exclusion_percentage,
         )
 
-    async def get_conversation_tests(self) -> StoryGraph:
+    def get_conversation_tests(self) -> StoryGraph:
         """Retrieves conversation test stories (see parent class for full docstring)."""
-        return await utils.story_graph_from_paths(
-            self._conversation_test_files, await self.get_domain(), use_e2e=True,
+        return utils.story_graph_from_paths(
+            self._conversation_test_files, self.get_domain(), use_e2e=True,
         )
 
-    async def get_nlu_data(self, language: Optional[Text] = "en") -> TrainingData:
+    def get_nlu_data(self, language: Optional[Text] = "en") -> TrainingData:
         """Retrieves NLU training data (see parent class for full docstring)."""
         return utils.training_data_from_paths(self._nlu_files, language)
 
-    async def get_domain(self) -> Domain:
+    def get_domain(self) -> Domain:
         """Retrieves model domain (see parent class for full docstring)."""
         domain = Domain.empty()
 
diff --git a/rasa/shared/importers/utils.py b/rasa/shared/importers/utils.py
index 343ad936eff3..4e364af576f8 100644
--- a/rasa/shared/importers/utils.py
+++ b/rasa/shared/importers/utils.py
@@ -12,17 +12,17 @@ def training_data_from_paths(paths: Iterable[Text], language: Text) -> TrainingD
     return TrainingData().merge(*training_data_sets)
 
 
-async def story_graph_from_paths(
+def story_graph_from_paths(
     files: List[Text],
     domain: Domain,
     template_variables: Optional[Dict] = None,
     use_e2e: bool = False,
     exclusion_percentage: Optional[int] = None,
 ) -> StoryGraph:
-
+    """Returns the `StoryGraph` from paths."""
     from rasa.shared.core.training_data import loading
 
-    story_steps = await loading.load_data_from_files(
+    story_steps = loading.load_data_from_files(
         files, domain, template_variables, use_e2e, exclusion_percentage
     )
     return StoryGraph(story_steps)
diff --git a/rasa/telemetry.py b/rasa/telemetry.py
index 0cbdd97e6a13..de9abcb11d2d 100644
--- a/rasa/telemetry.py
+++ b/rasa/telemetry.py
@@ -1,4 +1,5 @@
 import asyncio
+import contextlib
 from datetime import datetime
 from functools import wraps
 import hashlib
@@ -13,8 +14,6 @@
 import typing
 from typing import Any, Callable, Dict, List, Optional, Text, Union
 import uuid
-
-import async_generator
 import requests
 from terminaltables import SingleTable
 
@@ -677,10 +676,10 @@ def initialize_error_reporting() -> None:
             scope.set_context("Environment", default_context)
 
 
-@async_generator.asynccontextmanager
-async def track_model_training(
+@contextlib.contextmanager
+def track_model_training(
     training_data: "TrainingDataImporter", model_type: Text, is_finetuning: bool = False
-) -> typing.AsyncGenerator[None, None]:
+) -> typing.Generator[None, None, None]:
     """Track a model training started.
 
     WARNING: since this is a generator, it can't use the ensure telemetry
@@ -698,10 +697,10 @@ async def track_model_training(
         yield  # runs the training
         return  # closes the async context
 
-    config = await training_data.get_config()
-    stories = await training_data.get_stories()
-    nlu_data = await training_data.get_nlu_data()
-    domain = await training_data.get_domain()
+    config = training_data.get_config()
+    stories = training_data.get_stories()
+    nlu_data = training_data.get_nlu_data()
+    domain = training_data.get_domain()
     count_conditional_responses = domain.count_conditional_response_variations()
 
     training_id = uuid.uuid4().hex
diff --git a/rasa/validator.py b/rasa/validator.py
index 9bf82d44feef..1f7a922d8e5e 100644
--- a/rasa/validator.py
+++ b/rasa/validator.py
@@ -46,12 +46,12 @@ def __init__(
         self.nlu_config = RasaNLUModelConfig(config)
 
     @classmethod
-    async def from_importer(cls, importer: TrainingDataImporter) -> "Validator":
+    def from_importer(cls, importer: TrainingDataImporter) -> "Validator":
         """Create an instance from the domain, nlu and story files."""
-        domain = await importer.get_domain()
-        story_graph = await importer.get_stories()
-        intents = await importer.get_nlu_data()
-        config = await importer.get_config()
+        domain = importer.get_domain()
+        story_graph = importer.get_stories()
+        intents = importer.get_nlu_data()
+        config = importer.get_config()
 
         return cls(domain, intents, story_graph, config)
 
diff --git a/tests/cli/test_rasa_data.py b/tests/cli/test_rasa_data.py
index cb1a3b37dc98..5ffc091292af 100644
--- a/tests/cli/test_rasa_data.py
+++ b/tests/cli/test_rasa_data.py
@@ -137,7 +137,7 @@ def test_data_validate_stories_with_max_history_zero(monkeypatch: MonkeyPatch):
         ]
     )
 
-    async def mock_from_importer(importer: TrainingDataImporter) -> Validator:
+    def mock_from_importer(importer: TrainingDataImporter) -> Validator:
         return Mock()
 
     monkeypatch.setattr("rasa.validator.Validator.from_importer", mock_from_importer)
diff --git a/tests/conftest.py b/tests/conftest.py
index 94576159a0cd..7b175b35a61f 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -170,9 +170,7 @@ def event_loop(request: Request) -> Iterator[asyncio.AbstractEventLoop]:
 
 
 @pytest.fixture(scope="session")
-async def _trained_default_agent(
-    tmpdir_factory: TempdirFactory, stories_path: Text
-) -> Agent:
+def _trained_default_agent(tmpdir_factory: TempdirFactory, stories_path: Text) -> Agent:
     model_path = tmpdir_factory.mktemp("model").strpath
 
     agent = Agent(
@@ -181,7 +179,7 @@ async def _trained_default_agent(
         model_directory=model_path,
     )
 
-    training_data = await agent.load_data(stories_path)
+    training_data = agent.load_data(stories_path)
     agent.train(training_data)
     agent.persist(model_path)
     return agent
diff --git a/tests/core/policies/test_rule_policy.py b/tests/core/policies/test_rule_policy.py
index 287f440406d4..89900f74c5c7 100644
--- a/tests/core/policies/test_rule_policy.py
+++ b/tests/core/policies/test_rule_policy.py
@@ -679,7 +679,7 @@ def test_all_policy_attributes_are_persisted(tmpdir: Path):
     assert persisted_policy._enable_fallback_prediction == enable_fallback_prediction
 
 
-async def test_rule_policy_finetune(
+def test_rule_policy_finetune(
     tmp_path: Path, trained_rule_policy: RulePolicy, trained_rule_policy_domain: Domain
 ):
     trained_rule_policy.persist(tmp_path)
@@ -702,7 +702,7 @@ async def test_rule_policy_finetune(
         is_rule_tracker=True,
     )
 
-    original_data = await training.load_data(
+    original_data = training.load_data(
         "examples/rules/data/rules.yml", trained_rule_policy_domain
     )
 
@@ -720,7 +720,7 @@ async def test_rule_policy_finetune(
     )
 
 
-async def test_rule_policy_contradicting_rule_finetune(
+def test_rule_policy_contradicting_rule_finetune(
     tmp_path: Path, trained_rule_policy: RulePolicy, trained_rule_policy_domain: Domain
 ):
     trained_rule_policy.persist(tmp_path)
@@ -743,7 +743,7 @@ async def test_rule_policy_contradicting_rule_finetune(
         is_rule_tracker=True,
     )
 
-    original_data = await training.load_data(
+    original_data = training.load_data(
         "examples/rules/data/rules.yml", trained_rule_policy_domain
     )
 
@@ -1791,8 +1791,8 @@ def trained_rule_policy_domain() -> Domain:
 
 
 @pytest.fixture(scope="session")
-async def trained_rule_policy(trained_rule_policy_domain: Domain) -> RulePolicy:
-    trackers = await training.load_data(
+def trained_rule_policy(trained_rule_policy_domain: Domain) -> RulePolicy:
+    trackers = training.load_data(
         "examples/rules/data/rules.yml", trained_rule_policy_domain
     )
 
diff --git a/tests/core/policies/test_ted_policy.py b/tests/core/policies/test_ted_policy.py
index b44b5f674bc7..2bccb39297c3 100644
--- a/tests/core/policies/test_ted_policy.py
+++ b/tests/core/policies/test_ted_policy.py
@@ -205,7 +205,7 @@ def test_train_fails_with_checkpoint_zero_eval_num_epochs(self, tmp_path: Path):
         assert len([w for w in warning if warn_text in str(w.message)]) == 1
         assert not checkpoint_dir.is_dir()
 
-    async def test_training_with_no_intent(
+    def test_training_with_no_intent(
         self,
         featurizer: Optional[TrackerFeaturizer],
         priority: int,
@@ -226,7 +226,7 @@ async def test_training_with_no_intent(
         policy = self.create_policy(featurizer=featurizer, priority=priority)
         import tests.core.test_policies
 
-        training_trackers = await tests.core.test_policies.train_trackers(
+        training_trackers = tests.core.test_policies.train_trackers(
             default_domain, str(stories), augmentation_factor=20
         )
         with pytest.raises(RasaException) as e:
@@ -299,10 +299,10 @@ def test_label_data_assembly(
             == default_domain.num_actions
         )
 
-    async def test_gen_batch(
+    def test_gen_batch(
         self, trained_policy: TEDPolicy, default_domain: Domain, stories_path: Path
     ):
-        training_trackers = await tests.core.test_policies.train_trackers(
+        training_trackers = tests.core.test_policies.train_trackers(
             default_domain, stories_path, augmentation_factor=0
         )
         interpreter = RegexInterpreter()
diff --git a/tests/core/policies/test_unexpected_intent_policy.py b/tests/core/policies/test_unexpected_intent_policy.py
index 46908f9fec5b..2d34a2c45ce2 100644
--- a/tests/core/policies/test_unexpected_intent_policy.py
+++ b/tests/core/policies/test_unexpected_intent_policy.py
@@ -117,7 +117,7 @@ def test_label_data_assembly(
             0
         ].units == len(default_domain.intents)
 
-    async def test_training_with_no_intent(
+    def test_training_with_no_intent(
         self,
         featurizer: Optional[TrackerFeaturizer],
         priority: int,
@@ -138,20 +138,20 @@ async def test_training_with_no_intent(
         policy = self.create_policy(featurizer=featurizer, priority=priority)
         import tests.core.test_policies
 
-        training_trackers = await tests.core.test_policies.train_trackers(
+        training_trackers = tests.core.test_policies.train_trackers(
             default_domain, str(stories), augmentation_factor=20
         )
 
         with pytest.warns(UserWarning):
             policy.train(training_trackers, default_domain, RegexInterpreter())
 
-    async def test_prepared_data_for_threshold_prediction(
+    def test_prepared_data_for_threshold_prediction(
         self,
         trained_policy: UnexpecTEDIntentPolicy,
         default_domain: Domain,
         stories_path: Path,
     ):
-        training_trackers = await train_trackers(
+        training_trackers = train_trackers(
             default_domain, stories_path, augmentation_factor=0
         )
         interpreter = RegexInterpreter()
@@ -288,13 +288,13 @@ def test_label_quantiles_computation(self):
         for label_id, tolerance_thresholds in thresholds.items():
             assert expected_thresholds[label_id] == tolerance_thresholds
 
-    async def test_post_training_threshold_computation(
+    def test_post_training_threshold_computation(
         self,
         trained_policy: UnexpecTEDIntentPolicy,
         default_domain: Domain,
         stories_path: Path,
     ):
-        training_trackers = await train_trackers(
+        training_trackers = train_trackers(
             default_domain, stories_path, augmentation_factor=0
         )
         interpreter = RegexInterpreter()
diff --git a/tests/core/test_agent.py b/tests/core/test_agent.py
index 4955244435ab..7adef5b7131d 100644
--- a/tests/core/test_agent.py
+++ b/tests/core/test_agent.py
@@ -56,15 +56,15 @@ def model_server(
     return loop.run_until_complete(sanic_client(app))
 
 
-async def test_training_data_is_reproducible():
+def test_training_data_is_reproducible():
     training_data_file = "data/test_moodbot/data/stories.yml"
     agent = Agent(
         "data/test_moodbot/domain.yml", policies=[AugmentedMemoizationPolicy()]
     )
 
-    training_data = await agent.load_data(training_data_file)
+    training_data = agent.load_data(training_data_file)
     # make another copy of training data
-    same_training_data = await agent.load_data(training_data_file)
+    same_training_data = agent.load_data(training_data_file)
 
     # test if both datasets are identical (including in the same order)
     for i, x in enumerate(training_data):
diff --git a/tests/core/test_evaluation.py b/tests/core/test_evaluation.py
index e8aa838cf497..50e207dad683 100644
--- a/tests/core/test_evaluation.py
+++ b/tests/core/test_evaluation.py
@@ -59,7 +59,7 @@ async def test_evaluation_file_creation(
 async def test_end_to_end_evaluation_script(
     default_agent: Agent, end_to_end_story_path: Text
 ):
-    generator = await _create_data_generator(
+    generator = _create_data_generator(
         end_to_end_story_path, default_agent, use_conversation_test_files=True
     )
     completed_trackers = generator.generate_story_trackers()
@@ -99,7 +99,7 @@ async def test_end_to_end_evaluation_script(
 async def test_end_to_end_evaluation_script_unknown_entity(
     default_agent: Agent, e2e_story_file_unknown_entity_path: Text
 ):
-    generator = await _create_data_generator(
+    generator = _create_data_generator(
         e2e_story_file_unknown_entity_path,
         default_agent,
         use_conversation_test_files=True,
@@ -117,7 +117,7 @@ async def test_end_to_end_evaluation_script_unknown_entity(
 
 @pytest.mark.timeout(300, func_only=True)
 async def test_end_to_evaluation_with_forms(form_bot_agent: Agent):
-    generator = await _create_data_generator(
+    generator = _create_data_generator(
         "data/test_evaluations/test_form_end_to_end_stories.yml",
         form_bot_agent,
         use_conversation_test_files=True,
@@ -159,10 +159,10 @@ async def test_end_to_evaluation_trips_circuit_breaker(
         domain="data/test_domains/default.yml",
         policies=[MemoizationPolicy(max_history=11)],
     )
-    training_data = await agent.load_data(e2e_story_file_trips_circuit_breaker_path)
+    training_data = agent.load_data(e2e_story_file_trips_circuit_breaker_path)
     agent.train(training_data)
 
-    generator = await _create_data_generator(
+    generator = _create_data_generator(
         e2e_story_file_trips_circuit_breaker_path,
         agent,
         use_conversation_test_files=True,
@@ -270,7 +270,7 @@ def test_event_has_proper_implementation(
     ],
 )
 async def test_retrieval_intent(response_selector_agent: Agent, test_file: Text):
-    generator = await _create_data_generator(
+    generator = _create_data_generator(
         test_file, response_selector_agent, use_conversation_test_files=True,
     )
     test_stories = generator.generate_story_trackers()
diff --git a/tests/core/test_policies.py b/tests/core/test_policies.py
index 118470432ad0..f77d3be149dd 100644
--- a/tests/core/test_policies.py
+++ b/tests/core/test_policies.py
@@ -35,10 +35,10 @@
 from tests.core.utilities import get_tracker, tracker_from_dialogue
 
 
-async def train_trackers(
+def train_trackers(
     domain: Domain, stories_file: Text, augmentation_factor: int = 20
 ) -> List[TrackerWithCachedStates]:
-    return await training.load_data(
+    return training.load_data(
         stories_file, domain, augmentation_factor=augmentation_factor
     )
 
@@ -82,7 +82,7 @@ def tracker(self, default_domain: Domain) -> DialogueStateTracker:
         return DialogueStateTracker(DEFAULT_SENDER_ID, default_domain.slots)
 
     @pytest.fixture(scope="class")
-    async def trained_policy(
+    def trained_policy(
         self,
         featurizer: Optional[TrackerFeaturizer],
         priority: int,
@@ -90,7 +90,7 @@ async def trained_policy(
         default_domain: Domain,
     ) -> Policy:
         policy = self.create_policy(featurizer, priority)
-        training_trackers = await train_trackers(
+        training_trackers = train_trackers(
             default_domain, stories_path, augmentation_factor=20
         )
         policy.train(training_trackers, default_domain, RegexInterpreter())
@@ -109,7 +109,7 @@ def test_featurizer(self, trained_policy: Policy, tmp_path: Path):
         assert isinstance(loaded.featurizer.state_featurizer, SingleStateFeaturizer)
 
     @pytest.mark.parametrize("should_finetune", [False, True])
-    async def test_persist_and_load(
+    def test_persist_and_load(
         self,
         trained_policy: Policy,
         default_domain: Domain,
@@ -123,9 +123,7 @@ async def test_persist_and_load(
         )
         assert loaded.finetune_mode == should_finetune
 
-        trackers = await train_trackers(
-            default_domain, stories_path, augmentation_factor=20
-        )
+        trackers = train_trackers(default_domain, stories_path, augmentation_factor=20)
 
         for tracker in trackers:
             predicted_probabilities = loaded.predict_action_probabilities(
@@ -185,15 +183,13 @@ def test_featurizer(self, trained_policy: Policy, tmp_path: Path):
         assert isinstance(loaded.featurizer, MaxHistoryTrackerFeaturizer)
         assert loaded.featurizer.state_featurizer is None
 
-    async def test_memorise(
+    def test_memorise(
         self,
         trained_policy: MemoizationPolicy,
         default_domain: Domain,
         stories_path: Text,
     ):
-        trackers = await train_trackers(
-            default_domain, stories_path, augmentation_factor=20
-        )
+        trackers = train_trackers(default_domain, stories_path, augmentation_factor=20)
         trained_policy.train(trackers, default_domain, RegexInterpreter())
         lookup_with_augmentation = trained_policy.lookup
 
@@ -217,7 +213,7 @@ async def test_memorise(
         assert trained_policy._recall_states(random_states) is None
 
         # compare augmentation for augmentation_factor of 0 and 20:
-        trackers_no_augmentation = await train_trackers(
+        trackers_no_augmentation = train_trackers(
             default_domain, stories_path, augmentation_factor=0
         )
         trained_policy.train(
@@ -236,7 +232,7 @@ def test_memorise_with_nlu(
         recalled = trained_policy.recall(states, tracker, default_domain)
         assert recalled is not None
 
-    async def test_finetune_after_load(
+    def test_finetune_after_load(
         self,
         trained_policy: MemoizationPolicy,
         default_domain: Domain,
@@ -261,7 +257,7 @@ async def test_finetune_after_load(
                 ActionExecuted(ACTION_LISTEN_NAME),
             ],
         )
-        original_train_data = await train_trackers(
+        original_train_data = train_trackers(
             default_domain, stories_path, augmentation_factor=20
         )
         loaded_policy.train(
diff --git a/tests/core/test_test.py b/tests/core/test_test.py
index b0b125f32c1e..0edb7a1d597f 100644
--- a/tests/core/test_test.py
+++ b/tests/core/test_test.py
@@ -142,7 +142,7 @@ async def test_testing_valid_with_non_e2e_core_model(core_agent: Agent):
     assert "report" in result.keys()
 
 
-async def _train_rule_based_agent(
+def _train_rule_based_agent(
     moodbot_domain: Domain,
     train_file_name: Path,
     monkeypatch: MonkeyPatch,
@@ -163,7 +163,7 @@ async def _train_rule_based_agent(
 
     deterministic_policy = RulePolicy(restrict_rules=False)
     agent = Agent(moodbot_domain, SimplePolicyEnsemble([deterministic_policy]))
-    training_data = await agent.load_data(str(train_file_name))
+    training_data = agent.load_data(str(train_file_name))
 
     # Make the trackers compatible with rules
     # so that they are picked up by the policy.
@@ -204,7 +204,7 @@ async def test_action_unlikely_intent_warning(
     # We train on the above story so that RulePolicy can memorize
     # it and we don't have to worry about other actions being
     # predicted correctly.
-    agent = await _train_rule_based_agent(
+    agent = _train_rule_based_agent(
         moodbot_domain, file_name, monkeypatch, ignore_action_unlikely_intent=True
     )
 
@@ -254,7 +254,7 @@ async def test_action_unlikely_intent_correctly_predicted(
     # We train on the above story so that RulePolicy can memorize
     # it and we don't have to worry about other actions being
     # predicted correctly.
-    agent = await _train_rule_based_agent(
+    agent = _train_rule_based_agent(
         moodbot_domain, file_name, monkeypatch, ignore_action_unlikely_intent=False
     )
 
@@ -317,7 +317,7 @@ async def test_wrong_action_after_action_unlikely_intent(
     # We train on the above story so that RulePolicy can memorize
     # it and we don't have to worry about other actions being
     # predicted correctly.
-    agent = await _train_rule_based_agent(
+    agent = _train_rule_based_agent(
         moodbot_domain, train_file_name, monkeypatch, ignore_action_unlikely_intent=True
     )
 
@@ -387,7 +387,7 @@ async def test_action_unlikely_intent_not_found(
     # We train on the above story so that RulePolicy can memorize
     # it and we don't have to worry about other actions being
     # predicted correctly.
-    agent = await _train_rule_based_agent(
+    agent = _train_rule_based_agent(
         moodbot_domain,
         train_file_name,
         monkeypatch,
@@ -456,7 +456,7 @@ async def test_action_unlikely_intent_warning_and_story_error(
     # We train on the above story so that RulePolicy can memorize
     # it and we don't have to worry about other actions being
     # predicted correctly.
-    agent = await _train_rule_based_agent(
+    agent = _train_rule_based_agent(
         moodbot_domain, train_file_name, monkeypatch, ignore_action_unlikely_intent=True
     )
 
@@ -505,7 +505,7 @@ async def test_fail_on_prediction_errors(
     # We train on the above story so that RulePolicy can memorize
     # it and we don't have to worry about other actions being
     # predicted correctly.
-    agent = await _train_rule_based_agent(
+    agent = _train_rule_based_agent(
         moodbot_domain, file_name, monkeypatch, ignore_action_unlikely_intent=False
     )
 
@@ -603,7 +603,7 @@ async def test_multiple_warnings_sorted_on_severity(
     # We train on the stories as it is so that RulePolicy can memorize
     # it and we don't have to worry about other actions being
     # predicted correctly.
-    agent = await _train_rule_based_agent(
+    agent = _train_rule_based_agent(
         moodbot_domain,
         Path(test_story_path),
         monkeypatch,
diff --git a/tests/core/test_training.py b/tests/core/test_training.py
index 1eec838be83d..346f85cef689 100644
--- a/tests/core/test_training.py
+++ b/tests/core/test_training.py
@@ -21,7 +21,7 @@
 async def test_story_visualization(domain: Domain, tmp_path: Path):
     import rasa.shared.core.training_data.loading as core_loading
 
-    story_steps = await core_loading.load_data_from_resource(
+    story_steps = core_loading.load_data_from_resource(
         "data/test_yaml_stories/stories.yml", domain
     )
     out_file = str(tmp_path / "graph.html")
@@ -41,7 +41,7 @@ async def test_story_visualization(domain: Domain, tmp_path: Path):
 async def test_story_visualization_with_merging(domain: Domain):
     import rasa.shared.core.training_data.loading as core_loading
 
-    story_steps = await core_loading.load_data_from_resource(
+    story_steps = core_loading.load_data_from_resource(
         "data/test_yaml_stories/stories.yml", domain
     )
     generated_graph = await visualize_stories(
@@ -52,12 +52,12 @@ async def test_story_visualization_with_merging(domain: Domain):
     assert 20 < len(generated_graph.edges()) < 33
 
 
-async def test_training_script_without_max_history_set(
+def test_training_script_without_max_history_set(
     tmp_path: Path, domain_path: Text, stories_path: Text
 ):
     tmpdir = str(tmp_path)
 
-    await train(
+    train(
         domain_path,
         stories_path,
         tmpdir,
@@ -75,12 +75,12 @@ async def test_training_script_without_max_history_set(
                 assert policy.featurizer.max_history is None
 
 
-async def test_training_script_with_max_history_set(
+def test_training_script_with_max_history_set(
     tmp_path: Path, domain_path: Text, stories_path: Text
 ):
     tmpdir = str(tmp_path)
 
-    await train(
+    train(
         domain_path,
         stories_path,
         tmpdir,
@@ -97,8 +97,8 @@ async def test_training_script_with_max_history_set(
             assert policy.featurizer.max_history == expected_history
 
 
-async def test_training_script_with_restart_stories(tmp_path: Path, domain_path: Text):
-    await train(
+def test_training_script_with_restart_stories(tmp_path: Path, domain_path: Text):
+    train(
         domain_path,
         "data/test_yaml_stories/stories_restart.yml",
         str(tmp_path),
@@ -120,10 +120,7 @@ async def test_random_seed(
         ]
     }
 
-    # policy_train = Mock()
-    # monkeypatch.setattr(TED, "fit", policy_train)
-
-    agent_1 = await train(
+    agent_1 = train(
         domain_path,
         stories_path,
         str(tmp_path),
@@ -132,7 +129,7 @@ async def test_random_seed(
         additional_arguments={},
     )
 
-    agent_2 = await train(
+    agent_2 = train(
         domain_path,
         stories_path,
         str(tmp_path),
@@ -149,7 +146,7 @@ async def test_random_seed(
     assert probs_1["confidence"] == probs_2["confidence"]
 
 
-async def test_trained_interpreter_passed_to_policies(
+def test_trained_interpreter_passed_to_policies(
     tmp_path: Path, monkeypatch: MonkeyPatch, domain_path: Text, stories_path: Text
 ):
     policies_config = {
@@ -161,7 +158,7 @@ async def test_trained_interpreter_passed_to_policies(
 
     interpreter = Mock(spec=RasaNLUInterpreter)
 
-    await train(
+    train(
         domain_path,
         stories_path,
         str(tmp_path),
diff --git a/tests/core/training/test_interactive.py b/tests/core/training/test_interactive.py
index 4aa734770a9c..156b3ffe369d 100644
--- a/tests/core/training/test_interactive.py
+++ b/tests/core/training/test_interactive.py
@@ -675,9 +675,7 @@ async def test_initial_plotting_call(
     mock_file_importer: TrainingDataImporter,
 ):
     get_training_trackers = Mock(return_value=trackers)
-    monkeypatch.setattr(
-        interactive, "_get_training_trackers", asyncio.coroutine(get_training_trackers)
-    )
+    monkeypatch.setattr(interactive, "_get_training_trackers", get_training_trackers)
 
     monkeypatch.setattr(interactive.utils, "is_limit_reached", lambda _, __: True)
 
diff --git a/tests/core/training/test_story_conflict.py b/tests/core/training/test_story_conflict.py
index 2bac166ec71e..f4b4fb7ca743 100644
--- a/tests/core/training/test_story_conflict.py
+++ b/tests/core/training/test_story_conflict.py
@@ -17,13 +17,13 @@
 )
 
 
-async def _setup_trackers_for_testing(
+def _setup_trackers_for_testing(
     domain_path: Text, training_data_file: Text
 ) -> Tuple[List[TrackerWithCachedStates], Domain]:
     importer = RasaFileImporter(
         domain_path=domain_path, training_data_paths=[training_data_file]
     )
-    validator = await Validator.from_importer(importer)
+    validator = Validator.from_importer(importer)
 
     trackers = TrainingDataGenerator(
         validator.story_graph,
@@ -36,7 +36,7 @@ async def _setup_trackers_for_testing(
 
 
 async def test_find_no_conflicts(domain_path: Text, stories_path: Text):
-    trackers, domain = await _setup_trackers_for_testing(domain_path, stories_path)
+    trackers, domain = _setup_trackers_for_testing(domain_path, stories_path)
 
     # Create a list of `StoryConflict` objects
     conflicts = find_story_conflicts(trackers, domain, 5)
@@ -45,7 +45,7 @@ async def test_find_no_conflicts(domain_path: Text, stories_path: Text):
 
 
 async def test_find_conflicts_in_short_history():
-    trackers, domain = await _setup_trackers_for_testing(
+    trackers, domain = _setup_trackers_for_testing(
         "data/test_domains/default.yml",
         "data/test_yaml_stories/stories_conflicting_1.yml",
     )
@@ -60,7 +60,7 @@ async def test_find_conflicts_in_short_history():
 
 
 async def test_check_conflict_description():
-    trackers, domain = await _setup_trackers_for_testing(
+    trackers, domain = _setup_trackers_for_testing(
         "data/test_domains/default.yml",
         "data/test_yaml_stories/stories_conflicting_1.yml",
     )
@@ -73,7 +73,7 @@ async def test_check_conflict_description():
 
 
 async def test_find_conflicts_checkpoints():
-    trackers, domain = await _setup_trackers_for_testing(
+    trackers, domain = _setup_trackers_for_testing(
         "data/test_domains/default.yml",
         "data/test_yaml_stories/stories_conflicting_2.yml",
     )
@@ -86,7 +86,7 @@ async def test_find_conflicts_checkpoints():
 
 
 async def test_find_conflicts_or():
-    trackers, domain = await _setup_trackers_for_testing(
+    trackers, domain = _setup_trackers_for_testing(
         "data/test_domains/default.yml",
         "data/test_yaml_stories/stories_conflicting_3.yml",
     )
@@ -99,7 +99,7 @@ async def test_find_conflicts_or():
 
 
 async def test_find_conflicts_slots_that_break():
-    trackers, domain = await _setup_trackers_for_testing(
+    trackers, domain = _setup_trackers_for_testing(
         "data/test_domains/default.yml",
         "data/test_yaml_stories/stories_conflicting_4.yml",
     )
@@ -112,7 +112,7 @@ async def test_find_conflicts_slots_that_break():
 
 
 async def test_find_conflicts_slots_that_dont_break():
-    trackers, domain = await _setup_trackers_for_testing(
+    trackers, domain = _setup_trackers_for_testing(
         "data/test_domains/default.yml",
         "data/test_yaml_stories/stories_conflicting_5.yml",
     )
@@ -124,7 +124,7 @@ async def test_find_conflicts_slots_that_dont_break():
 
 
 async def test_find_conflicts_multiple_stories():
-    trackers, domain = await _setup_trackers_for_testing(
+    trackers, domain = _setup_trackers_for_testing(
         "data/test_domains/default.yml",
         "data/test_yaml_stories/stories_conflicting_6.yml",
     )
@@ -137,7 +137,7 @@ async def test_find_conflicts_multiple_stories():
 
 
 async def test_find_unlearnable_actions():
-    trackers, domain = await _setup_trackers_for_testing(
+    trackers, domain = _setup_trackers_for_testing(
         "data/test_domains/default.yml",
         "data/test_yaml_stories/stories_unexpected_intent_unlearnable.yml",
     )
diff --git a/tests/examples/test_example_bots_training_data.py b/tests/examples/test_example_bots_training_data.py
index 500d4df0fd5f..35c6a8ecd981 100644
--- a/tests/examples/test_example_bots_training_data.py
+++ b/tests/examples/test_example_bots_training_data.py
@@ -42,7 +42,7 @@
         ),
     ],
 )
-async def test_example_bot_training_data_not_raises(
+def test_example_bot_training_data_not_raises(
     config_file: Text, domain_file: Text, data_folder: Text
 ):
 
@@ -51,13 +51,13 @@ async def test_example_bot_training_data_not_raises(
     )
 
     with pytest.warns(None) as record:
-        await importer.get_nlu_data()
-        await importer.get_stories()
+        importer.get_nlu_data()
+        importer.get_stories()
 
     assert not len(record)
 
 
-async def test_example_bot_training_on_initial_project(tmp_path: Path):
+def test_example_bot_training_on_initial_project(tmp_path: Path):
     # we need to test this one separately, as we can't test it in place
     # configuration suggestions would otherwise change the initial file
     scaffold.create_initial_project(str(tmp_path))
@@ -69,7 +69,7 @@ async def test_example_bot_training_on_initial_project(tmp_path: Path):
     )
 
     with pytest.warns(None) as record:
-        await importer.get_nlu_data()
-        await importer.get_stories()
+        importer.get_nlu_data()
+        importer.get_stories()
 
     assert not len(record)
diff --git a/tests/nlu/test_config.py b/tests/nlu/test_config.py
index 80e24e8400e0..707524e85a34 100644
--- a/tests/nlu/test_config.py
+++ b/tests/nlu/test_config.py
@@ -164,7 +164,7 @@ async def test_train_docker_and_docs_configs(
 ):
     monkeypatch.setattr(autoconfig, "_dump_config", Mock())
     importer = RasaFileImporter(config_file=config_file)
-    imported_config = await importer.get_config()
+    imported_config = importer.get_config()
 
     loaded_config = config.load(imported_config)
 
diff --git a/tests/nlu/test_evaluation.py b/tests/nlu/test_evaluation.py
index 3a3bc6099462..e0a32547fcb1 100644
--- a/tests/nlu/test_evaluation.py
+++ b/tests/nlu/test_evaluation.py
@@ -352,10 +352,8 @@ def test_drop_intents_below_freq():
 @pytest.mark.timeout(
     300, func_only=True
 )  # these can take a longer time than the default timeout
-async def test_run_evaluation(
-    unpacked_trained_moodbot_path: Text, nlu_as_json_path: Text
-):
-    result = await run_evaluation(
+def test_run_evaluation(unpacked_trained_moodbot_path: Text, nlu_as_json_path: Text):
+    result = run_evaluation(
         nlu_as_json_path,
         os.path.join(unpacked_trained_moodbot_path, "nlu"),
         errors=False,
@@ -366,7 +364,7 @@ async def test_run_evaluation(
     assert result.get("intent_evaluation")
 
 
-async def test_eval_data(
+def test_eval_data(
     component_builder: ComponentBuilder,
     tmp_path: Path,
     project: Text,
@@ -386,7 +384,7 @@ async def test_eval_data(
     )
     interpreter = Interpreter.load(nlu_model_directory, component_builder)
 
-    data = await data_importer.get_nlu_data()
+    data = data_importer.get_nlu_data()
     (intent_results, response_selection_results, entity_results) = get_eval_data(
         interpreter, data
     )
@@ -975,7 +973,7 @@ async def test_nlu_comparison(
     test_data_importer = TrainingDataImporter.load_from_dict(
         training_data_paths=[nlu_as_json_path]
     )
-    test_data = await test_data_importer.get_nlu_data()
+    test_data = test_data_importer.get_nlu_data()
     await compare_nlu_models(
         configs, test_data, output, runs=2, exclusion_percentages=[50, 80]
     )
diff --git a/tests/shared/core/test_domain.py b/tests/shared/core/test_domain.py
index 59aa95697de8..f1a3cc6af4e8 100644
--- a/tests/shared/core/test_domain.py
+++ b/tests/shared/core/test_domain.py
@@ -58,11 +58,9 @@ def test_slots_states_before_user_utterance(domain: Domain):
     assert trackers_as_states == expected_states
 
 
-async def test_create_train_data_no_history(domain: Domain, stories_path: Text):
+def test_create_train_data_no_history(domain: Domain, stories_path: Text):
     featurizer = MaxHistoryTrackerFeaturizer(max_history=1)
-    training_trackers = await training.load_data(
-        stories_path, domain, augmentation_factor=0
-    )
+    training_trackers = training.load_data(stories_path, domain, augmentation_factor=0)
 
     assert len(training_trackers) == 4
     (decoded, _) = featurizer.training_states_and_labels(training_trackers, domain)
@@ -88,11 +86,9 @@ async def test_create_train_data_no_history(domain: Domain, stories_path: Text):
     ]
 
 
-async def test_create_train_data_with_history(domain: Domain, stories_path: Text):
+def test_create_train_data_with_history(domain: Domain, stories_path: Text):
     featurizer = MaxHistoryTrackerFeaturizer(max_history=4)
-    training_trackers = await training.load_data(
-        stories_path, domain, augmentation_factor=0
-    )
+    training_trackers = training.load_data(stories_path, domain, augmentation_factor=0)
     assert len(training_trackers) == 4
     (decoded, _) = featurizer.training_states_and_labels(training_trackers, domain)
 
@@ -132,14 +128,12 @@ def check_for_too_many_entities_and_remove_them(state: State) -> State:
     return state
 
 
-async def test_create_train_data_unfeaturized_entities():
+def test_create_train_data_unfeaturized_entities():
     domain_file = "data/test_domains/default_unfeaturized_entities.yml"
     stories_file = "data/test_yaml_stories/stories_unfeaturized_entities.yml"
     domain = Domain.load(domain_file)
     featurizer = MaxHistoryTrackerFeaturizer(max_history=1)
-    training_trackers = await training.load_data(
-        stories_file, domain, augmentation_factor=0
-    )
+    training_trackers = training.load_data(stories_file, domain, augmentation_factor=0)
 
     assert len(training_trackers) == 2
     (decoded, _) = featurizer.training_states_and_labels(training_trackers, domain)
diff --git a/tests/shared/core/test_trackers.py b/tests/shared/core/test_trackers.py
index 11340b36d11f..aef4a3b4843d 100644
--- a/tests/shared/core/test_trackers.py
+++ b/tests/shared/core/test_trackers.py
@@ -156,11 +156,11 @@ def test_tracker_store(store, pair):
     assert restored == tracker
 
 
-async def test_tracker_write_to_story(tmp_path: Path, moodbot_domain: Domain):
+def test_tracker_write_to_story(tmp_path: Path, moodbot_domain: Domain):
     tracker = tracker_from_dialogue(TEST_MOODBOT_DIALOGUE, moodbot_domain)
     p = tmp_path / "export.yml"
     tracker.export_stories_to_file(str(p))
-    trackers = await training.load_data(
+    trackers = training.load_data(
         str(p),
         moodbot_domain,
         use_story_concatenation=False,
@@ -516,10 +516,10 @@ def _load_tracker_from_json(tracker_dump: Text, domain: Domain) -> DialogueState
     )
 
 
-async def test_dump_and_restore_as_json(
+def test_dump_and_restore_as_json(
     default_agent: Agent, tmp_path: Path, stories_path: Text
 ):
-    trackers = await default_agent.load_data(stories_path)
+    trackers = default_agent.load_data(stories_path)
 
     for tracker in trackers:
         out_path = tmp_path / "dumped_tracker.json"
diff --git a/tests/shared/core/training_data/story_reader/test_common_story_reader.py b/tests/shared/core/training_data/story_reader/test_common_story_reader.py
index 49d0dcf9984b..ea3f1aaeccbf 100644
--- a/tests/shared/core/training_data/story_reader/test_common_story_reader.py
+++ b/tests/shared/core/training_data/story_reader/test_common_story_reader.py
@@ -18,8 +18,8 @@
 from rasa.utils.tensorflow.model_data_utils import _surface_attributes
 
 
-async def test_can_read_test_story(domain: Domain):
-    trackers = await training.load_data(
+def test_can_read_test_story(domain: Domain):
+    trackers = training.load_data(
         "data/test_yaml_stories/stories.yml",
         domain,
         use_story_concatenation=False,
@@ -53,10 +53,10 @@ async def test_can_read_test_story(domain: Domain):
         "data/test_yaml_stories/stories_checkpoint_after_or.yml",
     ],
 )
-async def test_can_read_test_story_with_checkpoint_after_or(
+def test_can_read_test_story_with_checkpoint_after_or(
     stories_file: Text, domain: Domain
 ):
-    trackers = await training.load_data(
+    trackers = training.load_data(
         stories_file,
         domain,
         use_story_concatenation=False,
@@ -73,8 +73,8 @@ async def test_can_read_test_story_with_checkpoint_after_or(
         "data/test_yaml_stories/stories_with_cycle.yml",
     ],
 )
-async def test_read_story_file_with_cycles(stories_file: Text, domain: Domain):
-    graph = await training.extract_story_graph(stories_file, domain)
+def test_read_story_file_with_cycles(stories_file: Text, domain: Domain):
+    graph = training.extract_story_graph(stories_file, domain)
 
     assert len(graph.story_steps) == 5
 
@@ -96,11 +96,9 @@ async def test_read_story_file_with_cycles(stories_file: Text, domain: Domain):
         "data/test_yaml_stories/stories_with_cycle.yml",
     ],
 )
-async def test_generate_training_data_with_cycles(stories_file: Text, domain: Domain):
+def test_generate_training_data_with_cycles(stories_file: Text, domain: Domain):
     featurizer = MaxHistoryTrackerFeaturizer(SingleStateFeaturizer(), max_history=4)
-    training_trackers = await training.load_data(
-        stories_file, domain, augmentation_factor=0,
-    )
+    training_trackers = training.load_data(stories_file, domain, augmentation_factor=0,)
 
     _, label_ids, _ = featurizer.featurize_trackers(
         training_trackers, domain, interpreter=RegexInterpreter()
@@ -125,10 +123,10 @@ async def test_generate_training_data_with_cycles(stories_file: Text, domain: Do
         "data/test_yaml_stories/stories_unused_checkpoints.yml",
     ],
 )
-async def test_generate_training_data_with_unused_checkpoints(
+def test_generate_training_data_with_unused_checkpoints(
     stories_file: Text, domain: Domain
 ):
-    training_trackers = await training.load_data(stories_file, domain)
+    training_trackers = training.load_data(stories_file, domain)
     # there are 3 training stories:
     #   2 with unused end checkpoints -> training_trackers
     #   1 with unused start checkpoints -> ignored
@@ -142,12 +140,10 @@ async def test_generate_training_data_with_unused_checkpoints(
         "data/test_yaml_stories/stories_defaultdomain.yml",
     ],
 )
-async def test_generate_training_data_original_and_augmented_trackers(
+def test_generate_training_data_original_and_augmented_trackers(
     stories_file: Text, domain: Domain
 ):
-    training_trackers = await training.load_data(
-        stories_file, domain, augmentation_factor=3,
-    )
+    training_trackers = training.load_data(stories_file, domain, augmentation_factor=3,)
     # there are three original stories
     # augmentation factor of 3 indicates max of 3*10 augmented stories generated
     # maximum number of stories should be augmented+original = 33
@@ -167,10 +163,10 @@ async def test_generate_training_data_original_and_augmented_trackers(
         "data/test_yaml_stories/stories_with_cycle.yml",
     ],
 )
-async def test_visualize_training_data_graph(
+def test_visualize_training_data_graph(
     stories_file: Text, tmp_path: Path, domain: Domain
 ):
-    graph = await training.extract_story_graph(stories_file, domain)
+    graph = training.extract_story_graph(stories_file, domain)
 
     graph = graph.with_cycles_removed()
 
@@ -200,13 +196,11 @@ async def test_visualize_training_data_graph(
         ["data/test_stories/stories.md", "data/test_mixed_yaml_md_stories"],
     ],
 )
-async def test_load_multi_file_training_data(stories_resources: List, domain: Domain):
+def test_load_multi_file_training_data(stories_resources: List, domain: Domain):
     # the stories file in `data/test_multifile_stories` is the same as in
     # `data/test_stories/stories.md`, but split across multiple files
     featurizer = MaxHistoryTrackerFeaturizer(SingleStateFeaturizer(), max_history=2)
-    trackers = await training.load_data(
-        stories_resources[0], domain, augmentation_factor=0
-    )
+    trackers = training.load_data(stories_resources[0], domain, augmentation_factor=0)
     trackers = sorted(trackers, key=lambda t: t.sender_id)
 
     (tr_as_sts, tr_as_acts) = featurizer.training_states_and_labels(trackers, domain)
@@ -220,7 +214,7 @@ async def test_load_multi_file_training_data(stories_resources: List, domain: Do
     )
 
     featurizer_mul = MaxHistoryTrackerFeaturizer(SingleStateFeaturizer(), max_history=2)
-    trackers_mul = await training.load_data(
+    trackers_mul = training.load_data(
         stories_resources[1], domain, augmentation_factor=0
     )
     trackers_mul = sorted(trackers_mul, key=lambda t: t.sender_id)
@@ -264,13 +258,11 @@ async def test_load_multi_file_training_data(stories_resources: List, domain: Do
     assert np.all(label_ids == label_ids_mul)
 
 
-async def test_load_training_data_reader_not_found_throws(
-    tmp_path: Path, domain: Domain
-):
+def test_load_training_data_reader_not_found_throws(tmp_path: Path, domain: Domain):
     (tmp_path / "file").touch()
 
     with pytest.raises(Exception):
-        await training.load_data(str(tmp_path), domain)
+        training.load_data(str(tmp_path), domain)
 
 
 def test_session_started_event_is_not_serialised():
@@ -284,9 +276,9 @@ def test_session_started_event_is_not_serialised():
         "data/test_yaml_stories/story_slot_different_types.yml",
     ],
 )
-async def test_yaml_slot_different_types(stories_file: Text, domain: Domain):
+def test_yaml_slot_different_types(stories_file: Text, domain: Domain):
     with pytest.warns(None):
-        tracker = await training.load_data(
+        tracker = training.load_data(
             stories_file,
             domain,
             use_story_concatenation=False,
diff --git a/tests/shared/core/training_data/story_reader/test_markdown_story_reader.py b/tests/shared/core/training_data/story_reader/test_markdown_story_reader.py
index 2eae1a9b5e32..55a5fab6c828 100644
--- a/tests/shared/core/training_data/story_reader/test_markdown_story_reader.py
+++ b/tests/shared/core/training_data/story_reader/test_markdown_story_reader.py
@@ -27,19 +27,19 @@
 from rasa.shared.core.training_data.structures import RuleStep
 
 
-async def test_persist_and_read_test_story_graph(tmp_path: Path, domain: Domain):
-    graph = await training.extract_story_graph("data/test_stories/stories.md", domain)
+def test_persist_and_read_test_story_graph(tmp_path: Path, domain: Domain):
+    graph = training.extract_story_graph("data/test_stories/stories.md", domain)
     out_path = tmp_path / "persisted_story.md"
     rasa.shared.utils.io.write_text_file(graph.as_story_string(), str(out_path))
 
-    recovered_trackers = await training.load_data(
+    recovered_trackers = training.load_data(
         str(out_path),
         domain,
         use_story_concatenation=False,
         tracker_limit=1000,
         remove_duplicates=False,
     )
-    existing_trackers = await training.load_data(
+    existing_trackers = training.load_data(
         "data/test_stories/stories.md",
         domain,
         use_story_concatenation=False,
@@ -56,19 +56,19 @@ async def test_persist_and_read_test_story_graph(tmp_path: Path, domain: Domain)
         existing_stories.discard(story_str)
 
 
-async def test_persist_and_read_test_story(tmp_path: Path, domain: Domain):
-    graph = await training.extract_story_graph("data/test_stories/stories.md", domain)
+def test_persist_and_read_test_story(tmp_path: Path, domain: Domain):
+    graph = training.extract_story_graph("data/test_stories/stories.md", domain)
     out_path = tmp_path / "persisted_story.md"
     rasa.shared.utils.io.write_text_file(graph.as_story_string(), out_path, append=True)
 
-    recovered_trackers = await training.load_data(
+    recovered_trackers = training.load_data(
         str(out_path),
         domain,
         use_story_concatenation=False,
         tracker_limit=1000,
         remove_duplicates=False,
     )
-    existing_trackers = await training.load_data(
+    existing_trackers = training.load_data(
         "data/test_stories/stories.md",
         domain,
         use_story_concatenation=False,
@@ -252,8 +252,8 @@ async def test_read_stories_with_multiline_comments(tmpdir, domain: Domain):
     assert len(story_steps[3].events) == 2
 
 
-async def test_read_stories_with_rules(domain: Domain):
-    story_steps = await loading.load_data_from_files(
+def test_read_stories_with_rules(domain: Domain):
+    story_steps = loading.load_data_from_files(
         ["data/test_stories/stories_with_rules.md"], domain
     )
 
@@ -273,8 +273,8 @@ async def test_read_stories_with_rules(domain: Domain):
     assert story_steps[4].block_name == "ML story 2"
 
 
-async def test_read_rules_without_stories(domain: Domain):
-    story_steps = await loading.load_data_from_files(
+def test_read_rules_without_stories(domain: Domain):
+    story_steps = loading.load_data_from_files(
         ["data/test_stories/rules_without_stories.md"], domain
     )
 
diff --git a/tests/shared/core/training_data/story_reader/test_yaml_story_reader.py b/tests/shared/core/training_data/story_reader/test_yaml_story_reader.py
index 17c9d50f94be..a779e53d33c4 100644
--- a/tests/shared/core/training_data/story_reader/test_yaml_story_reader.py
+++ b/tests/shared/core/training_data/story_reader/test_yaml_story_reader.py
@@ -27,14 +27,14 @@
 
 
 @pytest.fixture()
-async def rule_steps_without_stories(domain: Domain) -> List[StoryStep]:
+def rule_steps_without_stories(domain: Domain) -> List[StoryStep]:
     yaml_file = "data/test_yaml_stories/rules_without_stories.yml"
 
-    return await loading.load_data_from_files([yaml_file], domain)
+    return loading.load_data_from_files([yaml_file], domain)
 
 
-async def test_can_read_test_story_with_slots(domain: Domain):
-    trackers = await training.load_data(
+def test_can_read_test_story_with_slots(domain: Domain):
+    trackers = training.load_data(
         "data/test_yaml_stories/simple_story_with_only_end.yml",
         domain,
         use_story_concatenation=False,
@@ -138,8 +138,8 @@ async def test_default_slot_value_if_unfeaturized_slot():
     assert not warnings
 
 
-async def test_can_read_test_story_with_entities_slot_autofill(domain: Domain):
-    trackers = await training.load_data(
+def test_can_read_test_story_with_entities_slot_autofill(domain: Domain):
+    trackers = training.load_data(
         "data/test_yaml_stories/story_with_or_and_entities.yml",
         domain,
         use_story_concatenation=False,
@@ -175,8 +175,8 @@ async def test_can_read_test_story_with_entities_slot_autofill(domain: Domain):
     assert trackers[1].events[-1] == ActionExecuted("action_listen")
 
 
-async def test_can_read_test_story_with_entities_without_value(domain: Domain):
-    trackers = await training.load_data(
+def test_can_read_test_story_with_entities_without_value(domain: Domain):
+    trackers = training.load_data(
         "data/test_yaml_stories/story_with_or_and_entities_with_no_value.yml",
         domain,
         use_story_concatenation=False,
@@ -211,11 +211,11 @@ async def test_is_yaml_file(file: Text, is_yaml_file: bool):
     assert YAMLStoryReader.is_stories_file(file) == is_yaml_file
 
 
-async def test_yaml_intent_with_leading_slash_warning(domain: Domain):
+def test_yaml_intent_with_leading_slash_warning(domain: Domain):
     yaml_file = "data/test_wrong_yaml_stories/intent_with_leading_slash.yml"
 
     with pytest.warns(UserWarning) as record:
-        tracker = await training.load_data(
+        tracker = training.load_data(
             yaml_file,
             domain,
             use_story_concatenation=False,
@@ -229,10 +229,10 @@ async def test_yaml_intent_with_leading_slash_warning(domain: Domain):
     assert tracker[0].latest_message == UserUttered(intent={"name": "simple"})
 
 
-async def test_yaml_slot_without_value_is_parsed(domain: Domain):
+def test_yaml_slot_without_value_is_parsed(domain: Domain):
     yaml_file = "data/test_yaml_stories/story_with_slot_was_set.yml"
 
-    tracker = await training.load_data(
+    tracker = training.load_data(
         yaml_file,
         domain,
         use_story_concatenation=False,
@@ -243,11 +243,11 @@ async def test_yaml_slot_without_value_is_parsed(domain: Domain):
     assert tracker[0].events[-2] == SlotSet(key="name", value=DEFAULT_VALUE_TEXT_SLOTS)
 
 
-async def test_yaml_wrong_yaml_format_warning(domain: Domain):
+def test_yaml_wrong_yaml_format_warning(domain: Domain):
     yaml_file = "data/test_wrong_yaml_stories/wrong_yaml.yml"
 
     with pytest.raises(YamlSyntaxException):
-        _ = await training.load_data(
+        _ = training.load_data(
             yaml_file,
             domain,
             use_story_concatenation=False,
@@ -256,11 +256,11 @@ async def test_yaml_wrong_yaml_format_warning(domain: Domain):
         )
 
 
-async def test_read_rules_with_stories(domain: Domain):
+def test_read_rules_with_stories(domain: Domain):
 
     yaml_file = "data/test_yaml_stories/stories_and_rules.yml"
 
-    steps = await loading.load_data_from_files([yaml_file], domain)
+    steps = loading.load_data_from_files([yaml_file], domain)
 
     ml_steps = [s for s in steps if not isinstance(s, RuleStep)]
     rule_steps = [s for s in steps if isinstance(s, RuleStep)]
@@ -383,9 +383,9 @@ async def test_no_warning_if_intent_in_domain(domain: Domain):
     assert not len(record)
 
 
-async def test_parsing_of_e2e_stories(domain: Domain):
+def test_parsing_of_e2e_stories(domain: Domain):
     yaml_file = "data/test_yaml_stories/stories_hybrid_e2e.yml"
-    tracker = await training.load_data(
+    tracker = training.load_data(
         yaml_file,
         domain,
         use_story_concatenation=False,
diff --git a/tests/shared/core/training_data/test_graph.py b/tests/shared/core/training_data/test_graph.py
index d630edd8ea56..24b0d49b61a0 100644
--- a/tests/shared/core/training_data/test_graph.py
+++ b/tests/shared/core/training_data/test_graph.py
@@ -49,20 +49,18 @@ def test_is_empty():
     assert StoryGraph([]).is_empty()
 
 
-async def test_consistent_fingerprints():
+def test_consistent_fingerprints():
     stories_path = "data/test_yaml_stories/stories.yml"
     domain_path = "data/test_domains/default_with_slots.yml"
     domain = Domain.load(domain_path)
-    story_steps = await rasa.shared.core.training_data.loading.load_data_from_resource(
+    story_steps = rasa.shared.core.training_data.loading.load_data_from_resource(
         stories_path, domain
     )
     story_graph = StoryGraph(story_steps)
 
     # read again
-    story_steps_2 = await (
-        rasa.shared.core.training_data.loading.load_data_from_resource(
-            stories_path, domain
-        )
+    story_steps_2 = rasa.shared.core.training_data.loading.load_data_from_resource(
+        stories_path, domain
     )
     story_graph_2 = StoryGraph(story_steps_2)
 
@@ -72,11 +70,11 @@ async def test_consistent_fingerprints():
     assert fingerprint == fingerprint_2
 
 
-async def test_unique_checkpoint_names():
+def test_unique_checkpoint_names():
     stories_path = "data/test_yaml_stories/story_with_two_equal_or_statements.yml"
     domain_path = "data/test_domains/default_with_slots.yml"
     domain = Domain.load(domain_path)
-    story_steps = await rasa.shared.core.training_data.loading.load_data_from_resource(
+    story_steps = rasa.shared.core.training_data.loading.load_data_from_resource(
         stories_path, domain
     )
     start_checkpoint_names = {
diff --git a/tests/shared/core/training_data/test_visualization.py b/tests/shared/core/training_data/test_visualization.py
index 8c3a95f1bd85..d3125442494a 100644
--- a/tests/shared/core/training_data/test_visualization.py
+++ b/tests/shared/core/training_data/test_visualization.py
@@ -82,7 +82,7 @@ async def test_graph_persistence(domain: Domain, tmp_path: Path):
     from networkx.drawing import nx_pydot
     import rasa.shared.core.training_data.loading as core_loading
 
-    story_steps = await core_loading.load_data_from_resource(
+    story_steps = core_loading.load_data_from_resource(
         "data/test_yaml_stories/stories.yml", domain
     )
     out_file = str(tmp_path / "graph.html")
@@ -108,7 +108,7 @@ async def test_merge_nodes(domain: Domain, tmp_path: Path):
     from os.path import isfile
     import rasa.shared.core.training_data.loading as core_loading
 
-    story_steps = await core_loading.load_data_from_resource(
+    story_steps = core_loading.load_data_from_resource(
         "data/test_yaml_stories/stories.yml", domain
     )
     out_file = str(tmp_path / "graph.html")
diff --git a/tests/shared/importers/test_importer.py b/tests/shared/importers/test_importer.py
index 6c6d07cd1560..d184b69a5969 100644
--- a/tests/shared/importers/test_importer.py
+++ b/tests/shared/importers/test_importer.py
@@ -39,7 +39,7 @@ def default_importer(project: Text) -> TrainingDataImporter:
     )
 
 
-async def test_use_of_interface():
+def test_use_of_interface():
     importer = TrainingDataImporter()
 
     functions_to_test = [
@@ -50,10 +50,10 @@ async def test_use_of_interface():
     ]
     for f in functions_to_test:
         with pytest.raises(NotImplementedError):
-            await f()
+            f()
 
 
-async def test_combined_file_importer_with_single_importer(project: Text):
+def test_combined_file_importer_with_single_importer(project: Text):
     config_path = os.path.join(project, DEFAULT_CONFIG_PATH)
     domain_path = os.path.join(project, DEFAULT_DOMAIN_PATH)
     default_data_path = os.path.join(project, DEFAULT_DATA_PATH)
@@ -61,22 +61,22 @@ async def test_combined_file_importer_with_single_importer(project: Text):
     importer = RasaFileImporter(config_path, domain_path, [default_data_path])
     combined = CombinedDataImporter([importer])
 
-    assert await importer.get_config() == await combined.get_config()
-    actual_domain = await combined.get_domain()
-    expected_domain = await importer.get_domain()
+    assert importer.get_config() == combined.get_config()
+    actual_domain = combined.get_domain()
+    expected_domain = importer.get_domain()
     assert hash(actual_domain) == hash(expected_domain)
 
-    actual_training_data = await combined.get_nlu_data()
-    expected_training_data = await importer.get_nlu_data()
+    actual_training_data = combined.get_nlu_data()
+    expected_training_data = importer.get_nlu_data()
     assert hash(actual_training_data) == hash(expected_training_data)
 
-    expected_stories = await importer.get_stories()
-    actual_stories = await combined.get_stories()
+    expected_stories = importer.get_stories()
+    actual_stories = combined.get_stories()
 
     assert actual_stories.as_story_string() == expected_stories.as_story_string()
 
-    expected_tests = await importer.get_conversation_tests()
-    actual_tests = await combined.get_conversation_tests()
+    expected_tests = importer.get_conversation_tests()
+    actual_tests = combined.get_conversation_tests()
 
     assert actual_tests.as_story_string() == expected_tests.as_story_string()
 
@@ -138,7 +138,7 @@ def test_load_from_config(tmpdir: Path):
     assert isinstance(importer.importer._importer._importers[0], MultiProjectImporter)
 
 
-async def test_nlu_only(project: Text):
+def test_nlu_only(project: Text):
     config_path = os.path.join(project, DEFAULT_CONFIG_PATH)
     default_data_path = os.path.join(project, DEFAULT_DATA_PATH)
     actual = TrainingDataImporter.load_nlu_importer_from_config(
@@ -148,23 +148,23 @@ async def test_nlu_only(project: Text):
     assert isinstance(actual, NluDataImporter)
     assert isinstance(actual._importer, ResponsesSyncImporter)
 
-    stories = await actual.get_stories()
+    stories = actual.get_stories()
     assert stories.is_empty()
 
-    conversation_tests = await actual.get_stories()
+    conversation_tests = actual.get_stories()
     assert conversation_tests.is_empty()
 
-    domain = await actual.get_domain()
+    domain = actual.get_domain()
     assert domain.is_empty()
 
-    config = await actual.get_config()
+    config = actual.get_config()
     assert config
 
-    nlu_data = await actual.get_nlu_data()
+    nlu_data = actual.get_nlu_data()
     assert not nlu_data.is_empty()
 
 
-async def test_import_nlu_training_data_from_e2e_stories(
+def test_import_nlu_training_data_from_e2e_stories(
     default_importer: TrainingDataImporter,
 ):
     # The `E2EImporter` correctly wraps the underlying `CombinedDataImporter`
@@ -189,26 +189,24 @@ async def test_import_nlu_training_data_from_e2e_stories(
         ]
     )
 
-    async def mocked_stories(*_: Any, **__: Any) -> StoryGraph:
+    def mocked_stories(*_: Any, **__: Any) -> StoryGraph:
         return stories
 
     # Patch to return our test stories
     importer_without_e2e.get_stories = mocked_stories
 
     # The wrapping `E2EImporter` simply forwards these method calls
-    assert (await importer_without_e2e.get_stories()).fingerprint() == (
-        await default_importer.get_stories()
+    assert (importer_without_e2e.get_stories()).fingerprint() == (
+        default_importer.get_stories()
     ).fingerprint()
-    assert (await importer_without_e2e.get_config()) == (
-        await default_importer.get_config()
-    )
+    assert (importer_without_e2e.get_config()) == (default_importer.get_config())
 
     # Check additional NLU training data from stories was added
-    nlu_data = await default_importer.get_nlu_data()
+    nlu_data = default_importer.get_nlu_data()
 
     # The `E2EImporter` adds NLU training data based on our training stories
     assert len(nlu_data.training_examples) > len(
-        (await importer_without_e2e.get_nlu_data()).training_examples
+        importer_without_e2e.get_nlu_data().training_examples
     )
 
     # Check if the NLU training data was added correctly from the story training data
@@ -222,7 +220,7 @@ async def mocked_stories(*_: Any, **__: Any) -> StoryGraph:
     assert all(m in nlu_data.training_examples for m in expected_additional_messages)
 
 
-async def test_different_story_order_doesnt_change_nlu_training_data(
+def test_different_story_order_doesnt_change_nlu_training_data(
     default_importer: E2EImporter,
 ):
     stories = [
@@ -243,13 +241,13 @@ async def test_different_story_order_doesnt_change_nlu_training_data(
         ),
     ]
 
-    async def mocked_stories(*_: Any, **__: Any) -> StoryGraph:
+    def mocked_stories(*_: Any, **__: Any) -> StoryGraph:
         return StoryGraph(stories)
 
     # Patch to return our test stories
     default_importer.importer.get_stories = mocked_stories
 
-    training_data = await default_importer.get_nlu_data()
+    training_data = default_importer.get_nlu_data()
 
     # Pretend the order of  the stories changed. This should have no
     # effect on the NLU training data
@@ -258,25 +256,25 @@ async def mocked_stories(*_: Any, **__: Any) -> StoryGraph:
     # Make sure importer doesn't cache stories
     default_importer._cached_stories = None
 
-    training_data2 = await default_importer.get_nlu_data()
+    training_data2 = default_importer.get_nlu_data()
 
     assert hash(training_data) == hash(training_data2)
 
 
-async def test_import_nlu_training_data_with_default_actions(
+def test_import_nlu_training_data_with_default_actions(
     default_importer: TrainingDataImporter,
 ):
     assert isinstance(default_importer, E2EImporter)
     importer_without_e2e = default_importer.importer
 
     # Check additional NLU training data from domain was added
-    nlu_data = await default_importer.get_nlu_data()
+    nlu_data = default_importer.get_nlu_data()
 
     assert len(nlu_data.training_examples) > len(
-        (await importer_without_e2e.get_nlu_data()).training_examples
+        importer_without_e2e.get_nlu_data().training_examples
     )
 
-    extended_training_data = await default_importer.get_nlu_data()
+    extended_training_data = default_importer.get_nlu_data()
     assert all(
         Message(data={ACTION_NAME: action_name})
         in extended_training_data.training_examples
@@ -284,7 +282,7 @@ async def test_import_nlu_training_data_with_default_actions(
     )
 
 
-async def test_adding_e2e_actions_to_domain(default_importer: E2EImporter):
+def test_adding_e2e_actions_to_domain(default_importer: E2EImporter):
     additional_actions = ["Hi Joey.", "it's sunny outside."]
     stories = StoryGraph(
         [
@@ -311,13 +309,13 @@ async def test_adding_e2e_actions_to_domain(default_importer: E2EImporter):
         ]
     )
 
-    async def mocked_stories(*_: Any, **__: Any) -> StoryGraph:
+    def mocked_stories(*_: Any, **__: Any) -> StoryGraph:
         return stories
 
     # Patch to return our test stories
     default_importer.importer.get_stories = mocked_stories
 
-    domain = await default_importer.get_domain()
+    domain = default_importer.get_domain()
 
     assert all(
         action_name in domain.action_names_or_texts
@@ -325,7 +323,7 @@ async def mocked_stories(*_: Any, **__: Any) -> StoryGraph:
     )
 
 
-async def test_nlu_data_domain_sync_with_retrieval_intents(project: Text):
+def test_nlu_data_domain_sync_with_retrieval_intents(project: Text):
     config_path = os.path.join(project, DEFAULT_CONFIG_PATH)
     domain_path = "data/test_domains/default_retrieval_intents.yml"
     data_paths = [
@@ -336,8 +334,8 @@ async def test_nlu_data_domain_sync_with_retrieval_intents(project: Text):
         {}, config_path, domain_path, data_paths
     )
 
-    domain = await importer.get_domain()
-    nlu_data = await importer.get_nlu_data()
+    domain = importer.get_domain()
+    nlu_data = importer.get_nlu_data()
 
     assert domain.retrieval_intents == ["chitchat"]
     assert domain.intent_properties["chitchat"].get("is_retrieval_intent")
@@ -346,7 +344,7 @@ async def test_nlu_data_domain_sync_with_retrieval_intents(project: Text):
     assert "utter_chitchat" in domain.action_names_or_texts
 
 
-async def test_nlu_data_domain_sync_responses(project: Text):
+def test_nlu_data_domain_sync_responses(project: Text):
     config_path = os.path.join(project, DEFAULT_CONFIG_PATH)
     domain_path = "data/test_domains/default.yml"
     data_paths = ["data/test_responses/responses_utter_rasa.yml"]
@@ -356,7 +354,7 @@ async def test_nlu_data_domain_sync_responses(project: Text):
     )
 
     with pytest.warns(None):
-        domain = await importer.get_domain()
+        domain = importer.get_domain()
 
     # Responses were sync between "test_responses.yml" and the "domain.yml"
     assert "utter_rasa" in domain.responses.keys()
@@ -371,23 +369,23 @@ def test_importer_with_invalid_model_config(tmp_path: Path):
         TrainingDataImporter.load_from_config(str(config_file))
 
 
-async def test_importer_with_unicode_files():
+def test_importer_with_unicode_files():
     importer = TrainingDataImporter.load_from_dict(
         training_data_paths=["./data/test_nlu_no_responses/nlu_with_unicode.yml"]
     )
 
     # None of these should raise
-    nlu_data = await importer.get_nlu_data()
+    nlu_data = importer.get_nlu_data()
     assert not nlu_data.is_empty()
 
-    await importer.get_stories()
-    await importer.get_domain()
+    importer.get_stories()
+    importer.get_domain()
 
 
-async def test_read_conversation_tests(project: Text):
+def test_read_conversation_tests(project: Text):
     importer = TrainingDataImporter.load_from_dict(
         training_data_paths=[str(Path(project) / DEFAULT_CONVERSATION_TEST_PATH)]
     )
 
-    test_stories = await importer.get_conversation_tests()
+    test_stories = importer.get_conversation_tests()
     assert len(test_stories.story_steps) == 7
diff --git a/tests/shared/importers/test_multi_project.py b/tests/shared/importers/test_multi_project.py
index c74acf30ac6f..a067a667dda4 100644
--- a/tests/shared/importers/test_multi_project.py
+++ b/tests/shared/importers/test_multi_project.py
@@ -212,7 +212,7 @@ def test_not_importing_not_relevant_additional_files(tmp_path: Path):
     assert not selector.is_imported(str(not_relevant_file2))
 
 
-async def test_only_getting_e2e_conversation_tests_if_e2e_enabled(tmp_path: Path):
+def test_only_getting_e2e_conversation_tests_if_e2e_enabled(tmp_path: Path):
     from rasa.shared.core.training_data.structures import StoryGraph
     import rasa.shared.core.training_data.loading as core_loading
 
@@ -246,7 +246,7 @@ async def test_only_getting_e2e_conversation_tests_if_e2e_enabled(tmp_path: Path
 
     selector = MultiProjectImporter(config_path)
 
-    story_steps = await core_loading.load_data_from_resource(
+    story_steps = core_loading.load_data_from_resource(
         resource=str(story_test_file),
         domain=Domain.empty(),
         template_variables=None,
@@ -256,7 +256,7 @@ async def test_only_getting_e2e_conversation_tests_if_e2e_enabled(tmp_path: Path
 
     expected = StoryGraph(story_steps)
 
-    actual = await selector.get_conversation_tests()
+    actual = selector.get_conversation_tests()
 
     assert expected.as_story_string() == actual.as_story_string()
 
diff --git a/tests/shared/importers/test_rasa.py b/tests/shared/importers/test_rasa.py
index 17fb07b1e942..f99f45372af6 100644
--- a/tests/shared/importers/test_rasa.py
+++ b/tests/shared/importers/test_rasa.py
@@ -15,27 +15,27 @@
 from rasa.shared.importers.rasa import RasaFileImporter
 
 
-async def test_rasa_file_importer(project: Text):
+def test_rasa_file_importer(project: Text):
     config_path = os.path.join(project, DEFAULT_CONFIG_PATH)
     domain_path = os.path.join(project, DEFAULT_DOMAIN_PATH)
     default_data_path = os.path.join(project, DEFAULT_DATA_PATH)
 
     importer = RasaFileImporter(config_path, domain_path, [default_data_path])
 
-    domain = await importer.get_domain()
+    domain = importer.get_domain()
     assert len(domain.intents) == 7 + len(DEFAULT_INTENTS)
     assert domain.slots == [AnySlot(SESSION_START_METADATA_SLOT)]
     assert domain.entities == []
     assert len(domain.action_names_or_texts) == 18
     assert len(domain.responses) == 6
 
-    stories = await importer.get_stories()
+    stories = importer.get_stories()
     assert len(stories.story_steps) == 5
 
-    test_stories = await importer.get_conversation_tests()
+    test_stories = importer.get_conversation_tests()
     assert len(test_stories.story_steps) == 0
 
-    nlu_data = await importer.get_nlu_data("en")
+    nlu_data = importer.get_nlu_data("en")
     assert len(nlu_data.intents) == 7
     assert len(nlu_data.intent_examples) == 69
 
@@ -45,13 +45,13 @@ async def test_read_conversation_tests(project: Text):
         training_data_paths=[str(Path(project) / DEFAULT_CONVERSATION_TEST_PATH)]
     )
 
-    test_stories = await importer.get_conversation_tests()
+    test_stories = importer.get_conversation_tests()
     assert len(test_stories.story_steps) == 7
 
 
 async def test_rasa_file_importer_with_invalid_config():
     importer = RasaFileImporter(config_file="invalid path")
-    actual = await importer.get_config()
+    actual = importer.get_config()
 
     assert actual == {}
 
@@ -61,5 +61,5 @@ async def test_rasa_file_importer_with_invalid_domain(tmp_path: Path):
     config_file.write_text("")
     importer = TrainingDataImporter.load_from_dict({}, str(config_file), None, [])
 
-    actual = await importer.get_domain()
+    actual = importer.get_domain()
     assert actual.as_dict() == Domain.empty().as_dict()
diff --git a/tests/shared/nlu/training_data/test_training_data.py b/tests/shared/nlu/training_data/test_training_data.py
index 97423d81010c..dbc7af659b9c 100644
--- a/tests/shared/nlu/training_data/test_training_data.py
+++ b/tests/shared/nlu/training_data/test_training_data.py
@@ -1,4 +1,3 @@
-import asyncio
 from pathlib import Path
 from typing import Text, List, Dict, Any
 from unittest.mock import Mock
@@ -323,7 +322,7 @@ def test_number_of_examples_per_intent():
     assert training_data.number_of_examples_per_intent["ask_weather"] == 2
 
 
-async def test_number_of_examples_per_intent_with_yaml(tmp_path: Path):
+def test_number_of_examples_per_intent_with_yaml(tmp_path: Path):
     domain_path = tmp_path / "domain.yml"
     domain_path.write_text(Domain.empty().as_yaml())
 
@@ -341,7 +340,7 @@ async def test_number_of_examples_per_intent_with_yaml(tmp_path: Path):
         ],
     )
 
-    training_data = await importer.get_nlu_data()
+    training_data = importer.get_nlu_data()
     assert training_data.intents == {"greet", "ask_weather"}
     assert training_data.number_of_examples_per_intent["greet"] == 2
     assert training_data.number_of_examples_per_intent["ask_weather"] == 3
@@ -721,7 +720,7 @@ def test_custom_attributes(tmp_path):
     assert example.get("sentiment") == 0.8
 
 
-async def test_without_additional_e2e_examples(tmp_path: Path):
+def test_without_additional_e2e_examples(tmp_path: Path):
     domain_path = tmp_path / "domain.yml"
     domain_path.write_text(Domain.empty().as_yaml())
 
@@ -744,11 +743,11 @@ async def test_without_additional_e2e_examples(tmp_path: Path):
     )
 
     # Patch to return our test stories
-    existing.get_stories = asyncio.coroutine(lambda *args: stories)
+    existing.get_stories = lambda *args: stories
 
     importer = E2EImporter(existing)
 
-    training_data = await importer.get_nlu_data()
+    training_data = importer.get_nlu_data()
 
     assert training_data.training_examples
     assert not training_data.is_empty()
diff --git a/tests/test_model.py b/tests/test_model.py
index 3f0f191412e4..2994ee29d3b0 100644
--- a/tests/test_model.py
+++ b/tests/test_model.py
@@ -1,4 +1,3 @@
-import asyncio
 import os
 import tempfile
 import time
@@ -51,7 +50,7 @@
     FingerprintComparisonResult,
 )
 from rasa.exceptions import ModelNotFound
-from rasa.model_training import train_core_async
+from rasa.model_training import train_core
 
 
 def test_get_latest_model(tmp_path: Path):
@@ -232,26 +231,26 @@ def _project_files(
         str((Path(".") / "data/test_domains/default_with_mapping.yml").absolute()),
     ],
 )
-async def test_create_fingerprint_from_paths(project: Text, domain_path: Text):
+def test_create_fingerprint_from_paths(project: Text, domain_path: Text):
     project_files = _project_files(project, domain=domain_path)
 
-    assert await model_fingerprint(project_files)
+    assert model_fingerprint(project_files)
 
 
-async def test_fingerprinting_changed_response_text(project: Text):
+def test_fingerprinting_changed_response_text(project: Text):
     importer = _project_files(project)
 
-    old_fingerprint = await model_fingerprint(importer)
-    old_domain = await importer.get_domain()
+    old_fingerprint = model_fingerprint(importer)
+    old_domain = importer.get_domain()
 
     # Change NLG content but keep actions the same
     domain_with_changed_nlg = old_domain.as_dict()
     domain_with_changed_nlg[KEY_RESPONSES]["utter_greet"].append({"text": "hi"})
     domain_with_changed_nlg = Domain.from_dict(domain_with_changed_nlg)
 
-    importer.get_domain = asyncio.coroutine(lambda: domain_with_changed_nlg)
+    importer.get_domain = lambda: domain_with_changed_nlg
 
-    new_fingerprint = await model_fingerprint(importer)
+    new_fingerprint = model_fingerprint(importer)
 
     assert (
         old_fingerprint[FINGERPRINT_DOMAIN_WITHOUT_NLG_KEY]
@@ -260,7 +259,7 @@ async def test_fingerprinting_changed_response_text(project: Text):
     assert old_fingerprint[FINGERPRINT_NLG_KEY] != new_fingerprint[FINGERPRINT_NLG_KEY]
 
 
-async def test_fingerprinting_changing_config_epochs(project: Text, tmp_path):
+def test_fingerprinting_changing_config_epochs(project: Text, tmp_path):
     config1 = {
         "language": "en",
         "pipeline": [
@@ -293,7 +292,7 @@ async def test_fingerprinting_changing_config_epochs(project: Text, tmp_path):
     config1_path = tmp_path / "config1.yml"
     rasa.shared.utils.io.write_yaml(config1, config1_path, True)
     importer = TrainingDataImporter.load_from_config(str(config1_path))
-    old_fingerprint = await model_fingerprint(importer)
+    old_fingerprint = model_fingerprint(importer)
 
     config2 = {
         "language": "en",
@@ -327,7 +326,7 @@ async def test_fingerprinting_changing_config_epochs(project: Text, tmp_path):
     config2_path = tmp_path / "config2.yml"
     rasa.shared.utils.io.write_yaml(config2, config2_path, True)
     importer = TrainingDataImporter.load_from_config(str(config2_path))
-    new_fingerprint = await model_fingerprint(importer)
+    new_fingerprint = model_fingerprint(importer)
 
     assert (
         old_fingerprint[FINGERPRINT_CONFIG_WITHOUT_EPOCHS_KEY]
@@ -355,7 +354,7 @@ async def test_fingerprinting_changing_config_epochs(project: Text, tmp_path):
     config3_path = tmp_path / "config3.yml"
     rasa.shared.utils.io.write_yaml(config3, config3_path, True)
     importer = TrainingDataImporter.load_from_config(str(config3_path))
-    new_fingerprint = await model_fingerprint(importer)
+    new_fingerprint = model_fingerprint(importer)
 
     assert (
         old_fingerprint[FINGERPRINT_CONFIG_WITHOUT_EPOCHS_KEY]
@@ -364,7 +363,7 @@ async def test_fingerprinting_changing_config_epochs(project: Text, tmp_path):
 
 
 @pytest.mark.parametrize("empty_key", ["pipeline", "policies"])
-async def test_fingerprinting_config_epochs_empty_pipeline_or_policies(
+def test_fingerprinting_config_epochs_empty_pipeline_or_policies(
     project: Text, tmp_path: Path, empty_key: Text,
 ):
     config = {
@@ -378,19 +377,19 @@ async def test_fingerprinting_config_epochs_empty_pipeline_or_policies(
     model._get_fingerprint_of_config_without_epochs(config)
 
 
-async def test_fingerprinting_additional_action(project: Text):
+def test_fingerprinting_additional_action(project: Text):
     importer = _project_files(project)
 
-    old_fingerprint = await model_fingerprint(importer)
-    old_domain = await importer.get_domain()
+    old_fingerprint = model_fingerprint(importer)
+    old_domain = importer.get_domain()
 
     domain_with_new_action = old_domain.as_dict()
     domain_with_new_action[KEY_RESPONSES]["utter_new"] = [{"text": "hi"}]
     domain_with_new_action = Domain.from_dict(domain_with_new_action)
 
-    importer.get_domain = asyncio.coroutine(lambda: domain_with_new_action)
+    importer.get_domain = lambda: domain_with_new_action
 
-    new_fingerprint = await model_fingerprint(importer)
+    new_fingerprint = model_fingerprint(importer)
 
     assert (
         old_fingerprint[FINGERPRINT_DOMAIN_WITHOUT_NLG_KEY]
@@ -400,14 +399,14 @@ async def test_fingerprinting_additional_action(project: Text):
 
 
 @pytest.mark.parametrize("use_fingerprint", [True, False])
-async def test_rasa_packaging(
+def test_rasa_packaging(
     trained_rasa_model: Text, project: Text, use_fingerprint: bool, tmp_path: Path
 ):
     unpacked_model_path = get_model(trained_rasa_model)
 
     os.remove(os.path.join(unpacked_model_path, FINGERPRINT_FILE_PATH))
     if use_fingerprint:
-        fingerprint = await model_fingerprint(_project_files(project))
+        fingerprint = model_fingerprint(_project_files(project))
     else:
         fingerprint = None
 
@@ -492,7 +491,7 @@ def test_should_retrain(
     assert retrain.should_retrain_nlu() == fingerprint["retrain_nlu"]
 
 
-async def test_should_not_retrain_core(
+def test_should_not_retrain_core(
     domain_path: Text, tmp_path: Path, stack_config_path: Text
 ):
     # Don't use `stories_path` as checkpoints currently break fingerprinting
@@ -506,7 +505,7 @@ async def test_should_not_retrain_core(
   - action: utter_greet
     """
     )
-    trained_model = await train_core_async(
+    trained_model = train_core(
         domain_path, stack_config_path, str(story_file), str(tmp_path)
     )
 
@@ -514,7 +513,7 @@ async def test_should_not_retrain_core(
         stack_config_path, domain_path, training_data_paths=[str(story_file)]
     )
 
-    new_fingerprint = await model.model_fingerprint(importer)
+    new_fingerprint = model.model_fingerprint(importer)
 
     result = model.should_retrain(new_fingerprint, trained_model, tmp_path)
 
@@ -575,26 +574,26 @@ def test_fingerprint_comparison_result(
     assert comparison_result.should_retrain_nlu() == retrain_nlu
 
 
-async def test_update_with_new_domain(trained_rasa_model: Text, tmpdir: Path):
+def test_update_with_new_domain(trained_rasa_model: Text, tmpdir: Path):
     _ = model.unpack_model(trained_rasa_model, tmpdir)
 
     new_domain = Domain.empty()
 
     mocked_importer = Mock()
 
-    async def get_domain() -> Domain:
+    def get_domain() -> Domain:
         return new_domain
 
     mocked_importer.get_domain = get_domain
 
-    await model.update_model_with_new_domain(mocked_importer, tmpdir)
+    model.update_model_with_new_domain(mocked_importer, tmpdir)
 
     actual = Domain.load(tmpdir / DEFAULT_CORE_SUBDIRECTORY_NAME / DEFAULT_DOMAIN_PATH)
 
     assert actual.is_empty()
 
 
-async def test_update_with_new_domain_preserves_domain(
+def test_update_with_new_domain_preserves_domain(
     tmpdir: Path, domain_with_categorical_slot_path
 ):
     domain = Domain.load(domain_with_categorical_slot_path)
@@ -607,12 +606,12 @@ async def test_update_with_new_domain_preserves_domain(
 
     mocked_importer = Mock()
 
-    async def get_domain() -> Domain:
+    def get_domain() -> Domain:
         return Domain.load(domain_with_categorical_slot_path)
 
     mocked_importer.get_domain = get_domain
 
-    await model.update_model_with_new_domain(mocked_importer, tmpdir)
+    model.update_model_with_new_domain(mocked_importer, tmpdir)
 
     new_persisted = Domain.load(core_directory / DEFAULT_DOMAIN_PATH)
     new_persisted.compare_with_specification(str(core_directory))
@@ -622,7 +621,7 @@ async def get_domain() -> Domain:
     "min_compatible_version, old_model_version, can_tune",
     [("2.1.0", "2.1.0", True), ("2.0.0", "2.1.0", True), ("2.1.0", "2.0.0", False),],
 )
-async def test_can_finetune_min_version(
+def test_can_finetune_min_version(
     project: Text,
     monkeypatch: MonkeyPatch,
     old_model_version: Text,
@@ -635,8 +634,8 @@ async def test_can_finetune_min_version(
         rasa.constants, "MINIMUM_COMPATIBLE_VERSION", min_compatible_version
     )
     monkeypatch.setattr(rasa, "__version__", old_model_version)
-    old_fingerprint = await model_fingerprint(importer)
-    new_fingerprint = await model_fingerprint(importer)
+    old_fingerprint = model_fingerprint(importer)
+    new_fingerprint = model_fingerprint(importer)
 
     with mock.patch("rasa.model.MINIMUM_COMPATIBLE_VERSION", min_compatible_version):
         assert can_finetune(old_fingerprint, new_fingerprint) == can_tune
diff --git a/tests/test_model_testing.py b/tests/test_model_testing.py
index 5c5fbf78bb84..275dfc73e059 100644
--- a/tests/test_model_testing.py
+++ b/tests/test_model_testing.py
@@ -362,7 +362,7 @@ def test_evaluation_store_serialise(entity_predictions, entity_targets):
             i_target += 1
 
 
-async def test_test_does_not_use_rules(tmp_path: Path, default_agent: Agent):
+def test_test_does_not_use_rules(tmp_path: Path, default_agent: Agent):
     from rasa.core.test import _create_data_generator
 
     test_file = tmp_path / "test.yml"
@@ -383,7 +383,7 @@ async def test_test_does_not_use_rules(tmp_path: Path, default_agent: Agent):
 
     test_file.write_text(tests)
 
-    generator = await _create_data_generator(str(test_file), default_agent)
+    generator = _create_data_generator(str(test_file), default_agent)
     test_trackers = generator.generate_story_trackers()
     assert len(test_trackers) == 1
     assert test_trackers[0].sender_id == test_name
diff --git a/tests/test_model_training.py b/tests/test_model_training.py
index a6f3f362e473..03318d501c36 100644
--- a/tests/test_model_training.py
+++ b/tests/test_model_training.py
@@ -368,7 +368,9 @@ async def mock_async_func(*args: Any, **kwargs: Any) -> None:
 
 
 def mock_core_training(monkeypatch: MonkeyPatch) -> Mock:
-    return mock_async(monkeypatch, rasa.core.train, rasa.core.train.train.__name__)
+    mock = Mock()
+    monkeypatch.setattr(rasa.core.train, rasa.core.train.train.__name__, mock)
+    return mock
 
 
 def mock_nlu_training(monkeypatch: MonkeyPatch) -> Mock:
diff --git a/tests/test_telemetry.py b/tests/test_telemetry.py
index f88500b51ae6..813c095812f6 100644
--- a/tests/test_telemetry.py
+++ b/tests/test_telemetry.py
@@ -51,7 +51,8 @@ async def test_events_schema(
     # Generate all known backend telemetry events, and then use events.json to
     # validate their schema.
     training_data = TrainingDataImporter.load_from_config(config_path)
-    async with telemetry.track_model_training(training_data, "rasa"):
+
+    with telemetry.track_model_training(training_data, "rasa"):
         await asyncio.sleep(1)
 
     telemetry.track_telemetry_disabled()
diff --git a/tests/test_validator.py b/tests/test_validator.py
index 3e74867d8297..91d2ba430c47 100644
--- a/tests/test_validator.py
+++ b/tests/test_validator.py
@@ -8,7 +8,7 @@
 from pathlib import Path
 
 
-async def test_verify_nlu_with_e2e_story(tmp_path: Path, nlu_data_path: Path):
+def test_verify_nlu_with_e2e_story(tmp_path: Path, nlu_data_path: Path):
     print()
     story_file_name = tmp_path / "stories.yml"
     with open(story_file_name, "w") as file:
@@ -32,29 +32,29 @@ async def test_verify_nlu_with_e2e_story(tmp_path: Path, nlu_data_path: Path):
         training_data_paths=[story_file_name, nlu_data_path],
         training_type=TrainingType.NLU,
     )
-    validator = await Validator.from_importer(importer)
+    validator = Validator.from_importer(importer)
     assert validator.verify_nlu()
 
 
-async def test_verify_intents_does_not_fail_on_valid_data(nlu_data_path: Text):
+def test_verify_intents_does_not_fail_on_valid_data(nlu_data_path: Text):
     importer = RasaFileImporter(
         domain_path="data/test_moodbot/domain.yml", training_data_paths=[nlu_data_path],
     )
-    validator = await Validator.from_importer(importer)
+    validator = Validator.from_importer(importer)
     assert validator.verify_intents()
 
 
-async def test_verify_intents_does_fail_on_invalid_data(nlu_data_path: Text):
+def test_verify_intents_does_fail_on_invalid_data(nlu_data_path: Text):
     # domain and nlu data are from different domain and should produce warnings
     importer = RasaFileImporter(
         domain_path="data/test_domains/default.yml",
         training_data_paths=[nlu_data_path],
     )
-    validator = await Validator.from_importer(importer)
+    validator = Validator.from_importer(importer)
     assert not validator.verify_intents()
 
 
-async def test_verify_valid_responses():
+def test_verify_valid_responses():
     importer = RasaFileImporter(
         domain_path="data/test_domains/selectors.yml",
         training_data_paths=[
@@ -62,11 +62,11 @@ async def test_verify_valid_responses():
             "data/test_selectors/stories.yml",
         ],
     )
-    validator = await Validator.from_importer(importer)
+    validator = Validator.from_importer(importer)
     assert validator.verify_utterances_in_stories()
 
 
-async def test_verify_valid_responses_in_rules(nlu_data_path: Text):
+def test_verify_valid_responses_in_rules(nlu_data_path: Text):
     importer = RasaFileImporter(
         domain_path="data/test_domains/default.yml",
         training_data_paths=[
@@ -74,28 +74,28 @@ async def test_verify_valid_responses_in_rules(nlu_data_path: Text):
             "data/test_yaml_stories/rules_without_stories_and_wrong_names.yml",
         ],
     )
-    validator = await Validator.from_importer(importer)
+    validator = Validator.from_importer(importer)
     assert not validator.verify_utterances_in_stories()
 
 
-async def test_verify_story_structure(stories_path: Text):
+def test_verify_story_structure(stories_path: Text):
     importer = RasaFileImporter(
         domain_path="data/test_domains/default.yml", training_data_paths=[stories_path],
     )
-    validator = await Validator.from_importer(importer)
+    validator = Validator.from_importer(importer)
     assert validator.verify_story_structure(ignore_warnings=False)
 
 
-async def test_verify_bad_story_structure():
+def test_verify_bad_story_structure():
     importer = RasaFileImporter(
         domain_path="data/test_domains/default.yml",
         training_data_paths=["data/test_yaml_stories/stories_conflicting_2.yml"],
     )
-    validator = await Validator.from_importer(importer)
+    validator = Validator.from_importer(importer)
     assert not validator.verify_story_structure(ignore_warnings=False)
 
 
-async def test_verify_bad_e2e_story_structure_when_text_identical(tmp_path: Path):
+def test_verify_bad_e2e_story_structure_when_text_identical(tmp_path: Path):
     story_file_name = tmp_path / "stories.yml"
     story_file_name.write_text(
         """
@@ -120,11 +120,11 @@ async def test_verify_bad_e2e_story_structure_when_text_identical(tmp_path: Path
         training_data_paths=[story_file_name],
         training_type=TrainingType.NLU,
     )
-    validator = await Validator.from_importer(importer)
+    validator = Validator.from_importer(importer)
     assert not validator.verify_story_structure(ignore_warnings=False)
 
 
-async def test_verify_bad_e2e_story_structure_when_text_differs_by_whitespace(
+def test_verify_bad_e2e_story_structure_when_text_differs_by_whitespace(
     tmp_path: Path,
 ):
     story_file_name = tmp_path / "stories.yml"
@@ -150,11 +150,11 @@ async def test_verify_bad_e2e_story_structure_when_text_differs_by_whitespace(
         training_data_paths=[story_file_name],
         training_type=TrainingType.NLU,
     )
-    validator = await Validator.from_importer(importer)
+    validator = Validator.from_importer(importer)
     assert not validator.verify_story_structure(ignore_warnings=False)
 
 
-async def test_verify_correct_e2e_story_structure(tmp_path: Path):
+def test_verify_correct_e2e_story_structure(tmp_path: Path):
     story_file_name = tmp_path / "stories.yml"
     with open(story_file_name, "w") as file:
         file.write(
@@ -183,11 +183,11 @@ async def test_verify_correct_e2e_story_structure(tmp_path: Path):
         training_data_paths=[story_file_name],
         training_type=TrainingType.NLU,
     )
-    validator = await Validator.from_importer(importer)
+    validator = Validator.from_importer(importer)
     assert validator.verify_story_structure(ignore_warnings=False)
 
 
-async def test_verify_correct_e2e_story_structure_with_intents(tmp_path: Path):
+def test_verify_correct_e2e_story_structure_with_intents(tmp_path: Path):
     story_file_name = tmp_path / "stories.yml"
     with open(story_file_name, "w") as file:
         file.write(
@@ -209,49 +209,47 @@ async def test_verify_correct_e2e_story_structure_with_intents(tmp_path: Path):
         training_data_paths=[story_file_name],
         training_type=TrainingType.NLU,
     )
-    validator = await Validator.from_importer(importer)
+    validator = Validator.from_importer(importer)
     assert validator.verify_story_structure(ignore_warnings=False)
 
 
-async def test_verify_story_structure_ignores_rules():
+def test_verify_story_structure_ignores_rules():
     importer = RasaFileImporter(
         domain_path="data/test_domains/default.yml",
         training_data_paths=[
             "data/test_yaml_stories/stories_with_rules_conflicting.yml"
         ],
     )
-    validator = await Validator.from_importer(importer)
+    validator = Validator.from_importer(importer)
     assert validator.verify_story_structure(ignore_warnings=False)
 
 
-async def test_verify_bad_story_structure_ignore_warnings():
+def test_verify_bad_story_structure_ignore_warnings():
     importer = RasaFileImporter(
         domain_path="data/test_domains/default.yml",
         training_data_paths=["data/test_yaml_stories/stories_conflicting_2.yml"],
     )
-    validator = await Validator.from_importer(importer)
+    validator = Validator.from_importer(importer)
     assert validator.verify_story_structure(ignore_warnings=True)
 
 
-async def test_verify_there_is_example_repetition_in_intents(nlu_data_path: Text):
+def test_verify_there_is_example_repetition_in_intents(nlu_data_path: Text):
     # moodbot nlu data already has duplicated example 'good afternoon'
     # for intents greet and goodbye
     importer = RasaFileImporter(
         domain_path="data/test_moodbot/domain.yml", training_data_paths=[nlu_data_path],
     )
-    validator = await Validator.from_importer(importer)
+    validator = Validator.from_importer(importer)
     assert not validator.verify_example_repetition_in_intents(False)
 
 
-async def test_verify_logging_message_for_repetition_in_intents(
-    caplog, nlu_data_path: Text
-):
+def test_verify_logging_message_for_repetition_in_intents(caplog, nlu_data_path: Text):
     # moodbot nlu data already has duplicated example 'good afternoon'
     # for intents greet and goodbye
     importer = RasaFileImporter(
         domain_path="data/test_moodbot/domain.yml", training_data_paths=[nlu_data_path],
     )
-    validator = await Validator.from_importer(importer)
+    validator = Validator.from_importer(importer)
     caplog.clear()  # clear caplog to avoid counting earlier debug messages
     with pytest.warns(UserWarning) as record:
         validator.verify_example_repetition_in_intents(False)
@@ -259,12 +257,12 @@ async def test_verify_logging_message_for_repetition_in_intents(
     assert "You should fix that conflict " in record[0].message.args[0]
 
 
-async def test_early_exit_on_invalid_domain():
+def test_early_exit_on_invalid_domain():
     domain_path = "data/test_domains/duplicate_intents.yml"
 
     importer = RasaFileImporter(domain_path=domain_path)
     with pytest.warns(UserWarning) as record:
-        validator = await Validator.from_importer(importer)
+        validator = Validator.from_importer(importer)
     validator.verify_domain_validity()
 
     # two for non-unique domains
@@ -278,18 +276,16 @@ async def test_early_exit_on_invalid_domain():
     assert record[0].message.args[0] == record[1].message.args[0]
 
 
-async def test_verify_there_is_not_example_repetition_in_intents():
+def test_verify_there_is_not_example_repetition_in_intents():
     importer = RasaFileImporter(
         domain_path="data/test_moodbot/domain.yml",
         training_data_paths=["examples/knowledgebasebot/data/nlu.md"],
     )
-    validator = await Validator.from_importer(importer)
+    validator = Validator.from_importer(importer)
     assert validator.verify_example_repetition_in_intents(False)
 
 
-async def test_verify_actions_in_stories_not_in_domain(
-    tmp_path: Path, domain_path: Text
-):
+def test_verify_actions_in_stories_not_in_domain(tmp_path: Path, domain_path: Text):
     story_file_name = tmp_path / "stories.yml"
     story_file_name.write_text(
         """
@@ -305,7 +301,7 @@ async def test_verify_actions_in_stories_not_in_domain(
     importer = RasaFileImporter(
         domain_path=domain_path, training_data_paths=[story_file_name],
     )
-    validator = await Validator.from_importer(importer)
+    validator = Validator.from_importer(importer)
     with pytest.warns(UserWarning) as warning:
         validity = validator.verify_actions_in_stories_rules()
         assert validity is False
@@ -316,7 +312,7 @@ async def test_verify_actions_in_stories_not_in_domain(
     )
 
 
-async def test_verify_actions_in_rules_not_in_domain(tmp_path: Path, domain_path: Text):
+def test_verify_actions_in_rules_not_in_domain(tmp_path: Path, domain_path: Text):
     rules_file_name = tmp_path / "rules.yml"
     rules_file_name.write_text(
         """
@@ -331,7 +327,7 @@ async def test_verify_actions_in_rules_not_in_domain(tmp_path: Path, domain_path
     importer = RasaFileImporter(
         domain_path=domain_path, training_data_paths=[rules_file_name],
     )
-    validator = await Validator.from_importer(importer)
+    validator = Validator.from_importer(importer)
     with pytest.warns(UserWarning) as warning:
         validity = validator.verify_actions_in_stories_rules()
         assert validity is False
@@ -342,7 +338,7 @@ async def test_verify_actions_in_rules_not_in_domain(tmp_path: Path, domain_path
     )
 
 
-async def test_verify_form_slots_invalid_domain(tmp_path: Path):
+def test_verify_form_slots_invalid_domain(tmp_path: Path):
     domain = tmp_path / "domain.yml"
     domain.write_text(
         """
@@ -362,7 +358,7 @@ async def test_verify_form_slots_invalid_domain(tmp_path: Path):
         """
     )
     importer = RasaFileImporter(domain_path=domain)
-    validator = await Validator.from_importer(importer)
+    validator = Validator.from_importer(importer)
     with pytest.warns(UserWarning) as w:
         validity = validator.verify_form_slots()
         assert validity is False
@@ -374,7 +370,7 @@ async def test_verify_form_slots_invalid_domain(tmp_path: Path):
     )
 
 
-async def test_response_selector_responses_in_domain_no_errors():
+def test_response_selector_responses_in_domain_no_errors():
     importer = RasaFileImporter(
         config_file="data/test_config/config_defaults.yml",
         domain_path="data/test_domains/response_selector_responses_in_domain.yml",
@@ -383,22 +379,22 @@ async def test_response_selector_responses_in_domain_no_errors():
         ],
         training_type=TrainingType.CORE,
     )
-    validator = await Validator.from_importer(importer)
+    validator = Validator.from_importer(importer)
     assert validator.verify_utterances_in_stories(ignore_warnings=True)
 
 
-async def test_invalid_domain_mapping_policy():
+def test_invalid_domain_mapping_policy():
     importer = RasaFileImporter(
         domain_path="data/test_domains/default_with_mapping.yml"
     )
-    validator = await Validator.from_importer(importer)
+    validator = Validator.from_importer(importer)
     assert validator.verify_domain_validity() is False
 
 
 @pytest.mark.parametrize(
     ("file_name", "data_type"), [("stories", "story"), ("rules", "rule")]
 )
-async def test_valid_stories_rules_actions_in_domain(
+def test_valid_stories_rules_actions_in_domain(
     file_name: Text, data_type: Text, tmp_path: Path
 ):
     domain = tmp_path / "domain.yml"
@@ -423,14 +419,14 @@ async def test_valid_stories_rules_actions_in_domain(
         """
     )
     importer = RasaFileImporter(domain_path=domain, training_data_paths=[file_name],)
-    validator = await Validator.from_importer(importer)
+    validator = Validator.from_importer(importer)
     assert validator.verify_actions_in_stories_rules()
 
 
 @pytest.mark.parametrize(
     ("file_name", "data_type"), [("stories", "story"), ("rules", "rule")]
 )
-async def test_valid_stories_rules_default_actions(
+def test_valid_stories_rules_default_actions(
     file_name: Text, data_type: Text, tmp_path: Path
 ):
     domain = tmp_path / "domain.yml"
@@ -453,11 +449,11 @@ async def test_valid_stories_rules_default_actions(
             """
     )
     importer = RasaFileImporter(domain_path=domain, training_data_paths=[file_name],)
-    validator = await Validator.from_importer(importer)
+    validator = Validator.from_importer(importer)
     assert validator.verify_actions_in_stories_rules()
 
 
-async def test_valid_form_slots_in_domain(tmp_path: Path):
+def test_valid_form_slots_in_domain(tmp_path: Path):
     domain = tmp_path / "domain.yml"
     domain.write_text(
         """
@@ -477,5 +473,5 @@ async def test_valid_form_slots_in_domain(tmp_path: Path):
         """
     )
     importer = RasaFileImporter(domain_path=domain)
-    validator = await Validator.from_importer(importer)
+    validator = Validator.from_importer(importer)
     assert validator.verify_form_slots()


Code review comments:
diff_hunk: @@ -8,7 +8,7 @@
 from pathlib import Path
 
 
-async def test_verify_nlu_with_e2e_story(tmp_path: Path, nlu_data_path: Path):
+def test_verify_nlu_with_e2e_story(tmp_path: Path, nlu_data_path: Path):
     print()
path: tests/test_validator.py
text: @user1:
```suggestion
```

diff_hunk: @@ -45,13 +45,13 @@ async def test_read_conversation_tests(project: Text):
         training_data_paths=[str(Path(project) / DEFAULT_CONVERSATION_TEST_PATH)]
     )
 
-    test_stories = await importer.get_conversation_tests()
+    test_stories = importer.get_conversation_tests()
     assert len(test_stories.story_steps) == 7
 
 
 async def test_rasa_file_importer_with_invalid_config():
path: tests/shared/importers/test_rasa.py
text: @user1:
as well as `test_read_conversation_tests` and `test_rasa_file_importer_with_invalid_domain`
```suggestion
def test_rasa_file_importer_with_invalid_config():
```

diff_hunk: @@ -698,10 +697,10 @@ async def track_model_training(
         yield  # runs the training
         return  # closes the async context
path: rasa/telemetry.py
text: @user1:
```suggestion
        return
```