cognite-neat 0.109.4__py3-none-any.whl → 0.111.0__py3-none-any.whl

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._rules._constants import get_internal_properties
 from cognite.neat._rules._shared import VerifiedRules
 from cognite.neat._rules.models import (
     ExtensionCategory,
@@ -54,7 +55,7 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
     Style = Literal["none", "minimal", "default", "maximal"]
     DumpOptions = Literal["user", "last", "reference"]
     _main_header_by_sheet_name: ClassVar[dict[str, str]] = {
-        "Properties": "Definition of Properties per Class",
+        "Properties": "Definition of Properties",
         "Classes": "Definition of Classes",
         "Views": "Definition of Views",
         "Containers": "Definition of Containers",
@@ -64,13 +65,6 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
     style_options = get_args(Style)
     dump_options = get_args(DumpOptions)
 
-    _internal_columns: ClassVar[list[str]] = [
-        "physical",
-        "logical",
-        "conceptual",
-        "Neat ID",
-    ]
-
     def __init__(
         self,
         styling: Style = "default",
@@ -131,7 +125,7 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
                 if sheet.lower() == "metadata":
                     continue
                 ws = workbook[sheet]
-                for col in self._internal_columns:
+                for col in get_internal_properties():
                     column_letter = find_column_with_value(ws, col)
                     if column_letter:
                         ws.column_dimensions[column_letter].hidden = True

cognite/neat/_rules/exporters/_rules2instance_template.py

@@ -9,7 +9,7 @@ from openpyxl.utils import get_column_letter
 from openpyxl.worksheet.datavalidation import DataValidation
 
 from cognite.neat._rules._constants import EntityTypes
-from cognite.neat._rules.analysis import InformationAnalysis
+from cognite.neat._rules.analysis import RulesAnalysis
 from cognite.neat._rules.models.entities._single_value import ClassEntity
 from cognite.neat._rules.models.information._rules import InformationRules
 
@@ -55,7 +55,7 @@ class InstanceTemplateExporter(BaseExporter[InformationRules, Workbook]):
         # Remove default sheet named "Sheet"
         workbook.remove(workbook["Sheet"])
 
-        for class_, properties in InformationAnalysis(rules).class_property_pairs().items():
+        for class_, properties in RulesAnalysis(rules).properties_by_id_by_class().items():
             workbook.create_sheet(title=class_.suffix)
 
             # Add header rows

cognite/neat/_rules/exporters/_rules2ontology.py

@@ -15,7 +15,7 @@ from cognite.neat._issues.errors import (
 )
 from cognite.neat._issues.warnings import PropertyDefinitionDuplicatedWarning
 from cognite.neat._rules._constants import EntityTypes
-from cognite.neat._rules.analysis import InformationAnalysis
+from cognite.neat._rules.analysis import RulesAnalysis
 from cognite.neat._rules.models.data_types import DataType
 from cognite.neat._rules.models.entities import ClassEntity
 from cognite.neat._rules.models.information import (
@@ -121,11 +121,12 @@ class Ontology(OntologyModel):
                 )
             raise MultiValueError(errors)
 
-        class_dict = InformationAnalysis(rules).as_class_dict()
+        analysis = RulesAnalysis(rules)
+        class_dict = analysis.class_by_suffix()
         return cls(
             properties=[
                 OWLProperty.from_list_of_properties(definition, rules.metadata.namespace)
-                for definition in InformationAnalysis(rules).as_property_dict().values()
+                for definition in analysis.property_by_id().values()
             ],
             classes=[
                 OWLClass.from_class(definition, rules.metadata.namespace, rules.prefixes)
@@ -137,7 +138,7 @@ class Ontology(OntologyModel):
                     list(properties.values()),
                     rules.metadata.namespace,
                 )
-                for class_, properties in InformationAnalysis(rules).class_property_pairs().items()
+                for class_, properties in analysis.properties_by_id_by_class().items()
             ]
             + [
                 SHACLNodeShape.from_rules(

cognite/neat/_rules/importers/_base.py

@@ -1,15 +1,11 @@
-import warnings
 from abc import ABC, abstractmethod
-from collections.abc import Iterator
-from contextlib import contextmanager, suppress
+from contextlib import suppress
 from datetime import datetime
-from typing import TYPE_CHECKING, Any, Generic, Literal
+from typing import TYPE_CHECKING, Any, Generic
 
-from pydantic import ValidationError
 from rdflib import URIRef
 
 from cognite.neat._constants import DEFAULT_NAMESPACE
-from cognite.neat._issues import IssueList, NeatError, NeatWarning
 from cognite.neat._rules._shared import ReadRules, T_InputRules
 from cognite.neat._utils.auxiliary import class_html_doc
 
@@ -64,44 +60,3 @@ class BaseImporter(ABC, Generic[T_InputRules]):
     @property
     def source_uri(self) -> URIRef:
         return DEFAULT_NAMESPACE["UNKNOWN"]
-
-
-class _FutureResult:
-    def __init__(self) -> None:
-        self._result: Literal["success", "failure", "pending"] = "pending"
-
-    @property
-    def result(self) -> Literal["success", "failure", "pending"]:
-        return self._result
-
-
-@contextmanager
-def _handle_issues(
-    issues: IssueList,
-    error_cls: type[NeatError] = NeatError,
-    warning_cls: type[NeatWarning] = NeatWarning,
-    error_args: dict[str, Any] | None = None,
-) -> Iterator[_FutureResult]:
-    """This is an internal help function to handle issues and warnings.
-
-    Args:
-        issues: The issues list to append to.
-        error_cls: The class used to convert errors to issues.
-        warning_cls:  The class used to convert warnings to issues.
-
-    Returns:
-        FutureResult: A future result object that can be used to check the result of the context manager.
-    """
-    with warnings.catch_warnings(record=True) as warning_logger:
-        warnings.simplefilter("always")
-        future_result = _FutureResult()
-        try:
-            yield future_result
-        except ValidationError as e:
-            issues.extend(error_cls.from_errors(e.errors(), **(error_args or {})))  # type: ignore[arg-type]
-            future_result._result = "failure"
-        else:
-            future_result._result = "success"
-        finally:
-            if warning_logger:
-                issues.extend([warning_cls.from_warning(warning) for warning in warning_logger])  # type: ignore[misc]

cognite/neat/_rules/importers/_dms2rules.py

@@ -19,7 +19,7 @@ from cognite.client.data_classes.data_modeling.views import (
 from cognite.client.utils import ms_to_datetime
 
 from cognite.neat._client import NeatClient
-from cognite.neat._issues import IssueList, MultiValueError, NeatIssue
+from cognite.neat._issues import IssueList, MultiValueError, NeatIssue, catch_issues
 from cognite.neat._issues.errors import (
     FileTypeUnexpectedError,
     NeatValueError,
@@ -35,7 +35,7 @@ from cognite.neat._issues.warnings import (
     ResourceUnknownWarning,
 )
 from cognite.neat._rules._shared import ReadRules
-from cognite.neat._rules.importers._base import BaseImporter, _handle_issues
+from cognite.neat._rules.importers._base import BaseImporter
 from cognite.neat._rules.models import (
     DMSInputRules,
     DMSSchema,
@@ -131,11 +131,10 @@ class DMSImporter(BaseImporter[DMSInputRules]):
 
     @classmethod
     def from_data_model(cls, client: NeatClient, model: dm.DataModel[dm.View]) -> "DMSImporter":
-        issue_list = IssueList()
-        with _handle_issues(issue_list) as result:
+        with catch_issues() as issue_list:
             schema = client.schema.retrieve_data_model(model)
 
-        if result.result == "failure" or issue_list.has_errors:
+        if issue_list.has_errors:
             return cls(DMSSchema(), issue_list)
 
         metadata = cls._create_metadata_from_model(model)
@@ -187,10 +186,9 @@ class DMSImporter(BaseImporter[DMSInputRules]):
 
     @classmethod
     def from_directory(cls, directory: str | Path, client: NeatClient | None = None) -> "DMSImporter":
-        issue_list = IssueList()
-        with _handle_issues(issue_list) as _:
+        with catch_issues() as issue_list:
             schema = DMSSchema.from_directory(directory)
-        # If there were errors during the import, the to_rules
+        # If there were errors during the import, the to_rules will raise them.
         return cls(
             schema, issue_list, referenced_containers=cls._lookup_referenced_containers(schema, issue_list, client)
         )
@@ -202,8 +200,7 @@ class DMSImporter(BaseImporter[DMSInputRules]):
                 DMSSchema(),
                 [FileTypeUnexpectedError(Path(zip_file), frozenset([".zip"]))],
             )
-        issue_list = IssueList()
-        with _handle_issues(issue_list) as _:
+        with catch_issues() as issue_list:
             schema = DMSSchema.from_zip(zip_file)
         return cls(
             schema, issue_list, referenced_containers=cls._lookup_referenced_containers(schema, issue_list, client)

cognite/neat/_rules/importers/_dtdl2rules/dtdl_importer.py

@@ -19,7 +19,7 @@ from cognite.neat._rules.importers._dtdl2rules.dtdl_converter import _DTDLConver
 from cognite.neat._rules.importers._dtdl2rules.spec import DTDL_CLS_BY_TYPE_BY_SPEC, DTDLBase, Interface
 from cognite.neat._rules.models import InformationInputRules
 from cognite.neat._rules.models.information import InformationInputMetadata
-from cognite.neat._utils.text import humanize_collection, to_pascal
+from cognite.neat._utils.text import humanize_collection, to_pascal_case
 
 
 class DTDLImporter(BaseImporter[InformationInputRules]):
@@ -130,7 +130,7 @@ class DTDLImporter(BaseImporter[InformationInputRules]):
         metadata = self._default_metadata()
 
         if self.name:
-            metadata["name"] = to_pascal(self.name)
+            metadata["name"] = to_pascal_case(self.name)
         try:
             most_common_prefix = converter.get_most_common_prefix()
         except ValueError:

cognite/neat/_rules/importers/_rdf/_inference2rules.py

@@ -10,14 +10,16 @@ from cognite.client import data_modeling as dm
 from rdflib import RDF, RDFS, Graph, Namespace, URIRef
 from rdflib import Literal as RdfLiteral
 
+from cognite.neat._config import GLOBAL_CONFIG
 from cognite.neat._constants import NEAT, get_default_prefixes_and_namespaces
 from cognite.neat._issues import IssueList
 from cognite.neat._issues.warnings import PropertyValueTypeUndefinedWarning
-from cognite.neat._rules.analysis import InformationAnalysis
+from cognite.neat._rules.analysis import RulesAnalysis
 from cognite.neat._rules.models import InformationRules, data_types
 from cognite.neat._rules.models.data_types import AnyURI
 from cognite.neat._rules.models.entities._single_value import UnknownEntity
 from cognite.neat._rules.models.information import (
+    InformationClass,
     InformationInputClass,
     InformationInputProperty,
     InformationMetadata,
@@ -26,6 +28,7 @@ from cognite.neat._store import NeatGraphStore
 from cognite.neat._store._provenance import INSTANCES_ENTITY
 from cognite.neat._utils.collection_ import iterate_progress_bar
 from cognite.neat._utils.rdf_ import remove_namespace_from_uri, uri_to_short_form
+from cognite.neat._utils.text import NamingStandardization
 
 from ._base import DEFAULT_NON_EXISTING_NODE_TYPE, BaseRDFImporter
 
@@ -256,7 +259,7 @@ class InferenceImporter(BaseRDFImporter):
                 property_["value_type"].remove(str(self.non_existing_node_type))
 
             if len(property_["value_type"]) > 1:
-                property_["value_type"] = " | ".join([str(t) for t in property_["value_type"]])
+                property_["value_type"] = ", ".join([str(t) for t in property_["value_type"]])
             else:
                 property_["value_type"] = next(iter(property_["value_type"]))
 
@@ -402,7 +405,8 @@ class SubclassInferenceImporter(BaseRDFImporter):
         else:
             existing_classes = {}
         classes: list[InformationInputClass] = []
-        properties: list[InformationInputProperty] = []
+        properties_by_class_suffix_by_property_id: dict[str, dict[str, InformationInputProperty]] = {}
+
         # Help for IDE
         type_uri: URIRef
         parent_uri: URIRef
@@ -440,26 +444,51 @@ class SubclassInferenceImporter(BaseRDFImporter):
                         InformationInputClass(
                             class_=class_suffix,
                             implements=parent_suffix,
+                            instance_source=type_uri,
                         )
                     )
                 else:
                     classes.append(InformationInputClass.load(existing_classes[class_suffix].model_dump()))
+
+                properties_by_id: dict[str, InformationInputProperty] = {}
                 for property_uri, read_properties in properties_by_property_uri.items():
                     if property_uri in shared_property_uris:
                         shared_properties[property_uri].extend(read_properties)
                         continue
-                    properties.append(
-                        self._create_property(read_properties, class_suffix, type_uri, property_uri, prefixes)
-                    )
-
+                    property_id = remove_namespace_from_uri(property_uri)
+                    self._add_uri_namespace_to_prefixes(property_uri, prefixes)
+                    property_id_standardized = NamingStandardization.standardize_property_str(property_uri)
+                    if existing_prop := properties_by_id.get(property_id_standardized):
+                        if not isinstance(existing_prop.instance_source, list):
+                            existing_prop.instance_source = (
+                                [existing_prop.instance_source] if existing_prop.instance_source else []
+                            )
+                        existing_prop.instance_source.append(property_uri)
+                        continue
+                    else:
+                        properties_by_id[property_id_standardized] = self._create_property(
+                            read_properties, class_suffix, property_uri, property_id, prefixes
+                        )
+                properties_by_class_suffix_by_property_id[class_suffix] = properties_by_id
             if parent_suffix:
+                properties_by_id = {}
                 for property_uri, read_properties in shared_properties.items():
-                    properties.append(
-                        self._create_property(
-                            read_properties, parent_suffix, read_properties[0].type_uri, property_uri, prefixes
+                    property_id = remove_namespace_from_uri(property_uri)
+                    self._add_uri_namespace_to_prefixes(property_uri, prefixes)
+                    property_id_standardized = NamingStandardization.standardize_property_str(property_uri)
+                    if existing_prop := properties_by_id.get(property_id_standardized):
+                        if not isinstance(existing_prop.instance_source, list):
+                            existing_prop.instance_source = (
+                                [existing_prop.instance_source] if existing_prop.instance_source else []
+                            )
+                        existing_prop.instance_source.append(property_uri)
+                    else:
+                        properties_by_id[property_id_standardized] = self._create_property(
+                            read_properties, parent_suffix, property_uri, property_id, prefixes
                         )
-                    )
-        return classes, properties
+        return classes, [
+            prop for properties in properties_by_class_suffix_by_property_id.values() for prop in properties.values()
+        ]
 
     @staticmethod
     def _get_properties_by_class_by_property(
@@ -481,26 +510,40 @@ class SubclassInferenceImporter(BaseRDFImporter):
             type_uri, instance_count_literal = cast(tuple[URIRef, RdfLiteral], result_row)
             count_by_type[type_uri] = instance_count_literal.toPython()
         if self._rules:
-            analysis = InformationAnalysis(self._rules)
+            analysis = RulesAnalysis(self._rules)
             existing_class_properties = {
-                (class_entity.suffix, prop.property_)
-                for class_entity, properties in analysis.classes_with_properties(
-                    consider_inheritance=True, allow_different_namespace=True
+                (class_entity.suffix, prop.property_): prop
+                for class_entity, properties in analysis.properties_by_class(
+                    include_ancestors=True, include_different_space=True
                 ).items()
                 for prop in properties
             }
+            existing_classes = {cls_.class_.suffix: cls_ for cls_ in self._rules.classes}
         else:
-            existing_class_properties = set()
+            existing_class_properties = {}
+            existing_classes = {}
         properties_by_class_by_subclass: list[_ReadProperties] = []
-        for type_uri, instance_count in count_by_type.items():
+        existing_class: InformationClass | None
+        total_instance_count = sum(count_by_type.values())
+        iterable = count_by_type.items()
+        if GLOBAL_CONFIG.use_iterate_bar_threshold and total_instance_count > GLOBAL_CONFIG.use_iterate_bar_threshold:
+            iterable = iterate_progress_bar(iterable, len(count_by_type), "Inferring types...")  # type: ignore[assignment]
+        for type_uri, instance_count in iterable:
             property_query = self._properties_query.format(type=type_uri, unknown_type=NEAT.UnknownType)
             class_suffix = remove_namespace_from_uri(type_uri)
+            if (existing_class := existing_classes.get(class_suffix)) and existing_class.instance_source is None:
+                existing_class.instance_source = type_uri
+
             for result_row in self.graph.query(property_query):
                 property_uri, value_type_uri = cast(tuple[URIRef, URIRef], result_row)
                 if property_uri == RDF.type:
                     continue
                 property_str = remove_namespace_from_uri(property_uri)
-                if (class_suffix, property_str) in existing_class_properties:
+                if existing_property := existing_class_properties.get((class_suffix, property_str)):
+                    if existing_property.instance_source is None:
+                        existing_property.instance_source = [property_uri]
+                    elif existing_property.instance_source and property_uri not in existing_property.instance_source:
+                        existing_property.instance_source.append(property_uri)
                     continue
                 occurrence_query = self._max_occurrence_query.format(type=type_uri, property=property_uri)
                 max_occurrence = 1  # default value
@@ -531,21 +574,18 @@ class SubclassInferenceImporter(BaseRDFImporter):
         self,
         read_properties: list[_ReadProperties],
         class_suffix: str,
-        type_uri: URIRef,
         property_uri: URIRef,
+        property_id: str,
         prefixes: dict[str, Namespace],
     ) -> InformationInputProperty:
         first = read_properties[0]
         value_type = self._get_value_type(read_properties, prefixes)
-        property_name = remove_namespace_from_uri(property_uri)
-        self._add_uri_namespace_to_prefixes(property_uri, prefixes)
-
         return InformationInputProperty(
             class_=class_suffix,
-            property_=property_name,
+            property_=property_id,
             max_count=first.max_occurrence,
             value_type=value_type,
-            instance_source=(f"{uri_to_short_form(type_uri, prefixes)}({uri_to_short_form(property_uri, prefixes)})"),
+            instance_source=[property_uri],
         )
 
     def _get_value_type(
@@ -562,7 +602,7 @@ class SubclassInferenceImporter(BaseRDFImporter):
             return UnknownEntity()
         for uri_ref in value_types:
             self._add_uri_namespace_to_prefixes(uri_ref, prefixes)
-        return " | ".join(remove_namespace_from_uri(uri_ref) for uri_ref in value_types)
+        return ", ".join(remove_namespace_from_uri(uri_ref) for uri_ref in value_types)
 
     def _default_metadata(self) -> dict[str, Any]:
         now = datetime.now(timezone.utc)

cognite/neat/_rules/importers/_rdf/_shared.py

@@ -136,7 +136,7 @@ def parse_properties(graph: Graph, query: str, language: str, issue_list: IssueL
                 properties[id_]["value_type"].append(res["value_type"])
 
     for prop in properties.values():
-        prop["value_type"] = "|".join(prop["value_type"])
+        prop["value_type"] = ", ".join(prop["value_type"])
 
     if not properties:
         issue_list.append(NeatValueError("Unable to parse properties"))

cognite/neat/_rules/importers/_spreadsheet2rules.py

@@ -37,15 +37,15 @@ SOURCE_SHEET__TARGET_FIELD__HEADERS = [
         "Properties",
         "Properties",
         {
-            RoleTypes.information: "Property",
-            RoleTypes.dms: "View Property",
+            RoleTypes.information: ["Class", "Property"],
+            RoleTypes.dms: ["View", "View Property"],
         },
     ),
-    ("Classes", "Classes", "Class"),
-    ("Containers", "Containers", "Container"),
-    ("Views", "Views", "View"),
-    ("Enum", "Enum", "Collection"),
-    ("Nodes", "Nodes", "Node"),
+    ("Classes", "Classes", ["Class"]),
+    ("Containers", "Containers", ["Container"]),
+    ("Views", "Views", ["View"]),
+    ("Enum", "Enum", ["Collection"]),
+    ("Nodes", "Nodes", ["Node"]),
 ]
 
 
@@ -231,7 +231,10 @@ class SpreadsheetReader:
 
             try:
                 sheets[target_sheet_name], read_info_by_sheet[source_sheet_name] = read_individual_sheet(
-                    excel_file, source_sheet_name, return_read_info=True, expected_headers=[headers]
+                    excel_file,
+                    source_sheet_name,
+                    return_read_info=True,
+                    expected_headers=headers,
                 )
             except Exception as e:
                 self.issue_list.append(FileReadError(cast(Path, excel_file.io), str(e)))
@@ -273,7 +276,7 @@ class ExcelImporter(BaseImporter[T_InputRules]):
 
         rules_cls = INPUT_RULES_BY_ROLE[original_role]
         rules = cast(T_InputRules, rules_cls.load(sheets))
-        return ReadRules(rules, {"read_info_by_sheet": read_info_by_sheet})
+        return ReadRules(rules, read_info_by_sheet)
 
     @property
     def description(self) -> str:

cognite/neat/_rules/models/_base_rules.py

@@ -126,7 +126,6 @@ class SchemaModel(BaseModel):
         extra="ignore",
         use_enum_values=True,
     )
-    validators_to_skip: set[str] = Field(default_factory=set, exclude=True)
 
     @classmethod
     def mandatory_fields(cls, use_alias=False) -> set[str]:
@@ -256,7 +255,6 @@ class BaseRules(SchemaModel, ABC):
 
     Args:
         metadata: Data model metadata
-        validators_to_skip: List of validators to skip. Defaults to []
     """
 
     metadata: BaseMetadata

cognite/neat/_rules/models/data_types.py

@@ -130,6 +130,13 @@ class DataType(BaseModel):
     def as_xml_uri_ref(cls) -> URIRef:
         return XML_SCHEMA_NAMESPACE[cls.xsd]
 
+    @classmethod
+    def convert_value(cls, value: Any) -> Any:
+        if cls != Boolean:
+            return cls.python(value)
+        else:
+            return value.strip().lower() in {"true", "1", "yes"}
+
 
 class Boolean(DataType):
     python = bool

cognite/neat/_rules/models/dms/_exporter.py

@@ -99,6 +99,7 @@ class _DMSExporter:
             key=lambda x: x.as_tuple(),  # type: ignore[union-attr]
         )
         spaces = self._create_spaces(rules.metadata, containers, views, data_model)
+
         return DMSSchema(
             spaces=spaces,
             data_model=data_model,
@@ -114,14 +115,14 @@ class _DMSExporter:
         views: ViewApplyDict,
         data_model: dm.DataModelApply,
     ) -> SpaceApplyDict:
-        used_spaces = {container.space for container in containers.values()} | {view.space for view in views.values()}
-        if len(used_spaces) == 1:
-            # We skip the default space and only use this space for the data model
-            data_model.space = used_spaces.pop()
-            spaces = SpaceApplyDict([dm.SpaceApply(space=data_model.space)])
-        else:
-            used_spaces.add(metadata.space)
-            spaces = SpaceApplyDict([dm.SpaceApply(space=space) for space in used_spaces])
+        used_spaces = (
+            {container.space for container in containers.values()}
+            | {view.space for view in views.values()}
+            | {data_model.space}
+            | {metadata.space}
+        )
+
+        spaces = SpaceApplyDict([dm.SpaceApply(space=space) for space in used_spaces])
         if self.instance_space and self.instance_space not in spaces:
             spaces[self.instance_space] = dm.SpaceApply(space=self.instance_space, name=self.instance_space)
         return spaces

cognite/neat/_rules/models/dms/_rules.py

@@ -1,3 +1,4 @@
+import warnings
 from collections.abc import Hashable
 from typing import TYPE_CHECKING, Any, ClassVar, Literal
 
@@ -8,6 +9,7 @@ from pydantic_core.core_schema import SerializationInfo, ValidationInfo
 
 from cognite.neat._client.data_classes.schema import DMSSchema
 from cognite.neat._issues.errors import NeatValueError
+from cognite.neat._issues.warnings._general import NeatValueWarning
 from cognite.neat._rules.models._base_rules import (
     BaseMetadata,
     BaseRules,
@@ -116,7 +118,7 @@ class DMSProperty(SheetRow):
         description="Used to indicate whether the property holds single or multiple values (list). "
         "Only applies to primitive types.",
     )
-    default: str | int | dict | None = Field(
+    default: bool | str | int | float | dict | None = Field(
         None, alias="Default", description="Specifies default value for the property."
     )
     container: ContainerEntityType | None = Field(
@@ -168,6 +170,29 @@ class DMSProperty(SheetRow):
             raise ValueError(f"Reverse connection must have a value type that points to a view, got {value}")
         return value
 
+    @field_validator("default", mode="after")
+    def set_proper_type_on_default(cls, value: Any, info: ValidationInfo) -> Any:
+        if not value:
+            return value
+        value_type = info.data.get("value_type")
+        if not isinstance(value_type, DataType):
+            warnings.filterwarnings("default")
+            warnings.warn(
+                NeatValueWarning(f"Default value {value} set to connection {value_type} will be ignored"),
+                stacklevel=2,
+            )
+            return None
+        else:
+            try:
+                return value_type.convert_value(value)
+            except ValueError:
+                warnings.filterwarnings("default")
+                warnings.warn(
+                    NeatValueWarning(f"Could not convert {value} to {value_type}"),
+                    stacklevel=2,
+                )
+                return None
+
     @field_validator("container", "container_property", mode="after")
     def container_set_correctly(cls, value: Any, info: ValidationInfo) -> Any:
         if (connection := info.data.get("connection")) is None:
@@ -295,7 +320,9 @@ class DMSView(SheetRow):
         None, alias="Filter", description="Explicitly define the filter for the view."
     )
     in_model: bool = Field(
-        True, alias="In Model", description="Indicates whether the view being defined is a part of the data model."
+        True,
+        alias="In Model",
+        description="Indicates whether the view being defined is a part of the data model.",
     )
     logical: URIRefType | None = Field(
         None,

cognite/neat/_rules/models/dms/_rules_input.py

@@ -21,6 +21,7 @@ from cognite.neat._rules.models.entities import (
     load_connection,
     load_dms_value_type,
 )
+from cognite.neat._rules.models.entities._wrapped import DMSFilter
 from cognite.neat._utils.rdf_ import uri_display_name
 
 from ._rules import _DEFAULT_VERSION, DMSContainer, DMSEnum, DMSMetadata, DMSNode, DMSProperty, DMSRules, DMSView
@@ -69,7 +70,7 @@ class DMSInputMetadata(InputComponent[DMSMetadata]):
     def _get_description_and_creator(cls, description_raw: str | None) -> tuple[str | None, list[str]]:
         if description_raw and (description_match := re.search(r"Creator: (.+)", description_raw)):
             creator = description_match.group(1).split(", ")
-            description = description_raw.replace(description_match.string, "").strip() or None
+            description = description_raw.replace(description_match[0], "").strip() or None
         elif description_raw:
             creator = ["MISSING"]
             description = description_raw
@@ -193,6 +194,10 @@ class DMSInputView(InputComponent[DMSView]):
     neatId: str | URIRef | None = None
     logical: str | URIRef | None = None
 
+    def __post_init__(self):
+        if self.in_model is None:
+            self.in_model = True
+
     @classmethod
     def _get_verified_cls(cls) -> type[DMSView]:
         return DMSView
@@ -207,6 +212,8 @@ class DMSInputView(InputComponent[DMSView]):
         return ViewEntity.load(self.view, strict=True, space=default_space, version=default_version)
 
     def _load_implements(self, default_space: str, default_version: str) -> list[ViewEntity] | None:
+        self.implements = self.implements.strip() if self.implements else None
+
         return (
             [
                 ViewEntity.load(implement, strict=True, space=default_space, version=default_version)
@@ -230,6 +237,7 @@ class DMSInputView(InputComponent[DMSView]):
             implements=", ".join([str(ViewEntity.from_id(parent, _DEFAULT_VERSION)) for parent in view.implements])
             or None,
             in_model=in_model,
+            filter_=(str(DMSFilter.from_dms_filter(view.filter)) if view.filter else None),
         )