cognite-neat 0.88.2__py3-none-any.whl → 0.89.0__py3-none-any.whl

cognite/neat/rules/exporters/_validation.py

@@ -1,99 +1,14 @@
-import warnings
-from typing import Literal, overload
+from collections import defaultdict
+from collections.abc import Iterable
 
-from cognite.neat.exceptions import wrangle_warnings
-from cognite.neat.issues.neat_warnings.properties import PropertyRedefinedWarning
-from cognite.neat.rules.issues.dms import EntityIDNotDMSCompliantWarning
-from cognite.neat.rules.models import InformationRules
-from cognite.neat.utils.regex_patterns import DMS_PROPERTY_ID_COMPLIANCE_REGEX, PATTERNS, VIEW_ID_COMPLIANCE_REGEX
+from cognite.neat.rules.models.entities import ClassEntity
+from cognite.neat.rules.models.information import InformationProperty
 
 
-@overload
-def are_entity_names_dms_compliant(
-    rules: InformationRules, return_report: Literal[True]
-) -> tuple[bool, list[dict]]: ...
-
-
-@overload
-def are_entity_names_dms_compliant(rules: InformationRules, return_report: Literal[False] = False) -> bool: ...
-
-
-def are_entity_names_dms_compliant(
-    rules: InformationRules, return_report: bool = False
-) -> bool | tuple[bool, list[dict]]:
-    """Check if data model definitions are valid."""
-
-    flag: bool = True
-    with warnings.catch_warnings(record=True) as validation_warnings:
-        for class_ in rules.classes:
-            if not PATTERNS.view_id_compliance.match(class_.class_.suffix):
-                warnings.warn(
-                    EntityIDNotDMSCompliantWarning(class_.class_.versioned_id, "Class", VIEW_ID_COMPLIANCE_REGEX),
-                    stacklevel=2,
-                )
-                flag = False
-
-        for _, property_ in enumerate(rules.properties):
-            # check class id which would resolve as view/container id
-            if not PATTERNS.view_id_compliance.match(property_.class_.suffix):
-                warnings.warn(
-                    EntityIDNotDMSCompliantWarning(
-                        property_.class_.versioned_id,
-                        "Class",
-                        VIEW_ID_COMPLIANCE_REGEX,
-                    ),
-                    stacklevel=2,
-                )
-                flag = False
-
-            # check property id which would resolve as view/container id
-            if not PATTERNS.dms_property_id_compliance.match(property_.property_):
-                warnings.warn(
-                    EntityIDNotDMSCompliantWarning(property_.property_, "Property", DMS_PROPERTY_ID_COMPLIANCE_REGEX),
-                    stacklevel=2,
-                )
-                flag = False
-
-    if return_report:
-        return flag, wrangle_warnings(validation_warnings)
-    else:
-        return flag
-
-
-@overload
-def are_properties_redefined(rules: InformationRules, return_report: Literal[True]) -> tuple[bool, list[dict]]: ...
-
-
-@overload
-def are_properties_redefined(rules: InformationRules, return_report: Literal[False] = False) -> bool: ...
-
-
-def are_properties_redefined(rules: InformationRules, return_report: bool = False) -> bool | tuple[bool, list[dict]]:
-    flag: bool = False
-    with warnings.catch_warnings(record=True) as validation_warnings:
-        analyzed_properties: dict[str, list[str]] = {}
-        for property_ in rules.properties:
-            if property_.property_ not in analyzed_properties:
-                analyzed_properties[property_.property_] = [property_.class_.versioned_id]
-            elif property_.class_ in analyzed_properties[property_.property_]:
-                flag = True
-                warnings.warn(
-                    PropertyRedefinedWarning[str](property_.class_.versioned_id, "Class", property_.property_),
-                    stacklevel=2,
-                )
-
-            else:
-                analyzed_properties[property_.property_].append(property_.class_.versioned_id)
-
-    if return_report:
-        return flag, wrangle_warnings(validation_warnings)
-    else:
-        return flag
-
-
-def property_ids_camel_case_compliant(rules) -> bool | tuple[bool, list[dict]]:
-    raise NotImplementedError()
-
-
-def class_id_pascal_case_compliant(rules) -> bool | tuple[bool, list[dict]]:
-    raise NotImplementedError()
+def duplicated_properties(
+    properties: Iterable[InformationProperty],
+) -> dict[tuple[ClassEntity, str], list[tuple[int, InformationProperty]]]:
+    class_properties_by_id: dict[tuple[ClassEntity, str], list[tuple[int, InformationProperty]]] = defaultdict(list)
+    for prop_no, prop in enumerate(properties):
+        class_properties_by_id[(prop.class_, prop.property_)].append((prop_no, prop))
+    return {k: v for k, v in class_properties_by_id.items() if len(v) > 1}

cognite/neat/rules/importers/_base.py

@@ -4,76 +4,27 @@ from abc import ABC, abstractmethod
 from collections.abc import Iterator
 from contextlib import contextmanager
 from datetime import datetime
-from typing import Any, Literal, overload
+from typing import Any, Generic, Literal
 
 from pydantic import ValidationError
 from rdflib import Namespace
 
 from cognite.neat.issues import IssueList, NeatError, NeatWarning
-from cognite.neat.rules._shared import Rules
-from cognite.neat.rules.issues.base import (
-    NeatValidationError,
-    ValidationWarning,
-)
-from cognite.neat.rules.models import AssetRules, DMSRules, InformationRules, RoleTypes
+from cognite.neat.rules._shared import ReadRules, T_InputRules
 from cognite.neat.utils.auxiliary import class_html_doc
 
 
-class BaseImporter(ABC):
+class BaseImporter(ABC, Generic[T_InputRules]):
     """
     BaseImporter class which all importers inherit from.
     """
 
-    @overload
-    def to_rules(self, errors: Literal["raise"], role: RoleTypes | None = None) -> Rules: ...
-
-    @overload
-    def to_rules(
-        self, errors: Literal["continue"] = "continue", role: RoleTypes | None = None
-    ) -> tuple[Rules | None, IssueList]: ...
-
     @abstractmethod
-    def to_rules(
-        self,
-        errors: Literal["raise", "continue"] = "continue",
-        role: RoleTypes | None = None,
-    ) -> tuple[Rules | None, IssueList] | Rules:
-        """
-        Creates `Rules` object from the data for target role.
-        """
-        ...
-
-    @classmethod
-    def _to_output(
-        cls,
-        rules: Rules,
-        issues: IssueList,
-        errors: Literal["raise", "continue"] = "continue",
-        role: RoleTypes | None = None,
-    ) -> tuple[Rules | None, IssueList] | Rules:
-        """Converts the rules to the output format."""
-
-        if rules.metadata.role is role or role is None:
-            output = rules
-        elif isinstance(rules, DMSRules) or isinstance(rules, AssetRules) and role is RoleTypes.information:
-            output = rules.as_information_rules()
-        elif isinstance(rules, InformationRules) or isinstance(rules, AssetRules) and role is RoleTypes.dms:
-            output = rules.as_dms_rules()
-        else:
-            raise NotImplementedError(f"Role {role} is not supported for {type(rules).__name__} rules")
-
-        if errors == "raise":
-            return output
-        else:
-            return output, issues
-
-    @classmethod
-    def _return_or_raise(cls, issue_list: IssueList, errors: Literal["raise", "continue"]) -> tuple[None, IssueList]:
-        if errors == "raise":
-            raise issue_list.as_errors()
-        return None, issue_list
+    def to_rules(self) -> ReadRules[T_InputRules]:
+        """Creates `Rules` object from the data for target role."""
+        raise NotImplementedError()
 
-    def _default_metadata(self):
+    def _default_metadata(self) -> dict[str, Any]:
         return {
             "prefix": "neat",
             "schema": "partial",
@@ -103,8 +54,8 @@ class _FutureResult:
 @contextmanager
 def _handle_issues(
     issues: IssueList,
-    error_cls: type[NeatError] = NeatValidationError,
-    warning_cls: type[NeatWarning] = ValidationWarning,
+    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.