cognite-neat 0.123.2__py3-none-any.whl → 0.127.30__py3-none-any.whl

cognite/neat/v0/core/_data_model/importers/_rdf/_shared.py

@@ -0,0 +1,255 @@
+from typing import Any, Literal, cast
+from urllib.parse import quote
+
+from rdflib import BNode, Graph, Namespace, URIRef
+from rdflib import Literal as RdfLiteral
+from rdflib.plugins.sparql import prepareQuery
+from rdflib.query import ResultRow
+
+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.v0.core._utils.rdf_ import remove_namespace_from_uri, uri_to_entity_components
+
+
+def parse_concepts(
+    graph: Graph, query: str, parameters: set, language: str, issue_list: IssueList
+) -> tuple[dict, IssueList]:
+    """Parse concepts from graph
+
+    Args:
+        graph: Graph containing concept definitions
+        query: SPARQL query to use for parsing concepts
+        parameters: Set of parameters to extract from the query results
+        language: Language to use for parsing, by default "en"
+        issue_list: List to collect issues during parsing
+
+    Returns:
+        Dataframe containing owl classes
+    """
+
+    concepts: dict[str, dict] = {}
+
+    query = prepareQuery(query.format(language=language), initNs={k: v for k, v in graph.namespaces()})
+    prefixes = cognite_prefixes()
+
+    for raw in graph.query(query):
+        res: dict = convert_rdflib_content(
+            cast(ResultRow, raw).asdict(), uri_handling="as-concept-entity", prefixes=prefixes
+        )
+        res = {key: res.get(key, None) for key in parameters}
+
+        # Safeguarding against incomplete semantic definitions
+        if res["implements"] and isinstance(res["implements"], BNode):
+            issue_list.append(
+                ResourceRetrievalWarning(
+                    res["concept"],
+                    "implements",
+                    error=("Unable to determine concept that is being implemented"),
+                )
+            )
+            continue
+
+        # sanitize the concept and implements
+        res["concept"] = sanitize_entity(res["concept"])
+        res["implements"] = sanitize_entity(res["implements"]) if res["implements"] else None
+
+        concept_id = res["concept"]
+
+        if concept_id not in concepts:
+            concepts[concept_id] = res
+        else:
+            # Handling implements
+            if concepts[concept_id]["implements"] and isinstance(concepts[concept_id]["implements"], list):
+                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"] 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"]]
+
+            handle_meta("concept", concepts, concept_id, res, "name", issue_list)
+            handle_meta("concept", concepts, concept_id, res, "description", issue_list)
+    if not concepts:
+        issue_list.append(NeatValueError("Unable to parse concepts"))
+
+    return concepts, issue_list
+
+
+def parse_properties(
+    graph: Graph, query: str, parameters: set, language: str, issue_list: IssueList
+) -> tuple[dict, IssueList]:
+    """Parse properties from graph
+
+    Args:
+        graph: Graph containing property definitions
+        query: SPARQL query to use for parsing properties
+        parameters: Set of parameters to extract from the query results
+        language: Language to use for parsing, by default "en"
+        issue_list: List to collect issues during parsing
+
+    Returns:
+        Dataframe containing owl classes
+    """
+
+    properties: dict[str, dict] = {}
+
+    query = prepareQuery(query.format(language=language), initNs={k: v for k, v in graph.namespaces()})
+    prefixes = cognite_prefixes()
+
+    for raw in graph.query(query):
+        res: dict = convert_rdflib_content(
+            cast(ResultRow, raw).asdict(), uri_handling="as-concept-entity", prefixes=prefixes
+        )
+        res = {key: res.get(key, None) for key in parameters}
+
+        # Quote the concept id to ensure it is web-safe
+        res["property_"] = quote(res["property_"], safe="")
+        property_id = res["property_"]
+
+        # Skip Bnode
+        if isinstance(res["concept"], BNode):
+            issue_list.append(
+                ResourceRetrievalWarning(
+                    property_id,
+                    "property",
+                    error="Cannot determine concept of property as it is a blank node",
+                )
+            )
+            continue
+
+        # Skip Bnode
+        if isinstance(res["value_type"], BNode):
+            issue_list.append(
+                ResourceRetrievalWarning(
+                    property_id,
+                    "property",
+                    error="Unable to determine value type of property as it is a blank node",
+                )
+            )
+            continue
+
+        # Quote the concept and value_type if they exist if not signal neat that they are not available
+        res["concept"] = sanitize_entity(res["concept"]) if res["concept"] else str(Unknown)
+        res["value_type"] = sanitize_entity(res["value_type"]) if res["value_type"] else str(Unknown)
+
+        id_ = f"{res['concept']}.{res['property_']}"
+
+        if id_ not in properties:
+            properties[id_] = res
+            properties[id_]["value_type"] = [properties[id_]["value_type"]]
+        else:
+            handle_meta("property", properties, id_, res, "name", issue_list)
+            handle_meta(
+                "property",
+                properties,
+                id_,
+                res,
+                "description",
+                issue_list,
+            )
+
+            # Handling multi-value types
+            if res["value_type"] not in properties[id_]["value_type"]:
+                properties[id_]["value_type"].append(res["value_type"])
+
+    for prop in properties.values():
+        prop["value_type"] = ", ".join(prop["value_type"])
+
+    if not properties:
+        issue_list.append(NeatValueError("Unable to parse properties"))
+
+    return properties, issue_list
+
+
+def handle_meta(
+    resource_type: str,
+    resources: dict[str, dict],
+    resource_id: str,
+    res: dict,
+    feature: str,
+    issue_list: IssueList,
+) -> None:
+    if not resources[resource_id][feature] and res[feature]:
+        resources[resource_id][feature] = 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=current_value,
+                new_value=new_value,
+            )
+        )
+
+
+def convert_rdflib_content(
+    content: RdfLiteral | URIRef | dict | list,
+    uri_handling: Literal["skip", "remove-namespace", "as-concept-entity"] = "skip",
+    prefixes: dict[str, Namespace] | None = None,
+) -> Any:
+    """Converts rdflib content to a more Python-friendly format.
+
+    Args:
+        content: The content to convert, can be a RdfLiteral, URIRef, dict, or list.
+        uri_handling: How to handle URIs. Options are:
+            - "skip": Leave URIs as is.
+            - "remove-namespace": Remove the namespace from URIs.
+            - "short-form": Convert URIs to a short form using prefixes.
+
+    """
+    if isinstance(content, RdfLiteral):
+        return content.toPython()
+    elif isinstance(content, URIRef):
+        if uri_handling == "remove-namespace":
+            return remove_namespace_from_uri(content)
+        elif uri_handling == "as-concept-entity":
+            if components := uri_to_entity_components(content, prefixes or {}):
+                return ConceptEntity(prefix=components[0], suffix=components[3], version=components[2])
+            # fallback to "remove-namespace"
+            else:
+                return convert_rdflib_content(content, uri_handling="remove-namespace", prefixes=prefixes)
+        else:
+            return content.toPython()
+    elif isinstance(content, dict):
+        return {key: convert_rdflib_content(value, uri_handling, prefixes) for key, value in content.items()}
+    elif isinstance(content, list):
+        return [convert_rdflib_content(item, uri_handling, prefixes) for item in content]
+    else:
+        return content
+
+
+def sanitize_entity(entity: str | ConceptEntity, safe: str = "") -> str:
+    """Sanitize an entity to ensure it yields entity form that will pass downstream validation.
+
+    Args:
+        entity: The entity to sanitize. Can be a string or a ConceptEntity.
+        safe: Characters that should not be quoted during sanitization.
+
+    Returns:
+        A web-safe string representation of the entity
+    """
+    if isinstance(entity, str):
+        return quote(entity, safe=safe)
+    # if it already we dont need to quote it so we return its string representation
+    elif isinstance(entity, ConceptEntity):
+        return str(entity)
+    else:
+        raise ValueError(f"Invalid entity type: {type(entity)}. Expected str, ConceptEntity.")

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

@@ -10,27 +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._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
 
@@ -271,7 +279,7 @@ class ExcelImporter(BaseImporter[T_UnverifiedDataModel]):
             raise MultiValueError(issue_list.errors)
 
         if user_read is None:
-            return ImportedDataModel(None, {})
+            return ImportedDataModel(None, None)
 
         sheets = user_read.sheets
         original_role = user_read.role
@@ -287,7 +295,7 @@ class ExcelImporter(BaseImporter[T_UnverifiedDataModel]):
             except Exception as e:
                 issue_list.append(FileReadError(self.filepath, f"Failed to delete temporary file: {e}"))
 
-        return ImportedDataModel(data_model, read_info_by_sheet)
+        return ImportedDataModel(data_model, SpreadsheetContext(read_info_by_sheet))
 
     @property
     def description(self) -> str:
@@ -305,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(
@@ -322,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:
     """
@@ -341,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/v0/core/_data_model/models/_import_contexts.py

@@ -0,0 +1,82 @@
+from collections.abc import Hashable, ItemsView, Iterator, KeysView, Mapping, ValuesView
+from typing import TypeVar
+
+from rdflib import URIRef
+
+from cognite.neat.v0.core._utils.spreadsheet import SpreadsheetRead
+
+T_Key = TypeVar("T_Key", bound=Hashable)
+T_Value = TypeVar("T_Value")
+
+
+class ImportContext(dict, Mapping[T_Key, T_Value]):
+    def __init__(self, data: Mapping[T_Key, T_Value] | None = None) -> None:
+        super().__init__(data or {})
+
+    # The below methods are included to make better type hints in the IDE
+    def __getitem__(self, k: T_Key) -> T_Value:
+        return super().__getitem__(k)
+
+    def __setitem__(self, k: T_Key, v: T_Value) -> None:
+        super().__setitem__(k, v)
+
+    def __delitem__(self, k: T_Key) -> None:
+        super().__delitem__(k)
+
+    def __iter__(self) -> Iterator[T_Key]:
+        return super().__iter__()
+
+    def keys(self) -> KeysView[T_Key]:  # type: ignore[override]
+        return super().keys()
+
+    def values(self) -> ValuesView[T_Value]:  # type: ignore[override]
+        return super().values()
+
+    def items(self) -> ItemsView[T_Key, T_Value]:  # type: ignore[override]
+        return super().items()
+
+    def get(self, __key: T_Key, __default: T_Value | None = None) -> T_Value:  # type: ignore[override]
+        return super().get(__key, __default)
+
+    def pop(self, __key: T_Key, __default: T_Value | None = None) -> T_Value:  # type: ignore[override]
+        return super().pop(__key, __default)
+
+    def popitem(self) -> tuple[T_Key, T_Value]:
+        return super().popitem()
+
+
+class SpreadsheetContext(ImportContext[str, SpreadsheetRead]):
+    def __init__(self, data: dict[str, SpreadsheetRead] | None = None) -> None:
+        """Initialize the SpreadsheetContext with a dictionary of SpreadsheetRead objects.
+
+        Args:
+            data (dict[str, SpreadsheetRead]): A dictionary where keys are sheet names and values are
+                SpreadsheetRead objects containing the read data.
+        """
+        super().__init__(data or {})
+        for k, v in self.items():
+            if not isinstance(k, str):
+                raise TypeError(f"Expected string key, got {type(k).__name__}")
+            if not isinstance(v, SpreadsheetRead):
+                raise TypeError(f"Expected SpreadsheetRead for key '{k}', got {type(v).__name__}")
+
+
+class GraphContext(ImportContext[str, Mapping[URIRef, int]]):
+    def __init__(self, data: dict[str, Mapping[URIRef, int]] | None = None) -> None:
+        """Initialize the GraphContext with a dictionary of mappings from URIRef to int.
+
+        Args:
+            data (dict[str, Mapping[URIRef, int]]): A dictionary where keys are graph names and values are
+                mappings of URIRef to integer identifiers.
+        """
+        super().__init__(data or {})
+        for k, v in self.items():
+            if not isinstance(k, str):
+                raise TypeError(f"Expected string key, got {type(k).__name__}")
+            if not isinstance(v, Mapping):
+                raise TypeError(f"Expected Mapping[URIRef, int] for key '{k}', got {type(v).__name__}")
+            for uri, value in v.items():
+                if not isinstance(uri, URIRef):
+                    raise TypeError(f"Expected URIRef key in mapping for '{k}', got {type(uri).__name__}")
+                if not isinstance(value, int):
+                    raise TypeError(f"Expected int value in mapping for '{k}', got {type(value).__name__}")

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,
@@ -78,7 +78,7 @@ class UnverifiedConceptualMetadata(UnverifiedComponent[ConceptualMetadata]):
 
 @dataclass
 class UnverifiedConceptualProperty(UnverifiedComponent[ConceptualProperty]):
-    concept: ConceptEntity | str
+    concept: ConceptEntity | str | UnknownEntity
     property_: str
     value_type: DataType | ConceptEntity | MultiValueTypeInfo | UnknownEntity | str
     name: str | None = None
@@ -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
 
@@ -146,8 +152,8 @@ class UnverifiedConcept(UnverifiedComponent[Concept]):
 @dataclass
 class UnverifiedConceptualDataModel(UnverifiedDataModel[ConceptualDataModel]):
     metadata: UnverifiedConceptualMetadata
-    properties: list[UnverifiedConceptualProperty] = field(default_factory=list)
     concepts: list[UnverifiedConcept] = field(default_factory=list)
+    properties: list[UnverifiedConceptualProperty] = field(default_factory=list)
     prefixes: dict[str, Namespace] | None = None
 
     @classmethod