cognite-neat 0.95.0__tar.gz → 0.96.1__tar.gz

{cognite_neat-0.95.0 → cognite_neat-0.96.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cognite-neat
-Version: 0.95.0
+Version: 0.96.1
 Summary: Knowledge graph transformation
 Home-page: https://cognite-neat.readthedocs-hosted.com/
 License: Apache-2.0
@@ -17,7 +17,6 @@ Provides-Extra: all
 Provides-Extra: docs
 Provides-Extra: google
 Provides-Extra: graphql
-Provides-Extra: jupyter
 Provides-Extra: oxi
 Provides-Extra: service
 Requires-Dist: PyYAML
@@ -28,9 +27,7 @@ Requires-Dist: fastapi (>=0,<1) ; extra == "service" or extra == "all"
 Requires-Dist: google-api-python-client ; extra == "google"
 Requires-Dist: google-auth-oauthlib ; extra == "google"
 Requires-Dist: gspread ; extra == "google"
-Requires-Dist: ipycytoscape (>=1.3.3,<2.0.0)
 Requires-Dist: jinja2 (>=3.1.2,<4.0.0) ; extra == "graphql" or extra == "all"
-Requires-Dist: matplotlib (==3.5.2)
 Requires-Dist: mkdocs ; extra == "docs"
 Requires-Dist: mkdocs-autorefs (>=0.5.0,<0.6.0) ; extra == "docs"
 Requires-Dist: mkdocs-git-authors-plugin ; extra == "docs"
@@ -49,9 +46,10 @@ Requires-Dist: pydantic (>=2,<3)
 Requires-Dist: pymdown-extensions ; extra == "docs"
 Requires-Dist: pyoxigraph (==0.3.19) ; extra == "oxi" or extra == "all"
 Requires-Dist: python-multipart (==0.0.9) ; extra == "service" or extra == "all"
+Requires-Dist: pyvis (>=0.3.2,<0.4.0)
 Requires-Dist: rdflib
 Requires-Dist: requests
-Requires-Dist: rich[jupyter] (>=13.7.1,<14.0.0) ; extra == "jupyter"
+Requires-Dist: rich[jupyter] (>=13.7.1,<14.0.0)
 Requires-Dist: schedule (>=1,<2) ; extra == "service" or extra == "all"
 Requires-Dist: tomli (>=2.0.1,<3.0.0) ; python_version < "3.11"
 Requires-Dist: typing_extensions (>=4.8,<5.0) ; python_version < "3.11"

{cognite_neat-0.95.0 → cognite_neat-0.96.1}/cognite/neat/_constants.py

@@ -5,6 +5,32 @@ from rdflib import DCTERMS, OWL, RDF, RDFS, SKOS, XSD, Namespace, URIRef
 
 from cognite import neat
 
+
+def _is_in_notebook() -> bool:
+    try:
+        from IPython import get_ipython
+
+        if "IPKernelApp" not in get_ipython().config:  # pragma: no cover
+            return False
+    except ImportError:
+        return False
+    except AttributeError:
+        return False
+    return True
+
+
+def _is_in_browser() -> bool:
+    try:
+        from pyodide.ffi import IN_BROWSER  # type: ignore [import-not-found]
+    except ModuleNotFoundError:
+        return False
+    return IN_BROWSER
+
+
+IN_PYODIDE = _is_in_browser()
+IN_NOTEBOOK = _is_in_notebook() or IN_PYODIDE
+
+
 PACKAGE_DIRECTORY = Path(neat.__file__).parent
 COGNITE_MODELS = (
     DataModelId("cdf_cdm", "CogniteCore", "v1"),

{cognite_neat-0.95.0 → cognite_neat-0.96.1}/cognite/neat/_issues/_base.py

@@ -11,7 +11,12 @@ from typing import Any, ClassVar, Literal, TypeAlias, TypeVar, get_args, get_ori
 from warnings import WarningMessage
 
 import pandas as pd
-from cognite.client.data_classes.data_modeling import ContainerId, PropertyId, ViewId
+from cognite.client.data_classes.data_modeling import (
+    ContainerId,
+    DataModelId,
+    PropertyId,
+    ViewId,
+)
 from pydantic_core import ErrorDetails
 
 from cognite.neat._utils.spreadsheet import SpreadsheetRead
@@ -67,7 +72,7 @@ class NeatIssue:
     extra: ClassVar[str | None] = None
     fix: ClassVar[str | None] = None
 
-    def as_message(self) -> str:
+    def as_message(self, include_type: bool = True) -> str:
         """Return a human-readable message for the issue."""
         template = self.__doc__
         if not template:
@@ -79,8 +84,10 @@ class NeatIssue:
             msg += "\n" + self.extra.format(**variables)
         if self.fix:
             msg += f"\nFix: {self.fix.format(**variables)}"
-        name = type(self).__name__
-        return f"{name}: {msg}"
+        if include_type:
+            name = type(self).__name__
+            msg = f"{name}: {msg}"
+        return msg
 
     def _get_variables(self) -> tuple[dict[str, str], bool]:
         variables: dict[str, str] = {}
@@ -123,6 +130,8 @@ class NeatIssue:
             return value.dump()
         elif isinstance(value, PropertyId):
             return value.dump(camel_case=True)
+        elif isinstance(value, DataModelId):
+            return value.dump(camel_case=True, include_type=False)
         raise ValueError(f"Unsupported type: {type(value)}")
 
     @classmethod
@@ -169,6 +178,8 @@ class NeatIssue:
             return tuple(cls._load_value(subtype, item) for item in value)
         elif type_ is ViewId:
             return ViewId.load(value)
+        elif type_ is DataModelId:
+            return DataModelId.load(value)
         elif type_ is PropertyId:
             return PropertyId.load(value)
         elif type_ is ContainerId:
@@ -266,7 +277,7 @@ class DefaultPydanticError(NeatError, ValueError):
             msg=error["msg"],
         )
 
-    def as_message(self) -> str:
+    def as_message(self, include_type: bool = True) -> str:
         if self.loc and len(self.loc) == 1:
             return f"{self.loc[0]} sheet: {self.msg}"
         elif self.loc and len(self.loc) == 2:
@@ -307,7 +318,7 @@ class RowError(NeatError, ValueError):
             url=str(url) if (url := error.get("url")) else None,
         )
 
-    def as_message(self) -> str:
+    def as_message(self, include_type: bool = True) -> str:
         input_str = str(self.input) if self.input is not None else ""
         input_str = input_str[:50] + "..." if len(input_str) > 50 else input_str
         output = (
@@ -350,7 +361,7 @@ class DefaultWarning(NeatWarning):
             source=warning.source,
         )
 
-    def as_message(self) -> str:
+    def as_message(self, include_type: bool = True) -> str:
         return str(self.warning)
 
 
@@ -421,7 +432,12 @@ class IssueList(NeatIssueList[NeatIssue]):
     def _repr_html_(self) -> str | None:
         if not self:
             return "<p>'No issues found'</p>"
-        return super()._repr_html_()
+        df = self.to_pandas()
+        agg_df = df["NeatIssue"].value_counts().to_frame()
+        if len(agg_df) < 10:
+            return agg_df._repr_html_()  # type: ignore[operator]
+        else:
+            return agg_df.head()._repr_html_()  # type: ignore[operator]
 
 
 T_Cls = TypeVar("T_Cls")

{cognite_neat-0.95.0 → cognite_neat-0.96.1}/cognite/neat/_issues/errors/_resources.py

@@ -40,7 +40,7 @@ class ResourceNotFoundError(ResourceError, Generic[T_Identifier, T_ReferenceIden
     referred_type: ResourceType | None = None
     more: str | None = None
 
-    def as_message(self) -> str:
+    def as_message(self, include_type: bool = True) -> str:
         msg = (self.__doc__ or "").format(resource_type=self.resource_type, identifier=self.identifier)
         if self.referred_by and self.referred_type:
             msg += self.extra.format(referred_type=self.referred_type, referred_by=self.referred_by)
@@ -99,7 +99,7 @@ class ResourceChangedError(ResourceError[T_Identifier]):
     changed_properties: frozenset[str]
     changed_attributes: frozenset[str]
 
-    def as_message(self) -> str:
+    def as_message(self, include_type: bool = True) -> str:
         if self.changed_properties:
             changed = f" properties {humanize_collection(self.changed_properties)}."
         elif self.changed_attributes:

{cognite_neat-0.95.0 → cognite_neat-0.96.1}/cognite/neat/_issues/warnings/_models.py

@@ -2,7 +2,7 @@ from abc import ABC
 from dataclasses import dataclass
 from typing import ClassVar
 
-from cognite.client.data_classes.data_modeling import ViewId
+from cognite.client.data_classes.data_modeling import DataModelId, ViewId
 
 from cognite.neat._constants import DMS_VIEW_CONTAINER_SIZE_LIMIT
 from cognite.neat._issues import NeatWarning
@@ -18,7 +18,7 @@ class BreakingModelingPrincipleWarning(NeatWarning, ABC):
     url: ClassVar[str]
     specific: str
 
-    def as_message(self) -> str:
+    def as_message(self, include_type: bool = True) -> str:
         principle = type(self).__name__.removesuffix("Warning")
         url = f"{_BASE_URL}#{self.url}"
         return (self.__doc__ or "").format(
@@ -90,3 +90,21 @@ class NotSupportedHasDataFilterLimitWarning(CDFNotSupportedWarning):
     view_id: ViewId
     count: int
     limit: int = DMS_VIEW_CONTAINER_SIZE_LIMIT
+
+
+@dataclass(unsafe_hash=True)
+class EnterpriseModelNotBuildOnTopOfCDMWarning(UserModelingWarning):
+    """Enterprise data model being build on top {reference_model_id}. This is not recommended."""
+
+    fix = "Always build Enterprise Data Model on top of Cognite Data Model such as Core Data Model."
+
+    reference_model_id: DataModelId
+
+
+@dataclass(unsafe_hash=True)
+class SolutionModelBuildOnTopOfCDMWarning(UserModelingWarning):
+    """Solution data model being build on top Cognite Data Model {reference_model_id}. This is not recommended."""
+
+    fix = "Always build solution data model on top of enterprise data model."
+
+    reference_model_id: DataModelId

{cognite_neat-0.95.0 → cognite_neat-0.96.1}/cognite/neat/_rules/exporters/_rules2excel.py

@@ -13,6 +13,7 @@ from openpyxl.styles import Alignment, Border, Font, PatternFill, Side
 from openpyxl.worksheet.worksheet import Worksheet
 from rdflib import Namespace
 
+from cognite.neat._constants import COGNITE_MODELS
 from cognite.neat._rules._shared import VerifiedRules
 from cognite.neat._rules.models import (
     DataModelType,
@@ -21,6 +22,7 @@ from cognite.neat._rules.models import (
     SheetRow,
 )
 from cognite.neat._rules.models.dms import DMSMetadata
+from cognite.neat._rules.models.dms._rules import DMSRules
 from cognite.neat._rules.models.domain import DomainMetadata
 from cognite.neat._rules.models.information import InformationMetadata
 from cognite.neat._rules.models.information._rules import InformationRules
@@ -134,8 +136,12 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
             self._write_metadata_sheet(workbook, dumped_last_rules["Metadata"], sheet_prefix="Last")
 
         if dumped_reference_rules:
-            self._write_sheets(workbook, dumped_reference_rules, rules, sheet_prefix="Ref")
-            self._write_metadata_sheet(workbook, dumped_reference_rules["Metadata"], sheet_prefix="Ref")
+            if isinstance(rules.reference, DMSRules):
+                sheet_prefix = "CDM" if rules.reference.metadata.as_data_model_id() in COGNITE_MODELS else "Ref"
+            else:
+                sheet_prefix = "Ref"
+            self._write_sheets(workbook, dumped_reference_rules, rules, sheet_prefix=sheet_prefix)
+            self._write_metadata_sheet(workbook, dumped_reference_rules["Metadata"], sheet_prefix=sheet_prefix)
 
         if isinstance(rules, InformationRules) and rules.prefixes:
             self._write_prefixes_sheet(workbook, rules.prefixes)

{cognite_neat-0.95.0 → cognite_neat-0.96.1}/cognite/neat/_rules/transformers/__init__.py

@@ -6,6 +6,7 @@ from ._converters import (
     InformationToAsset,
     InformationToDMS,
     ReduceCogniteModel,
+    SetIDDMSModel,
     ToCompliantEntities,
     ToExtension,
 )
@@ -31,4 +32,5 @@ __all__ = [
     "RuleMapper",
     "ToExtension",
     "ReduceCogniteModel",
+    "SetIDDMSModel",
 ]

{cognite_neat-0.95.0 → cognite_neat-0.96.1}/cognite/neat/_rules/transformers/_converters.py

@@ -12,6 +12,10 @@ from rdflib import Namespace
 
 from cognite.neat._constants import COGNITE_MODELS, DMS_CONTAINER_PROPERTY_SIZE_LIMIT
 from cognite.neat._issues.errors import NeatValueError
+from cognite.neat._issues.warnings._models import (
+    EnterpriseModelNotBuildOnTopOfCDMWarning,
+    SolutionModelBuildOnTopOfCDMWarning,
+)
 from cognite.neat._issues.warnings.user_modeling import ParentInDifferentSpaceWarning
 from cognite.neat._rules._constants import EntityTypes
 from cognite.neat._rules._shared import InputRules, JustRules, OutRules, VerifiedRules
@@ -29,6 +33,7 @@ from cognite.neat._rules.models import (
 )
 from cognite.neat._rules.models.data_types import DataType, String
 from cognite.neat._rules.models.dms import DMSMetadata, DMSProperty, DMSView
+from cognite.neat._rules.models.dms._rules import DMSContainer
 from cognite.neat._rules.models.entities import (
     AssetEntity,
     AssetFields,
@@ -49,6 +54,8 @@ from cognite.neat._rules.models.information._rules_input import (
     InformationInputProperty,
     InformationInputRules,
 )
+from cognite.neat._utils.collection_ import remove_list_elements
+from cognite.neat._utils.text import to_camel
 
 from ._base import RulesTransformer
 
@@ -227,61 +234,173 @@ class ConvertToRules(ConversionTransformer[VerifiedRules, VerifiedRules]):
 _T_Entity = TypeVar("_T_Entity", bound=ClassEntity | ViewEntity)
 
 
+class SetIDDMSModel(RulesTransformer[DMSRules, DMSRules]):
+    def __init__(self, new_id: DataModelId | tuple[str, str, str]):
+        self.new_id = DataModelId.load(new_id)
+
+    def transform(self, rules: DMSRules | OutRules[DMSRules]) -> JustRules[DMSRules]:
+        if self.new_id.version is None:
+            raise NeatValueError("Version is required when setting a new Data Model ID")
+        dump = self._to_rules(rules).dump()
+        dump["metadata"]["space"] = self.new_id.space
+        dump["metadata"]["external_id"] = self.new_id.external_id
+        dump["metadata"]["version"] = self.new_id.version
+        # Serialize and deserialize to set the new space and external_id
+        # as the default values for the new model.
+        return JustRules(DMSRules.model_validate(DMSInputRules.load(dump).dump()))
+
+
 class ToExtension(RulesTransformer[DMSRules, DMSRules]):
     def __init__(
         self,
         new_model_id: DataModelIdentifier,
-        org_name: str | None = None,
-        mode: Literal["composition"] = "composition",
+        org_name: str = "My",
+        type_: Literal["enterprise", "solution"] = "enterprise",
+        mode: Literal["read", "write"] = "read",
+        dummy_property: str = "GUID",
     ):
         self.new_model_id = DataModelId.load(new_model_id)
+        if not self.new_model_id.version:
+            raise NeatValueError("Version is required for the new model.")
+
         self.org_name = org_name
         self.mode = mode
+        self.type_ = type_
+        self.dummy_property = dummy_property
 
     def transform(self, rules: DMSRules | OutRules[DMSRules]) -> JustRules[DMSRules]:
         # Copy to ensure immutability
-        verified = self._to_rules(rules)
-        if self.org_name is None and verified.metadata.as_data_model_id() in COGNITE_MODELS:
-            raise NeatValueError(f"Prefix is required when extending {verified.metadata.as_data_model_id()}")
-        source_id = verified.metadata.as_data_model_id()
+        reference_model = self._to_rules(rules)
+        reference_model_id = reference_model.metadata.as_data_model_id()
+
+        # if model is solution then we need to get correct space for views and containers
+        if self.type_ == "solution":
+            if self.mode not in ["read", "write"]:
+                raise NeatValueError(f"Unsupported mode: {self.mode}")
+
+            if reference_model_id in COGNITE_MODELS:
+                warnings.warn(
+                    SolutionModelBuildOnTopOfCDMWarning(reference_model_id=reference_model_id),
+                    stacklevel=2,
+                )
 
-        dump = verified.dump()
+            return self._to_solution(reference_model)
+
+        elif self.type_ == "enterprise":
+            if reference_model_id not in COGNITE_MODELS:
+                warnings.warn(
+                    EnterpriseModelNotBuildOnTopOfCDMWarning(reference_model_id=reference_model_id).as_message(),
+                    stacklevel=2,
+                )
+
+            return self._to_enterprise(reference_model)
+
+        else:
+            raise NeatValueError(f"Unsupported data model type: {self.type_}")
+
+    def _has_views_in_multiple_space(self, rules: DMSRules) -> bool:
+        return any(view.view.space != rules.metadata.space for view in rules.views)
+
+    def _to_solution(self, reference_rules: DMSRules) -> JustRules[DMSRules]:
+        """For creation of solution data model / rules specifically for mapping over existing containers."""
+
+        dump = reference_rules.dump()
+
+        # Prepare new model metadata prior validation
         dump["metadata"]["schema_"] = SchemaCompleteness.partial.value
+        dump["metadata"]["data_model_type"] = self.type_
+        dump["metadata"]["name"] = f"{self.org_name} {self.type_} data model"
         dump["metadata"]["space"] = self.new_model_id.space
         dump["metadata"]["external_id"] = self.new_model_id.external_id
-        if self.new_model_id.version is not None:
-            dump["metadata"]["version"] = self.new_model_id.version
-        # Serialize and deserialize to set the new space and external_id
-        # as the default values for the new model.
-        new_model = DMSRules.model_validate(DMSInputRules.load(dump).dump())
+        dump["metadata"]["version"] = self.new_model_id.version
+
+        # dropping reference and last from the dump as they can cause validation
+        # issues especially if reference is enterprise model build on top of CDM
+        dump.pop("reference", None)
+        dump.pop("last", None)
 
-        # Write back the original space and external_id for the container of the new model.
-        for prop in new_model.properties:
+        # Set implement to NONE for all views
+        for view in dump["views"]:
+            view["implements"] = None
+
+        if self._has_views_in_multiple_space(reference_rules):
+            views_to_remove = []
+            for view in dump["views"]:
+                if ":" in view["view"]:
+                    views_to_remove.append(view)
+
+            dump["views"] = remove_list_elements(dump["views"], views_to_remove)
+
+        solution_model = DMSRules.model_validate(DMSInputRules.load(dump).dump())
+
+        # Dropping containers coming from reference model
+        solution_model.containers = SheetList[DMSContainer]()
+
+        # We want to map properties to existing containers allowing extension
+        for prop in solution_model.properties:
             if prop.container and prop.container.space == self.new_model_id.space:
                 prop.container = ContainerEntity(
-                    space=source_id.space,
+                    space=reference_rules.metadata.space,
                     externalId=prop.container.suffix,
                 )
 
-        if self.mode == "composition":
-            new_model.containers = None
-            for view in new_model.views:
-                view.implements = None
-
-        if source_id in COGNITE_MODELS:
-            # Remove CognitePrefixes.
-            for prop in new_model.properties:
-                prop.view = self._remove_cognite_prefix(prop.view)
-                prop.class_ = self._remove_cognite_prefix(prop.class_)
+        # If reference model on which we are mapping one of Cognite Data Models
+        # since we want to affix these with the organization name
+        if reference_rules.metadata.as_data_model_id() in COGNITE_MODELS:
+            # Remove Cognite affix in view external_id / suffix.
+            for prop in solution_model.properties:
+                prop.view = self._remove_cognite_affix(prop.view)
+                prop.class_ = self._remove_cognite_affix(prop.class_)
                 if isinstance(prop.value_type, ViewEntity):
-                    prop.value_type = self._remove_cognite_prefix(prop.value_type)
-            for view in new_model.views:
-                view.view = self._remove_cognite_prefix(view.view)
-                view.class_ = self._remove_cognite_prefix(view.class_)
+                    prop.value_type = self._remove_cognite_affix(prop.value_type)
+            for view in solution_model.views:
+                view.view = self._remove_cognite_affix(view.view)
+                view.class_ = self._remove_cognite_affix(view.class_)
 
-        return JustRules(new_model)
+        if self.mode == "write":
+            _, new_containers, new_properties = self._get_new_components(solution_model)
 
-    def _remove_cognite_prefix(self, entity: _T_Entity) -> _T_Entity:
+            # Here we add ONLY dummy properties of the solution model and
+            # corresponding solution model space containers to hold them
+            solution_model.containers.extend(new_containers)
+            solution_model.properties.extend(new_properties)
+
+        return JustRules(solution_model)
+
+    def _to_enterprise(self, reference_model: DMSRules) -> JustRules[DMSRules]:
+        dump = reference_model.dump()
+
+        # This is must prior model validation to avoid validation issues
+        dump["metadata"]["schema_"] = SchemaCompleteness.partial.value
+
+        # This will create reference model components in the enterprise model space
+        enterprise_model = DMSRules.model_validate(DMSInputRules.load(dump).dump())
+
+        # Post validation metadata update:
+        enterprise_model.metadata.name = self.type_
+        enterprise_model.metadata.name = f"{self.org_name} {self.type_} data model"
+        enterprise_model.metadata.space = self.new_model_id.space
+        enterprise_model.metadata.external_id = self.new_model_id.external_id
+        enterprise_model.metadata.version = cast(str, self.new_model_id.version)
+
+        if reference_model.metadata.as_data_model_id() in COGNITE_MODELS:
+            enterprise_model.reference = reference_model
+
+        # Here we are creating enterprise specific components
+        enterprise_views, enterprise_containers, enterprise_properties = self._get_new_components(enterprise_model)
+
+        # And we are adding them to the enterprise model
+        # extending reference views with new ones
+        enterprise_model.views.extend(enterprise_views)
+
+        # while overwriting containers and properties with new ones
+        enterprise_model.containers = enterprise_containers
+        enterprise_model.properties = enterprise_properties
+
+        return JustRules(enterprise_model)
+
+    def _remove_cognite_affix(self, entity: _T_Entity) -> _T_Entity:
+        """This method removes `Cognite` affix from the entity."""
         new_suffix = entity.suffix.replace("Cognite", self.org_name or "")
         if isinstance(entity, ViewEntity):
             return ViewEntity(space=entity.space, externalId=new_suffix, version=entity.version)  # type: ignore[return-value]
@@ -289,6 +408,53 @@ class ToExtension(RulesTransformer[DMSRules, DMSRules]):
             return ClassEntity(prefix=entity.prefix, suffix=new_suffix, version=entity.version)  # type: ignore[return-value]
         raise ValueError(f"Unsupported entity type: {type(entity)}")
 
+    def _get_new_components(
+        self, rules: DMSRules
+    ) -> tuple[SheetList[DMSView], SheetList[DMSContainer], SheetList[DMSProperty]]:
+        new_views = SheetList[DMSView]()
+        new_containers = SheetList[DMSContainer]()
+        new_properties = SheetList[DMSProperty]()
+
+        for definition in rules.views:
+            view_entity = self._remove_cognite_affix(definition.view)
+
+            view_entity.version = cast(str, self.new_model_id.version)
+            view_entity.prefix = self.new_model_id.space
+            container_entity = ContainerEntity(space=view_entity.prefix, externalId=view_entity.external_id)
+            class_entity = ClassEntity(prefix=view_entity.prefix, suffix=view_entity.suffix)
+
+            view = DMSView(
+                view=view_entity,
+                implements=[definition.view],
+                in_model=True,
+                class_=class_entity,
+                name=definition.name,
+            )
+
+            container = DMSContainer(
+                container=container_entity,
+                class_=class_entity,
+            )
+
+            property_ = DMSProperty(
+                view=view_entity,
+                view_property=f"{to_camel(view_entity.suffix)}{self.dummy_property}",
+                value_type=String(),
+                nullable=True,
+                immutable=False,
+                is_list=False,
+                container=container_entity,
+                container_property=f"{to_camel(view_entity.suffix)}{self.dummy_property}",
+                class_=class_entity,
+                property_=f"{to_camel(view_entity.suffix)}{self.dummy_property}",
+            )
+
+            new_properties.append(property_)
+            new_views.append(view)
+            new_containers.append(container)
+
+        return new_views, new_containers, new_properties
+
 
 class ReduceCogniteModel(RulesTransformer[DMSRules, DMSRules]):
     _ASSET_VIEW = ViewId("cdf_cdm", "CogniteAsset", "v1")
@@ -329,17 +495,20 @@ class ReduceCogniteModel(RulesTransformer[DMSRules, DMSRules]):
         ),
     }
 
-    def __init__(self, drop: Collection[Literal["3D", "Annotation", "BaseViews"]]):
-        self.drop = drop
+    def __init__(self, drop: Collection[Literal["3D", "Annotation", "BaseViews"] | str]):
+        self.drop_collection = cast(
+            list[Literal["3D", "Annotation", "BaseViews"]],
+            [collection for collection in drop if collection in self._VIEW_BY_COLLECTION],
+        )
+        self.drop_external_ids = {external_id for external_id in drop if external_id not in self._VIEW_BY_COLLECTION}
 
     def transform(self, rules: DMSRules | OutRules[DMSRules]) -> JustRules[DMSRules]:
         verified = self._to_rules(rules)
         if verified.metadata.as_data_model_id() not in COGNITE_MODELS:
             raise NeatValueError(f"Can only reduce Cognite Data Models, not {verified.metadata.as_data_model_id()}")
-        if invalid := (set(self.drop) - set(self._VIEW_BY_COLLECTION.keys())):
-            raise NeatValueError(f"Invalid drop values: {invalid}. Expected {set(self._VIEW_BY_COLLECTION)}")
 
-        exclude_views = {view for collection in self.drop for view in self._VIEW_BY_COLLECTION[collection]}
+        exclude_views = {view for collection in self.drop_collection for view in self._VIEW_BY_COLLECTION[collection]}
+        exclude_views |= {view.view.as_id() for view in verified.views if view.view.suffix in self.drop_external_ids}
         new_model = verified.model_copy(deep=True)
 
         properties_by_view = DMSAnalysis(new_model).classes_with_properties(consider_inheritance=True)
@@ -359,7 +528,7 @@ class ReduceCogniteModel(RulesTransformer[DMSRules, DMSRules]):
         return JustRules(new_model)
 
     def _is_asset_3D_property(self, prop: DMSProperty) -> bool:
-        if "3D" not in self.drop:
+        if "3D" not in self.drop_collection:
             return False
         return prop.view.as_id() == self._ASSET_VIEW and prop.property_ == "object3D"