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

cognite/neat/rules/issues/tables.py

@@ -0,0 +1,72 @@
+from dataclasses import dataclass
+
+from .base import NeatValidationError
+
+
+@dataclass(frozen=True)
+class NotValidRDFPathError(NeatValidationError):
+    """Provided `rdfpath` is not valid, i.e. it cannot be converted to SPARQL query.
+
+    Args:
+        rdf_path: `rdfpath` that raised exception
+
+    Notes:
+        Get familiar with `rdfpath` to avoid this exception.
+    """
+
+    description = "Provided `rdfpath` is not valid, i.e. it cannot be converted to SPARQL query"
+    fix = "Get familiar with `rdfpath` and check if provided path is valid!"
+    rdf_path: str
+
+    def message(self) -> str:
+        message = f"{self.rdf_path} is not a valid rdfpath!"
+
+        message += f"\nDescription: {self.description}"
+        message += f"\nFix: {self.fix}"
+        return message
+
+
+@dataclass(frozen=True)
+class NotValidTableLookUpError(NeatValidationError):
+    """Provided `table lookup` is not valid, i.e. it cannot be converted to CDF lookup.
+
+    Args:
+        table_look_up: `table_look_up`, a part of `rawlookup`, that raised exception
+
+    Notes:
+        Get familiar with `rawlookup` and `rdfpath` to avoid this exception.
+    """
+
+    description = "Provided table lookup is not valid, i.e. it cannot be converted to CDF lookup"
+    fix = "Get familiar with RAW look up and RDF paths and check if provided rawlookup is valid"
+    table_look_up: str
+
+    def message(self) -> str:
+        message = f"{self.table_look_up} is not a valid table lookup"
+
+        message += f"\nDescription: {self.description}"
+        message += f"\nFix: {self.fix}"
+        return message
+
+
+@dataclass(frozen=True)
+class NotValidRAWLookUpError(NeatValidationError):
+    """Provided `rawlookup` is not valid, i.e. it cannot be converted to SPARQL query and CDF lookup
+
+    Args:
+        raw_look_up: `rawlookup` rule that raised exception
+
+    Notes:
+        Get familiar with `rawlookup` and `rdfpath` to avoid this exception.
+    """
+
+    description = "Provided rawlookup is not valid, i.e. it cannot be converted to SPARQL query and CDF lookup"
+    fix = "Get familiar with `rawlookup` and `rdfpath` to avoid this exception"
+    raw_look_up: str
+
+    def message(self):
+        message = f"Invalid rawlookup expected traversal | table lookup, got {self.raw_look_up}"
+
+        message += f"\nDescription: {self.description}"
+        message += f"\nFix: {self.fix}"
+        return message

cognite/neat/rules/models/_rdfpath.py

@@ -8,7 +8,7 @@ from typing import ClassVar, Literal
 
 from pydantic import BaseModel, field_validator, model_serializer
 
-from cognite.neat.rules import exceptions
+from cognite.neat.rules.issues.tables import NotValidRAWLookUpError, NotValidRDFPathError, NotValidTableLookUpError
 
 if sys.version_info >= (3, 11):
     from enum import StrEnum
@@ -313,7 +313,7 @@ def parse_traversal(raw: str) -> SelfReferenceProperty | SingleProperty | Hop:
     elif result := HOP_REGEX_COMPILED.match(raw):
         return Hop.from_string(class_=result.group("origin"), traversal=result.group(_traversal))
     else:
-        raise exceptions.NotValidRDFPath(raw).to_pydantic_custom_error()
+        raise NotValidRDFPathError(raw).as_pydantic_exception()
 
 
 def parse_table_lookup(raw: str) -> TableLookup:
@@ -323,7 +323,7 @@ def parse_table_lookup(raw: str) -> TableLookup:
             key=result.group(Lookup.key),
             value=result.group(Lookup.value),
         )
-    raise exceptions.NotValidTableLookUp(raw).to_pydantic_custom_error()
+    raise NotValidTableLookUpError(raw).as_pydantic_exception()
 
 
 def parse_rule(rule_raw: str, rule_type: TransformationRuleType | None) -> RDFPath:
@@ -334,7 +334,7 @@ def parse_rule(rule_raw: str, rule_type: TransformationRuleType | None) -> RDFPa
         case TransformationRuleType.rawlookup:
             rule_raw = rule_raw.replace(" ", "")
             if Counter(rule_raw).get("|") != 1:
-                raise exceptions.NotValidRAWLookUp(rule_raw).to_pydantic_custom_error()
+                raise NotValidRAWLookUpError(rule_raw).as_pydantic_exception()
             traversal, table_lookup = rule_raw.split("|")
             return RawLookup(
                 traversal=parse_traversal(traversal),

cognite/neat/rules/models/_types/_field.py

@@ -1,7 +1,6 @@
-import re
 import warnings
 from collections.abc import Callable
-from typing import Annotated, Any, cast
+from typing import Annotated, Any
 
 import rdflib
 from pydantic import (
@@ -17,11 +16,10 @@ from pydantic import (
 from pydantic.functional_serializers import PlainSerializer
 from pydantic_core import PydanticCustomError
 
-from cognite.neat.rules import exceptions
-from cognite.neat.rules.issues.importing import MoreThanOneNonAlphanumericCharacterWarning
-
-from ._base import (
-    MORE_THAN_ONE_NONE_ALPHANUMERIC_REGEX,
+from cognite.neat.issues.neat_warnings.identifier import RegexViolationWarning
+from cognite.neat.rules.issues.spreadsheet import RegexViolationError
+from cognite.neat.utils.regex_patterns import (
+    PATTERNS,
     PREFIX_COMPLIANCE_REGEX,
     PROPERTY_ID_COMPLIANCE_REGEX,
     VERSION_COMPLIANCE_REGEX,
@@ -74,11 +72,7 @@ NamespaceType = Annotated[
 PrefixType = Annotated[
     str,
     StringConstraints(pattern=PREFIX_COMPLIANCE_REGEX),
-    _custom_error(
-        lambda _, value: exceptions.PrefixesRegexViolation(
-            cast(list[str], [value]), PREFIX_COMPLIANCE_REGEX
-        ).to_pydantic_custom_error()
-    ),
+    _custom_error(lambda _, value: RegexViolationError(value, PREFIX_COMPLIANCE_REGEX).as_pydantic_exception()),
 ]
 
 ExternalIdType = Annotated[
@@ -89,19 +83,18 @@ ExternalIdType = Annotated[
 VersionType = Annotated[
     str,
     StringConstraints(pattern=VERSION_COMPLIANCE_REGEX),
-    _custom_error(
-        lambda _, value: exceptions.VersionRegexViolation(
-            version=cast(str, value), regex_expression=VERSION_COMPLIANCE_REGEX
-        ).to_pydantic_custom_error()
-    ),
+    _custom_error(lambda _, value: RegexViolationError(value, VERSION_COMPLIANCE_REGEX).as_pydantic_exception()),
 ]
 
 
 def _property_validation(value: str) -> str:
-    if not re.match(PROPERTY_ID_COMPLIANCE_REGEX, value):
-        _raise(exceptions.PropertyIDRegexViolation(value, PROPERTY_ID_COMPLIANCE_REGEX).to_pydantic_custom_error())
-    if re.search(MORE_THAN_ONE_NONE_ALPHANUMERIC_REGEX, value):
-        warnings.warn(MoreThanOneNonAlphanumericCharacterWarning("property", value), stacklevel=2)
+    if not PATTERNS.property_id_compliance.match(value):
+        _raise(RegexViolationError(value, PROPERTY_ID_COMPLIANCE_REGEX).as_pydantic_exception())
+    if PATTERNS.more_than_one_alphanumeric.search(value):
+        warnings.warn(
+            RegexViolationWarning(value, PROPERTY_ID_COMPLIANCE_REGEX, "property", "MoreThanOneNonAlphanumeric"),
+            stacklevel=2,
+        )
     return value
 
 

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

@@ -1,8 +1,8 @@
 from graphlib import CycleError
 from typing import cast
 
+from cognite.neat.issues import IssueList
 from cognite.neat.rules import issues
-from cognite.neat.rules.issues.base import IssueList
 from cognite.neat.rules.models._base import SheetList
 from cognite.neat.rules.models.asset._rules import AssetProperty, AssetRules
 from cognite.neat.rules.models.entities import AssetEntity, AssetFields, ClassEntity

cognite/neat/rules/models/dms/_schema.py

@@ -25,20 +25,16 @@ from cognite.client.data_classes.data_modeling.views import (
 )
 from cognite.client.data_classes.transformations.common import Edges, EdgeType, Nodes, ViewInfo
 
+from cognite.neat.issues import NeatError
+from cognite.neat.issues.errors.properties import ReferredPropertyNotFoundError
+from cognite.neat.issues.errors.resources import ReferredResourceNotFoundError
+from cognite.neat.issues.neat_warnings.resources import FailedLoadingResourcesWarning, MultipleResourcesWarning
 from cognite.neat.rules import issues
 from cognite.neat.rules.issues.dms import (
     ContainerPropertyUsedMultipleTimesError,
     DirectRelationMissingSourceWarning,
-    DMSSchemaError,
     DuplicatedViewInDataModelError,
     IncompleteSchemaError,
-    MissingContainerError,
-    MissingContainerPropertyError,
-    MissingEdgeViewError,
-    MissingParentViewError,
-    MissingSourceViewError,
-    MissingSpaceError,
-    MissingViewError,
     MissingViewInModelWarning,
 )
 from cognite.neat.rules.models.data_types import _DATA_TYPE_BY_DMS_TYPE
@@ -168,14 +164,10 @@ class DMSSchema:
             connection_referenced_view_ids |= cls._connection_references(view)
         connection_referenced_view_ids = connection_referenced_view_ids - existing_view_ids
         if connection_referenced_view_ids:
-            warnings.warn(
-                MissingViewInModelWarning(data_model.as_id(), connection_referenced_view_ids), UserWarning, stacklevel=2
-            )
+            warnings.warn(MissingViewInModelWarning(data_model.as_id(), connection_referenced_view_ids), stacklevel=2)
             connection_referenced_views = view_loader.retrieve(list(connection_referenced_view_ids))
             if failed := connection_referenced_view_ids - set(connection_referenced_views.as_ids()):
-                warnings.warn(
-                    issues.importing.FailedImportWarning({repr(v) for v in failed}), UserWarning, stacklevel=2
-                )
+                warnings.warn(FailedLoadingResourcesWarning[dm.ViewId](frozenset(failed), "View"), stacklevel=2)
             views.extend(connection_referenced_views)
 
         # We need to include parent views in the schema to make sure that the schema is valid.
@@ -432,8 +424,9 @@ class DMSSchema:
                 if attr.name == "data_model":
                     if isinstance(items, list) and len(items) > 1:
                         warnings.warn(
-                            issues.importing.MultipleDataModelsWarning(
-                                [item.get("externalId", "Unknown") for item in items]
+                            MultipleResourcesWarning[str](
+                                frozenset([item.get("externalId", "Unknown") for item in items]),
+                                "DataModel",
                             ),
                             stacklevel=2,
                         )
@@ -522,8 +515,8 @@ class DMSSchema:
         else:
             raise ValueError(f"Cannot sort item of type {type(item)}")
 
-    def validate(self) -> list[DMSSchemaError]:
-        errors: set[DMSSchemaError] = set()
+    def validate(self) -> list[NeatError]:
+        errors: set[NeatError] = set()
         defined_spaces = self.spaces.copy()
         defined_containers = self.containers.copy()
         defined_views = self.views.copy()
@@ -535,28 +528,42 @@ class DMSSchema:
 
         for container in self.containers.values():
             if container.space not in defined_spaces:
-                errors.add(MissingSpaceError(space=container.space, referred_by=container.as_id()))
+                errors.add(
+                    ReferredResourceNotFoundError[str, dm.ContainerId](
+                        container.space, "Space", container.as_id(), "Container"
+                    )
+                )
 
         for view in self.views.values():
             view_id = view.as_id()
             if view.space not in defined_spaces:
-                errors.add(MissingSpaceError(space=view.space, referred_by=view_id))
+                errors.add(ReferredResourceNotFoundError[str, dm.ViewId](view.space, "Space", view_id, "View"))
 
             for parent in view.implements or []:
                 if parent not in defined_views:
-                    errors.add(MissingParentViewError(view=parent, referred_by=view_id))
+                    errors.add(
+                        ReferredPropertyNotFoundError[dm.ViewId, dm.ViewId](
+                            parent, "View", view_id, "View", property_name="implements"
+                        )
+                    )
 
             for prop_name, prop in (view.properties or {}).items():
                 if isinstance(prop, dm.MappedPropertyApply):
                     ref_container = defined_containers.get(prop.container)
                     if ref_container is None:
-                        errors.add(MissingContainerError(container=prop.container, referred_by=view_id))
+                        errors.add(
+                            ReferredResourceNotFoundError[dm.ContainerId, dm.ViewId](
+                                prop.container, "Container", view_id, "View"
+                            )
+                        )
                     elif prop.container_property_identifier not in ref_container.properties:
                         errors.add(
-                            MissingContainerPropertyError(
-                                container=prop.container,
-                                property=prop.container_property_identifier,
-                                referred_by=view_id,
+                            ReferredPropertyNotFoundError[dm.ContainerId, dm.ViewId](
+                                prop.container,
+                                "Container",
+                                view_id,
+                                "View",
+                                property_name=prop.container_property_identifier,
                             )
                         )
                     else:
@@ -568,14 +575,22 @@ class DMSSchema:
                             )
 
                 if isinstance(prop, dm.EdgeConnectionApply) and prop.source not in defined_views:
-                    errors.add(MissingSourceViewError(view=prop.source, property=prop_name, referred_by=view_id))
+                    errors.add(
+                        ReferredPropertyNotFoundError[dm.ViewId, dm.ViewId](
+                            prop.source, "View", view_id, "View", property_name=prop_name
+                        )
+                    )
 
                 if (
                     isinstance(prop, dm.EdgeConnectionApply)
                     and prop.edge_source is not None
                     and prop.edge_source not in defined_views
                 ):
-                    errors.add(MissingEdgeViewError(view=prop.edge_source, property=prop_name, referred_by=view_id))
+                    errors.add(
+                        ReferredPropertyNotFoundError[dm.ViewId, dm.ViewId](
+                            prop.edge_source, "View", view_id, "View", property_name=prop_name
+                        )
+                    )
 
             # This allows for multiple view properties to be mapped to the same container property,
             # as long as they have different external_id, otherwise this will lead to raising
@@ -610,13 +625,21 @@ class DMSSchema:
         if self.data_model:
             model = self.data_model
             if model.space not in defined_spaces:
-                errors.add(MissingSpaceError(space=model.space, referred_by=model.as_id()))
+                errors.add(
+                    ReferredResourceNotFoundError[str, dm.DataModelId](
+                        model.space, "Space", model.as_id(), "Data Model"
+                    )
+                )
 
             view_counts: dict[dm.ViewId, int] = defaultdict(int)
             for view_id_or_class in model.views or []:
                 view_id = view_id_or_class if isinstance(view_id_or_class, dm.ViewId) else view_id_or_class.as_id()
                 if view_id not in defined_views:
-                    errors.add(MissingViewError(referred_by=model.as_id(), view=view_id))
+                    errors.add(
+                        ReferredResourceNotFoundError[dm.ViewId, dm.DataModelId](
+                            view_id, "View", model.as_id(), "DataModel"
+                        )
+                    )
                 view_counts[view_id] += 1
 
             for view_id, count in view_counts.items():

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

@@ -3,8 +3,8 @@ from typing import Any, ClassVar
 
 from cognite.client import data_modeling as dm
 
+from cognite.neat.issues import IssueList, NeatIssueList
 from cognite.neat.rules import issues
-from cognite.neat.rules.issues import IssueList
 from cognite.neat.rules.models._base import DataModelType, ExtensionCategory, SchemaCompleteness
 from cognite.neat.rules.models._constants import DMS_CONTAINER_SIZE_LIMIT
 from cognite.neat.rules.models.data_types import DataType
@@ -31,7 +31,7 @@ class DMSPostValidation:
         self.views = rules.views
         self.issue_list = IssueList()
 
-    def validate(self) -> IssueList:
+    def validate(self) -> NeatIssueList:
         self._validate_raw_filter()
         self._consistent_container_properties()
 

cognite/neat/rules/models/entities.py

@@ -418,6 +418,9 @@ class ViewEntity(DMSVersionedEntity[ViewId]):
     ) -> ViewId:
         return ViewId(space=self.space, external_id=self.external_id, version=self.version)
 
+    def to_property_id(self, property_id: str) -> PropertyId:
+        return PropertyId(source=self.as_id(), property=property_id)
+
     @classmethod
     def from_id(cls, id: ViewId, default_version: str | None = None) -> "ViewEntity":
         if id.version is not None:

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

@@ -9,7 +9,8 @@ from rdflib import Namespace
 
 from cognite.neat.constants import get_default_prefixes
 from cognite.neat.issues import MultiValueError
-from cognite.neat.rules import exceptions, issues
+from cognite.neat.rules import issues
+from cognite.neat.rules.issues.spreadsheet import DefaultValueTypeNotProperError
 from cognite.neat.rules.models._base import (
     BaseMetadata,
     BaseRules,
@@ -227,11 +228,11 @@ class InformationProperty(SheetEntity):
                         self.default = self.value_type.python(self.default)
 
                 except Exception:
-                    exceptions.DefaultValueTypeNotProper(
+                    raise DefaultValueTypeNotProperError(
                         self.property_,
                         type(self.default),
-                        self.value_type.python,
-                    )
+                        str(self.value_type.python),
+                    ).as_exception() from None
         return self
 
     @property

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

@@ -2,8 +2,8 @@ import itertools
 from collections import Counter
 from typing import cast
 
+from cognite.neat.issues import IssueList
 from cognite.neat.rules import issues
-from cognite.neat.rules.issues import IssueList
 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

cognite/neat/utils/rdf_.py

@@ -1,6 +1,8 @@
 import re
-from typing import Any, Literal, TypeAlias, cast, overload
+from collections.abc import Iterable
+from typing import Any, Literal, TypeAlias, overload
 
+from cognite.client.utils.useful_types import SequenceNotStr
 from pydantic import HttpUrl, TypeAdapter, ValidationError
 from rdflib import Literal as RdfLiteral
 from rdflib import Namespace, URIRef
@@ -10,7 +12,8 @@ Triple: TypeAlias = tuple[URIRef, URIRef, RdfLiteral | URIRef]
 
 @overload
 def remove_namespace_from_uri(
-    *URI: URIRef | str,
+    URI: URIRef | str,
+    *,
     special_separator: str = "#_",
     validation: Literal["full", "prefix"] = "prefix",
 ) -> str: ...
@@ -18,17 +21,19 @@ def remove_namespace_from_uri(
 
 @overload
 def remove_namespace_from_uri(
-    *URI: tuple[URIRef | str, ...],
+    URI: SequenceNotStr[URIRef | str],
+    *,
     special_separator: str = "#_",
     validation: Literal["full", "prefix"] = "prefix",
-) -> tuple[str, ...]: ...
+) -> list[str]: ...
 
 
 def remove_namespace_from_uri(
-    *URI: URIRef | str | tuple[URIRef | str, ...],
+    URI: URIRef | str | SequenceNotStr[URIRef | str],
+    *,
     special_separator: str = "#_",
     validation: Literal["full", "prefix"] = "prefix",
-) -> tuple[str, ...] | str:
+) -> str | list[str]:
     """Removes namespace from URI
 
     Args
@@ -51,11 +56,14 @@ def remove_namespace_from_uri(
         >>> remove_namespace_from_uri("http://www.example.org/index.html#section2", "http://www.example.org/index.html#section3")
         ('section2', 'section3')
     """
+    is_single = False
+    uris: Iterable[str | URIRef]
     if isinstance(URI, str | URIRef):
         uris = (URI,)
-    elif isinstance(URI, tuple):
+        is_single = True
+    elif isinstance(URI, SequenceNotStr):
         # Assume that all elements in the tuple are of the same type following type hint
-        uris = cast(tuple[URIRef | str, ...], URI)
+        uris = URI
     else:
         raise TypeError(f"URI must be of type URIRef or str, got {type(URI)}")
 
@@ -73,7 +81,7 @@ def remove_namespace_from_uri(
             else:
                 output.append(str(u))
 
-    return tuple(output) if len(output) > 1 else output[0]
+    return output[0] if is_single else output
 
 
 def get_namespace(URI: URIRef, special_separator: str = "#_") -> str:

cognite/neat/utils/regex_patterns.py

@@ -0,0 +1,52 @@
+import re
+from functools import cached_property
+
+MORE_THAN_ONE_NONE_ALPHANUMERIC_REGEX = r"([_-]{2,})"
+PREFIX_COMPLIANCE_REGEX = r"^([a-zA-Z]+)([a-zA-Z0-9]*[_-]{0,1}[a-zA-Z0-9_-]*)([a-zA-Z0-9]*)$"
+
+VIEW_ID_COMPLIANCE_REGEX = (
+    r"(?!^(Query|Mutation|Subscription|String|Int32|Int64|Int|Float32|Float64|Float|"
+    r"Timestamp|JSONObject|Date|Numeric|Boolean|PageInfo|File|Sequence|TimeSeries)$)"
+    r"(^[a-zA-Z][a-zA-Z0-9_]{0,253}[a-zA-Z0-9]?$)"
+)
+DMS_PROPERTY_ID_COMPLIANCE_REGEX = (
+    r"(?!^(space|externalId|createdTime|lastUpdatedTime|deletedTime|edge_id|"
+    r"node_id|project_id|property_group|seq|tg_table_name|extensions)$)"
+    r"(^[a-zA-Z][a-zA-Z0-9_]{0,253}[a-zA-Z0-9]?$)"
+)
+CLASS_ID_COMPLIANCE_REGEX = r"(?!^(Class|class)$)(^[a-zA-Z][a-zA-Z0-9._-]{0,253}[a-zA-Z0-9]?$)"
+PROPERTY_ID_COMPLIANCE_REGEX = r"^(\*)|(?!^(Property|property)$)(^[a-zA-Z][a-zA-Z0-9._-]{0,253}[a-zA-Z0-9]?$)"
+VERSION_COMPLIANCE_REGEX = r"^[a-zA-Z0-9]([.a-zA-Z0-9_-]{0,41}[a-zA-Z0-9])?$"
+
+
+class _Patterns:
+    @cached_property
+    def more_than_one_alphanumeric(self) -> re.Pattern:
+        return re.compile(MORE_THAN_ONE_NONE_ALPHANUMERIC_REGEX)
+
+    @cached_property
+    def prefix_compliance(self) -> re.Pattern[str]:
+        return re.compile(PREFIX_COMPLIANCE_REGEX)
+
+    @cached_property
+    def view_id_compliance(self) -> re.Pattern[str]:
+        return re.compile(VIEW_ID_COMPLIANCE_REGEX)
+
+    @cached_property
+    def dms_property_id_compliance(self) -> re.Pattern[str]:
+        return re.compile(DMS_PROPERTY_ID_COMPLIANCE_REGEX)
+
+    @cached_property
+    def class_id_compliance(self) -> re.Pattern[str]:
+        return re.compile(CLASS_ID_COMPLIANCE_REGEX)
+
+    @cached_property
+    def property_id_compliance(self) -> re.Pattern[str]:
+        return re.compile(PROPERTY_ID_COMPLIANCE_REGEX)
+
+    @cached_property
+    def version_compliance(self) -> re.Pattern[str]:
+        return re.compile(VERSION_COMPLIANCE_REGEX)
+
+
+PATTERNS = _Patterns()

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

@@ -5,8 +5,8 @@ from typing import ClassVar
 from cognite.client import CogniteClient
 from cognite.client.data_classes.data_modeling import DataModelId
 
+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
@@ -19,6 +19,7 @@ CATEGORY = __name__.split(".")[-1].replace("_", " ").title()
 __all__ = [
     "ExcelToRules",
     "OntologyToRules",
+    "IMFToRules",
     "DMSToRules",
     "RulesInferenceFromRdfFile",
 ]
@@ -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 StepNotInitialized(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"""