cognite-toolkit 0.7.39__py3-none-any.whl → 0.7.51__py3-none-any.whl

cognite_toolkit/_cdf_tk/commands/_migrate/migration_io.py

@@ -5,10 +5,19 @@ from cognite.client.data_classes import Annotation
 from cognite.client.data_classes.data_modeling import EdgeId, InstanceApply, NodeId
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient
-from cognite_toolkit._cdf_tk.client.data_classes.legacy.pending_instances_ids import PendingInstanceId
-from cognite_toolkit._cdf_tk.client.data_classes.three_d import (
+from cognite_toolkit._cdf_tk.client.http_client import (
+    FailedResponse,
+    HTTPClient,
+    HTTPMessage,
+    ItemsRequest,
+    RequestMessage2,
+    SuccessResponseItems,
+    ToolkitAPIError,
+)
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.pending_instances_ids import PendingInstanceId
+from cognite_toolkit._cdf_tk.client.resource_classes.three_d import (
+    AssetMappingClassicResponse,
     AssetMappingDMRequest,
-    AssetMappingResponse,
     ThreeDModelResponse,
 )
 from cognite_toolkit._cdf_tk.commands._migrate.data_classes import ThreeDMigrationRequest
@@ -29,21 +38,12 @@ from cognite_toolkit._cdf_tk.storageio.selectors import (
 )
 from cognite_toolkit._cdf_tk.tk_warnings import MediumSeverityWarning
 from cognite_toolkit._cdf_tk.utils.collection import chunker_sequence
-from cognite_toolkit._cdf_tk.utils.http_client import (
-    FailedResponse,
-    HTTPClient,
-    HTTPMessage,
-    ItemsRequest,
-    SimpleBodyRequest,
-    SuccessResponseItems,
-    ToolkitAPIError,
-)
 from cognite_toolkit._cdf_tk.utils.useful_types import (
     AssetCentricKindExtended,
     AssetCentricType,
     JsonVal,
-    T_AssetCentricResource,
 )
+from cognite_toolkit._cdf_tk.utils.useful_types2 import T_AssetCentricResource
 
 from .data_classes import (
     AnnotationMapping,
@@ -78,7 +78,7 @@ class AssetCentricMigrationIO(
         self.skip_linking = skip_linking
 
     def as_id(self, item: AssetCentricMapping) -> str:
-        return f"{item.mapping.resource_type}_{item.mapping.id}"
+        return str(item.mapping.as_asset_centric_id())
 
     def stream_data(self, selector: AssetCentricMigrationSelector, limit: int | None = None) -> Iterator[Page]:
         if isinstance(selector, MigrationCSVFileSelector):
@@ -181,7 +181,7 @@ class AssetCentricMigrationIO(
 
         pending_instance_id_endpoint = self.PENDING_INSTANCE_ID_ENDPOINT_BY_KIND[selector.kind]
         results: list[HTTPMessage] = []
-        to_upload = self.link_asset_centric(data_chunk, http_client, results, pending_instance_id_endpoint)
+        to_upload = self.link_asset_centric(data_chunk, http_client, pending_instance_id_endpoint)
         if to_upload:
             results.extend(list(super().upload_items(to_upload, http_client, None)))
         return results
@@ -191,7 +191,6 @@ class AssetCentricMigrationIO(
         cls,
         data_chunk: Sequence[UploadItem[InstanceApply]],
         http_client: HTTPClient,
-        results: list[HTTPMessage],
         pending_instance_id_endpoint: str,
     ) -> Sequence[UploadItem[InstanceApply]]:
         """Links asset-centric resources to their (uncreated) instances using the pending-instance-ids endpoint."""
@@ -212,7 +211,6 @@ class AssetCentricMigrationIO(
             for res in batch_results:
                 if isinstance(res, SuccessResponseItems):
                     successful_linked.update(res.ids)
-            results.extend(batch_results)
         to_upload = [item for item in data_chunk if item.source_id in successful_linked]
         return to_upload
 
@@ -393,7 +391,7 @@ class ThreeDMigrationIO(UploadableStorageIO[ThreeDSelector, ThreeDModelResponse,
         self.data_model_type = data_model_type
 
     def as_id(self, item: ThreeDModelResponse) -> str:
-        return f"{item.name}_{item.id!s}"
+        return item.name
 
     def _is_selected(self, item: ThreeDModelResponse, included_models: set[int] | None) -> bool:
         return self._is_correct_type(item) and (included_models is None or item.id in included_models)
@@ -415,7 +413,7 @@ class ThreeDMigrationIO(UploadableStorageIO[ThreeDSelector, ThreeDModelResponse,
         total = 0
         while True:
             request_limit = min(self.DOWNLOAD_LIMIT, limit - total) if limit is not None else self.DOWNLOAD_LIMIT
-            response = self.client.tool.three_d.models.iterate(
+            response = self.client.tool.three_d.models_classic.paginate(
                 published=published, include_revision_info=True, limit=request_limit, cursor=cursor
             )
             items = [item for item in response.items if self._is_selected(item, included_models)]
@@ -466,18 +464,20 @@ class ThreeDMigrationIO(UploadableStorageIO[ThreeDSelector, ThreeDModelResponse,
         for data in data_chunk:
             if data.source_id not in success_ids:
                 continue
-            revision = http_client.request_with_retries(
-                message=SimpleBodyRequest(
+            revision = http_client.request_single_retries(
+                message=RequestMessage2(
                     endpoint_url=self.client.config.create_api_url(self.REVISION_ENDPOINT),
                     method="POST",
                     body_content={"items": [data.item.revision.dump(camel_case=True)]},
                 )
             )
-            results.extend(revision.as_item_responses(data.source_id))
+            results.append(revision.as_item_response(data.source_id))
         return results
 
 
-class ThreeDAssetMappingMigrationIO(UploadableStorageIO[ThreeDSelector, AssetMappingResponse, AssetMappingDMRequest]):
+class ThreeDAssetMappingMigrationIO(
+    UploadableStorageIO[ThreeDSelector, AssetMappingClassicResponse, AssetMappingDMRequest]
+):
     KIND = "3DMigrationAssetMapping"
     SUPPORTED_DOWNLOAD_FORMATS = frozenset({".ndjson"})
     SUPPORTED_COMPRESSIONS = frozenset({".gz"})
@@ -493,10 +493,12 @@ class ThreeDAssetMappingMigrationIO(UploadableStorageIO[ThreeDSelector, AssetMap
         # We can only migrate asset mappings for 3D models that are already migrated to data modeling.
         self._3D_io = ThreeDMigrationIO(client, data_model_type="data modeling")
 
-    def as_id(self, item: AssetMappingResponse) -> str:
+    def as_id(self, item: AssetMappingClassicResponse) -> str:
         return f"AssetMapping_{item.model_id!s}_{item.revision_id!s}_{item.asset_id!s}"
 
-    def stream_data(self, selector: ThreeDSelector, limit: int | None = None) -> Iterable[Page[AssetMappingResponse]]:
+    def stream_data(
+        self, selector: ThreeDSelector, limit: int | None = None
+    ) -> Iterable[Page[AssetMappingClassicResponse]]:
         total = 0
         for three_d_page in self._3D_io.stream_data(selector, None):
             for model in three_d_page.items:
@@ -510,7 +512,7 @@ class ThreeDAssetMappingMigrationIO(UploadableStorageIO[ThreeDSelector, AssetMap
                     )
                     if limit is not None and total >= limit:
                         return
-                    response = self.client.tool.three_d.asset_mappings.iterate(
+                    response = self.client.tool.three_d.asset_mappings_classic.paginate(
                         model_id=model.id,
                         revision_id=model.last_revision_info.revision_id,
                         cursor=cursor,
@@ -562,6 +564,6 @@ class ThreeDAssetMappingMigrationIO(UploadableStorageIO[ThreeDSelector, AssetMap
         raise NotImplementedError("Deserializing 3D Asset Mappings from JSON is not supported.")
 
     def data_to_json_chunk(
-        self, data_chunk: Sequence[AssetMappingResponse], selector: ThreeDSelector | None = None
+        self, data_chunk: Sequence[AssetMappingClassicResponse], selector: ThreeDSelector | None = None
     ) -> list[dict[str, JsonVal]]:
         raise NotImplementedError("Serializing 3D Asset Mappings to JSON is not supported.")

cognite_toolkit/_cdf_tk/commands/_profile.py

@@ -21,7 +21,7 @@ from rich.spinner import Spinner
 from rich.table import Table
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient
-from cognite_toolkit._cdf_tk.client.data_classes.legacy.raw import RawProfileResults, RawTable
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.raw import RawProfileResults, RawTable
 from cognite_toolkit._cdf_tk.constants import MAX_ROW_ITERATION_RUN_QUERY
 from cognite_toolkit._cdf_tk.exceptions import ToolkitMissingDependencyError, ToolkitThrottledError, ToolkitValueError
 from cognite_toolkit._cdf_tk.utils.aggregators import (

cognite_toolkit/_cdf_tk/commands/_purge.py

@@ -16,7 +16,14 @@ from rich.console import Console
 from rich.panel import Panel
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient
-from cognite_toolkit._cdf_tk.client.data_classes.instance_api import TypedInstanceIdentifier
+from cognite_toolkit._cdf_tk.client.http_client import (
+    HTTPClient,
+    ItemsRequest,
+    ItemsRequest2,
+    ItemsSuccessResponse2,
+    SuccessResponseItems,
+)
+from cognite_toolkit._cdf_tk.client.resource_classes.instance_api import TypedInstanceIdentifier
 from cognite_toolkit._cdf_tk.cruds import (
     AssetCRUD,
     ContainerCRUD,
@@ -59,13 +66,6 @@ from cognite_toolkit._cdf_tk.utils.aggregators import (
     SequenceAggregator,
     TimeSeriesAggregator,
 )
-from cognite_toolkit._cdf_tk.utils.http_client import (
-    HTTPClient,
-    ItemsRequest,
-    ItemsRequest2,
-    ItemsSuccessResponse2,
-    SuccessResponseItems,
-)
 from cognite_toolkit._cdf_tk.utils.producer_worker import ProducerWorkerExecutor
 from cognite_toolkit._cdf_tk.utils.useful_types import JsonVal
 from cognite_toolkit._cdf_tk.utils.validate_access import ValidateAccess

cognite_toolkit/_cdf_tk/commands/_upload.py

@@ -9,6 +9,7 @@ from cognite.client.data_classes.data_modeling import (
 from rich.console import Console
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient
+from cognite_toolkit._cdf_tk.client.http_client import HTTPClient, ItemMessage, SuccessResponseItems
 from cognite_toolkit._cdf_tk.constants import DATA_MANIFEST_SUFFIX, DATA_RESOURCE_DIR
 from cognite_toolkit._cdf_tk.cruds import ViewCRUD
 from cognite_toolkit._cdf_tk.exceptions import ToolkitValueError
@@ -24,7 +25,6 @@ from cognite_toolkit._cdf_tk.storageio.selectors._instances import InstanceSpace
 from cognite_toolkit._cdf_tk.tk_warnings import HighSeverityWarning, MediumSeverityWarning, ToolkitWarning
 from cognite_toolkit._cdf_tk.utils.auth import EnvironmentVariables
 from cognite_toolkit._cdf_tk.utils.fileio import MultiFileReader
-from cognite_toolkit._cdf_tk.utils.http_client import HTTPClient, ItemMessage, SuccessResponseItems
 from cognite_toolkit._cdf_tk.utils.producer_worker import ProducerWorkerExecutor
 from cognite_toolkit._cdf_tk.utils.progress_tracker import ProgressTracker
 from cognite_toolkit._cdf_tk.utils.useful_types import JsonVal

cognite_toolkit/_cdf_tk/commands/build_cmd.py

@@ -11,10 +11,10 @@ from rich import print
 from rich.panel import Panel
 from rich.progress import track
 
-from cognite_toolkit._cdf_tk.builders import Builder, create_builder
+from cognite_toolkit._cdf_tk.builders import Builder, FunctionBuilder, create_builder
 from cognite_toolkit._cdf_tk.cdf_toml import CDFToml
 from cognite_toolkit._cdf_tk.client import ToolkitClient
-from cognite_toolkit._cdf_tk.client.data_classes.legacy.raw import RawDatabase
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.raw import RawDatabase
 from cognite_toolkit._cdf_tk.commands._base import ToolkitCommand
 from cognite_toolkit._cdf_tk.constants import (
     _RUNNING_IN_BROWSER,
@@ -33,6 +33,7 @@ from cognite_toolkit._cdf_tk.cruds import (
     DataSetsCRUD,
     ExtractionPipelineConfigCRUD,
     FileCRUD,
+    FunctionCRUD,
     LocationFilterCRUD,
     NodeCRUD,
     RawDatabaseCRUD,
@@ -415,6 +416,15 @@ class BuildCommand(ToolkitCommand):
 
             build_resources_by_folder[resource_name].extend(built_resources)
 
+            # Collect validation metrics from FunctionBuilder
+            if resource_name == FunctionCRUD.folder_name and isinstance(builder, FunctionBuilder):
+                self._additional_tracking_info.function_validation_count += builder.validation_count
+                self._additional_tracking_info.function_validation_failures += builder.validation_failures
+                self._additional_tracking_info.function_validation_credential_errors += (
+                    builder.validation_credential_errors
+                )
+                self._additional_tracking_info.function_validation_time_ms += builder.validation_time_ms
+
         return build_resources_by_folder
 
     def _get_builder(self, build_dir: Path, resource_name: str) -> Builder:

cognite_toolkit/_cdf_tk/commands/build_v2/_module_parser.py

@@ -0,0 +1,138 @@
+from pathlib import Path
+
+from cognite_toolkit._cdf_tk.constants import EXCL_FILES, MODULES
+from cognite_toolkit._cdf_tk.cruds import CRUDS_BY_FOLDER_NAME, CRUDS_BY_FOLDER_NAME_INCLUDE_ALPHA
+from cognite_toolkit._cdf_tk.data_classes import IssueList
+from cognite_toolkit._cdf_tk.data_classes._issues import ModuleLoadingIssue
+from cognite_toolkit._cdf_tk.exceptions import ToolkitError
+from cognite_toolkit._cdf_tk.utils import humanize_collection, module_path_display_name
+
+
+class ModulesParser:
+    def __init__(self, organization_dir: Path, selected: list[str | Path] | None = None):
+        self.organization_dir = organization_dir
+        self.selected = selected
+
+    def parse(self) -> tuple[list[Path], IssueList]:
+        modules_root = self.organization_dir / MODULES
+        if not modules_root.exists():
+            raise ToolkitError(f"Module root directory '{modules_root}' not found")
+
+        module_paths: list[Path] = []
+        excluded_module_paths: list[Path] = []
+        issues: IssueList = IssueList()
+        for resource_file in self.organization_dir.glob("**/*.y*ml"):
+            if resource_file.name in EXCL_FILES:
+                continue
+
+            # Get the module folder for the resource file.
+            module_path = self._get_module_path_from_resource_file_path(resource_file)
+            if not module_path:
+                continue
+
+            # If the module has already been processed, skip it.
+            if module_path in module_paths or module_path in excluded_module_paths:
+                continue
+
+            # Skip the modules that do not match the selection
+            if not self._matches_selection(module_path, modules_root, self.selected):
+                excluded_module_paths.append(module_path)
+                continue
+
+            module_paths.append(module_path)
+
+        deepest_module_paths = self._find_modules_with_submodules(module_paths)
+        parent_module_paths = set(module_paths) - set(deepest_module_paths)
+        if parent_module_paths:
+            module_paths = deepest_module_paths
+            issues.extend(
+                ModuleLoadingIssue(
+                    message=f"Module {module_path_display_name(self.organization_dir, parent_module_path)!r} is skipped because it has submodules"
+                )
+                for parent_module_path in parent_module_paths
+            )
+
+        valid_module_paths: list[Path] = []
+        for module_path in module_paths:
+            valid_module_path, issue = self._check_resource_folder_content(module_path)
+            if issue:
+                issues.append(issue)
+            if valid_module_path:
+                valid_module_paths.append(valid_module_path)
+
+        return valid_module_paths, issues
+
+    def _get_module_path_from_resource_file_path(self, resource_file: Path) -> Path | None:
+        # recognize the module by containing a resource associated by a CRUD.
+        # Special case: if the resource folder is a subfolder of a CRUD, return the parent of the subfolder.
+        resource_folder = resource_file.parent
+        crud = next(iter(CRUDS_BY_FOLDER_NAME_INCLUDE_ALPHA.get(resource_folder.name, [])), None)
+        if crud:
+            # iterate over the parents of the resource folder until we find the module folder.
+            # This is to handle the special case of a subfolder of a CRUD, or yamls in for example function subfolders.
+            for p in resource_file.parents:
+                if p.name == crud.folder_name:
+                    return p.parent
+                if p.name == MODULES:
+                    return p
+        return None
+
+    def _check_resource_folder_content(self, module_path: Path) -> tuple[None | Path, ModuleLoadingIssue | None]:
+        resource_folder_names = {d.name for d in module_path.iterdir() if d.is_dir()}
+        unrecognized_resource_folder_names = resource_folder_names - CRUDS_BY_FOLDER_NAME.keys()
+
+        issue = (
+            ModuleLoadingIssue(
+                message=f"Module {module_path_display_name(self.organization_dir, module_path)!r} contains unrecognized resource folder(s): {humanize_collection(unrecognized_resource_folder_names)}"
+            )
+            if unrecognized_resource_folder_names
+            else None
+        )
+
+        has_valid_resource_folders = bool(resource_folder_names & CRUDS_BY_FOLDER_NAME.keys())
+        return (module_path if has_valid_resource_folders else None, issue)
+
+    def _matches_selection(self, module_path: Path, modules_root: Path, selected: list[str | Path] | None) -> bool:
+        if not selected:
+            return True
+
+        rel = module_path.relative_to(modules_root)
+        rel_parts = [p.lower() for p in rel.parts]
+        if not rel_parts:
+            # module_path is the modules_root itself
+            return False
+        name_lower = rel_parts[-1]
+        modules_lower = MODULES.lower()
+
+        for sel in selected:
+            sel_path = Path(sel) if isinstance(sel, str) else sel
+
+            sel_parts = [p.lower() for p in sel_path.parts]
+            if not sel_parts:
+                continue
+
+            if sel_parts[0] == modules_lower:
+                sel_parts = sel_parts[1:]
+
+            if not sel_parts:
+                return True
+
+            if len(sel_parts) == 1 and name_lower == sel_parts[0]:
+                return True
+
+            if rel_parts[: len(sel_parts)] == sel_parts:
+                return True
+
+        return False
+
+    def _find_modules_with_submodules(self, module_paths: list[Path]) -> list[Path]:
+        """Remove parent modules when they have submodules. Keep only the deepest modules."""
+        return [
+            module_path
+            for module_path in module_paths
+            if not any(
+                module_path in other_module_path.parents
+                for other_module_path in module_paths
+                if other_module_path != module_path
+            )
+        ]

cognite_toolkit/_cdf_tk/commands/build_v2/_modules_parser.py

@@ -0,0 +1,163 @@
+from pathlib import Path
+
+from cognite_toolkit._cdf_tk.constants import EXCL_FILES, MODULES
+from cognite_toolkit._cdf_tk.cruds import CRUDS_BY_FOLDER_NAME, CRUDS_BY_FOLDER_NAME_INCLUDE_ALPHA
+from cognite_toolkit._cdf_tk.data_classes import IssueList
+from cognite_toolkit._cdf_tk.data_classes._issues import ModuleLoadingIssue
+from cognite_toolkit._cdf_tk.exceptions import ToolkitError
+from cognite_toolkit._cdf_tk.utils import module_path_display_name
+
+
+class ModulesParser:
+    def __init__(self, organization_dir: Path, selected: list[str | Path] | None = None):
+        self.organization_dir = organization_dir
+        self.selected = selected
+        self.issues = IssueList()
+
+    def parse(self) -> list[Path]:
+        modules_root = self.organization_dir / MODULES
+        if not modules_root.exists():
+            raise ToolkitError(f"Module root directory '{modules_root.as_posix()}' not found")
+
+        module_paths: list[Path] = []
+        for resource_file in self.organization_dir.glob("**/*.y*ml"):
+            if resource_file.name in EXCL_FILES:
+                continue
+
+            # Get the module folder for the resource file.
+            module_path = self._get_module_path_from_resource_file_path(resource_file)
+            if not module_path:
+                continue
+
+            # If the module has already been processed, skip it.
+            if module_path in module_paths:
+                continue
+
+            module_paths.append(module_path)
+
+        deepest_module_paths = self._find_modules_with_submodules(module_paths)
+        parent_module_paths = set(module_paths) - set(deepest_module_paths)
+        if parent_module_paths:
+            module_paths = deepest_module_paths
+            self.issues.extend(
+                ModuleLoadingIssue(
+                    message=f"Module {module_path_display_name(self.organization_dir, parent_module_path)!r} is skipped because it has submodules",
+                )
+                for parent_module_path in parent_module_paths
+            )
+
+        all_module_paths = module_paths
+
+        if self.selected:
+            normalized_selected = self._normalize_selection(self.selected)
+            selected_module_paths = [
+                module_path
+                for module_path in all_module_paths
+                if self._matches_selection(module_path, modules_root, normalized_selected)
+            ]
+            for selected_module in self.selected:
+                normalized_selected_item = self._normalize_selection([selected_module])
+                has_match = any(
+                    self._matches_selection(found_module, modules_root, normalized_selected_item)
+                    for found_module in all_module_paths
+                )
+                if not has_match:
+                    self.issues.append(
+                        ModuleLoadingIssue(
+                            message=f"Module '{selected_module}' not found",
+                        )
+                    )
+
+            module_paths = selected_module_paths
+
+        valid_module_paths: list[Path] = []
+        for module_path in module_paths:
+            valid_module_path, issue = self._check_resource_folder_content(module_path)
+            if issue:
+                self.issues.append(issue)
+            if valid_module_path:
+                valid_module_paths.append(valid_module_path)
+
+        return valid_module_paths
+
+    def _get_module_path_from_resource_file_path(self, resource_file: Path) -> Path | None:
+        # recognize the module by traversing the parents of the resource file until we find a CRUD folder
+
+        for parent in resource_file.parents:
+            if parent.name in CRUDS_BY_FOLDER_NAME_INCLUDE_ALPHA:
+                # special case: if the crud is FunctionCRUD, the resource file has to be a direct descendent.
+                if parent.name == "functions" and resource_file.parent.name != "functions":
+                    return None
+                return parent.parent
+            if parent.name == MODULES:
+                return parent
+        return None
+
+    def _check_resource_folder_content(self, module_path: Path) -> tuple[None | Path, ModuleLoadingIssue | None]:
+        resource_folder_names = {d.name for d in module_path.iterdir() if d.is_dir()}
+        unrecognized_resource_folder_names = resource_folder_names - CRUDS_BY_FOLDER_NAME.keys()
+
+        issue = (
+            ModuleLoadingIssue(
+                message=f"Module {module_path_display_name(self.organization_dir, module_path)!r} contains unrecognized resource folder(s): {', '.join(unrecognized_resource_folder_names)}"
+            )
+            if unrecognized_resource_folder_names
+            else None
+        )
+
+        has_valid_resource_folders = bool(resource_folder_names & CRUDS_BY_FOLDER_NAME.keys())
+        return (module_path if has_valid_resource_folders else None, issue)
+
+    def _matches_selection(
+        self, module_path: Path, modules_root: Path, normalized_selected: list[tuple[str, ...]] | None
+    ) -> bool:
+        if not normalized_selected:
+            return True
+
+        rel = module_path.relative_to(modules_root)
+        rel_parts = tuple(p.lower() for p in rel.parts)
+        if not rel_parts:
+            # module_path is the modules_root itself
+            return False
+        name_lower = rel_parts[-1]
+
+        for sel_parts in normalized_selected:
+            if not sel_parts:
+                return True
+
+            if len(sel_parts) == 1 and name_lower == sel_parts[0]:
+                return True
+
+            if rel_parts[: len(sel_parts)] == sel_parts:
+                return True
+
+        return False
+
+    def _normalize_selection(self, selected: list[str | Path]) -> list[tuple[str, ...]]:
+        normalized: list[tuple[str, ...]] = []
+        modules_lower = MODULES.lower()
+        for sel in selected:
+            if isinstance(sel, Path):
+                sel_parts = sel.parts
+            else:
+                sel_parts = tuple(part for part in str(sel).replace("\\", "/").split("/") if part)
+
+            sel_parts_lower = tuple(part.lower() for part in sel_parts)
+            if sel_parts_lower and sel_parts_lower[0] == modules_lower:
+                sel_parts_lower = sel_parts_lower[1:]
+
+            normalized.append(sel_parts_lower)
+
+        return normalized
+
+    def _find_modules_with_submodules(self, module_paths: list[Path]) -> list[Path]:
+        """Remove parent modules when they have submodules. Keep only the deepest modules."""
+        return [
+            module_path
+            for module_path in module_paths
+            if not any(
+                module_path in other_module_path.parents
+                for other_module_path in module_paths
+                if other_module_path != module_path
+            )
+        ]