cognite-neat 0.103.0__py3-none-any.whl → 0.104.0__py3-none-any.whl

cognite/neat/_rules/importers/_dms2rules.py

@@ -19,7 +19,7 @@ from cognite.client.data_classes.data_modeling.views import (
 from cognite.client.utils import ms_to_datetime
 
 from cognite.neat._client import NeatClient
-from cognite.neat._issues import IssueList, NeatIssue
+from cognite.neat._issues import IssueList, MultiValueError, NeatIssue
 from cognite.neat._issues.errors import FileTypeUnexpectedError, ResourceMissingIdentifierError, ResourceRetrievalError
 from cognite.neat._issues.warnings import (
     PropertyNotFoundWarning,
@@ -89,6 +89,14 @@ class DMSImporter(BaseImporter[DMSInputRules]):
                 continue
             self._all_containers_by_id[container.as_id()] = container
 
+    @property
+    def description(self) -> str:
+        if self.root_schema.data_model is not None:
+            identifier = f"{self.root_schema.data_model.as_id().as_tuple()!s}"
+        else:
+            identifier = "Unknown"
+        return f"DMS Data model {identifier} read as unverified data model"
+
     @classmethod
     def from_data_model_id(
         cls,
@@ -197,12 +205,14 @@ class DMSImporter(BaseImporter[DMSInputRules]):
         if self.issue_list.has_errors:
             # In case there were errors during the import, the to_rules method will return None
             self._end = datetime.now(timezone.utc)
-            return ReadRules(None, self.issue_list, {})
+            self.issue_list.trigger_warnings()
+            raise MultiValueError(self.issue_list.errors)
 
         if not self.root_schema.data_model:
             self.issue_list.append(ResourceMissingIdentifierError("data model", type(self.root_schema).__name__))
             self._end = datetime.now(timezone.utc)
-            return ReadRules(None, self.issue_list, {})
+            self.issue_list.trigger_warnings()
+            raise MultiValueError(self.issue_list.errors)
 
         model = self.root_schema.data_model
 
@@ -213,8 +223,10 @@ class DMSImporter(BaseImporter[DMSInputRules]):
         )
 
         self._end = datetime.now(timezone.utc)
-
-        return ReadRules(user_rules, self.issue_list, {})
+        self.issue_list.trigger_warnings()
+        if self.issue_list.has_errors:
+            raise MultiValueError(self.issue_list.errors)
+        return ReadRules(user_rules, {})
 
     def _create_rule_components(
         self,

cognite/neat/_rules/importers/_dtdl2rules/dtdl_importer.py

@@ -5,7 +5,7 @@ from pathlib import Path
 
 from pydantic import ValidationError
 
-from cognite.neat._issues import IssueList, NeatIssue
+from cognite.neat._issues import IssueList, MultiValueError, NeatIssue
 from cognite.neat._issues.warnings import (
     FileItemNotSupportedWarning,
     FileMissingRequiredFieldWarning,
@@ -144,5 +144,8 @@ class DTDLImporter(BaseImporter[InformationInputRules]):
             properties=converter.properties,
             classes=converter.classes,
         )
+        converter.issues.trigger_warnings()
+        if converter.issues.has_errors:
+            raise MultiValueError(converter.issues.errors)
 
-        return ReadRules(rules, converter.issues, {})
+        return ReadRules(rules, {})

cognite/neat/_rules/importers/_rdf/_base.py

@@ -5,7 +5,7 @@ from cognite.client import data_modeling as dm
 from rdflib import Graph, Namespace, URIRef
 
 from cognite.neat._constants import get_default_prefixes_and_namespaces
-from cognite.neat._issues import IssueList
+from cognite.neat._issues import IssueList, MultiValueError
 from cognite.neat._issues.errors import FileReadError
 from cognite.neat._issues.errors._general import NeatValueError
 from cognite.neat._rules._shared import ReadRules
@@ -13,9 +13,7 @@ from cognite.neat._rules.importers._base import BaseImporter
 from cognite.neat._rules.models._base_rules import RoleTypes
 from cognite.neat._rules.models.data_types import AnyURI
 from cognite.neat._rules.models.entities import UnknownEntity
-from cognite.neat._rules.models.information import (
-    InformationInputRules,
-)
+from cognite.neat._rules.models.information import InformationInputRules
 from cognite.neat._store import NeatGraphStore
 from cognite.neat._utils.rdf_ import get_namespace
 
@@ -50,6 +48,7 @@ class BaseRDFImporter(BaseImporter[InformationInputRules]):
         max_number_of_instance: int,
         non_existing_node_type: UnknownEntity | AnyURI,
         language: str,
+        source_name: str = "Unknown",
     ) -> None:
         self.issue_list = issue_list
         self.graph = graph
@@ -60,6 +59,7 @@ class BaseRDFImporter(BaseImporter[InformationInputRules]):
         self.max_number_of_instance = max_number_of_instance
         self.non_existing_node_type = non_existing_node_type
         self.language = language
+        self.source_name = source_name
 
     @classmethod
     def from_graph_store(
@@ -87,6 +87,7 @@ class BaseRDFImporter(BaseImporter[InformationInputRules]):
         max_number_of_instance: int = -1,
         non_existing_node_type: UnknownEntity | AnyURI = DEFAULT_NON_EXISTING_NODE_TYPE,
         language: str = "en",
+        source_name: str = "Unknown",
     ):
         issue_list = IssueList(title=f"{cls.__name__} issues")
 
@@ -107,6 +108,7 @@ class BaseRDFImporter(BaseImporter[InformationInputRules]):
             max_number_of_instance=max_number_of_instance,
             non_existing_node_type=non_existing_node_type,
             language=language,
+            source_name=source_name,
         )
 
     def to_rules(
@@ -115,16 +117,16 @@ class BaseRDFImporter(BaseImporter[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 ReadRules(None, self.issue_list, {})
+            self.issue_list.trigger_warnings()
+            raise MultiValueError(self.issue_list.errors)
 
         rules_dict = self._to_rules_components()
 
         rules = InformationInputRules.load(rules_dict)
-
-        return ReadRules(rules, self.issue_list, {})
+        self.issue_list.trigger_warnings()
+        return ReadRules(rules, {})
 
     def _to_rules_components(self) -> dict:
         raise NotImplementedError()

cognite/neat/_rules/importers/_rdf/_imf2rules.py

@@ -74,6 +74,10 @@ PROPERTIES_QUERY = """
 class IMFImporter(BaseRDFImporter):
     """Convert IMF Types provided as SHACL shapes to Input Rules."""
 
+    @property
+    def description(self) -> str:
+        return f"IMF Types {self.source_name} read as unverified data model"
+
     def _to_rules_components(
         self,
     ) -> dict:

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

@@ -16,6 +16,7 @@ from cognite.neat._rules.models.information import (
     InformationMetadata,
 )
 from cognite.neat._store import NeatGraphStore
+from cognite.neat._store._provenance import INSTANCES_ENTITY
 from cognite.neat._utils.rdf_ import remove_namespace_from_uri, uri_to_short_form
 
 from ._base import DEFAULT_NON_EXISTING_NODE_TYPE, BaseRDFImporter
@@ -94,6 +95,7 @@ class InferenceImporter(BaseRDFImporter):
         max_number_of_instance: int = -1,
         non_existing_node_type: UnknownEntity | AnyURI = DEFAULT_NON_EXISTING_NODE_TYPE,
         language: str = "en",
+        source_name: str = "Unknown",
     ) -> "InferenceImporter":
         return super().from_file(
             filepath,
@@ -101,6 +103,7 @@ class InferenceImporter(BaseRDFImporter):
             max_number_of_instance,
             non_existing_node_type,
             language,
+            source_name=source_name,
         )
 
     @classmethod
@@ -283,3 +286,7 @@ class InferenceImporter(BaseRDFImporter):
             updated=now,
             description="Inferred model from knowledge graph",
         )
+
+    @property
+    def source_uri(self) -> URIRef:
+        return INSTANCES_ENTITY.id_

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

@@ -78,3 +78,7 @@ class OWLImporter(BaseRDFImporter):
         }
 
         return components
+
+    @property
+    def description(self) -> str:
+        return f"Ontology {self.source_name} read as unverified data model"

cognite/neat/_rules/importers/_spreadsheet2rules.py

@@ -11,9 +11,9 @@ from typing import Literal, cast
 import pandas as pd
 from cognite.client.utils._importing import local_import
 from pandas import ExcelFile
-from rdflib import Namespace
+from rdflib import Namespace, URIRef
 
-from cognite.neat._issues import IssueList
+from cognite.neat._issues import IssueList, MultiValueError
 from cognite.neat._issues.errors import (
     FileMissingRequiredFieldError,
     FileNotFoundNeatError,
@@ -253,18 +253,19 @@ class ExcelImporter(BaseImporter[T_InputRules]):
     def to_rules(self) -> ReadRules[T_InputRules]:
         issue_list = IssueList(title=f"'{self.filepath.name}'")
         if not self.filepath.exists():
-            issue_list.append(FileNotFoundNeatError(self.filepath))
-            return ReadRules(None, issue_list, {})
+            raise FileNotFoundNeatError(self.filepath)
 
         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 ReadRules(None, issue_list, {})
 
+        issue_list.trigger_warnings()
         if issue_list.has_errors:
-            return ReadRules(None, issue_list, {})
+            raise MultiValueError(issue_list.errors)
+
+        if user_read is None:
+            return ReadRules(None, {})
 
         sheets = user_read.sheets
         original_role = user_read.role
@@ -272,7 +273,15 @@ class ExcelImporter(BaseImporter[T_InputRules]):
 
         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})
+        return ReadRules(rules, {"read_info_by_sheet": read_info_by_sheet})
+
+    @property
+    def description(self) -> str:
+        return f"Excel file {self.filepath.name} read as unverified data model"
+
+    @property
+    def source_uri(self) -> URIRef:
+        return URIRef(f"file://{self.filepath.name}")
 
 
 class GoogleSheetImporter(BaseImporter[T_InputRules]):

cognite/neat/_rules/importers/_yaml2rules.py

@@ -3,7 +3,7 @@ from typing import Any, cast
 
 import yaml
 
-from cognite.neat._issues import IssueList, NeatIssue
+from cognite.neat._issues import IssueList, MultiValueError, NeatIssue
 from cognite.neat._issues.errors import (
     FileMissingRequiredFieldError,
     FileNotAFileError,
@@ -36,24 +36,32 @@ class YAMLImporter(BaseImporter[T_InputRules]):
         raw_data: dict[str, Any],
         read_issues: list[NeatIssue] | None = None,
         filepaths: list[Path] | None = None,
+        source_name: str = "Unknown",
     ) -> None:
         self.raw_data = raw_data
         self._read_issues = IssueList(read_issues)
         self._filepaths = filepaths
+        self._source_name = source_name
+
+    @property
+    def description(self) -> str:
+        return f"YAML file {self._source_name} read as unverified data model"
 
     @classmethod
-    def from_file(cls, filepath: Path):
+    def from_file(cls, filepath: Path, source_name: str = "Unknown") -> "YAMLImporter":
         if not filepath.exists():
             return cls({}, [FileNotFoundNeatError(filepath)])
         elif not filepath.is_file():
             return cls({}, [FileNotAFileError(filepath)])
         elif filepath.suffix not in [".yaml", ".yml"]:
             return cls({}, [FileTypeUnexpectedError(filepath, frozenset([".yaml", ".yml"]))])
-        return cls(yaml.safe_load(filepath.read_text()), filepaths=[filepath])
+        return cls(yaml.safe_load(filepath.read_text()), filepaths=[filepath], source_name=source_name)
 
     def to_rules(self) -> ReadRules[T_InputRules]:
         if self._read_issues.has_errors or not self.raw_data:
-            return ReadRules(None, self._read_issues, {})
+            self._read_issues.trigger_warnings()
+            raise MultiValueError(self._read_issues.errors)
+
         issue_list = IssueList(title="YAML Importer", issues=self._read_issues)
 
         if not self._filepaths:
@@ -69,13 +77,15 @@ class YAMLImporter(BaseImporter[T_InputRules]):
 
         if "metadata" not in self.raw_data:
             self._read_issues.append(FileMissingRequiredFieldError(metadata_file, "section", "metadata"))
-            return ReadRules(None, self._read_issues, {})
+            issue_list.trigger_warnings()
+            raise MultiValueError(self._read_issues.errors)
 
         metadata = self.raw_data["metadata"]
 
         if "role" not in metadata:
             self._read_issues.append(FileMissingRequiredFieldError(metadata, "metadata", "role"))
-            return ReadRules(None, self._read_issues, {})
+            issue_list.trigger_warnings()
+            raise MultiValueError(self._read_issues.errors)
 
         role_input = RoleTypes(metadata["role"])
         role_enum = RoleTypes(role_input)
@@ -83,4 +93,8 @@ class YAMLImporter(BaseImporter[T_InputRules]):
 
         rules = cast(T_InputRules, rules_cls.load(self.raw_data))
 
-        return ReadRules(rules, issue_list, {})
+        issue_list.trigger_warnings()
+        if self._read_issues.has_errors:
+            raise MultiValueError(self._read_issues.errors)
+
+        return ReadRules[T_InputRules](rules, {})

cognite/neat/_rules/models/_base_input.py

@@ -110,7 +110,7 @@ class InputRules(Generic[T_BaseRules], ABC):
     def _dataclass_fields(self) -> list[Field]:
         return list(fields(self))
 
-    def as_rules(self) -> T_BaseRules:
+    def as_verified_rules(self) -> T_BaseRules:
         cls_ = self._get_verified_cls()
         return cls_.model_validate(self.dump())
 

cognite/neat/_rules/models/_base_rules.py

@@ -50,6 +50,7 @@ from cognite.neat._rules.models._types import (
 )
 from cognite.neat._rules.models.data_types import DataType
 from cognite.neat._rules.models.entities import EdgeEntity, ReverseConnectionEntity, ViewEntity
+from cognite.neat._utils.rdf_ import uri_display_name
 
 if sys.version_info >= (3, 11):
     from enum import StrEnum
@@ -285,6 +286,10 @@ class BaseRules(SchemaModel, ABC):
             ]
         return headers_by_sheet
 
+    @property
+    def display_name(self):
+        return uri_display_name(self.metadata.identifier)
+
     def dump(
         self,
         entities_exclude_defaults: bool = True,

cognite/neat/_rules/models/dms/_rules.py

@@ -447,6 +447,10 @@ class DMSRules(BaseRules):
 
         return _DMSExporter(self, instance_space, remove_cdf_spaces=remove_cdf_spaces).to_schema()
 
+    @classmethod
+    def display_type_name(cls) -> str:
+        return "VerifiedDMSModel"
+
     def _repr_html_(self) -> str:
         summary = {
             "aspect": self.metadata.aspect,

cognite/neat/_rules/models/dms/_rules_input.py

@@ -21,6 +21,7 @@ from cognite.neat._rules.models.entities import (
     load_connection,
     load_dms_value_type,
 )
+from cognite.neat._utils.rdf_ import uri_display_name
 
 from ._rules import _DEFAULT_VERSION, DMSContainer, DMSEnum, DMSMetadata, DMSNode, DMSProperty, DMSRules, DMSView
 
@@ -289,6 +290,14 @@ class DMSInputRules(InputRules[DMSRules]):
             "Nodes": [node_type.dump(default_space) for node_type in self.nodes or []] or None,
         }
 
+    @classmethod
+    def display_type_name(cls) -> str:
+        return "UnverifiedDMSModel"
+
+    @property
+    def display_name(self):
+        return uri_display_name(self.metadata.identifier)
+
     def _repr_html_(self) -> str:
         summary = {
             "type": "Physical Data Model",

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

@@ -194,6 +194,8 @@ class DMSValidation:
     ) -> dict[ViewId, set[ViewId]]:
         @lru_cache
         def get_parents(child_view_id: ViewId) -> set[ViewId]:
+            if child_view_id not in all_views_by_id:
+                return set()
             child_view = all_views_by_id[child_view_id]
             parents = set(child_view.implements or [])
             for parent_id in child_view.implements or []:

cognite/neat/_rules/models/entities/_single_value.py

@@ -201,16 +201,36 @@ class Entity(BaseModel, extra="ignore"):
             for field_name, field in self.model_fields.items()
             if (v := getattr(self, field_name)) is not None and field_name not in {"prefix", "suffix"}
         }
+        # We only remove the default values if all the fields are default
+        # For example, if we dump `cdf_cdm:CogniteAsset(version=v1)` and the default is `version=v1`,
+        # we should not remove it unless the space is `cdf_cdm`
+        to_delete: list[str] = []
+        is_removing_defaults = True
         if isinstance(defaults, dict):
             for key, value in defaults.items():
-                if key in model_dump and model_dump[key] == value:
-                    del model_dump[key]
-        # Sorting to ensure deterministic order
-        args = ",".join(f"{k}={v}" for k, v in sorted(model_dump.items(), key=lambda x: x[0]))
-        if self.prefix == Undefined or (isinstance(defaults, dict) and self.prefix == defaults.get("prefix")):
+                if key not in model_dump:
+                    continue
+                if model_dump[key] == value:
+                    to_delete.append(key)
+                elif isinstance(self, EdgeEntity):
+                    # Exception is edge entity, then, we remove all the defaults we can.
+                    continue
+                else:
+                    # Not all fields are default. We should not remove any of them.
+                    is_removing_defaults = False
+                    break
+        if isinstance(defaults, dict) and self.prefix == defaults.get("prefix") and is_removing_defaults:
+            base_id = str(self.suffix)
+        elif self.prefix == Undefined:
             base_id = str(self.suffix)
         else:
+            is_removing_defaults = False
             base_id = f"{self.prefix}:{self.suffix!s}"
+        if is_removing_defaults:
+            for key in to_delete:
+                del model_dump[key]
+        # Sorting to ensure deterministic order
+        args = ",".join(f"{k}={v}" for k, v in sorted(model_dump.items(), key=lambda x: x[0]))
         if args:
             return f"{base_id}({args})"
         else:

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

@@ -272,6 +272,10 @@ class InformationRules(BaseRules):
 
         return _InformationRulesConverter(self).as_dms_rules()
 
+    @classmethod
+    def display_type_name(cls) -> str:
+        return "VerifiedInformationModel"
+
     def _repr_html_(self) -> str:
         summary = {
             "type": "Logical Data Model",

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

@@ -14,6 +14,7 @@ from cognite.neat._rules.models.entities import (
     UnknownEntity,
     load_value_type,
 )
+from cognite.neat._utils.rdf_ import uri_display_name
 
 from ._rules import (
     InformationClass,
@@ -150,6 +151,14 @@ class InformationInputRules(InputRules[InformationRules]):
             Prefixes=self.prefixes,
         )
 
+    @classmethod
+    def display_type_name(cls) -> str:
+        return "UnverifiedInformationModel"
+
+    @property
+    def display_name(self):
+        return uri_display_name(self.metadata.identifier)
+
     def _repr_html_(self) -> str:
         summary = {
             "type": "Logical Data Model",

cognite/neat/_rules/models/mapping/_classic2core.py

@@ -32,9 +32,6 @@ def load_classic_to_core_mapping(org_name: str, source_space: str, source_versio
     if not isinstance(read.rules, DMSInputRules):
         raise NeatValueError(f"Expected DMS rules, but got {type(read.rules).__name__}")
 
-    verified = VerifyDMSRules(errors="raise", validate=False).transform(read)
+    verified = VerifyDMSRules(validate=False).transform(read)
 
-    if verified.rules is None:
-        raise NeatValueError("Failed to verify the rules.")
-
-    return verified.rules
+    return verified

cognite/neat/_rules/transformers/__init__.py

@@ -1,7 +1,9 @@
-from ._base import RulesPipeline, RulesTransformer
+from ._base import RulesTransformer
 from ._converters import (
+    AddClassImplements,
     ConvertToRules,
     DMSToInformation,
+    IncludeReferenced,
     InformationToDMS,
     PrefixEntities,
     ReduceCogniteModel,
@@ -10,20 +12,19 @@ from ._converters import (
     ToExtension,
 )
 from ._mapping import AsParentPropertyId, MapOneToOne, RuleMapper
-from ._pipelines import ImporterPipeline
 from ._verification import VerifyAnyRules, VerifyDMSRules, VerifyInformationRules
 
 __all__ = [
+    "AddClassImplements",
     "AsParentPropertyId",
     "ConvertToRules",
     "DMSToInformation",
-    "ImporterPipeline",
+    "IncludeReferenced",
     "InformationToDMS",
     "MapOneToOne",
     "PrefixEntities",
     "ReduceCogniteModel",
     "RuleMapper",
-    "RulesPipeline",
     "RulesTransformer",
     "SetIDDMSModel",
     "ToCompliantEntities",

cognite/neat/_rules/transformers/_base.py

@@ -1,18 +1,12 @@
+import inspect
 from abc import ABC, abstractmethod
-from collections.abc import MutableSequence
-from typing import Generic, TypeVar
+from functools import lru_cache
+from types import UnionType
+from typing import Generic, TypeVar, Union, get_args, get_origin
 
 from cognite.neat._constants import DEFAULT_NAMESPACE
-from cognite.neat._issues import IssueList, NeatError
-from cognite.neat._issues.errors import NeatTypeError, NeatValueError
-from cognite.neat._rules._shared import (
-    InputRules,
-    JustRules,
-    MaybeRules,
-    OutRules,
-    Rules,
-    VerifiedRules,
-)
+from cognite.neat._rules._shared import ReadRules, Rules
+from cognite.neat._rules.models import DMSInputRules, InformationInputRules
 from cognite.neat._store._provenance import Agent as ProvenanceAgent
 
 T_RulesIn = TypeVar("T_RulesIn", bound=Rules)
@@ -20,69 +14,51 @@ T_RulesOut = TypeVar("T_RulesOut", bound=Rules)
 
 
 class RulesTransformer(ABC, Generic[T_RulesIn, T_RulesOut]):
-    """This is the base class for all rule transformers.
-
-    Note transformers follow the functional pattern Monad
-    https://en.wikipedia.org/wiki/Monad_(functional_programming)
-    """
+    """This is the base class for all rule transformers."""
 
     @abstractmethod
-    def transform(self, rules: T_RulesIn | OutRules[T_RulesIn]) -> OutRules[T_RulesOut]:
+    def transform(self, rules: T_RulesIn) -> T_RulesOut:
         """Transform the input rules into the output rules."""
         raise NotImplementedError()
 
-    def try_transform(self, rules: MaybeRules[T_RulesIn]) -> MaybeRules[T_RulesOut]:
-        """Try to transform the input rules into the output rules."""
-        try:
-            result = self.transform(rules)
-        except NeatError:
-            # Any error caught during transformation will be returned as issues
-            return MaybeRules(None, rules.issues)
-        issues = IssueList(rules.issues, title=rules.issues.title)
-        if isinstance(result, MaybeRules):
-            issues.extend(result.issues)
-        return MaybeRules(result.get_rules(), issues)
-
-    @classmethod
-    def _to_rules(cls, rules: T_RulesIn | OutRules[T_RulesIn]) -> T_RulesIn:
-        if isinstance(rules, JustRules):
-            return rules.rules
-        elif isinstance(rules, MaybeRules):
-            if rules.rules is None:
-                raise NeatValueError("Rules is missing cannot convert")
-            return rules.rules
-        elif isinstance(rules, VerifiedRules | InputRules):
-            return rules  # type: ignore[return-value]
-        else:
-            raise NeatTypeError(f"Unsupported type: {type(rules)}")
-
     @property
     def agent(self) -> ProvenanceAgent:
         """Provenance agent for the importer."""
         return ProvenanceAgent(id_=DEFAULT_NAMESPACE[f"agent/{type(self).__name__}"])
 
+    @property
+    def description(self) -> str:
+        """Get the description of the transformer."""
+        return "MISSING DESCRIPTION"
 
-class RulesPipeline(list, MutableSequence[RulesTransformer], Generic[T_RulesIn, T_RulesOut]):
-    def transform(self, rules: T_RulesIn | OutRules[T_RulesIn]) -> OutRules[T_RulesOut]:
-        """Transform the input rules into the output rules."""
-        for transformer in self:
-            rules = transformer.transform(rules)
-        return rules  # type: ignore[return-value]
+    def is_valid_input(self, rules: T_RulesIn) -> bool:
+        """Check if the input rules are valid."""
+        types = self.transform_type_hint()
+        for type_ in types:
+            if get_origin(type_) is ReadRules:
+                inner = get_args(type_)[0]
+                if isinstance(rules, ReadRules) and isinstance(rules.rules, inner):
+                    return True
+            elif isinstance(rules, type_):
+                return True
+        return False
+
+    @classmethod
+    @lru_cache(maxsize=1)
+    def transform_type_hint(cls) -> tuple[type, ...]:
+        # This is an expensive operation, so we cache the result
+        signature = inspect.signature(cls.transform)
+        annotation = signature.parameters["rules"].annotation
+        if isinstance(annotation, TypeVar):
+            if annotation.__bound__ is None:
+                raise TypeError(f"TypeVar {annotation} must be bound to a type.")
+            annotation = annotation.__bound__
+        # The annotation can be a type or a generic
+        if get_origin(annotation) in [UnionType, Union]:
+            return get_args(annotation)
 
-    def try_transform(self, rules: MaybeRules[T_RulesIn]) -> MaybeRules[T_RulesOut]:
-        """Try to transform the input rules into the output rules."""
-        for transformer in self:
-            rules = transformer.try_transform(rules)
-        return rules  # type: ignore[return-value]
+        if get_origin(annotation) is ReadRules and isinstance(get_args(annotation)[0], TypeVar):
+            # Hardcoded for now, as we only have two types of ReadRules
+            return ReadRules[DMSInputRules], ReadRules[InformationInputRules]
 
-    def run(self, rules: T_RulesIn | OutRules[T_RulesIn]) -> T_RulesOut:
-        """Run the pipeline from the input rules to the output rules."""
-        output = self.transform(rules)
-        if isinstance(output, MaybeRules):
-            if output.rules is None:
-                raise NeatValueError(f"Rule transformation failed: {output.issues}")
-            return output.rules
-        elif isinstance(output, JustRules):
-            return output.rules
-        else:
-            raise NeatTypeError(f"Rule transformation failed: {output}")
+        return (annotation,)