cognite-neat 0.88.1__py3-none-any.whl → 0.88.3__py3-none-any.whl

cognite/neat/rules/models/information/_rules.py

@@ -8,9 +8,7 @@ from pydantic.main import IncEx
 from rdflib import Namespace
 
 from cognite.neat.constants import get_default_prefixes
-from cognite.neat.issues import MultiValueError
-from cognite.neat.rules import issues
-from cognite.neat.rules.issues.spreadsheet import DefaultValueTypeNotProperError
+from cognite.neat.issues.errors import PropertyDefinitionError
 from cognite.neat.rules.models._base import (
     BaseMetadata,
     BaseRules,
@@ -228,11 +226,12 @@ class InformationProperty(SheetEntity):
                         self.default = self.value_type.python(self.default)
 
                 except Exception:
-                    raise DefaultValueTypeNotProperError(
+                    raise PropertyDefinitionError(
+                        self.class_,
+                        "Class",
                         self.property_,
-                        type(self.default),
-                        str(self.value_type.python),
-                    ).as_exception() from None
+                        f"Default value {self.default} is not of type {self.value_type.python}",
+                    ) from None
         return self
 
     @property
@@ -306,7 +305,7 @@ class InformationRules(BaseRules):
         if issue_list.warnings:
             issue_list.trigger_warnings()
         if issue_list.has_errors:
-            raise MultiValueError([error for error in issue_list if isinstance(error, issues.NeatValidationError)])
+            raise issue_list.as_exception()
         return self
 
     def dump(

cognite/neat/rules/models/information/_validation.py

@@ -2,8 +2,8 @@ import itertools
 from collections import Counter
 from typing import cast
 
-from cognite.neat.rules import issues
-from cognite.neat.rules.issues import IssueList
+from cognite.neat.issues import IssueList
+from cognite.neat.issues.errors import NeatValueError, ResourceNotDefinedError
 from cognite.neat.rules.models._base import DataModelType, SchemaCompleteness
 from cognite.neat.rules.models.entities import ClassEntity, EntityTypes, UnknownEntity
 from cognite.neat.utils.rdf_ import get_inheritance_path
@@ -58,9 +58,9 @@ class InformationPostValidation:
                 ):
                     dangling_classes.add(class_)
 
-        if dangling_classes:
+        for class_ in dangling_classes:
             self.issue_list.append(
-                issues.spreadsheet.ClassNoPropertiesNoParentError([class_.versioned_id for class_ in dangling_classes])
+                NeatValueError(f"Class {class_} has no properties and is not a parent of any class with properties")
             )
 
     def _referenced_parent_classes_exist(self) -> None:
@@ -70,9 +70,15 @@ class InformationPostValidation:
         parents = set(itertools.chain.from_iterable(class_parent_pairs.values()))
 
         if undefined_parents := parents.difference(classes):
-            self.issue_list.append(
-                issues.spreadsheet.ParentClassesNotDefinedError([missing.versioned_id for missing in undefined_parents])
-            )
+            for parent in undefined_parents:
+                # Todo: include row and column number
+                self.issue_list.append(
+                    ResourceNotDefinedError[ClassEntity](
+                        resource_type="class",
+                        identifier=parent,
+                        location="Classes sheet",
+                    )
+                )
 
     def _referenced_classes_exist(self) -> None:
         # needs to be complete for this validation to pass
@@ -83,21 +89,27 @@ class InformationPostValidation:
         if self.metadata.schema_ == SchemaCompleteness.complete and (
             missing_classes := referred_classes.difference(defined_classes)
         ):
-            self.issue_list.append(
-                issues.spreadsheet.PropertiesDefinedForUndefinedClassesError(
-                    [missing.versioned_id for missing in missing_classes]
+            for class_ in missing_classes:
+                self.issue_list.append(
+                    ResourceNotDefinedError[ClassEntity](
+                        resource_type="class",
+                        identifier=class_,
+                        location="Classes sheet",
+                    )
                 )
-            )
 
         # USE CASE: models are extended (user + last = complete)
         if self.metadata.schema_ == SchemaCompleteness.extended:
             defined_classes |= {class_.class_ for class_ in cast(InformationRules, self.rules.last).classes}
             if missing_classes := referred_classes.difference(defined_classes):
-                self.issue_list.append(
-                    issues.spreadsheet.PropertiesDefinedForUndefinedClassesError(
-                        [missing.versioned_id for missing in missing_classes]
+                for class_ in missing_classes:
+                    self.issue_list.append(
+                        ResourceNotDefinedError[ClassEntity](
+                            resource_type="class",
+                            identifier=class_,
+                            location="Classes sheet",
+                        )
                     )
-                )
 
     def _referenced_value_types_exist(self) -> None:
         # adding UnknownEntity to the set of defined classes to handle the case where a property references an unknown
@@ -112,21 +124,29 @@ class InformationPostValidation:
         if self.metadata.schema_ == SchemaCompleteness.complete and (
             missing_value_types := referred_object_types.difference(defined_classes)
         ):
-            self.issue_list.append(
-                issues.spreadsheet.ValueTypeNotDefinedError(
-                    [cast(ClassEntity, missing).versioned_id for missing in missing_value_types]
+            # Todo: include row and column number
+            for missing in missing_value_types:
+                self.issue_list.append(
+                    ResourceNotDefinedError[ClassEntity](
+                        resource_type="class",
+                        identifier=cast(ClassEntity, missing),
+                        location="Classes sheet",
+                    )
                 )
-            )
 
         # USE CASE: models are extended (user + last = complete)
         if self.metadata.schema_ == SchemaCompleteness.extended:
             defined_classes |= {class_.class_ for class_ in cast(InformationRules, self.rules.last).classes}
             if missing_value_types := referred_object_types.difference(defined_classes):
-                self.issue_list.append(
-                    issues.spreadsheet.ValueTypeNotDefinedError(
-                        [cast(ClassEntity, missing).versioned_id for missing in missing_value_types]
+                # Todo: include row and column number
+                for missing in missing_value_types:
+                    self.issue_list.append(
+                        ResourceNotDefinedError(
+                            resource_type="class",
+                            identifier=cast(ClassEntity, missing),
+                            location="Classes sheet",
+                        )
                     )
-                )
 
     def _class_parent_pairs(self) -> dict[ClassEntity, list[ClassEntity]]:
         class_subclass_pairs: dict[ClassEntity, list[ClassEntity]] = {}
@@ -173,7 +193,10 @@ class InformationPostValidation:
             reused_namespaces = [value for value, count in Counter(prefixes.values()).items() if count > 1]
             impacted_prefixes = [key for key, value in prefixes.items() if value in reused_namespaces]
             self.issue_list.append(
-                issues.spreadsheet.PrefixNamespaceCollisionError(
-                    prefixes=impacted_prefixes, namespaces=reused_namespaces
+                NeatValueError(
+                    "Namespace collision detected. The following prefixes "
+                    f"are assigned to the same namespace: {impacted_prefixes}"
+                    f"\nImpacted namespaces: {reused_namespaces}"
+                    "\nMake sure that each unique namespace is assigned to a unique prefix"
                 )
             )

cognite/neat/rules/transformers/_base.py

@@ -0,0 +1,15 @@
+from abc import ABC, abstractmethod
+from typing import Generic, TypeVar
+
+from cognite.neat.rules._shared import Rules
+
+T_RulesIn = TypeVar("T_RulesIn", bound=Rules)
+T_RulesOut = TypeVar("T_RulesOut", bound=Rules)
+
+
+class RulesTransformer(ABC, Generic[T_RulesIn, T_RulesOut]):
+    """This is the base class for all rule transformers."""
+
+    @abstractmethod
+    def transform(self, rules: T_RulesIn) -> T_RulesOut:
+        raise NotImplementedError()

cognite/neat/utils/auxiliary.py

@@ -3,15 +3,14 @@ import importlib
 import inspect
 import logging
 import time
-from collections.abc import Callable, Iterable
+from collections.abc import Callable
 from datetime import datetime
 from functools import wraps
 from types import ModuleType
 
 from cognite.client.exceptions import CogniteDuplicatedError, CogniteReadTimeout
-from pydantic_core import ErrorDetails
 
-from cognite.neat.exceptions import NeatImportError
+from cognite.neat.issues.errors import NeatImportError
 
 
 def local_import(module: str, extra: str) -> ModuleType:
@@ -119,38 +118,6 @@ def create_sha256_hash(string: str) -> str:
     return hash_value
 
 
-# Will likely be removed with legacy code
-def generate_exception_report(exceptions: list[dict] | list[ErrorDetails] | None, category: str = "") -> str:
-    exceptions_as_dict = _order_expectations_by_type(exceptions) if exceptions else {}
-    report = ""
-
-    for exception_type in exceptions_as_dict.keys():
-        title = f"# {category}: {exception_type}" if category else ""
-        warnings = "\n- " + "\n- ".join(exceptions_as_dict[exception_type])
-        report += title + warnings + "\n\n"
-
-    return report
-
-
-def _order_expectations_by_type(
-    exceptions: list[dict] | list[ErrorDetails],
-) -> dict[str, list[str]]:
-    exception_dict: dict[str, list[str]] = {}
-    for exception in exceptions:
-        if not isinstance(exception["loc"], str) and isinstance(exception["loc"], Iterable):
-            location = f"[{'/'.join(str(e) for e in exception['loc'])}]"
-        else:
-            location = ""
-
-        issue = f"{exception['msg']} {location}"
-
-        if exception_dict.get(exception["type"]) is None:
-            exception_dict[exception["type"]] = [issue]
-        else:
-            exception_dict[exception["type"]].append(issue)
-    return exception_dict
-
-
 def string_to_ideal_type(input_string: str) -> int | bool | float | datetime | str:
     try:
         # Try converting to int

cognite/neat/utils/text.py

@@ -1,4 +1,6 @@
 import re
+from collections.abc import Collection
+from typing import Any
 
 
 def to_camel(string: str) -> str:
@@ -106,3 +108,18 @@ def to_snake(string: str) -> str:
 
 def replace_non_alphanumeric_with_underscore(text: str) -> str:
     return re.sub(r"\W+", "_", text)
+
+
+def humanize_collection(collection: Collection[Any], /, *, sort: bool = True) -> str:
+    if not collection:
+        return ""
+    elif len(collection) == 1:
+        return str(next(iter(collection)))
+
+    strings = (str(item) for item in collection)
+    if sort:
+        sequence = sorted(strings)
+    else:
+        sequence = list(strings)
+
+    return f"{', '.join(sequence[:-1])} and {sequence[-1]}"

cognite/neat/workflows/base.py

@@ -13,9 +13,9 @@ from prometheus_client import Gauge
 
 from cognite.neat.app.monitoring.metrics import NeatMetricsCollector
 from cognite.neat.config import Config
+from cognite.neat.issues.errors import WorkflowConfigurationNotSetError, WorkflowStepOutputError
 from cognite.neat.utils.auxiliary import retry_decorator
 from cognite.neat.workflows import cdf_store, utils
-from cognite.neat.workflows._exceptions import ConfigurationNotSet, InvalidStepOutputException
 from cognite.neat.workflows.cdf_store import CdfStore
 from cognite.neat.workflows.model import (
     FlowMessage,
@@ -316,7 +316,7 @@ class BaseWorkflow:
                         elif isinstance(out_obj, DataContract):
                             self.data[type(out_obj).__name__] = out_obj
                         else:
-                            raise InvalidStepOutputException(step_type=type(out_obj).__name__)
+                            raise WorkflowStepOutputError(step_type=type(out_obj).__name__)
 
             elif step.stype == StepType.START_WORKFLOW_TASK_STEP:
                 if self.task_builder:
@@ -510,7 +510,7 @@ class BaseWorkflow:
         if storage_type == "transformation_rules":
             self.rules_storage_path = Path(storage_path)
             if self.default_dataset_id is None:
-                raise ConfigurationNotSet("default_dataset_id")
+                raise WorkflowConfigurationNotSetError("default_dataset_id")
             self.cdf_store = cdf_store.CdfStore(
                 self.cdf_client, data_set_id=self.default_dataset_id, rules_storage_path=self.rules_storage_path
             )
@@ -576,7 +576,7 @@ class BaseWorkflow:
 
         file_list: list[Path] = []
         if self.data_store_path is None:
-            raise ConfigurationNotSet("data_store_path")
+            raise WorkflowConfigurationNotSetError("data_store_path")
         workflow_data_path = Path(self.data_store_path) / "workflows" / self.name
         try:
             for root, _dirs, files in os.walk(workflow_data_path):

cognite/neat/workflows/cdf_store.py

@@ -11,7 +11,7 @@ from cognite.client.data_classes import Event, FileMetadataUpdate
 from fastapi.encoders import jsonable_encoder
 from pydantic import BaseModel
 
-from cognite.neat.workflows._exceptions import ConfigurationNotSet
+from cognite.neat.issues.errors import WorkflowConfigurationNotSetError
 from cognite.neat.workflows.model import WorkflowFullStateReport, WorkflowState, WorkflowStepEvent
 from cognite.neat.workflows.utils import get_file_hash
 
@@ -53,7 +53,7 @@ class CdfStore:
     def package_workflow(self, workflow_name: str) -> str:
         """Creates a zip archive from a folder"""
         if self.workflows_storage_path is None:
-            raise ConfigurationNotSet("workflows_storage_path")
+            raise WorkflowConfigurationNotSetError("workflows_storage_path")
         folder_path = self.workflows_storage_path / workflow_name
         archive_path = self.workflows_storage_path / f"{workflow_name}.zip"
         # Make sure the folder exists
@@ -77,7 +77,7 @@ class CdfStore:
         # Make sure the archive exists
         workflow_name = workflow_name.replace(".zip", "")
         if self.workflows_storage_path is None:
-            raise ConfigurationNotSet("workflows_storage_path")
+            raise WorkflowConfigurationNotSetError("workflows_storage_path")
         package_full_path = Path(self.workflows_storage_path) / f"{workflow_name}.zip"
         output_folder = Path(self.workflows_storage_path) / workflow_name
         if not package_full_path.is_file():

cognite/neat/workflows/steps/data_contracts.py

@@ -9,13 +9,13 @@ from cognite.client.data_classes import (
 )
 from cognite.client.data_classes.data_modeling import EdgeApply, NodeApply
 
-from cognite.neat.graph.stores import NeatGraphStore
 from cognite.neat.rules.models import (
     AssetRules,
     DMSRules,
     DomainRules,
     InformationRules,
 )
+from cognite.neat.store import NeatGraphStore
 from cognite.neat.workflows.steps.step_model import DataContract
 
 

cognite/neat/workflows/steps/lib/current/graph_extractor.py

@@ -8,8 +8,8 @@ from rdflib import URIRef
 from cognite.neat.constants import DEFAULT_NAMESPACE
 from cognite.neat.graph.extractors import RdfFileExtractor
 from cognite.neat.graph.extractors._mock_graph_generator import MockGraphGenerator
+from cognite.neat.issues.errors import WorkflowStepNotInitializedError
 from cognite.neat.rules._shared import DMSRules, InformationRules
-from cognite.neat.workflows._exceptions import StepNotInitialized
 from cognite.neat.workflows.model import FlowMessage, StepExecutionStatus
 from cognite.neat.workflows.steps.data_contracts import MultiRuleData, NeatGraph
 from cognite.neat.workflows.steps.step_model import Configurable, Step
@@ -45,7 +45,7 @@ class GraphFromMockData(Step):
         self, rules: MultiRuleData, graph_store: NeatGraph
     ) -> FlowMessage:
         if self.configs is None:
-            raise StepNotInitialized(type(self).__name__)
+            raise WorkflowStepNotInitializedError(type(self).__name__)
 
         if not rules.information and not rules.dms:
             return FlowMessage(
@@ -110,7 +110,7 @@ class GraphFromRdfFile(Step):
 
     def run(self, graph_store: NeatGraph) -> FlowMessage:  # type: ignore[override, syntax]
         if self.configs is None or self.data_store_path is None:
-            raise StepNotInitialized(type(self).__name__)
+            raise WorkflowStepNotInitializedError(type(self).__name__)
 
         if source_file := self.configs["File path"]:
             NeatGraph.graph.write(

cognite/neat/workflows/steps/lib/current/graph_loader.py

@@ -2,7 +2,7 @@ import time
 from pathlib import Path
 from typing import ClassVar
 
-from cognite.neat.workflows._exceptions import StepNotInitialized
+from cognite.neat.issues.errors import WorkflowStepNotInitializedError
 from cognite.neat.workflows.model import FlowMessage
 from cognite.neat.workflows.steps.data_contracts import NeatGraph
 from cognite.neat.workflows.steps.step_model import Configurable, Step
@@ -34,7 +34,7 @@ class GraphToRdfFile(Step):
         self, graph: NeatGraph
     ) -> FlowMessage:  # type: ignore[syntax]
         if self.configs is None or self.data_store_path is None:
-            raise StepNotInitialized(type(self).__name__)
+            raise WorkflowStepNotInitializedError(type(self).__name__)
 
         storage_path = self.data_store_path / Path(self.configs["File path"])
         relative_graph_file_path = str(storage_path).split("/data/")[1]

cognite/neat/workflows/steps/lib/current/graph_store.py

@@ -1,6 +1,6 @@
 from typing import ClassVar
 
-from cognite.neat.graph.stores import NeatGraphStore
+from cognite.neat.store import NeatGraphStore
 from cognite.neat.workflows.model import FlowMessage
 from cognite.neat.workflows.steps.data_contracts import (
     MultiRuleData,

cognite/neat/workflows/steps/lib/current/rules_exporter.py

@@ -2,10 +2,10 @@ import time
 from pathlib import Path
 from typing import ClassVar, Literal, cast
 
+from cognite.neat.issues.errors import WorkflowStepNotInitializedError
 from cognite.neat.rules import exporters
-from cognite.neat.rules._shared import DMSRules, InformationRules, Rules
+from cognite.neat.rules._shared import DMSRules, InformationRules, VerifiedRules
 from cognite.neat.rules.models import RoleTypes
-from cognite.neat.workflows._exceptions import StepNotInitialized
 from cognite.neat.workflows.model import FlowMessage, StepExecutionStatus
 from cognite.neat.workflows.steps.data_contracts import CogniteClient, MultiRuleData
 from cognite.neat.workflows.steps.step_model import Configurable, Step
@@ -61,7 +61,7 @@ class DeleteDataModelFromCDF(Step):
 
     def run(self, rules: MultiRuleData, cdf_client: CogniteClient) -> FlowMessage:  # type: ignore[override]
         if self.configs is None or self.data_store_path is None:
-            raise StepNotInitialized(type(self).__name__)
+            raise WorkflowStepNotInitializedError(type(self).__name__)
         components_to_delete = {
             cast(Literal["all", "spaces", "data_models", "views", "containers"], key)
             for key, value in self.complex_configs["Components"].items()
@@ -168,7 +168,7 @@ class RulesToDMS(Step):
 
     def run(self, rules: MultiRuleData, cdf_client: CogniteClient) -> FlowMessage:  # type: ignore[override]
         if self.configs is None or self.data_store_path is None:
-            raise StepNotInitialized(type(self).__name__)
+            raise WorkflowStepNotInitializedError(type(self).__name__)
         existing_components_handling = cast(
             Literal["fail", "update", "skip", "force"], self.configs["Existing component handling"]
         )
@@ -291,7 +291,7 @@ class RulesToExcel(Step):
 
     def run(self, rules: MultiRuleData) -> FlowMessage:  # type: ignore[override, syntax]
         if self.configs is None or self.data_store_path is None:
-            raise StepNotInitialized(type(self).__name__)
+            raise WorkflowStepNotInitializedError(type(self).__name__)
 
         dump_format = self.configs.get("Dump Format", "user")
         styling = cast(exporters.ExcelExporter.Style, self.configs.get("Styling", "default"))
@@ -317,7 +317,7 @@ class RulesToExcel(Step):
             new_model_id=new_model_id,
         )
 
-        rule_instance: Rules
+        rule_instance: VerifiedRules
         if rules.domain:
             rule_instance = rules.domain
         elif rules.information:
@@ -369,7 +369,7 @@ class RulesToOntology(Step):
 
     def run(self, rules: MultiRuleData) -> FlowMessage:  # type: ignore[override, syntax]
         if self.configs is None or self.data_store_path is None:
-            raise StepNotInitialized(type(self).__name__)
+            raise WorkflowStepNotInitializedError(type(self).__name__)
 
         if not rules.information and not rules.dms:
             return FlowMessage(
@@ -420,7 +420,7 @@ class RulesToSHACL(Step):
 
     def run(self, rules: MultiRuleData) -> FlowMessage:  # type: ignore[override, syntax]
         if self.configs is None or self.data_store_path is None:
-            raise StepNotInitialized(type(self).__name__)
+            raise WorkflowStepNotInitializedError(type(self).__name__)
 
         if not rules.information and not rules.dms:
             return FlowMessage(
@@ -471,7 +471,7 @@ class RulesToSemanticDataModel(Step):
 
     def run(self, rules: MultiRuleData) -> FlowMessage:  # type: ignore[override, syntax]
         if self.configs is None or self.data_store_path is None:
-            raise StepNotInitialized(type(self).__name__)
+            raise WorkflowStepNotInitializedError(type(self).__name__)
 
         if not rules.information and not rules.dms:
             return FlowMessage(
@@ -525,7 +525,7 @@ class RulesToCDFTransformations(Step):
 
     def run(self, rules: MultiRuleData, cdf_client: CogniteClient) -> FlowMessage:  # type: ignore[override]
         if self.configs is None or self.data_store_path is None:
-            raise StepNotInitialized(type(self).__name__)
+            raise WorkflowStepNotInitializedError(type(self).__name__)
 
         input_rules = rules.dms or rules.information
         if input_rules is None:

cognite/neat/workflows/steps/lib/current/rules_importer.py

@@ -5,11 +5,11 @@ from typing import ClassVar
 from cognite.client import CogniteClient
 from cognite.client.data_classes.data_modeling import DataModelId
 
+from cognite.neat.issues.errors import WorkflowStepNotInitializedError
+from cognite.neat.issues.formatters import FORMATTER_BY_NAME
 from cognite.neat.rules import importers
-from cognite.neat.rules.issues.formatters import FORMATTER_BY_NAME
 from cognite.neat.rules.models import RoleTypes
 from cognite.neat.rules.models.entities import DataModelEntity, DMSUnknownEntity
-from cognite.neat.workflows._exceptions import StepNotInitialized
 from cognite.neat.workflows.model import FlowMessage, StepExecutionStatus
 from cognite.neat.workflows.steps.data_contracts import MultiRuleData
 from cognite.neat.workflows.steps.step_model import Configurable, Step
@@ -19,6 +19,7 @@ CATEGORY = __name__.split(".")[-1].replace("_", " ").title()
 __all__ = [
     "ExcelToRules",
     "OntologyToRules",
+    "IMFToRules",
     "DMSToRules",
     "RulesInferenceFromRdfFile",
 ]
@@ -54,7 +55,7 @@ class ExcelToRules(Step):
 
     def run(self, flow_message: FlowMessage) -> (FlowMessage, MultiRuleData):  # type: ignore[syntax, override]
         if self.configs is None or self.data_store_path is None:
-            raise StepNotInitialized(type(self).__name__)
+            raise WorkflowStepNotInitializedError(type(self).__name__)
 
         file_name = self.configs.get("File name", None)
         full_path = flow_message.payload.get("full_path", None) if flow_message.payload else None
@@ -123,7 +124,7 @@ class OntologyToRules(Step):
 
     def run(self, flow_message: FlowMessage) -> (FlowMessage, MultiRuleData):  # type: ignore[syntax, override]
         if self.configs is None or self.data_store_path is None:
-            raise StepNotInitialized(type(self).__name__)
+            raise WorkflowStepNotInitializedError(type(self).__name__)
 
         file_name = self.configs.get("File name", None)
         full_path = flow_message.payload.get("full_path", None) if flow_message.payload else None
@@ -162,6 +163,77 @@ class OntologyToRules(Step):
         return FlowMessage(output_text=output_text), MultiRuleData.from_rules(rules)
 
 
+class IMFToRules(Step):
+    """This step import rules from the IMF-types and validates them."""
+
+    description = "This step imports rules from an RDF file "
+    version = "private-beta"
+    category = CATEGORY
+    configurables: ClassVar[list[Configurable]] = [
+        Configurable(
+            name="File name",
+            value="",
+            label="""Full file name of the RDF-file containing the IMF-types in the rules folder.
+                If not provided, step will attempt to get file name from payload
+                    of 'File Uploader' step (if exist)""",
+        ),
+        Configurable(
+            name="Report formatter",
+            value=next(iter(FORMATTER_BY_NAME.keys())),
+            label="The format of the report for the validation of the rules",
+            options=list(FORMATTER_BY_NAME),
+        ),
+        Configurable(
+            name="Role",
+            value="infer",
+            label="For what role Rules are intended?",
+            options=["infer", *RoleTypes.__members__.keys()],
+        ),
+    ]
+
+    def run(self, flow_message: FlowMessage) -> (FlowMessage, MultiRuleData):  # type: ignore[syntax, override]
+        if self.configs is None or self.data_store_path is None:
+            raise WorkflowStepNotInitializedError(type(self).__name__)
+
+        file_name = self.configs.get("File name", None)
+
+        full_path = flow_message.payload.get("full_path", None) if flow_message.payload else None
+
+        if file_name:
+            rules_file_path = self.config.rules_store_path / file_name
+
+        elif full_path:
+            rules_file_path = full_path
+        else:
+            error_text = "Expected either 'File name' in the step config or 'File uploader' step uploading Excel Rules."
+            return FlowMessage(error_text=error_text, step_execution_status=StepExecutionStatus.ABORT_AND_FAIL)
+
+        # if role is None, it will be inferred from the rules file
+        role = self.configs.get("Role")
+        role_enum = None
+        if role != "infer" and role is not None:
+            role_enum = RoleTypes[role]
+
+        ontology_importer = importers.IMFImporter(filepath=rules_file_path)
+        rules, issues = ontology_importer.to_rules(errors="continue", role=role_enum)
+
+        if rules is None:
+            output_dir = self.config.staging_path
+            report_writer = FORMATTER_BY_NAME[self.configs["Report formatter"]]()
+            report_writer.write_to_file(issues, file_or_dir_path=output_dir)
+            report_file = report_writer.default_file_name
+            error_text = (
+                "<p></p>"
+                f'<a href="/data/staging/{report_file}?{time.time()}" '
+                f'target="_blank">Failed to validate rules, click here for report</a>'
+            )
+            return FlowMessage(error_text=error_text, step_execution_status=StepExecutionStatus.ABORT_AND_FAIL)
+
+        output_text = "Rules validation passed successfully!"
+
+        return FlowMessage(output_text=output_text), MultiRuleData.from_rules(rules)
+
+
 class DMSToRules(Step):
     """This step imports rules from CDF Data Model"""
 
@@ -199,7 +271,7 @@ class DMSToRules(Step):
 
     def run(self, cdf_client: CogniteClient) -> (FlowMessage, MultiRuleData):  # type: ignore[syntax, override]
         if self.configs is None or self.data_store_path is None:
-            raise StepNotInitialized(type(self).__name__)
+            raise WorkflowStepNotInitializedError(type(self).__name__)
 
         datamodel_id_str = self.configs.get("Data model id")
         if datamodel_id_str is None:
@@ -288,7 +360,7 @@ class RulesInferenceFromRdfFile(Step):
 
     def run(self, flow_message: FlowMessage) -> (FlowMessage, MultiRuleData):  # type: ignore[syntax, override]
         if self.configs is None or self.data_store_path is None:
-            raise StepNotInitialized(type(self).__name__)
+            raise WorkflowStepNotInitializedError(type(self).__name__)
 
         file_path = self.configs.get("File path", None)
         full_path = flow_message.payload.get("full_path", None) if flow_message.payload else None