cognite-toolkit 0.5.44__py3-none-any.whl → 0.7.34__py3-none-any.whl

cognite_toolkit/_cdf_tk/apps/_run.py

@@ -1,5 +1,5 @@
 from pathlib import Path
-from typing import Annotated, Any, Optional
+from typing import Annotated, Any
 
 import typer
 from rich import print
@@ -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))
@@ -59,7 +66,7 @@ class RunApp(typer.Typer):
     def run_workflow(
         ctx: typer.Context,
         external_id: Annotated[
-            Optional[str],
+            str | None,
             typer.Option(
                 "--external-id",
                 "-e",
@@ -67,7 +74,7 @@ class RunApp(typer.Typer):
             ),
         ] = None,
         version: Annotated[
-            Optional[str],
+            str | None,
             typer.Option(
                 "--version",
                 "-v",
@@ -83,7 +90,7 @@ class RunApp(typer.Typer):
             ),
         ] = CDF_TOML.cdf.default_organization_dir,
         env_name: Annotated[
-            Optional[str],
+            str | None,
             typer.Option(
                 "--env",
                 "-e",
@@ -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.")
 
@@ -130,7 +139,7 @@ class RunFunctionApp(typer.Typer):
     def run_local(
         ctx: typer.Context,
         external_id: Annotated[
-            Optional[str],
+            str | None,
             typer.Argument(
                 help="External id of the function to run.",
             ),
@@ -144,7 +153,7 @@ class RunFunctionApp(typer.Typer):
             ),
         ] = CDF_TOML.cdf.default_organization_dir,
         env_name: Annotated[
-            Optional[str],
+            str | None,
             typer.Option(
                 "--env",
                 "-e",
@@ -152,7 +161,7 @@ class RunFunctionApp(typer.Typer):
             ),
         ] = CDF_TOML.cdf.default_env,
         schedule: Annotated[
-            Optional[str],
+            str | None,
             typer.Option(
                 "--schedule",
                 "-s",
@@ -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(
@@ -195,7 +205,7 @@ class RunFunctionApp(typer.Typer):
     def run_cdf(
         ctx: typer.Context,
         external_id: Annotated[
-            Optional[str],
+            str | None,
             typer.Argument(
                 help="External id of the function to run. If not provided, the function "
                 "will be selected interactively.",
@@ -210,7 +220,7 @@ class RunFunctionApp(typer.Typer):
             ),
         ] = CDF_TOML.cdf.default_organization_dir,
         env_name: Annotated[
-            Optional[str],
+            str | None,
             typer.Option(
                 "--env",
                 "-e",
@@ -218,7 +228,7 @@ class RunFunctionApp(typer.Typer):
             ),
         ] = CDF_TOML.cdf.default_env,
         schedule: Annotated[
-            Optional[str],
+            str | None,
             typer.Option(
                 "--schedule",
                 "-s",
@@ -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

@@ -0,0 +1,107 @@
+from pathlib import Path
+from typing import Annotated, Any
+
+import questionary
+import typer
+from questionary import Choice
+
+from cognite_toolkit._cdf_tk.commands import UploadCommand
+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("dir")(self.upload_dir)
+
+    @staticmethod
+    def upload_main(ctx: typer.Context) -> None:
+        """Commands to upload data to CDF."""
+        if ctx.invoked_subcommand is None:
+            print("Use [bold yellow]cdf upload --help[/] for more information.")
+        return None
+
+    @staticmethod
+    def upload_dir(
+        ctx: typer.Context,
+        input_dir: Annotated[
+            Path | None,
+            typer.Argument(
+                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(
+                "--dry-run",
+                "-d",
+                help="If set, the command will not actually upload the data, but will print what would be uploaded.",
+            ),
+        ] = False,
+        deploy_resources: Annotated[
+            bool,
+            typer.Option(
+                "--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,
+        verbose: Annotated[
+            bool,
+            typer.Option(
+                "--verbose",
+                "-v",
+                help="Turn on to get more verbose output when running the command",
+            ),
+        ] = False,
+    ) -> None:
+        """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(
+                input_dir=input_dir,
+                dry_run=dry_run,
+                verbose=verbose,
+                deploy_resources=deploy_resources,
+                client=client,
+            )
+        )

cognite_toolkit/_cdf_tk/builders/__init__.py

@@ -1,6 +1,9 @@
+from collections.abc import Callable
 from pathlib import Path
 
-from ._base import Builder, DefaultBuilder, get_loader
+from cognite_toolkit._cdf_tk.tk_warnings import ToolkitWarning
+
+from ._base import Builder, DefaultBuilder, get_resource_crud
 from ._datamodels import DataModelBuilder
 from ._file import FileBuilder
 from ._function import FunctionBuilder
@@ -13,11 +16,12 @@ from ._transformation import TransformationBuilder
 def create_builder(
     resource_folder: str,
     build_dir: Path | None,
+    warn: Callable[[ToolkitWarning], None] | None = None,
 ) -> Builder:
     if builder_cls := _BUILDER_BY_RESOURCE_FOLDER.get(resource_folder):
-        return builder_cls(build_dir)  # type: ignore[abstract]
+        return builder_cls(build_dir, warn=warn)  # type: ignore[abstract]
 
-    return DefaultBuilder(build_dir, resource_folder)
+    return DefaultBuilder(build_dir, resource_folder, warn)
 
 
 _BUILDER_BY_RESOURCE_FOLDER = {_builder._resource_folder: _builder for _builder in Builder.__subclasses__()}
@@ -32,5 +36,5 @@ __all__ = [
     "StreamlitBuilder",
     "TransformationBuilder",
     "create_builder",
-    "get_loader",
+    "get_resource_crud",
 ]

cognite_toolkit/_cdf_tk/builders/_base.py

@@ -2,9 +2,14 @@ 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 (
+    RESOURCE_CRUD_BY_FOLDER_NAME,
+    GroupCRUD,
+    ResourceCRUD,
+)
 from cognite_toolkit._cdf_tk.data_classes import (
     BuildDestinationFile,
     BuildSourceFile,
@@ -14,13 +19,6 @@ from cognite_toolkit._cdf_tk.data_classes import (
 from cognite_toolkit._cdf_tk.exceptions import (
     AmbiguousResourceFileError,
 )
-from cognite_toolkit._cdf_tk.loaders import (
-    LOADER_BY_FOLDER_NAME,
-    GroupLoader,
-    RawDatabaseLoader,
-    RawTableLoader,
-    ResourceLoader,
-)
 from cognite_toolkit._cdf_tk.tk_warnings import (
     ToolkitNotSupportedWarning,
     ToolkitWarning,
@@ -31,7 +29,6 @@ from cognite_toolkit._cdf_tk.tk_warnings.fileread import (
 )
 from cognite_toolkit._cdf_tk.utils import (
     humanize_collection,
-    safe_read,
 )
 
 
@@ -42,8 +39,10 @@ class Builder(ABC):
         self,
         build_dir: Path | None,
         resource_folder: str | None = None,
+        warn: Callable[[ToolkitWarning], None] | None = None,
     ):
         self._build_dir = build_dir
+        self.warn = warn
         self.resource_counter = 0
         if self._resource_folder is not None:
             self.resource_folder = self._resource_folder
@@ -100,35 +99,32 @@ class Builder(ABC):
         destination_path.parent.mkdir(parents=True, exist_ok=True)
         return destination_path
 
-    def _get_loader(self, source_path: Path) -> tuple[None, ToolkitWarning] | tuple[type[ResourceLoader], None]:
-        return get_loader(source_path, self.resource_folder)
+    def _get_loader(self, source_path: Path) -> tuple[None, ToolkitWarning] | tuple[type[ResourceCRUD], None]:
+        return get_resource_crud(source_path, self.resource_folder)
 
 
-def get_loader(
-    source_path: Path,
-    resource_folder: str,
-    force_pattern: bool = False,
-) -> tuple[None, ToolkitWarning] | tuple[type[ResourceLoader], None]:
-    folder_loaders = LOADER_BY_FOLDER_NAME.get(resource_folder, [])
-    if not folder_loaders:
+def get_resource_crud(
+    source_path: Path, resource_folder: str
+) -> tuple[None, ToolkitWarning] | tuple[type[ResourceCRUD], None]:
+    """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(LOADER_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:
@@ -137,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 RawTableLoader, None
-        else:
-            return RawDatabaseLoader, None
-    elif len(loaders) > 1 and all(issubclass(loader, GroupLoader) for loader in loaders):
-        # There are two group loaders, one for resource scoped and one for all scoped.
-        return GroupLoader, 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[ResourceLoader], loaders[0]), None
+    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(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):

cognite_toolkit/_cdf_tk/builders/_datamodels.py

@@ -5,6 +5,7 @@ from typing import Any
 
 from cognite_toolkit._cdf_tk.builders import Builder
 from cognite_toolkit._cdf_tk.constants import INDEX_PATTERN
+from cognite_toolkit._cdf_tk.cruds import GraphQLCRUD
 from cognite_toolkit._cdf_tk.data_classes import (
     BuildDestinationFile,
     BuildSourceFile,
@@ -12,12 +13,11 @@ from cognite_toolkit._cdf_tk.data_classes import (
     SourceLocation,
 )
 from cognite_toolkit._cdf_tk.exceptions import ToolkitFileNotFoundError
-from cognite_toolkit._cdf_tk.loaders import GraphQLLoader
 from cognite_toolkit._cdf_tk.tk_warnings import ToolkitWarning
 
 
 class DataModelBuilder(Builder):
-    _resource_folder = GraphQLLoader.folder_name
+    _resource_folder = GraphQLCRUD.folder_name
 
     def build(
         self, source_files: list[BuildSourceFile], module: ModuleLocation, console: Callable[[str], None] | None = None
@@ -42,7 +42,7 @@ class DataModelBuilder(Builder):
             destination_path = self._create_destination_path(source_file.source.path, loader.kind)
 
             extra_sources: list[SourceLocation] | None = None
-            if loader is GraphQLLoader:
+            if loader is GraphQLCRUD:
                 # The GraphQL must be copied over instead of added to the DML field as
                 # it is hashed in the deployment step and used to determine if the DML has changed.
                 extra_sources = self._copy_graphql_to_build(source_file, destination_path, graphql_files)
@@ -71,7 +71,7 @@ class DataModelBuilder(Builder):
             if "dml" in entry:
                 expected_filename = entry["dml"]
             else:
-                expected_filename = f"{INDEX_PATTERN.sub('', source_file.source.path.stem.removesuffix(GraphQLLoader.kind).removesuffix('.'))}.graphql"
+                expected_filename = f"{INDEX_PATTERN.sub('', source_file.source.path.stem.removesuffix(GraphQLCRUD.kind).removesuffix('.'))}.graphql"
             expected_path = source_file.source.path.parent / Path(expected_filename)
 
             if expected_path in graphql_files:

cognite_toolkit/_cdf_tk/builders/_file.py

@@ -3,18 +3,18 @@ from collections.abc import Callable, Iterable
 from typing import Any
 
 from cognite_toolkit._cdf_tk.builders import Builder
+from cognite_toolkit._cdf_tk.cruds import CogniteFileCRUD, FileCRUD, FileMetadataCRUD
 from cognite_toolkit._cdf_tk.data_classes import (
     BuildDestinationFile,
     BuildSourceFile,
     ModuleLocation,
 )
 from cognite_toolkit._cdf_tk.exceptions import ToolkitYAMLFormatError
-from cognite_toolkit._cdf_tk.loaders import CogniteFileLoader, FileLoader, FileMetadataLoader
 from cognite_toolkit._cdf_tk.tk_warnings import LowSeverityWarning, ToolkitWarning
 
 
 class FileBuilder(Builder):
-    _resource_folder = FileMetadataLoader.folder_name
+    _resource_folder = FileMetadataCRUD.folder_name
     template_pattern = "$FILENAME"
 
     def build(
@@ -30,7 +30,7 @@ class FileBuilder(Builder):
                 if warning is not None:
                     yield [warning]
                 continue
-            if loader in {FileMetadataLoader, CogniteFileLoader}:
+            if loader in {FileMetadataCRUD, CogniteFileCRUD}:
                 loaded = self._expand_file_metadata(loaded, module, console)
             destination_path = self._create_destination_path(source_file.source.path, loader.kind)
 
@@ -78,8 +78,8 @@ class FileBuilder(Builder):
                 f"Expanding file metadata..."
             )
         expanded_metadata: list[dict[str, Any]] = []
-        for filepath in module.source_paths_by_resource_folder[FileLoader.folder_name]:
-            if not FileLoader.is_supported_file(filepath):
+        for filepath in module.source_paths_by_resource_folder[FileCRUD.folder_name]:
+            if not FileCRUD.is_supported_file(filepath):
                 continue
             new_entry = copy.deepcopy(template)
             new_entry["externalId"] = new_entry["externalId"].replace(cls.template_pattern, filepath.name)

cognite_toolkit/_cdf_tk/builders/_function.py

@@ -2,6 +2,7 @@ import shutil
 from collections.abc import Callable, Iterable, Sequence
 
 from cognite_toolkit._cdf_tk.builders import Builder
+from cognite_toolkit._cdf_tk.cruds import FunctionCRUD
 from cognite_toolkit._cdf_tk.data_classes import (
     BuildDestinationFile,
     BuildSourceFile,
@@ -9,7 +10,6 @@ from cognite_toolkit._cdf_tk.data_classes import (
     ModuleLocation,
 )
 from cognite_toolkit._cdf_tk.exceptions import ToolkitFileExistsError, ToolkitNotADirectoryError, ToolkitValueError
-from cognite_toolkit._cdf_tk.loaders import FunctionLoader
 from cognite_toolkit._cdf_tk.tk_warnings import (
     FileReadWarning,
     HighSeverityWarning,
@@ -21,7 +21,7 @@ from cognite_toolkit._cdf_tk.tk_warnings import (
 
 
 class FunctionBuilder(Builder):
-    _resource_folder = FunctionLoader.folder_name
+    _resource_folder = FunctionCRUD.folder_name
 
     def build(
         self, source_files: list[BuildSourceFile], module: ModuleLocation, console: Callable[[str], None] | None = None
@@ -40,7 +40,7 @@ class FunctionBuilder(Builder):
                 continue
 
             warnings = WarningList[FileReadWarning]()
-            if loader is FunctionLoader:
+            if loader is FunctionCRUD:
                 warnings = self.copy_function_directory_to_build(source_file)
 
             destination_path = self._create_destination_path(source_file.source.path, loader.kind)
@@ -58,17 +58,17 @@ class FunctionBuilder(Builder):
         self, built_resources: BuiltResourceList, module: ModuleLocation
     ) -> WarningList[ToolkitWarning]:
         warnings = WarningList[ToolkitWarning]()
-        has_config_files = any(resource.kind == FunctionLoader.kind for resource in built_resources)
+        has_config_files = any(resource.kind == FunctionCRUD.kind for resource in built_resources)
         if has_config_files:
             return warnings
         config_files_misplaced = [
             file
-            for file in module.source_paths_by_resource_folder[FunctionLoader.folder_name]
-            if FunctionLoader.is_supported_file(file)
+            for file in module.source_paths_by_resource_folder[FunctionCRUD.folder_name]
+            if FunctionCRUD.is_supported_file(file)
         ]
         if config_files_misplaced:  # and not has_config_files:
             for yaml_source_path in config_files_misplaced:
-                required_location = module.dir / FunctionLoader.folder_name / yaml_source_path.name
+                required_location = module.dir / FunctionCRUD.folder_name / yaml_source_path.name
                 warning = LowSeverityWarning(
                     f"The required Function resource configuration file "
                     f"was not found in {required_location.as_posix()!r}. "

cognite_toolkit/_cdf_tk/builders/_location.py

@@ -1,20 +1,18 @@
 from collections.abc import Callable, Iterable, Sequence
 from graphlib import CycleError, TopologicalSorter
-from pathlib import Path
 from typing import Any
 
 from cognite_toolkit._cdf_tk.builders._base import Builder
-from cognite_toolkit._cdf_tk.constants import INDEX_PATTERN
+from cognite_toolkit._cdf_tk.cruds._resource_cruds.location import LocationFilterCRUD
 from cognite_toolkit._cdf_tk.data_classes._build_files import BuildDestinationFile, BuildSourceFile
 from cognite_toolkit._cdf_tk.data_classes._module_directories import ModuleLocation
 from cognite_toolkit._cdf_tk.exceptions import ToolkitError
-from cognite_toolkit._cdf_tk.loaders._resource_loaders.location_loaders import LocationFilterLoader
 from cognite_toolkit._cdf_tk.tk_warnings.base import ToolkitWarning, WarningList
 from cognite_toolkit._cdf_tk.tk_warnings.fileread import FileReadWarning
 
 
 class LocationBuilder(Builder):
-    _resource_folder = LocationFilterLoader.folder_name
+    _resource_folder = LocationFilterCRUD.folder_name
 
     def build(
         self, source_files: list[BuildSourceFile], module: ModuleLocation, console: Callable[[str], None] | None = None
@@ -32,7 +30,7 @@ class LocationBuilder(Builder):
 
         for source_file in source_files:
             loader, warning = self._get_loader(source_file.source.path)
-            if isinstance(loader, LocationFilterLoader):
+            if isinstance(loader, LocationFilterCRUD):
                 if warning is not None:
                     yield [warning]
                 continue
@@ -49,7 +47,7 @@ class LocationBuilder(Builder):
                 parent_external_id = loaded_location.get("parentExternalId")
 
                 if ext_id:
-                    location_by_external_id[ext_id] = (loaded_location, source_file)
+                    location_by_external_id[ext_id] = loaded_location, source_file
                     location_hierarchy_graph.setdefault(ext_id, [])
 
                     if parent_external_id:
@@ -58,20 +56,23 @@ class LocationBuilder(Builder):
 
             warnings = WarningList[FileReadWarning]()
 
-        ordered_locations = []
+        ordered_locations: list[dict] = []
         try:
             for external_id in TopologicalSorter(location_hierarchy_graph).static_order():
-                (location, _) = location_by_external_id[external_id]
+                if external_id not in location_by_external_id:
+                    # The dependency is not in the module, so we skip it.
+                    continue
+                location, _ = location_by_external_id[external_id]
                 ordered_locations.append(location)
         except CycleError:
             raise ToolkitError(
                 "Circular dependency found in Locations. Locations must be hierarchical. Please check the externalId and parentExternalId fields."
             )
 
-        for i, item in enumerate(ordered_locations):
+        for item in ordered_locations:
             external_id = item["externalId"]
             (location, build_source_file) = location_by_external_id[external_id]
-            destination_path = self._create_file_path(build_source_file.source.path, i, loader.kind)  # type: ignore[union-attr]
+            destination_path = self._create_destination_path(build_source_file.source.path, loader.kind)  # type: ignore[union-attr]
 
             yield BuildDestinationFile(
                 path=destination_path,
@@ -81,24 +82,3 @@ class LocationBuilder(Builder):
                 extra_sources=None,
                 warnings=warnings,
             )
-
-    def _create_file_path(self, source_path: Path, index: int, kind: str) -> Path:
-        """Helper function to prefix the filename with an index that ensures correct deployment order.
-        It also adds the kind as a suffix.
-
-        """
-        filestem = source_path.stem
-        # Get rid of the local index
-        filestem = INDEX_PATTERN.sub("", filestem)
-
-        # Increment to ensure we do not get duplicate filenames when we flatten the file
-        # structure from the module to the build directory.
-        self.resource_counter = index
-
-        filename = f"{self.resource_counter}.{filestem}"
-        if not filename.casefold().endswith(kind.casefold()):
-            filename = f"{filename}.{kind}"
-        filename = f"{filename}{source_path.suffix}"
-        destination_path = self.build_dir / self.resource_folder / filename
-        destination_path.parent.mkdir(parents=True, exist_ok=True)
-        return destination_path