cognite-neat 0.123.24__py3-none-any.whl → 1.0.22__py3-none-any.whl

cognite/neat/_v0/core/_data_model/importers/_rdf/_owl2data_model.py

@@ -0,0 +1,144 @@
+"""This module performs importing of various formats to one of serializations for which
+there are loaders to data model pydantic class."""
+
+from cognite.neat._v0.core._data_model.importers._rdf._base import BaseRDFImporter
+from cognite.neat._v0.core._data_model.importers._rdf._shared import (
+    parse_concepts,
+    parse_properties,
+)
+
+CLASSES_QUERY = """SELECT ?concept  ?name ?description ?implements
+        WHERE {{
+
+        ?concept  a owl:Class .
+        OPTIONAL {{?concept  rdfs:subClassOf ?implements }}.
+        OPTIONAL {{?concept  rdfs:label|skos:prefLabel ?name }}.
+        OPTIONAL {{?concept  rdfs:comment|skos:definition ?description}} .
+
+
+        FILTER (!isBlank(?concept ))
+        FILTER (!bound(?implements) || !isBlank(?implements))
+
+        FILTER (!bound(?name) || LANG(?name) = "" || LANGMATCHES(LANG(?name), "{language}"))
+        FILTER (!bound(?description) || LANG(?description) = "" || LANGMATCHES(LANG(?description), "{language}"))
+
+    }}
+    """
+
+CLASSES_QUERY_PARAMETERS = {"concept", "name", "description", "implements"}
+
+PROPERTIES_QUERY = """ SELECT ?concept ?property_ ?name ?description ?value_type ?min_count ?max_count ?default
+    WHERE {{
+        ?property_ a ?property_Type.
+        FILTER (?property_Type IN (owl:ObjectProperty, owl:DatatypeProperty ) )
+
+        # --- 1. Explicit Domain Discovery ---
+
+        # A. Handling owl:domain when it is expressed as owl restriction
+        OPTIONAL {{
+            ?property_ rdfs:domain ?domain_exp_node .
+            FILTER(isBlank(?domain_exp_node))
+            ?domain_exp_node owl:unionOf|owl:intersectionOf ?exp_concepts_list .
+            ?exp_concepts_list rdf:rest*/rdf:first ?explicit_concept.
+        }}
+
+        # B. Handling the domain when it is a single concept
+        OPTIONAL {{
+            ?property_ rdfs:domain ?domain_exp_node .
+            FILTER(!isBlank(?domain_exp_node))
+            BIND(?domain_exp_node AS ?explicit_concept)
+        }}
+
+        # --- 2. Inherited Domain Discovery (Fallback) ---
+
+        # C. Handling inherited domain when parent domain is a restriction
+        OPTIONAL {{
+            ?property_ rdfs:subPropertyOf ?parent_property .
+            ?parent_property rdfs:domain ?parent_domain_node .
+            FILTER(isBlank(?parent_domain_node))
+            ?parent_domain_node owl:unionOf|owl:intersectionOf ?parent_concepts_list .
+            ?parent_concepts_list rdf:rest*/rdf:first ?inherited_concept.
+        }}
+
+        # D. Handling inherited domain when parent domain is a single concept
+        OPTIONAL {{
+            ?property_ rdfs:subPropertyOf ?parent_property .
+            ?parent_property rdfs:domain ?parent_domain_node .
+            FILTER(!isBlank(?parent_domain_node))
+            BIND(?parent_domain_node AS ?inherited_concept)
+        }}
+
+        # Final Concept Assignment with Priority ---
+        # COALESCE prioritizes ?explicit_concept over ?inherited_concept
+        BIND(COALESCE(?explicit_concept, ?inherited_concept) AS ?concept)
+
+
+        # Handling owl:range when it is expressed as owl restriction
+        OPTIONAL {{
+            ?property_ rdfs:range ?range .
+            FILTER(isBlank(?range))
+            ?range owl:unionOf|owl:intersectionOf ?value_types .
+            ?value_types rdf:rest*/rdf:first ?value_type.
+        }}
+
+        # Handling the range when it is a single concept
+        OPTIONAL {{
+            ?property_ rdfs:range ?range .
+            FILTER(!isBlank(?range))
+            BIND(?range AS ?value_type)
+        }}
+
+        OPTIONAL {{?property_ rdfs:label|skos:prefLabel ?name }}.
+        OPTIONAL {{?property_ rdfs:comment|skos:definition ?description}}.
+        OPTIONAL {{?property_ owl:maxCardinality ?max_count}}.
+        OPTIONAL {{?property_ owl:minCardinality ?min_count}}.
+
+        # FILTERS
+        FILTER (!isBlank(?property_))
+        FILTER (!bound(?name) || LANG(?name) = "" || LANGMATCHES(LANG(?name), "{language}"))
+        FILTER (!bound(?description) || LANG(?description) = "" || LANGMATCHES(LANG(?description), "{language}"))
+    }}
+    """
+PROPERTIES_QUERY_PARAMETERS = {
+    "concept",
+    "property_",
+    "name",
+    "description",
+    "value_type",
+    "min_count",
+    "max_count",
+    "default",
+}
+
+
+class OWLImporter(BaseRDFImporter):
+    """Convert OWL ontology to unverified data model.
+
+    Args:
+        filepath: Path to OWL ontology
+    """
+
+    def _to_data_model_components(
+        self,
+    ) -> dict:
+        concepts, issue_list = parse_concepts(
+            self.graph, CLASSES_QUERY, CLASSES_QUERY_PARAMETERS, self.language, self.issue_list
+        )
+        self.issue_list = issue_list
+
+        properties, issue_list = parse_properties(
+            self.graph, PROPERTIES_QUERY, PROPERTIES_QUERY_PARAMETERS, self.language, self.issue_list
+        )
+        self.issue_list = issue_list
+
+        components = {
+            "Metadata": self._metadata,
+            "Concepts": list(concepts.values()) if concepts else [],
+            "Properties": list(properties.values()) if properties else [],
+        }
+
+        return components
+
+    @property
+    def description(self) -> str:
+        return f"Ontology {self.source_name} read as unverified data model"

cognite/neat/{core → _v0/core}/_data_model/importers/_rdf/_shared.py

@@ -6,16 +6,16 @@ from rdflib import Literal as RdfLiteral
 from rdflib.plugins.sparql import prepareQuery
 from rdflib.query import ResultRow
 
-from cognite.neat.core._constants import cognite_prefixes
-from cognite.neat.core._data_model.models.entities._constants import Unknown
-from cognite.neat.core._data_model.models.entities._single_value import ConceptEntity
-from cognite.neat.core._issues._base import IssueList
-from cognite.neat.core._issues.errors._general import NeatValueError
-from cognite.neat.core._issues.warnings._resources import (
+from cognite.neat._v0.core._constants import cognite_prefixes
+from cognite.neat._v0.core._data_model.models.entities._constants import Unknown
+from cognite.neat._v0.core._data_model.models.entities._single_value import ConceptEntity
+from cognite.neat._v0.core._issues._base import IssueList
+from cognite.neat._v0.core._issues.errors._general import NeatValueError
+from cognite.neat._v0.core._issues.warnings._resources import (
     ResourceRedefinedWarning,
     ResourceRetrievalWarning,
 )
-from cognite.neat.core._utils.rdf_ import remove_namespace_from_uri, uri_to_entity_components
+from cognite.neat._v0.core._utils.rdf_ import remove_namespace_from_uri, uri_to_entity_components
 
 
 def parse_concepts(
@@ -67,13 +67,13 @@ def parse_concepts(
         else:
             # Handling implements
             if concepts[concept_id]["implements"] and isinstance(concepts[concept_id]["implements"], list):
-                if res["implements"] not in concepts[concept_id]["implements"]:
+                if res["implements"] and res["implements"] not in concepts[concept_id]["implements"]:
                     concepts[concept_id]["implements"].append(res["implements"])
 
             elif concepts[concept_id]["implements"] and isinstance(concepts[concept_id]["implements"], str):
                 concepts[concept_id]["implements"] = [concepts[concept_id]["implements"]]
 
-                if res["implements"] not in concepts[concept_id]["implements"]:
+                if res["implements"] and res["implements"] not in concepts[concept_id]["implements"]:
                     concepts[concept_id]["implements"].append(res["implements"])
             elif res["implements"]:
                 concepts[concept_id]["implements"] = [res["implements"]]
@@ -183,15 +183,19 @@ def handle_meta(
     if not resources[resource_id][feature] and res[feature]:
         resources[resource_id][feature] = res[feature]
 
-    # RAISE warning only if the feature is being redefined
-    elif resources[resource_id][feature] and res[feature]:
+    current_value = resources[resource_id][feature]
+    new_value = res[feature]
+
+    if not current_value and new_value:
+        resources[resource_id][feature] = new_value
+    elif current_value and new_value and current_value != new_value:
         issue_list.append(
             ResourceRedefinedWarning(
                 identifier=resource_id,
                 resource_type=resource_type,
                 feature=feature,
-                current_value=resources[resource_id][feature],
-                new_value=res[feature],
+                current_value=current_value,
+                new_value=new_value,
             )
         )
 

cognite/neat/{core → _v0/core}/_data_model/importers/_spreadsheet2data_model.py

@@ -10,28 +10,35 @@ import pandas as pd
 from openpyxl import load_workbook
 from openpyxl.worksheet.worksheet import Worksheet
 from pandas import ExcelFile
+from pydantic import ValidationError
 from rdflib import Namespace, URIRef
 
-from cognite.neat.core._data_model._shared import (
+from cognite.neat._v0.core._data_model._constants import SPLIT_ON_COMMA_PATTERN
+from cognite.neat._v0.core._data_model._shared import (
     ImportedDataModel,
     T_UnverifiedDataModel,
 )
-from cognite.neat.core._data_model.models import (
+from cognite.neat._v0.core._data_model.models import (
     UNVERIFIED_DATA_MODEL_BY_ROLE,
     VERIFIED_DATA_MODEL_BY_ROLE,
     RoleTypes,
     SchemaCompleteness,
 )
-from cognite.neat.core._data_model.models._import_contexts import SpreadsheetContext
-from cognite.neat.core._issues import IssueList, MultiValueError
-from cognite.neat.core._issues.errors import (
+from cognite.neat._v0.core._data_model.models._import_contexts import SpreadsheetContext
+from cognite.neat._v0.core._data_model.models.entities._single_value import ContainerConstraintEntity, ContainerEntity
+from cognite.neat._v0.core._issues import IssueList, MultiValueError
+from cognite.neat._v0.core._issues.errors import (
     FileMissingRequiredFieldError,
     FileNotFoundNeatError,
     FileReadError,
 )
-from cognite.neat.core._issues.warnings import FileMissingRequiredFieldWarning
-from cognite.neat.core._utils.spreadsheet import SpreadsheetRead, read_individual_sheet
-from cognite.neat.core._utils.text import humanize_collection
+from cognite.neat._v0.core._issues.warnings import FileMissingRequiredFieldWarning
+from cognite.neat._v0.core._utils.spreadsheet import (
+    SpreadsheetRead,
+    find_column_and_row_with_value,
+    read_individual_sheet,
+)
+from cognite.neat._v0.core._utils.text import humanize_collection
 
 from ._base import BaseImporter
 
@@ -306,7 +313,7 @@ class ExcelImporter(BaseImporter[T_UnverifiedDataModel]):
 
         """
 
-        workbook = load_workbook(filepath)
+        workbook = load_workbook(filepath, data_only=True)
 
         if "Classes" in workbook.sheetnames:
             print(
@@ -323,13 +330,17 @@ class ExcelImporter(BaseImporter[T_UnverifiedDataModel]):
             if "Properties" in workbook.sheetnames:
                 _replace_class_with_concept_cell(workbook["Properties"])
 
-            with tempfile.NamedTemporaryFile(prefix="temp_neat_file", suffix=".xlsx", delete=False) as temp_file:
-                workbook.save(temp_file.name)
-                return Path(temp_file.name)
+        elif "Containers" in workbook.sheetnames:
+            _replace_legacy_constraint_form(workbook["Containers"])
+            _replace_legacy_constraint_form(workbook["Properties"])
 
         else:
             return filepath
 
+        with tempfile.NamedTemporaryFile(prefix="temp_neat_file", suffix=".xlsx", delete=False) as temp_file:
+            workbook.save(temp_file.name)
+            return Path(temp_file.name)
+
 
 def _replace_class_with_concept_cell(sheet: Worksheet) -> None:
     """
@@ -342,3 +353,72 @@ def _replace_class_with_concept_cell(sheet: Worksheet) -> None:
         for cell in row:
             if cell.value == "Class":
                 cell.value = "Concept"
+
+
+def _replace_legacy_constraint_form(sheet: Worksheet) -> None:
+    """
+    Replaces the legacy form of container constraints with the new form in the given sheet.
+
+    Args:
+        sheet (Worksheet): The sheet in which to replace the old form of container constraints.
+    """
+    column, row = find_column_and_row_with_value(sheet, "Constraint", False)
+
+    if not column or not row:
+        return None
+
+    # Iterate over values in the constraint column and replace old form with new form
+    replaced: bool = False
+    for cell_row in sheet.iter_rows(min_row=row + 1, min_col=column, max_col=column):
+        cell = cell_row[0]
+        if cell.value is not None:  # Skip empty cells
+            # Container sheet update
+            if sheet.title.lower() == "containers":
+                constraints = []
+                for constraint in SPLIT_ON_COMMA_PATTERN.split(str(cell.value)):
+                    # latest format, do nothing
+                    if "require" in constraint.lower():
+                        constraints.append(constraint)
+                        continue
+
+                    try:
+                        container = ContainerEntity.load(constraint, space="default")
+                        container_str = container.external_id if container.space == "default" else str(container)
+                        constraints.append(
+                            f"requires:{container.space}_{container.external_id}(require={container_str})"
+                        )
+                        replaced = True
+                    except ValidationError:
+                        constraints.append(constraint)
+
+                cell.value = ",".join(constraints)
+
+            # Properties sheet update
+            elif sheet.title.lower() == "properties":
+                constraints = []
+                for constraint in SPLIT_ON_COMMA_PATTERN.split(str(cell.value)):
+                    try:
+                        constraint_entity = ContainerConstraintEntity.load(constraint)
+
+                        if constraint_entity.prefix in ["uniqueness", "requires"]:
+                            constraints.append(constraint)
+
+                        # Replace old format with new format
+                        else:
+                            constraints.append(f"uniqueness:{constraint}")
+                            replaced = True
+
+                    # If the constraint is not valid, we keep it as is
+                    # to be caught by validation later
+                    except ValidationError:
+                        constraints.append(constraint)
+
+                cell.value = ",".join(constraints)
+
+    if replaced:
+        print(
+            (
+                "You are using a legacy container constraints format "
+                f"in the {sheet.title} sheet. Please update to the latest format."
+            ),
+        )

cognite/neat/{core → _v0/core}/_data_model/models/__init__.py

@@ -1,8 +1,8 @@
-from cognite.neat.core._client.data_classes.schema import DMSSchema
-from cognite.neat.core._data_model.models.conceptual._unverified import (
+from cognite.neat._v0.core._client.data_classes.schema import DMSSchema
+from cognite.neat._v0.core._data_model.models.conceptual._unverified import (
     UnverifiedConceptualDataModel,
 )
-from cognite.neat.core._data_model.models.conceptual._verified import (
+from cognite.neat._v0.core._data_model.models.conceptual._verified import (
     ConceptualDataModel,
 )
 

cognite/neat/{core → _v0/core}/_data_model/models/_base_verified.py

@@ -26,8 +26,8 @@ from pydantic.main import IncEx
 from pydantic_core import core_schema
 from rdflib import Namespace, URIRef
 
-from cognite.neat.core._constants import DEFAULT_NAMESPACE
-from cognite.neat.core._data_model.models._types import (
+from cognite.neat._v0.core._constants import DEFAULT_NAMESPACE
+from cognite.neat._v0.core._data_model.models._types import (
     ContainerEntityType,
     DataModelExternalIdType,
     PhysicalPropertyType,
@@ -37,13 +37,13 @@ from cognite.neat.core._data_model.models._types import (
     VersionType,
     ViewEntityType,
 )
-from cognite.neat.core._data_model.models.data_types import DataType
-from cognite.neat.core._data_model.models.entities import (
+from cognite.neat._v0.core._data_model.models.data_types import DataType
+from cognite.neat._v0.core._data_model.models.entities import (
     EdgeEntity,
     ReverseConnectionEntity,
     ViewEntity,
 )
-from cognite.neat.core._utils.rdf_ import uri_display_name
+from cognite.neat._v0.core._utils.rdf_ import uri_display_name
 
 if sys.version_info >= (3, 11):
     from enum import StrEnum

cognite/neat/{core → _v0/core}/_data_model/models/_import_contexts.py

@@ -3,7 +3,7 @@ from typing import TypeVar
 
 from rdflib import URIRef
 
-from cognite.neat.core._utils.spreadsheet import SpreadsheetRead
+from cognite.neat._v0.core._utils.spreadsheet import SpreadsheetRead
 
 T_Key = TypeVar("T_Key", bound=Hashable)
 T_Value = TypeVar("T_Value")

cognite/neat/{core → _v0/core}/_data_model/models/_types.py

@@ -14,21 +14,21 @@ from pydantic import (
 )
 from pydantic.functional_serializers import PlainSerializer
 
-from cognite.neat.core._data_model._constants import (
+from cognite.neat._v0.core._data_model._constants import (
     DATA_MODEL_COMPLIANCE_REGEX,
     PATTERNS,
     PREFIX_COMPLIANCE_REGEX,
     VERSION_COMPLIANCE_REGEX,
     EntityTypes,
 )
-from cognite.neat.core._data_model.models.entities._multi_value import MultiValueTypeInfo
-from cognite.neat.core._data_model.models.entities._single_value import (
+from cognite.neat._v0.core._data_model.models.entities._multi_value import MultiValueTypeInfo
+from cognite.neat._v0.core._data_model.models.entities._single_value import (
     ConceptEntity,
     ContainerEntity,
     ViewEntity,
 )
-from cognite.neat.core._issues.errors import RegexViolationError
-from cognite.neat.core._issues.warnings import RegexViolationWarning
+from cognite.neat._v0.core._issues.errors import RegexViolationError
+from cognite.neat._v0.core._issues.warnings import RegexViolationWarning
 
 Entities: TypeAlias = ConceptEntity | ViewEntity | ContainerEntity
 T_Entities = TypeVar("T_Entities", bound=Entities)

cognite/neat/{core → _v0/core}/_data_model/models/conceptual/_unverified.py

@@ -6,19 +6,19 @@ import pandas as pd
 from cognite.client import data_modeling as dm
 from rdflib import Namespace, URIRef
 
-from cognite.neat.core._constants import DEFAULT_NAMESPACE
-from cognite.neat.core._data_model.models._base_unverified import (
+from cognite.neat._v0.core._constants import DEFAULT_NAMESPACE
+from cognite.neat._v0.core._data_model.models._base_unverified import (
     UnverifiedComponent,
     UnverifiedDataModel,
 )
-from cognite.neat.core._data_model.models.data_types import DataType
-from cognite.neat.core._data_model.models.entities import (
+from cognite.neat._v0.core._data_model.models.data_types import DataType
+from cognite.neat._v0.core._data_model.models.entities import (
     ConceptEntity,
     MultiValueTypeInfo,
     UnknownEntity,
     load_value_type,
 )
-from cognite.neat.core._utils.rdf_ import uri_display_name
+from cognite.neat._v0.core._utils.rdf_ import uri_display_name
 
 from ._verified import (
     Concept,
@@ -100,8 +100,8 @@ class UnverifiedConceptualProperty(UnverifiedComponent[ConceptualProperty]):
 
     def dump(self, default_prefix: str, **kwargs) -> dict[str, Any]:  # type: ignore
         output = super().dump()
-        output["Concept"] = ConceptEntity.load(self.concept, prefix=default_prefix)
-        output["Value Type"] = load_value_type(self.value_type, default_prefix)
+        output["Concept"] = ConceptEntity.load(self.concept, prefix=default_prefix, return_on_failure=True)
+        output["Value Type"] = load_value_type(self.value_type, default_prefix, return_on_failure=True)
         return output
 
     def copy(self, update: dict[str, Any], default_prefix: str) -> "UnverifiedConceptualProperty":
@@ -135,10 +135,16 @@ class UnverifiedConcept(UnverifiedComponent[Concept]):
         parent: list[ConceptEntity] | None = None
         if isinstance(self.implements, str):
             self.implements = self.implements.strip()
-            parent = [ConceptEntity.load(parent, prefix=default_prefix) for parent in self.implements.split(",")]
+            parent = [
+                ConceptEntity.load(parent_str, prefix=default_prefix, return_on_failure=True)
+                for parent_str in self.implements.split(",")
+            ]
         elif isinstance(self.implements, list):
-            parent = [ConceptEntity.load(parent_, prefix=default_prefix) for parent_ in self.implements]
-        output["Concept"] = ConceptEntity.load(self.concept, prefix=default_prefix)
+            parent = [
+                ConceptEntity.load(parent_str, prefix=default_prefix, return_on_failure=True)
+                for parent_str in self.implements
+            ]
+        output["Concept"] = ConceptEntity.load(self.concept, prefix=default_prefix, return_on_failure=True)
         output["Implements"] = parent
         return output
 

cognite/neat/{core → _v0/core}/_data_model/models/conceptual/_validation.py

@@ -1,28 +1,28 @@
 import itertools
 from collections import Counter, defaultdict
 
-from cognite.neat.core._constants import get_base_concepts
-from cognite.neat.core._data_model._constants import PATTERNS, EntityTypes
-from cognite.neat.core._data_model.models._import_contexts import ImportContext, SpreadsheetContext
-from cognite.neat.core._data_model.models.entities import ConceptEntity, UnknownEntity
-from cognite.neat.core._data_model.models.entities._multi_value import MultiValueTypeInfo
-from cognite.neat.core._issues import IssueList
-from cognite.neat.core._issues.errors import NeatValueError
-from cognite.neat.core._issues.errors._resources import (
+from cognite.neat._v0.core._constants import get_base_concepts
+from cognite.neat._v0.core._data_model._constants import PATTERNS, EntityTypes
+from cognite.neat._v0.core._data_model.models._import_contexts import ImportContext, SpreadsheetContext
+from cognite.neat._v0.core._data_model.models.entities import ConceptEntity, UnknownEntity
+from cognite.neat._v0.core._data_model.models.entities._multi_value import MultiValueTypeInfo
+from cognite.neat._v0.core._issues import IssueList
+from cognite.neat._v0.core._issues.errors import NeatValueError
+from cognite.neat._v0.core._issues.errors._resources import (
     ResourceDuplicatedError,
     ResourceNotDefinedError,
 )
-from cognite.neat.core._issues.warnings._models import (
+from cognite.neat._v0.core._issues.warnings._models import (
     ConceptOnlyDataModelWarning,
     ConversionToPhysicalModelImpossibleWarning,
     DanglingPropertyWarning,
     UndefinedConceptWarning,
 )
-from cognite.neat.core._issues.warnings._resources import (
+from cognite.neat._v0.core._issues.warnings._resources import (
     ResourceNotDefinedWarning,
     ResourceRegexViolationWarning,
 )
-from cognite.neat.core._utils.text import humanize_collection
+from cognite.neat._v0.core._utils.text import humanize_collection
 
 from ._verified import ConceptualDataModel
 
@@ -37,7 +37,7 @@ class ConceptualValidation:
         context: ImportContext | None = None,
     ):
         # import here to avoid circular import issues
-        from cognite.neat.core._data_model.analysis._base import DataModelAnalysis
+        from cognite.neat._v0.core._data_model.analysis._base import DataModelAnalysis
 
         self.data_model = data_model
         self.analysis = DataModelAnalysis(self.data_model)

cognite/neat/{core → _v0/core}/_data_model/models/conceptual/_verified.py

@@ -7,9 +7,9 @@ from pydantic import Field, field_serializer, field_validator, model_validator
 from pydantic_core.core_schema import SerializationInfo
 from rdflib import Namespace, URIRef
 
-from cognite.neat.core._constants import get_default_prefixes_and_namespaces
-from cognite.neat.core._data_model._constants import EntityTypes
-from cognite.neat.core._data_model.models._base_verified import (
+from cognite.neat._v0.core._constants import get_default_prefixes_and_namespaces
+from cognite.neat._v0.core._data_model._constants import EntityTypes
+from cognite.neat._v0.core._data_model.models._base_verified import (
     BaseVerifiedDataModel,
     BaseVerifiedMetadata,
     DataModelLevel,
@@ -17,7 +17,7 @@ from cognite.neat.core._data_model.models._base_verified import (
     SheetList,
     SheetRow,
 )
-from cognite.neat.core._data_model.models._types import (
+from cognite.neat._v0.core._data_model.models._types import (
     ConceptEntityType,
     ConceptualPropertyType,
     MultiValueTypeType,
@@ -25,17 +25,17 @@ from cognite.neat.core._data_model.models._types import (
 )
 
 # NeatIdType,
-from cognite.neat.core._data_model.models.data_types import DataType
-from cognite.neat.core._data_model.models.entities import (
+from cognite.neat._v0.core._data_model.models.data_types import DataType
+from cognite.neat._v0.core._data_model.models.entities import (
     ClassEntityList,
     ConceptEntity,
     ConceptualEntity,
     UnknownEntity,
 )
-from cognite.neat.core._issues.errors import PropertyDefinitionError
+from cognite.neat._v0.core._issues.errors import PropertyDefinitionError
 
 if TYPE_CHECKING:
-    from cognite.neat.core._data_model.models import PhysicalDataModel
+    from cognite.neat._v0.core._data_model.models import PhysicalDataModel
 
 
 class ConceptualMetadata(BaseVerifiedMetadata):
@@ -303,7 +303,7 @@ class ConceptualDataModel(BaseVerifiedDataModel):
                 classes_by_neat_id[view.conceptual].physical = neat_id
 
     def as_physical_data_model(self) -> "PhysicalDataModel":
-        from cognite.neat.core._data_model.transformers._converters import (
+        from cognite.neat._v0.core._data_model.transformers._converters import (
             _ConceptualDataModelConverter,
         )
 

cognite/neat/{core → _v0/core}/_data_model/models/data_types.py

@@ -10,12 +10,12 @@ from pydantic import BaseModel, Field, model_serializer, model_validator
 from pydantic.functional_validators import ModelWrapValidatorHandler
 from rdflib import URIRef
 
-from cognite.neat.core._constants import XML_SCHEMA_NAMESPACE
-from cognite.neat.core._data_model._constants import (
+from cognite.neat._v0.core._constants import XML_SCHEMA_NAMESPACE
+from cognite.neat._v0.core._data_model._constants import (
     SPLIT_ON_COMMA_PATTERN,
     SPLIT_ON_EQUAL_PATTERN,
 )
-from cognite.neat.core._data_model.models.entities._single_value import (
+from cognite.neat._v0.core._data_model.models.entities._single_value import (
     ConceptEntity,
     UnitEntity,
 )
@@ -246,6 +246,11 @@ class String(DataType):
     sql = "STRING"
 
     name: typing.Literal["string"] = "string"
+    max_text_size: int | None = Field(
+        None,
+        alias="maxTextSize",
+        description="Specifies the maximum size in bytes of the text property, when encoded with utf-8.",
+    )
 
 
 class LangString(DataType):
@@ -256,6 +261,11 @@ class LangString(DataType):
     sql = "STRING"
 
     name: typing.Literal["langString"] = "langString"
+    max_text_size: int | None = Field(
+        None,
+        alias="maxTextSize",
+        description="Specifies the maximum size in bytes of the text property, when encoded with utf-8.",
+    )
 
 
 class AnyURI(DataType):
@@ -292,7 +302,7 @@ class DateTime(DataType):
     python = datetime
     dms = dms.Timestamp
     graphql = "Timestamp"
-    xsd = "dateTimeStamp"
+    xsd = "dateTime"
     sql = "TIMESTAMP"
 
     name: typing.Literal["dateTime"] = "dateTime"

cognite/neat/{core → _v0/core}/_data_model/models/entities/__init__.py

@@ -1,11 +1,13 @@
 from ._constants import Undefined, Unknown
 from ._loaders import load_connection, load_dms_value_type, load_value_type
 from ._multi_value import MultiValueTypeInfo
+from ._restrictions import ConceptPropertyCardinalityConstraint, ConceptPropertyValueConstraint, parse_restriction
 from ._single_value import (
     AssetEntity,
     AssetFields,
     ConceptEntity,
     ConceptualEntity,
+    ContainerConstraintEntity,
     ContainerEntity,
     ContainerIndexEntity,
     DataModelEntity,
@@ -31,7 +33,10 @@ __all__ = [
     "CdfResourceEntityList",
     "ClassEntityList",
     "ConceptEntity",
+    "ConceptPropertyCardinalityConstraint",
+    "ConceptPropertyValueConstraint",
     "ConceptualEntity",
+    "ContainerConstraintEntity",
     "ContainerEntity",
     "ContainerEntityList",
     "ContainerIndexEntity",
@@ -61,4 +66,5 @@ __all__ = [
     "load_connection",
     "load_dms_value_type",
     "load_value_type",
+    "parse_restriction",
 ]