cognite-toolkit 0.6.39__py3-none-any.whl → 0.7.30__py3-none-any.whl

cognite_toolkit/_cdf_tk/apps/_modules_app.py

@@ -51,6 +51,22 @@ class ModulesApp(typer.Typer):
                 help="Clean target directory if it exists",
             ),
         ] = False,
+        library_url: Annotated[
+            str | None,
+            typer.Option(
+                "--library-url",
+                "-u",
+                help="URL of the library to add to the project.",
+            ),
+        ] = None,
+        library_checksum: Annotated[
+            str | None,
+            typer.Option(
+                "--library-checksum",
+                "-c",
+                help="Checksum of the library to add to the project.",
+            ),
+        ] = None,
         verbose: Annotated[
             bool,
             typer.Option(
@@ -62,12 +78,20 @@ class ModulesApp(typer.Typer):
     ) -> None:
         """Initialize or upgrade a new CDF project with templates interactively."""
 
+        if library_url and not library_checksum:
+            raise typer.BadParameter(
+                "--library-checksum must be provided when --library-url is specified.",
+                param_hint="--library-checksum",
+            )
+
         with ModulesCommand() as cmd:
             cmd.run(
                 lambda: cmd.init(
                     organization_dir=organization_dir,
                     select_all=all,
                     clean=clean,
+                    library_url=library_url,
+                    library_checksum=library_checksum,
                 )
             )
 

cognite_toolkit/_cdf_tk/apps/_profile_app.py

@@ -58,9 +58,9 @@ class ProfileApp(typer.Typer):
         cmd = ProfileAssetCommand(output_spreadsheet)
         cmd.run(
             lambda: cmd.assets(
-                client,
-                hierarchy,
-                verbose,
+                client=client,
+                hierarchy=hierarchy,
+                verbose=verbose,
             )
         )
 

cognite_toolkit/_cdf_tk/apps/_purge.py

@@ -1,6 +1,6 @@
 from enum import Enum
 from pathlib import Path
-from typing import Annotated, Any
+from typing import Annotated, Any, cast
 
 import questionary
 import typer
@@ -8,10 +8,15 @@ from rich import print
 
 from cognite_toolkit._cdf_tk.commands import PurgeCommand
 from cognite_toolkit._cdf_tk.exceptions import ToolkitValueError
-from cognite_toolkit._cdf_tk.feature_flags import Flags
-from cognite_toolkit._cdf_tk.storageio import InstanceFileSelector, InstanceSelector, InstanceViewSelector
+from cognite_toolkit._cdf_tk.storageio.selectors import (
+    InstanceFileSelector,
+    InstanceSelector,
+    InstanceViewSelector,
+    SelectedView,
+)
 from cognite_toolkit._cdf_tk.utils.auth import EnvironmentVariables
-from cognite_toolkit._cdf_tk.utils.interactive_select import DataModelingSelect
+from cognite_toolkit._cdf_tk.utils.cli_args import parse_view_str
+from cognite_toolkit._cdf_tk.utils.interactive_select import AssetInteractiveSelect, DataModelingSelect
 
 
 class InstanceTypeEnum(str, Enum):
@@ -25,16 +30,15 @@ class PurgeApp(typer.Typer):
         self.callback(invoke_without_command=True)(self.main)
         self.command("dataset")(self.purge_dataset)
         self.command("space")(self.purge_space)
-        if Flags.PURGE_INSTANCES.is_enabled():
-            self.command("instances")(self.purge_instances)
+        self.command("instances")(self.purge_instances)
 
     def main(self, ctx: typer.Context) -> None:
-        """Commands purge functionality"""
+        """Commands deleting data from Cognite Data Fusion."""
         if ctx.invoked_subcommand is None:
             print("Use [bold yellow]cdf purge --help[/] for more information.")
 
+    @staticmethod
     def purge_dataset(
-        self,
         ctx: typer.Context,
         external_id: Annotated[
             str | None,
@@ -42,12 +46,38 @@ class PurgeApp(typer.Typer):
                 help="External id of the dataset to purge. If not provided, interactive mode will be used.",
             ),
         ] = None,
-        include_dataset: Annotated[
+        archive_dataset: Annotated[
             bool,
             typer.Option(
-                "--include-dataset",
-                "-i",
-                help="Include dataset in the purge. This will also archive the dataset.",
+                "--archive-dataset",
+                help="Whether to archive the dataset itself after purging its contents.",
+            ),
+        ] = False,
+        skip_data: Annotated[
+            bool,
+            typer.Option(
+                "--skip-data",
+                "-s",
+                help="Skip deleting the data in the dataset, only delete configurations. The resources that are "
+                "considered data are: time series, event, files, assets, sequences, relationships, "
+                "labels, and 3D Models",
+            ),
+        ] = False,
+        include_configurations: Annotated[
+            bool,
+            typer.Option(
+                "--include-configurations",
+                "-c",
+                help="Include configurations, workflows, extraction pipelines and transformations in the purge.",
+            ),
+        ] = False,
+        asset_recursive: Annotated[
+            bool,
+            typer.Option(
+                "--asset-recursive",
+                "-a",
+                help="When deleting assets, delete all child assets recursively. CAVEAT: This can lead to assets"
+                " not in the selected dataset being deleted if they are children of assets in the dataset.",
             ),
         ] = False,
         dry_run: Annotated[
@@ -78,19 +108,49 @@ class PurgeApp(typer.Typer):
         """This command will delete the contents of the specified dataset"""
         cmd = PurgeCommand()
         client = EnvironmentVariables.create_from_environment().get_client()
+
+        if external_id is None:
+            # Is Interactive
+            interactive = AssetInteractiveSelect(client, operation="purge")
+            external_id = interactive.select_data_set(allow_empty=False)
+            skip_data = not questionary.confirm(
+                "Delete data in the dataset (time series, events, files, assets, sequences, relationships, labels, 3D models)?",
+                default=True,
+            ).ask()
+            include_configurations = questionary.confirm(
+                "Delete configurations (workflows, extraction pipelines and transformations) in the dataset?",
+                default=False,
+            ).ask()
+            asset_recursive = questionary.confirm(
+                "When deleting assets, delete all child assets recursively? (WARNING: This can lead "
+                "to assets not in the selected dataset being deleted if they are children of assets in the dataset.)",
+                default=False,
+            ).ask()
+            archive_dataset = questionary.confirm("Archive the dataset itself after purging?", default=False).ask()
+            dry_run = questionary.confirm("Dry run?", default=True).ask()
+            verbose = questionary.confirm("Verbose?", default=True).ask()
+
+            user_options = [archive_dataset, dry_run, verbose, skip_data, include_configurations, asset_recursive]
+
+            if any(selected is None for selected in user_options):
+                raise typer.Abort("Aborted by user.")
+
         cmd.run(
             lambda: cmd.dataset(
                 client,
                 external_id,
-                include_dataset,
+                archive_dataset,
+                not skip_data,
+                include_configurations,
+                asset_recursive,
                 dry_run,
                 auto_yes,
                 verbose,
             )
         )
 
+    @staticmethod
     def purge_space(
-        self,
         ctx: typer.Context,
         space: Annotated[
             str | None,
@@ -106,6 +166,20 @@ class PurgeApp(typer.Typer):
                 help="Include space in the purge. This will also delete the space.",
             ),
         ] = False,
+        delete_datapoints: Annotated[
+            bool,
+            typer.Option(
+                "--delete-datapoints",
+                help="Delete datapoints linked to CogniteTimeSeries nodes in the space.",
+            ),
+        ] = False,
+        delete_file_content: Annotated[
+            bool,
+            typer.Option(
+                "--delete-file-content",
+                help="Delete file content linked to CogniteFile nodes in the space.",
+            ),
+        ] = False,
         dry_run: Annotated[
             bool,
             typer.Option(
@@ -135,24 +209,45 @@ class PurgeApp(typer.Typer):
 
         cmd = PurgeCommand()
         client = EnvironmentVariables.create_from_environment().get_client()
+
+        if space is None:
+            # Is Interactive
+            interactive = DataModelingSelect(client, operation="purge")
+            space_type = interactive.select_space_type()
+            if space_type == "empty":
+                space = interactive.select_empty_spaces(multiselect=False)
+            elif space_type == "instance":
+                space = interactive.select_instance_space(multiselect=False)
+            elif space_type == "schema":
+                space = interactive.select_schema_space(include_global=False).space
+            else:
+                raise ToolkitValueError("Invalid space type selected.")
+            dry_run = questionary.confirm("Dry run?", default=True).ask()
+            if space_type == "empty":
+                include_space = True
+            else:
+                include_space = questionary.confirm("Delete the space itself?", default=False).ask()
+
         cmd.run(
             lambda: cmd.space(
-                client,
-                space,
-                include_space,
-                dry_run,
-                auto_yes,
-                verbose,
+                client=client,
+                selected_space=space,
+                include_space=include_space,
+                delete_datapoints=delete_datapoints,
+                delete_file_content=delete_file_content,
+                dry_run=dry_run,
+                auto_yes=auto_yes,
+                verbose=verbose,
             )
         )
 
     @staticmethod
     def purge_instances(
         view: Annotated[
-            list[str] | None,
+            str | None,
             typer.Argument(
                 help="Purge instances with properties in the specified view. Expected format is "
-                "'space externalId version'. For example 'cdf_cdm CogniteTimeSeries v1' will purge all nodes"
+                "'space:externalId/version'. For example 'cdf_cdm:CogniteTimeSeries/v1' will purge all nodes"
                 "that have properties in the CogniteTimeSeries view. If not provided and no "
                 "instance list is provided, interactive mode will be used.",
             ),
@@ -238,7 +333,9 @@ class PurgeApp(typer.Typer):
             selected_instance_type = interactive.select_instance_type(select_view.used_for)
             instance_space = interactive.select_instance_space(True, select_view.as_id(), selected_instance_type)
             selector = InstanceViewSelector(
-                view=select_view.as_id(),
+                view=SelectedView(
+                    space=select_view.space, external_id=select_view.external_id, version=select_view.version
+                ),
                 instance_type=selected_instance_type,
                 instance_spaces=tuple(instance_space) if instance_space else None,
             )
@@ -247,8 +344,11 @@ class PurgeApp(typer.Typer):
         elif instance_list is not None:
             selector = InstanceFileSelector(datafile=instance_list)
         elif view is not None:
+            view_id = parse_view_str(view)
             selector = InstanceViewSelector(
-                view=cmd.get_selected_view_id(view),
+                view=SelectedView(
+                    space=view_id.space, external_id=view_id.external_id, version=cast(str, view_id.version)
+                ),
                 instance_type=instance_type.value,
                 instance_spaces=tuple(instance_space) if instance_space is not None else None,
             )

cognite_toolkit/_cdf_tk/apps/_run.py

@@ -23,9 +23,15 @@ class RunApp(typer.Typer):
         self.command("workflow")(self.run_workflow)
         self.add_typer(RunFunctionApp(*args, **kwargs), name="function")
 
+    @staticmethod
+    def _print_deprecation_warning() -> None:
+        """Print deprecation warning for the run plugin."""
+        print("The run plugin is deprecated and will be replaced by the dev plugin in v0.8.0.")
+
     @staticmethod
     def main(ctx: typer.Context) -> None:
         """Commands to execute processes in CDF."""
+        RunApp._print_deprecation_warning()
         if ctx.invoked_subcommand is None:
             print("Use [bold yellow]cdf run --help[/] for more information.")
 
@@ -51,6 +57,7 @@ class RunApp(typer.Typer):
         ] = False,
     ) -> None:
         """This command will run the specified transformation using a one-time session."""
+        RunApp._print_deprecation_warning()
         cmd = RunTransformationCommand()
         client = EnvironmentVariables.create_from_environment().get_client()
         cmd.run(lambda: cmd.run_transformation(client, external_id))
@@ -108,6 +115,7 @@ class RunApp(typer.Typer):
         ] = False,
     ) -> None:
         """This command will run the specified workflow."""
+        RunApp._print_deprecation_warning()
         cmd = RunWorkflowCommand()
         env_vars = EnvironmentVariables.create_from_environment()
         cmd.run(lambda: cmd.run_workflow(env_vars, organization_dir, env_name, external_id, version, wait))
@@ -123,6 +131,7 @@ class RunFunctionApp(typer.Typer):
     @staticmethod
     def main(ctx: typer.Context) -> None:
         """Commands to execute function."""
+        RunApp._print_deprecation_warning()
         if ctx.invoked_subcommand is None:
             print("Use [bold yellow]cdf run function --help[/] for more information.")
 
@@ -178,6 +187,7 @@ class RunFunctionApp(typer.Typer):
         ] = False,
     ) -> None:
         """This command will run the specified function locally."""
+        RunApp._print_deprecation_warning()
         cmd = RunFunctionCommand()
         env_vars = EnvironmentVariables.create_from_environment()
         cmd.run(
@@ -243,6 +253,7 @@ class RunFunctionApp(typer.Typer):
         ] = False,
     ) -> None:
         """This command will run the specified function (assuming it is deployed) in CDF."""
+        RunApp._print_deprecation_warning()
         cmd = RunFunctionCommand()
         env_vars = EnvironmentVariables.create_from_environment()
         cmd.run(lambda: cmd.run_cdf(env_vars, organization_dir, env_name, external_id, schedule, wait))

cognite_toolkit/_cdf_tk/apps/_upload_app.py

@@ -1,20 +1,22 @@
 from pathlib import Path
 from typing import Annotated, Any
 
+import questionary
 import typer
-from rich import print
+from questionary import Choice
 
 from cognite_toolkit._cdf_tk.commands import UploadCommand
-from cognite_toolkit._cdf_tk.storageio import AssetIO, RawIO
+from cognite_toolkit._cdf_tk.constants import DATA_DEFAULT_DIR, DATA_MANIFEST_SUFFIX, DATA_RESOURCE_DIR
 from cognite_toolkit._cdf_tk.utils.auth import EnvironmentVariables
 
+DEFAULT_INPUT_DIR = Path.cwd() / DATA_DEFAULT_DIR
+
 
 class UploadApp(typer.Typer):
     def __init__(self, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
         self.callback(invoke_without_command=True)(self.upload_main)
-        self.command("raw")(self.upload_raw_cmd)
-        self.command("assets")(self.upload_assets_cmd)
+        self.command("dir")(self.upload_dir)
 
     @staticmethod
     def upload_main(ctx: typer.Context) -> None:
@@ -24,19 +26,18 @@ class UploadApp(typer.Typer):
         return None
 
     @staticmethod
-    def upload_raw_cmd(
+    def upload_dir(
         ctx: typer.Context,
         input_dir: Annotated[
-            Path,
+            Path | None,
             typer.Argument(
-                help="The directory containing the RAW tables to upload. "
-                "If not specified, the current working directory will be used.",
+                help="The directory containing the data to upload. If not specified, an interactive prompt will ask for the directory.",
                 exists=True,
                 file_okay=False,
                 dir_okay=True,
                 resolve_path=True,
             ),
-        ],
+        ] = None,
         dry_run: Annotated[
             bool,
             typer.Option(
@@ -45,65 +46,14 @@ class UploadApp(typer.Typer):
                 help="If set, the command will not actually upload the data, but will print what would be uploaded.",
             ),
         ] = False,
-        ensure_tables: Annotated[
-            bool,
-            typer.Option(
-                "--ensure-tables",
-                "-e",
-                help="If set, the command will ensure that the RAW database and table exist in CDF before uploading.",
-            ),
-        ] = True,
-        verbose: Annotated[
-            bool,
-            typer.Option(
-                "--verbose",
-                "-v",
-                help="Turn on to get more verbose output when running the command",
-            ),
-        ] = False,
-    ) -> None:
-        """This command will upload data from the input directory to CDF."""
-        cmd = UploadCommand()
-
-        client = EnvironmentVariables.create_from_environment().get_client()
-        cmd.run(
-            lambda: cmd.upload(
-                io=RawIO(client=client),
-                input_dir=input_dir,
-                ensure_configurations=ensure_tables,
-                dry_run=dry_run,
-                verbose=verbose,
-            )
-        )
-
-    @staticmethod
-    def upload_assets_cmd(
-        ctx: typer.Context,
-        input_dir: Annotated[
-            Path,
-            typer.Argument(
-                help="The directory containing the asset files to upload.",
-                exists=True,
-                file_okay=False,
-                dir_okay=True,
-                resolve_path=True,
-            ),
-        ],
-        dry_run: Annotated[
+        deploy_resources: Annotated[
             bool,
             typer.Option(
-                "--dry-run",
-                "-d",
-                help="If set, the command will not actually upload the data, but will print what would be uploaded.",
+                "--deploy-resources",
+                "-r",
+                help="If set, the command will look for resource configuration files in adjacent folders and create them if they do not exist.",
             ),
         ] = False,
-        ensure_dataset_and_labels: Annotated[
-            bool,
-            typer.Option(
-                "--ensure-dataset-and-labels",
-                help="If set, the command will look for datasets and labels in adjacent folders and create them if they do not exist.",
-            ),
-        ] = True,
         verbose: Annotated[
             bool,
             typer.Option(
@@ -113,16 +63,45 @@ class UploadApp(typer.Typer):
             ),
         ] = False,
     ) -> None:
-        """This command will upload assets from input directory to CDF."""
+        """Commands to upload data to CDF."""
         cmd = UploadCommand()
+        if input_dir is None:
+            input_candidate = sorted({p.parent for p in DEFAULT_INPUT_DIR.rglob(f"**/*{DATA_MANIFEST_SUFFIX}")})
+            if not input_candidate:
+                typer.echo(f"No data manifests found in default directory: {DEFAULT_INPUT_DIR}")
+                raise typer.Exit(code=1)
+            input_dir = questionary.select(
+                "Select the input directory containing the data to upload:",
+                choices=[Choice(str(option.name), value=option) for option in input_candidate],
+            ).ask()
+            if input_dir is None:
+                typer.echo("No input directory selected. Exiting.")
+                raise typer.Exit(code=1)
+            dry_run = questionary.confirm("Proceed with dry run?", default=dry_run).ask()
+            if dry_run is None:
+                typer.echo("No selection made for dry run. Exiting.")
+                raise typer.Exit(code=1)
+            resource_dir = Path(input_dir) / DATA_RESOURCE_DIR
+            if resource_dir.exists():
+                if resource_dir.is_relative_to(Path.cwd()):
+                    display_name = resource_dir.relative_to(Path.cwd()).as_posix()
+                else:
+                    display_name = resource_dir.as_posix()
+
+                deploy_resources = questionary.confirm(
+                    f"Deploy resources found in {display_name!r}?", default=deploy_resources
+                ).ask()
+                if deploy_resources is None:
+                    typer.echo("No selection made for deploying resources. Exiting.")
+                    raise typer.Exit(code=1)
 
         client = EnvironmentVariables.create_from_environment().get_client()
         cmd.run(
             lambda: cmd.upload(
-                io=AssetIO(client=client),
                 input_dir=input_dir,
-                ensure_configurations=ensure_dataset_and_labels,
                 dry_run=dry_run,
                 verbose=verbose,
+                deploy_resources=deploy_resources,
+                client=client,
             )
         )

cognite_toolkit/_cdf_tk/builders/__init__.py

@@ -3,7 +3,7 @@ from pathlib import Path
 
 from cognite_toolkit._cdf_tk.tk_warnings import ToolkitWarning
 
-from ._base import Builder, DefaultBuilder, get_loader
+from ._base import Builder, DefaultBuilder, get_resource_crud
 from ._datamodels import DataModelBuilder
 from ._file import FileBuilder
 from ._function import FunctionBuilder
@@ -36,5 +36,5 @@ __all__ = [
     "StreamlitBuilder",
     "TransformationBuilder",
     "create_builder",
-    "get_loader",
+    "get_resource_crud",
 ]

cognite_toolkit/_cdf_tk/builders/_base.py

@@ -2,14 +2,12 @@ import difflib
 from abc import ABC, abstractmethod
 from collections.abc import Callable, Iterable, Sequence
 from pathlib import Path
-from typing import Any, ClassVar, cast
+from typing import Any, ClassVar
 
 from cognite_toolkit._cdf_tk.constants import INDEX_PATTERN
 from cognite_toolkit._cdf_tk.cruds import (
-    CRUDS_BY_FOLDER_NAME,
+    RESOURCE_CRUD_BY_FOLDER_NAME,
     GroupCRUD,
-    RawDatabaseCRUD,
-    RawTableCRUD,
     ResourceCRUD,
 )
 from cognite_toolkit._cdf_tk.data_classes import (
@@ -31,7 +29,6 @@ from cognite_toolkit._cdf_tk.tk_warnings.fileread import (
 )
 from cognite_toolkit._cdf_tk.utils import (
     humanize_collection,
-    safe_read,
 )
 
 
@@ -103,34 +100,31 @@ class Builder(ABC):
         return destination_path
 
     def _get_loader(self, source_path: Path) -> tuple[None, ToolkitWarning] | tuple[type[ResourceCRUD], None]:
-        return get_loader(source_path, self.resource_folder)
+        return get_resource_crud(source_path, self.resource_folder)
 
 
-def get_loader(
-    source_path: Path,
-    resource_folder: str,
-    force_pattern: bool = False,
+def get_resource_crud(
+    source_path: Path, resource_folder: str
 ) -> tuple[None, ToolkitWarning] | tuple[type[ResourceCRUD], None]:
-    folder_loaders = CRUDS_BY_FOLDER_NAME.get(resource_folder, [])
-    if not folder_loaders:
+    """Get the appropriate CRUD class for the given source file and resource folder."""
+    folder_cruds = RESOURCE_CRUD_BY_FOLDER_NAME.get(resource_folder, [])
+    if not folder_cruds:
         return None, ToolkitNotSupportedWarning(
             f"resource of type {resource_folder!r} in {source_path.name}.",
-            details=f"Available resources are: {', '.join(CRUDS_BY_FOLDER_NAME.keys())}",
+            details=f"Available resources are: {humanize_collection(RESOURCE_CRUD_BY_FOLDER_NAME.keys())}",
         )
 
-    loaders = [
-        loader for loader in folder_loaders if loader.is_supported_file(source_path, force_pattern=force_pattern)
-    ]
-    if len(loaders) == 0:
+    crud_candidates = [crud_cls for crud_cls in folder_cruds if crud_cls.is_supported_file(source_path)]
+    if len(crud_candidates) == 0:
         suggestion: str | None = None
         if "." in source_path.stem:
             core, kind = source_path.stem.rsplit(".", 1)
-            match = difflib.get_close_matches(kind, [loader.kind for loader in folder_loaders])
+            match = difflib.get_close_matches(kind, [crud_cls.kind for crud_cls in folder_cruds])
             if match:
                 suggested_name = f"{core}.{match[0]}{source_path.suffix}"
                 suggestion = f"Did you mean to call the file {suggested_name!r}?"
         else:
-            kinds = [loader.kind for loader in folder_loaders]
+            kinds = [crud.kind for crud in folder_cruds]
             if len(kinds) == 1:
                 suggestion = f"Did you mean to call the file '{source_path.stem}.{kinds[0]}{source_path.suffix}'?"
             else:
@@ -139,30 +133,22 @@ def get_loader(
                     f"the resource type. Supported types are: {humanize_collection(kinds)}."
                 )
         return None, UnknownResourceTypeWarning(source_path, suggestion)
-    elif len(loaders) > 1 and all(loader.folder_name == "raw" for loader in loaders):
-        # Raw files can be ambiguous, so we need to check the content.
-        # If there is a tableName field, it is a table, otherwise it is a database.
-        if any(
-            line.strip().startswith("tableName:") or line.strip().startswith("- tableName:")
-            for line in safe_read(source_path).splitlines()
-        ):
-            return RawTableCRUD, None
-        else:
-            return RawDatabaseCRUD, None
-    elif len(loaders) > 1 and all(issubclass(loader, GroupCRUD) for loader in loaders):
-        # There are two group loaders, one for resource scoped and one for all scoped.
+    elif len(crud_candidates) > 1 and all(issubclass(loader, GroupCRUD) for loader in crud_candidates):
+        # There are two group cruds, one for resource scoped and one for all scoped.
         return GroupCRUD, None
-    elif len(loaders) > 1:
-        names = humanize_collection(
-            [f"'{source_path.stem}.{loader.kind}{source_path.suffix}'" for loader in loaders], bind_word="or"
-        )
-        raise AmbiguousResourceFileError(
-            f"Ambiguous resource file {source_path.name} in {resource_folder} folder. "
-            f"Unclear whether it is {humanize_collection([loader.kind for loader in loaders], bind_word='or')}."
-            f"\nPlease name the file {names}."
-        )
-
-    return cast(type[ResourceCRUD], loaders[0]), None
+    elif len(crud_candidates) == 1:
+        return crud_candidates[0], None
+
+    # This is unreachable with our current ResourceCRUD classes. We have tests that is exhaustive over
+    # all ResourceCRUDs to ensure this.
+    names = humanize_collection(
+        [f"'{source_path.stem}.{loader.kind}{source_path.suffix}'" for loader in crud_candidates], bind_word="or"
+    )
+    raise AmbiguousResourceFileError(
+        f"Ambiguous resource file {source_path.name} in {resource_folder} folder. "
+        f"Unclear whether it is {humanize_collection([crud_cls.kind for crud_cls in crud_candidates], bind_word='or')}."
+        f"\nPlease name the file {names}."
+    )
 
 
 class DefaultBuilder(Builder):