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

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

@@ -1,22 +1,22 @@
 from collections import Counter, defaultdict
 from datetime import datetime
 from pathlib import Path
-from typing import Literal, cast, overload
+from typing import cast
 
 from rdflib import Graph, Namespace, URIRef
 from rdflib import Literal as RdfLiteral
 
-import cognite.neat.rules.issues as issues
 from cognite.neat.constants import DEFAULT_NAMESPACE, get_default_prefixes
-from cognite.neat.graph.stores import NeatGraphStore
 from cognite.neat.issues import IssueList
-from cognite.neat.rules.importers._base import BaseImporter, Rules, _handle_issues
-from cognite.neat.rules.models import InformationRules, RoleTypes
-from cognite.neat.rules.models._base import MatchType
+from cognite.neat.issues.errors import FileReadError
+from cognite.neat.rules._shared import ReadRules
+from cognite.neat.rules.importers._base import BaseImporter
+from cognite.neat.rules.models._base_rules import MatchType
 from cognite.neat.rules.models.information import (
+    InformationInputRules,
     InformationMetadata,
-    InformationRulesInput,
 )
+from cognite.neat.store import NeatGraphStore
 from cognite.neat.utils.rdf_ import get_namespace, remove_namespace_from_uri, uri_to_short_form
 
 ORDERED_CLASSES_QUERY = """SELECT ?class (count(?s) as ?instances )
@@ -44,7 +44,7 @@ INSTANCE_PROPERTIES_DEFINITION = """SELECT ?property (count(?property) as ?occur
                                     GROUP BY ?property ?dataType ?objectType"""
 
 
-class InferenceImporter(BaseImporter):
+class InferenceImporter(BaseImporter[InformationInputRules]):
     """Infers rules from a triple store.
 
     Rules inference through analysis of knowledge graph provided in various formats.
@@ -106,8 +106,8 @@ class InferenceImporter(BaseImporter):
         graph = Graph()
         try:
             graph.parse(filepath)
-        except Exception:
-            issue_list.append(issues.fileread.FileReadError(filepath))
+        except Exception as e:
+            issue_list.append(FileReadError(filepath, str(e)))
 
         return cls(
             issue_list,
@@ -147,44 +147,21 @@ class InferenceImporter(BaseImporter):
     ) -> "InferenceImporter":
         raise NotImplementedError("JSON file format is not supported yet.")
 
-    @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]: ...
-
     def to_rules(
         self,
-        errors: Literal["raise", "continue"] = "continue",
-        role: RoleTypes | None = None,
-    ) -> tuple[Rules | None, IssueList] | Rules:
+    ) -> ReadRules[InformationInputRules]:
         """
         Creates `Rules` object from the data for target role.
         """
 
         if self.issue_list.has_errors:
             # In case there were errors during the import, the to_rules method will return None
-            return self._return_or_raise(self.issue_list, errors)
+            return ReadRules(None, self.issue_list, {})
 
         rules_dict = self._to_rules_components()
 
-        with _handle_issues(self.issue_list) as future:
-            rules: InformationRules
-            rules = InformationRulesInput.load(rules_dict).as_rules()
-
-        if future.result == "failure" or self.issue_list.has_errors:
-            return self._return_or_raise(self.issue_list, errors)
-
-        return self._to_output(
-            rules,
-            self.issue_list,
-            errors=errors,
-            role=role,
-        )
+        rules = InformationInputRules.load(rules_dict)
+        return ReadRules(rules, self.issue_list, {})
 
     def _to_rules_components(
         self,

cognite/neat/rules/importers/_rdf/_owl2rules/_owl2classes.py

@@ -34,6 +34,7 @@ def parse_owl_classes(graph: Graph, language: str = "en") -> list[dict]:
         FILTER (!bound(?parentClass) || !isBlank(?parentClass))
         FILTER (!bound(?name) || LANG(?name) = "" || LANGMATCHES(LANG(?name), "en"))
         FILTER (!bound(?description) || LANG(?description) = "" || LANGMATCHES(LANG(?description), "en"))
+        BIND(?class AS ?reference)
     }
     """
 

cognite/neat/rules/importers/_rdf/_owl2rules/_owl2properties.py

@@ -40,6 +40,7 @@ def parse_owl_properties(graph: Graph, language: str = "en") -> list[dict]:
         FILTER (!bound(?description) || LANG(?description) = "" || LANGMATCHES(LANG(?description), "en"))
         BIND(IF(bound(?minCount), ?minCount, 0) AS ?minCount)
         BIND(IF(bound(?maxCount), ?maxCount, 1) AS ?maxCount)
+        BIND(?property AS ?reference)
     }
     """
 

cognite/neat/rules/importers/_rdf/_owl2rules/_owl2rules.py

@@ -2,21 +2,22 @@
 there are loaders to TransformationRules pydantic class."""
 
 from pathlib import Path
-from typing import Literal, overload
 
 from rdflib import DC, DCTERMS, OWL, RDF, RDFS, SKOS, Graph
 
 from cognite.neat.issues import IssueList
-from cognite.neat.rules.importers._base import BaseImporter, Rules
+from cognite.neat.issues.errors import FileReadError
+from cognite.neat.rules._shared import ReadRules
+from cognite.neat.rules.importers._base import BaseImporter
 from cognite.neat.rules.importers._rdf._shared import make_components_compliant
-from cognite.neat.rules.models import InformationRules, RoleTypes
+from cognite.neat.rules.models import InformationInputRules
 
 from ._owl2classes import parse_owl_classes
 from ._owl2metadata import parse_owl_metadata
 from ._owl2properties import parse_owl_properties
 
 
-class OWLImporter(BaseImporter):
+class OWLImporter(BaseImporter[InformationInputRules]):
     """Convert OWL ontology to tables/ transformation rules / Excel file.
 
         Args:
@@ -37,24 +38,12 @@ class OWLImporter(BaseImporter):
     def __init__(self, filepath: Path):
         self.owl_filepath = filepath
 
-    @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]: ...
-
-    def to_rules(
-        self,
-        errors: Literal["raise", "continue"] = "continue",
-        role: RoleTypes | None = None,
-    ) -> tuple[Rules | None, IssueList] | Rules:
+    def to_rules(self) -> ReadRules[InformationInputRules]:
         graph = Graph()
         try:
             graph.parse(self.owl_filepath)
         except Exception as e:
-            raise Exception(f"Could not parse owl file: {e}") from e
+            return ReadRules(None, IssueList([FileReadError(self.owl_filepath, f"Could not parse owl file: {e}")]), {})
 
         # bind key namespaces
         graph.bind("owl", OWL)
@@ -72,5 +61,5 @@ class OWLImporter(BaseImporter):
 
         components = make_components_compliant(components)
 
-        rules = InformationRules.model_validate(components)
-        return self._to_output(rules, IssueList(), errors, role)
+        rules = InformationInputRules.load(components)
+        return ReadRules(rules, IssueList(), {})

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

@@ -4,7 +4,7 @@ import numpy as np
 import pandas as pd
 from rdflib import OWL, Literal, Namespace
 
-from cognite.neat.rules.models._base import MatchType
+from cognite.neat.rules.models._base_rules import MatchType
 from cognite.neat.rules.models.data_types import _XSD_TYPES
 from cognite.neat.utils.rdf_ import remove_namespace_from_uri
 from cognite.neat.utils.regex_patterns import PATTERNS
@@ -23,13 +23,13 @@ def parse_raw_classes_dataframe(query_results: list[tuple]) -> pd.DataFrame:
             "Comment",
         ],
     )
+
     if df.empty:
         return df
 
     # # remove NaNs
     df.replace(np.nan, "", regex=True, inplace=True)
 
-    df.Reference = df.Class
     df.Class = df.Class.apply(lambda x: remove_namespace_from_uri(x))
     df["Match Type"] = len(df) * [MatchType.exact]
     df["Comment"] = len(df) * [None]
@@ -202,7 +202,7 @@ def parse_raw_properties_dataframe(query_results: list[tuple]) -> pd.DataFrame:
         return df
 
     df.replace(np.nan, "", regex=True, inplace=True)
-    df.Reference = df.Reference if df.Reference.unique() else df.Property.copy(deep=True)
+
     df.Class = df.Class.apply(lambda x: remove_namespace_from_uri(x))
     df.Property = df.Property.apply(lambda x: remove_namespace_from_uri(x))
     df["Value Type"] = df["Value Type"].apply(lambda x: remove_namespace_from_uri(x))
@@ -231,7 +231,7 @@ def clean_up_properties(df: pd.DataFrame) -> pd.DataFrame:
                     "Min Count": property_grouped_df["Min Count"].unique()[0],
                     "Max Count": property_grouped_df["Max Count"].unique()[0],
                     "Default": property_grouped_df["Default"].unique()[0],
-                    "Reference": property_grouped_df["Reference"].unique()[0] or property_,
+                    "Reference": property_grouped_df["Reference"].unique()[0],
                     "Match Type": property_grouped_df["Match Type"].unique()[0],
                     "Comment": property_grouped_df["Comment"].unique()[0],
                     "_property_type": property_grouped_df["_property_type"].unique()[0],

cognite/neat/rules/importers/_spreadsheet2rules.py

@@ -6,29 +6,30 @@ generating a list of rules based on which nodes that form the graph are made.
 from collections import UserDict, defaultdict
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Literal, cast, overload
+from typing import Literal, cast
 
 import pandas as pd
+from cognite.client.utils._importing import local_import
 from pandas import ExcelFile
 
 from cognite.neat.issues import IssueList
-from cognite.neat.rules import issues
+from cognite.neat.issues.errors import (
+    FileMissingRequiredFieldError,
+    FileNotFoundNeatError,
+    FileReadError,
+    PropertyDefinitionDuplicatedError,
+)
+from cognite.neat.rules._shared import ReadRules, T_InputRules
 from cognite.neat.rules.models import (
-    RULES_PER_ROLE,
-    AssetRules,
-    DMSRules,
-    DomainRules,
-    InformationRules,
+    INPUT_RULES_BY_ROLE,
+    VERIFIED_RULES_BY_ROLE,
     RoleTypes,
     SchemaCompleteness,
 )
-from cognite.neat.rules.models.asset import AssetRulesInput
-from cognite.neat.rules.models.dms import DMSRulesInput
-from cognite.neat.rules.models.information import InformationRulesInput
-from cognite.neat.utils.auxiliary import local_import
 from cognite.neat.utils.spreadsheet import SpreadsheetRead, read_individual_sheet
+from cognite.neat.utils.text import humanize_collection
 
-from ._base import BaseImporter, Rules, _handle_issues
+from ._base import BaseImporter
 
 SOURCE_SHEET__TARGET_FIELD__HEADERS = [
     (
@@ -47,7 +48,7 @@ SOURCE_SHEET__TARGET_FIELD__HEADERS = [
 ]
 
 MANDATORY_SHEETS_BY_ROLE: dict[RoleTypes, set[str]] = {
-    role_type: {str(sheet_name) for sheet_name in RULES_PER_ROLE[role_type].mandatory_fields(use_alias=True)}
+    role_type: {str(sheet_name) for sheet_name in VERIFIED_RULES_BY_ROLE[role_type].mandatory_fields(use_alias=True)}
     for role_type in RoleTypes.__members__.values()
 }
 
@@ -77,12 +78,12 @@ class MetadataRaw(UserDict):
 
     def is_valid(self, issue_list: IssueList, filepath: Path) -> bool:
         if not self.has_role_field:
-            issue_list.append(issues.spreadsheet_file.RoleMissingOrUnsupportedError(filepath))
+            issue_list.append(FileMissingRequiredFieldError(filepath, "metadata", "role"))
             return False
 
         # check if there is a schema field if role is not domain expert
         if self.role != RoleTypes.domain_expert and not self.has_schema_field:
-            issue_list.append(issues.spreadsheet_file.SchemaMissingOrUnsupportedError(filepath))
+            issue_list.append(FileMissingRequiredFieldError(filepath, "metadata", "schema"))
             return False
         return True
 
@@ -153,11 +154,7 @@ class SpreadsheetReader:
     def _read_metadata(self, excel_file: ExcelFile, filepath: Path) -> MetadataRaw | None:
         if self.metadata_sheet_name not in excel_file.sheet_names:
             if self.required:
-                self.issue_list.append(
-                    issues.spreadsheet_file.MetadataSheetMissingOrFailedError(
-                        filepath, sheet_name=self.metadata_sheet_name
-                    )
-                )
+                self.issue_list.append(FileMissingRequiredFieldError(filepath, "sheet", self.metadata_sheet_name))
             return None
 
         metadata = MetadataRaw.from_excel(excel_file, self.metadata_sheet_name)
@@ -178,7 +175,9 @@ class SpreadsheetReader:
         if missing_sheets := expected_sheet_names.difference(set(excel_file.sheet_names)):
             if self.required:
                 self.issue_list.append(
-                    issues.spreadsheet_file.SheetMissingError(cast(Path, excel_file.io), list(missing_sheets))
+                    FileMissingRequiredFieldError(
+                        cast(Path, excel_file.io), "sheets", humanize_collection(missing_sheets)
+                    )
                 )
             return None, read_info_by_sheet
 
@@ -197,13 +196,13 @@ class SpreadsheetReader:
                     excel_file, source_sheet_name, return_read_info=True, expected_headers=[headers]
                 )
             except Exception as e:
-                self.issue_list.append(issues.spreadsheet_file.ReadSpreadsheetsError(cast(Path, excel_file.io), str(e)))
+                self.issue_list.append(FileReadError(cast(Path, excel_file.io), str(e)))
                 continue
 
         return sheets, read_info_by_sheet
 
 
-class ExcelImporter(BaseImporter):
+class ExcelImporter(BaseImporter[T_InputRules]):
     """Import rules from an Excel file.
 
     Args:
@@ -213,30 +212,18 @@ class ExcelImporter(BaseImporter):
     def __init__(self, filepath: Path):
         self.filepath = filepath
 
-    @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]: ...
-
-    def to_rules(
-        self, errors: Literal["raise", "continue"] = "continue", role: RoleTypes | None = None
-    ) -> tuple[Rules | None, IssueList] | Rules:
+    def to_rules(self) -> ReadRules[T_InputRules]:
         issue_list = IssueList(title=f"'{self.filepath.name}'")
         if not self.filepath.exists():
-            issue_list.append(issues.spreadsheet_file.SpreadsheetNotFoundError(self.filepath))
-            return self._return_or_raise(issue_list, errors)
+            issue_list.append(FileNotFoundNeatError(self.filepath))
+            return ReadRules(None, issue_list, {})
 
         with pd.ExcelFile(self.filepath) as excel_file:
             user_reader = SpreadsheetReader(issue_list)
 
             user_read = user_reader.read(excel_file, self.filepath)
             if user_read is None or issue_list.has_errors:
-                return self._return_or_raise(issue_list, errors)
+                return ReadRules(None, issue_list, {})
 
             last_read: ReadResult | None = None
             if any(sheet_name.startswith("Last") for sheet_name in user_reader.seen_sheets):
@@ -248,11 +235,20 @@ class ExcelImporter(BaseImporter):
                 reference_read = SpreadsheetReader(issue_list, sheet_prefix="Ref").read(excel_file, self.filepath)
 
         if issue_list.has_errors:
-            return self._return_or_raise(issue_list, errors)
+            return ReadRules(None, issue_list, {})
 
         if reference_read and user_read.role != reference_read.role:
-            issue_list.append(issues.spreadsheet_file.RoleMismatchError(self.filepath))
-            return self._return_or_raise(issue_list, errors)
+            issue_list.append(
+                PropertyDefinitionDuplicatedError(
+                    self.filepath.as_posix(),
+                    "spreadsheet.metadata",  # type: ignore[arg-type]
+                    "role",
+                    frozenset({user_read.role, reference_read.role}),
+                    ("user", "reference"),
+                    "sheet",
+                )
+            )
+            return ReadRules(None, issue_list, {})
 
         sheets = user_read.sheets
         original_role = user_read.role
@@ -267,34 +263,12 @@ class ExcelImporter(BaseImporter):
             sheets["reference"] = reference_read.sheets
             read_info_by_sheet.update(reference_read.read_info_by_sheet)
 
-        rules_cls = RULES_PER_ROLE[original_role]
-        with _handle_issues(
-            issue_list,
-            error_cls=issues.spreadsheet.InvalidSheetError,
-            error_args={"read_info_by_sheet": read_info_by_sheet},
-        ) as future:
-            rules: Rules
-            if rules_cls is DMSRules:
-                rules = DMSRulesInput.load(sheets).as_rules()
-            elif rules_cls is InformationRules:
-                rules = InformationRulesInput.load(sheets).as_rules()
-            elif rules_cls is AssetRules:
-                rules = AssetRulesInput.load(sheets).as_rules()
-            else:
-                rules = rules_cls.model_validate(sheets)  # type: ignore[attr-defined]
-
-        if future.result == "failure" or issue_list.has_errors:
-            return self._return_or_raise(issue_list, errors)
-
-        return self._to_output(
-            rules,
-            issue_list,
-            errors=errors,
-            role=role,
-        )
+        rules_cls = INPUT_RULES_BY_ROLE[original_role]
+        rules = cast(T_InputRules, rules_cls.load(sheets))
+        return ReadRules(rules, issue_list, {"read_info_by_sheet": read_info_by_sheet})
 
 
-class GoogleSheetImporter(BaseImporter):
+class GoogleSheetImporter(BaseImporter[T_InputRules]):
     """Import rules from a Google Sheet.
 
     .. warning::
@@ -310,38 +284,13 @@ class GoogleSheetImporter(BaseImporter):
         self.sheet_id = sheet_id
         self.skiprows = skiprows
 
-    @overload
-    def to_rules(self, errors: Literal["raise"], role: RoleTypes | None = None) -> Rules: ...
+    def to_rules(self) -> ReadRules[T_InputRules]:
+        raise NotImplementedError("Google Sheet Importer is not yet implemented.")
 
-    @overload
-    def to_rules(
-        self, errors: Literal["continue"] = "continue", role: RoleTypes | None = None
-    ) -> tuple[Rules | None, IssueList]: ...
-
-    def to_rules(
-        self, errors: Literal["raise", "continue"] = "continue", role: RoleTypes | None = None
-    ) -> tuple[Rules | None, IssueList] | Rules:
+    def _get_sheets(self) -> dict[str, pd.DataFrame]:
         local_import("gspread", "google")
         import gspread  # type: ignore[import]
 
-        role = role or RoleTypes.domain_expert
-        rules_model = cast(DomainRules | InformationRules | AssetRules | DMSRules, RULES_PER_ROLE[role])
-
         client_google = gspread.service_account()
         google_sheet = client_google.open_by_key(self.sheet_id)
-        sheets = {worksheet.title: pd.DataFrame(worksheet.get_all_records()) for worksheet in google_sheet.worksheets()}
-        sheet_names = {str(name).lower() for name in sheets.keys()}
-
-        if missing_sheets := rules_model.mandatory_fields().difference(sheet_names):
-            raise ValueError(f"Missing mandatory sheets: {missing_sheets}")
-
-        if role == RoleTypes.domain_expert:
-            output = rules_model.model_validate(sheets)
-        elif role == RoleTypes.information:
-            output = rules_model.model_validate(sheets)
-        elif role == RoleTypes.dms:
-            output = rules_model.model_validate(sheets)
-        else:
-            raise ValueError(f"Role {role} is not valid.")
-
-        return self._to_output(output, IssueList(), errors=errors, role=role)
+        return {worksheet.title: pd.DataFrame(worksheet.get_all_records()) for worksheet in google_sheet.worksheets()}

cognite/neat/rules/importers/_yaml2rules.py

@@ -1,18 +1,23 @@
 from pathlib import Path
-from typing import Any, Literal, overload
+from typing import Any, cast
 
 import yaml
 
-from cognite.neat.issues import IssueList
-from cognite.neat.rules import issues
-from cognite.neat.rules.issues import NeatValidationError, ValidationIssue
-from cognite.neat.rules.models import RULES_PER_ROLE, DMSRules, RoleTypes
-from cognite.neat.rules.models.dms import DMSRulesInput
+from cognite.neat.issues import IssueList, NeatIssue
+from cognite.neat.issues.errors import (
+    FileMissingRequiredFieldError,
+    FileNotAFileError,
+    FileNotFoundNeatError,
+    FileTypeUnexpectedError,
+)
+from cognite.neat.issues.warnings import NeatValueWarning
+from cognite.neat.rules._shared import ReadRules, T_InputRules
+from cognite.neat.rules.models import INPUT_RULES_BY_ROLE, RoleTypes
 
-from ._base import BaseImporter, Rules, _handle_issues
+from ._base import BaseImporter
 
 
-class YAMLImporter(BaseImporter):
+class YAMLImporter(BaseImporter[T_InputRules]):
     """Imports the rules from a YAML file.
 
     Args:
@@ -29,7 +34,7 @@ class YAMLImporter(BaseImporter):
     def __init__(
         self,
         raw_data: dict[str, Any],
-        read_issues: list[ValidationIssue] | None = None,
+        read_issues: list[NeatIssue] | None = None,
         filepaths: list[Path] | None = None,
     ) -> None:
         self.raw_data = raw_data
@@ -39,34 +44,22 @@ class YAMLImporter(BaseImporter):
     @classmethod
     def from_file(cls, filepath: Path):
         if not filepath.exists():
-            return cls({}, [issues.fileread.FileNotFoundError(filepath)])
-        if not filepath.is_file():
-            return cls({}, [issues.fileread.FileNotAFileError(filepath)])
+            return cls({}, [FileNotFoundNeatError(filepath)])
+        elif not filepath.is_file():
+            return cls({}, [FileNotAFileError(filepath)])
         elif filepath.suffix not in [".yaml", ".yml"]:
-            return cls({}, [issues.fileread.InvalidFileFormatError(filepath, [".yaml", ".yml"])])
+            return cls({}, [FileTypeUnexpectedError(filepath, frozenset([".yaml", ".yml"]))])
         return cls(yaml.safe_load(filepath.read_text()), filepaths=[filepath])
 
-    @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]: ...
-
-    def to_rules(
-        self, errors: Literal["raise", "continue"] = "continue", role: RoleTypes | None = None
-    ) -> tuple[Rules | None, IssueList] | Rules:
-        if any(issue for issue in self._read_issues if isinstance(issue, NeatValidationError)) or not self.raw_data:
-            if errors == "raise":
-                raise self._read_issues.as_errors()
-            return None, self._read_issues
+    def to_rules(self) -> ReadRules[T_InputRules]:
+        if self._read_issues.has_errors or not self.raw_data:
+            return ReadRules(None, self._read_issues, {})
         issue_list = IssueList(title="YAML Importer", issues=self._read_issues)
 
         if not self._filepaths:
             issue_list.append(
-                issues.fileread.BugInImporterWarning(
-                    importer_name=type(self).__name__, error="No filepaths when there is content", filepath=Path()
+                NeatValueWarning(
+                    f"{type(self).__name__} was called without filepaths when there is content",
                 )
             )
             metadata_file = Path()
@@ -75,38 +68,19 @@ class YAMLImporter(BaseImporter):
             metadata_file = metadata_file_nullable or self._filepaths[0]
 
         if "metadata" not in self.raw_data:
-            self._read_issues.append(
-                issues.spreadsheet_file.MetadataSheetMissingOrFailedError(metadata_file, "Metadata not found in file")
-            )
-            if errors == "raise":
-                raise self._read_issues.as_errors()
-            return None, self._read_issues
+            self._read_issues.append(FileMissingRequiredFieldError(metadata_file, "section", "metadata"))
+            return ReadRules(None, self._read_issues, {})
 
         metadata = self.raw_data["metadata"]
 
         if "role" not in metadata:
-            self._read_issues.append(
-                issues.spreadsheet_file.MetadataSheetMissingOrFailedError(metadata_file, "Role not found in metadata")
-            )
-            if errors == "raise":
-                raise self._read_issues.as_errors()
-            return None, self._read_issues
+            self._read_issues.append(FileMissingRequiredFieldError(metadata, "metadata", "role"))
+            return ReadRules(None, self._read_issues, {})
 
         role_input = RoleTypes(metadata["role"])
         role_enum = RoleTypes(role_input)
-        rules_model = RULES_PER_ROLE[role_enum]
-
-        with _handle_issues(issue_list) as future:
-            rules: Rules
-            if rules_model is DMSRules:
-                rules = DMSRulesInput.load(self.raw_data).as_rules()
-            else:
-                rules = rules_model.model_validate(self.raw_data)
-
-        if future.result == "failure":
-            if errors == "continue":
-                return None, issue_list
-            else:
-                raise issue_list.as_errors()
-
-        return self._to_output(rules, issue_list, errors, role)
+        rules_cls = INPUT_RULES_BY_ROLE[role_enum]
+
+        rules = cast(T_InputRules, rules_cls.load(self.raw_data))
+
+        return ReadRules(rules, issue_list, {})

cognite/neat/rules/models/__init__.py

@@ -1,12 +1,25 @@
-from cognite.neat.rules.models.asset import AssetRules
-from cognite.neat.rules.models.domain import DomainRules
+from cognite.neat.rules.models.asset._rules import AssetRules
+from cognite.neat.rules.models.asset._rules_input import AssetInputRules
+from cognite.neat.rules.models.domain import DomainInputRules, DomainRules
 from cognite.neat.rules.models.information._rules import InformationRules
+from cognite.neat.rules.models.information._rules_input import InformationInputRules
 
-from ._base import DataModelType, ExtensionCategory, RoleTypes, SchemaCompleteness, SheetEntity, SheetList
+from ._base_rules import DataModelType, ExtensionCategory, RoleTypes, SchemaCompleteness, SheetEntity, SheetList
 from .dms._rules import DMSRules
+from .dms._rules_input import DMSInputRules
 from .dms._schema import DMSSchema
 
-RULES_PER_ROLE: dict[RoleTypes, type[DomainRules] | type[InformationRules] | type[AssetRules] | type[DMSRules]] = {
+INPUT_RULES_BY_ROLE: dict[
+    RoleTypes, type[InformationInputRules] | type[AssetInputRules] | type[DMSInputRules] | type[DomainInputRules]
+] = {
+    RoleTypes.domain_expert: DomainInputRules,
+    RoleTypes.information: InformationInputRules,
+    RoleTypes.asset: AssetInputRules,
+    RoleTypes.dms: DMSInputRules,
+}
+VERIFIED_RULES_BY_ROLE: dict[
+    RoleTypes, type[InformationRules] | type[AssetRules] | type[DMSRules] | type[DomainRules]
+] = {
     RoleTypes.domain_expert: DomainRules,
     RoleTypes.information: InformationRules,
     RoleTypes.asset: AssetRules,
@@ -16,10 +29,13 @@ RULES_PER_ROLE: dict[RoleTypes, type[DomainRules] | type[InformationRules] | typ
 
 __all__ = [
     "DomainRules",
+    "DMSInputRules",
+    "InformationInputRules",
+    "AssetInputRules",
     "InformationRules",
     "AssetRules",
     "DMSRules",
-    "RULES_PER_ROLE",
+    "INPUT_RULES_BY_ROLE",
     "DMSSchema",
     "RoleTypes",
     "SchemaCompleteness",