cognite-neat 0.109.4__py3-none-any.whl → 0.110.0__py3-none-any.whl

cognite/neat/_rules/analysis/_dms.py

@@ -1,57 +0,0 @@
-from collections import defaultdict
-
-from rdflib import URIRef
-
-from cognite.neat._constants import DMS_LISTABLE_PROPERTY_LIMIT
-from cognite.neat._rules.models.dms import DMSProperty, DMSRules, DMSView
-from cognite.neat._rules.models.entities import ViewEntity
-
-from ._base import BaseAnalysis
-
-
-class DMSAnalysis(BaseAnalysis[DMSRules, DMSView, DMSProperty, ViewEntity, str]):
-    """Assumes analysis over only the complete schema"""
-
-    def _get_classes(self) -> list[DMSView]:
-        return list(self.rules.views)
-
-    def _get_properties(self) -> list[DMSProperty]:
-        return list(self.rules.properties)
-
-    def _get_cls_entity(self, class_: DMSView | DMSProperty) -> ViewEntity:
-        return class_.view
-
-    def _get_cls_parents(self, class_: DMSView) -> list[ViewEntity] | None:
-        return list(class_.implements) if class_.implements else None
-
-    @classmethod
-    def _set_cls_entity(cls, property_: DMSProperty, class_: ViewEntity) -> None:
-        property_.view = class_
-
-    def _get_object(self, property_: DMSProperty) -> ViewEntity | None:
-        return property_.value_type if isinstance(property_.value_type, ViewEntity) else None
-
-    def _get_max_occurrence(self, property_: DMSProperty) -> int | float | None:
-        return DMS_LISTABLE_PROPERTY_LIMIT if property_.is_list else 1
-
-    def subset_rules(self, desired_classes: set[ViewEntity]) -> DMSRules:
-        raise NotImplementedError()
-
-    def _get_prop_entity(self, property_: DMSProperty) -> str:
-        return property_.view_property
-
-    def views_with_properties_linked_to_classes(
-        self,
-        consider_inheritance: bool = False,
-        allow_different_namespace: bool = False,
-    ) -> dict[ViewEntity, dict[str, URIRef]]:
-        view_property_pairs = self.classes_with_properties(consider_inheritance, allow_different_namespace)
-
-        view_and_properties_with_links: dict[ViewEntity, dict[str, URIRef]] = defaultdict(dict)
-
-        for view, properties in view_property_pairs.items():
-            view_and_properties_with_links[view] = {
-                prop.view_property: prop.logical for prop in properties if prop.logical
-            }
-
-        return view_and_properties_with_links

cognite/neat/_rules/analysis/_information.py

@@ -1,249 +0,0 @@
-import warnings
-from typing import Any, cast
-
-from pydantic import ValidationError
-from rdflib import URIRef
-
-from cognite.neat._rules._constants import EntityTypes
-from cognite.neat._rules.models import SchemaCompleteness
-from cognite.neat._rules.models._rdfpath import (
-    Hop,
-    RDFPath,
-    SelfReferenceProperty,
-    SingleProperty,
-)
-from cognite.neat._rules.models.entities import ClassEntity
-from cognite.neat._rules.models.entities._multi_value import MultiValueTypeInfo
-from cognite.neat._rules.models.information import (
-    InformationClass,
-    InformationProperty,
-    InformationRules,
-)
-from cognite.neat._utils.collection_ import most_occurring_element
-from cognite.neat._utils.rdf_ import get_inheritance_path
-
-from ._base import BaseAnalysis
-
-
-class InformationAnalysis(BaseAnalysis[InformationRules, InformationClass, InformationProperty, ClassEntity, str]):
-    """Assumes analysis over only the complete schema"""
-
-    def _get_object(self, property_: InformationProperty) -> ClassEntity | None:
-        return property_.value_type if isinstance(property_.value_type, ClassEntity) else None
-
-    def _get_max_occurrence(self, property_: InformationProperty) -> int | float | None:
-        return property_.max_count
-
-    def _get_cls_entity(self, class_: InformationClass | InformationProperty) -> ClassEntity:
-        return class_.class_
-
-    @classmethod
-    def _set_cls_entity(cls, property_: InformationProperty, class_: ClassEntity) -> None:
-        property_.class_ = class_
-
-    def _get_prop_entity(self, property_: InformationProperty) -> str:
-        return property_.property_
-
-    def _get_cls_parents(self, class_: InformationClass) -> list[ClassEntity] | None:
-        return list(class_.implements or []) or None
-
-    def _get_properties(self) -> list[InformationProperty]:
-        return list(self.rules.properties)
-
-    def _get_classes(self) -> list[InformationClass]:
-        return list(self.rules.classes)
-
-    def has_hop_transformations(self):
-        return any(
-            prop_.instance_source and isinstance(prop_.instance_source.traversal, Hop)
-            for prop_ in self.rules.properties
-        )
-
-    def has_self_reference_property_transformations(self):
-        return any(
-            prop_.instance_source and isinstance(prop_.instance_source.traversal, SelfReferenceProperty)
-            for prop_ in self.rules.properties
-        )
-
-    def all_reference_transformations(self):
-        return [
-            prop_
-            for prop_ in self.rules.properties
-            if prop_.instance_source and isinstance(prop_.instance_source.traversal, SelfReferenceProperty)
-        ]
-
-    def define_property_renaming_config(self, class_: ClassEntity) -> dict[str | URIRef, str]:
-        property_renaming_configuration: dict[str | URIRef, str] = {}
-
-        if definitions := self.class_property_pairs(only_rdfpath=True, consider_inheritance=True).get(class_, None):
-            for property_id, definition in definitions.items():
-                transformation = cast(RDFPath, definition.instance_source)
-
-                # use case we have a single property rdf path, and defined prefix
-                # in either metadata or prefixes of rules
-                if isinstance(
-                    transformation.traversal,
-                    SingleProperty,
-                ) and (
-                    transformation.traversal.property.prefix in self.rules.prefixes
-                    or transformation.traversal.property.prefix == self.rules.metadata.prefix
-                ):
-                    namespace = (
-                        self.rules.metadata.namespace
-                        if transformation.traversal.property.prefix == self.rules.metadata.prefix
-                        else self.rules.prefixes[transformation.traversal.property.prefix]
-                    )
-
-                    property_renaming_configuration[namespace[transformation.traversal.property.suffix]] = property_id
-
-                # otherwise we default to the property id
-                else:
-                    property_renaming_configuration[property_id] = property_id
-
-        return property_renaming_configuration
-
-    def neat_id_to_instance_source_property_uri(self, property_neat_id: URIRef) -> URIRef | None:
-        if (
-            (property_ := self.properties_by_neat_id.get(property_neat_id))
-            and property_.instance_source
-            and isinstance(
-                property_.instance_source.traversal,
-                SingleProperty,
-            )
-            and (
-                property_.instance_source.traversal.property.prefix in self.rules.prefixes
-                or property_.instance_source.traversal.property.prefix == self.rules.metadata.prefix
-            )
-        ):
-            namespace = (
-                self.rules.metadata.namespace
-                if property_.instance_source.traversal.property.prefix == self.rules.metadata.prefix
-                else self.rules.prefixes[property_.instance_source.traversal.property.prefix]
-            )
-
-            return namespace[property_.instance_source.traversal.property.suffix]
-        return None
-
-    def property_types(self, class_: ClassEntity) -> dict[str, EntityTypes]:
-        property_types = {}
-        if definitions := self.class_property_pairs(consider_inheritance=True).get(class_, None):
-            for property_id, definition in definitions.items():
-                property_types[property_id] = definition.type_
-
-        return property_types
-
-    def most_occurring_class_in_transformations(self, class_: ClassEntity) -> ClassEntity | None:
-        classes = []
-        if class_property_pairs := self.class_property_pairs(consider_inheritance=True, only_rdfpath=True).get(
-            class_, None
-        ):
-            for property_ in class_property_pairs.values():
-                classes.append(cast(RDFPath, property_.instance_source).traversal.class_)
-
-            return cast(ClassEntity, most_occurring_element(classes))
-        else:
-            return None
-
-    def subset_rules(self, desired_classes: set[ClassEntity]) -> InformationRules:
-        """
-        Subset rules to only include desired classes and their properties.
-
-        Args:
-            desired_classes: Desired classes to include in the reduced data model
-
-        Returns:
-            Instance of InformationRules
-
-        !!! note "Inheritance"
-            If desired classes contain a class that is a subclass of another class(es), the parent class(es)
-            will be included in the reduced data model as well even though the parent class(es) are
-            not in the desired classes set. This is to ensure that the reduced data model is
-            consistent and complete.
-
-        !!! note "Partial Reduction"
-            This method does not perform checks if classes that are value types of desired classes
-            properties are part of desired classes. If a class is not part of desired classes, but it
-            is a value type of a property of a class that is part of desired classes, derived reduced
-            rules will be marked as partial.
-
-        !!! note "Validation"
-            This method will attempt to validate the reduced rules with custom validations.
-            If it fails, it will return a partial rules with a warning message, validated
-            only with base Pydantic validators.
-        """
-        class_as_dict = self.as_class_dict()
-        class_parents_pairs = self.class_parent_pairs()
-        defined_classes = self.defined_classes(consider_inheritance=True)
-
-        possible_classes = defined_classes.intersection(desired_classes)
-        impossible_classes = desired_classes - possible_classes
-
-        # need to add all the parent classes of the desired classes to the possible classes
-        parents: set[ClassEntity] = set()
-        for class_ in possible_classes:
-            parents = parents.union({parent for parent in get_inheritance_path(class_, class_parents_pairs)})
-        possible_classes = possible_classes.union(parents)
-
-        if not possible_classes:
-            raise ValueError("None of the desired classes are defined in the data model!")
-
-        if impossible_classes:
-            warnings.warn(
-                f"Could not find the following classes defined in the data model: {impossible_classes}",
-                stacklevel=2,
-            )
-
-        reduced_data_model: dict[str, Any] = {
-            "metadata": self.rules.metadata.model_copy(),
-            "prefixes": (self.rules.prefixes or {}).copy(),
-            "classes": [],
-            "properties": [],
-        }
-
-        for class_ in possible_classes:
-            reduced_data_model["classes"].append(class_as_dict[str(class_.suffix)])
-
-        class_property_pairs = self.classes_with_properties(consider_inheritance=False)
-
-        for class_, properties in class_property_pairs.items():
-            if class_ in possible_classes:
-                reduced_data_model["properties"].extend(properties)
-
-        try:
-            return type(self.rules)(**reduced_data_model)
-        except ValidationError as e:
-            warnings.warn(f"Reduced data model is not complete: {e}", stacklevel=2)
-            reduced_data_model["metadata"].schema_ = SchemaCompleteness.partial
-            return type(self.rules).model_construct(**reduced_data_model)
-
-    def class_uri(self, class_: ClassEntity) -> URIRef | None:
-        """Get URI for a class entity based on the rules.
-
-        Args:
-            class_: instance of ClassEntity
-
-        Returns:
-            URIRef of the class entity or None if not found
-        """
-
-        # we need to handle optional renamings and we do this
-        # by checking if the most occurring class in transformations alternatively
-        # in cases when we are not specifying transformations we default to the class entity
-        if not (most_frequent_class := self.most_occurring_class_in_transformations(class_)):
-            most_frequent_class = class_
-
-        # case 1 class prefix in rules.prefixes
-        if most_frequent_class.prefix in self.rules.prefixes:
-            return self.rules.prefixes[cast(str, most_frequent_class.prefix)][most_frequent_class.suffix]
-
-        # case 2 class prefix equal to rules.metadata.prefix
-        elif most_frequent_class.prefix == self.rules.metadata.prefix:
-            return self.rules.metadata.namespace[most_frequent_class.suffix]
-
-        # case 3 when class prefix is not found in prefixes of rules
-        else:
-            return None
-
-    @property
-    def multi_value_properties(self) -> list[InformationProperty]:
-        return [prop_ for prop_ in self.rules.properties if isinstance(prop_.value_type, MultiValueTypeInfo)]

cognite/neat/_rules/models/_rdfpath.py

@@ -1,372 +0,0 @@
-""" """
-
-import re
-import sys
-import urllib.parse
-from collections import Counter
-from functools import total_ordering
-from typing import ClassVar, Literal
-
-from pydantic import BaseModel, field_validator, model_serializer
-
-from cognite.neat._issues.errors import NeatValueError
-
-if sys.version_info >= (3, 11):
-    from enum import StrEnum
-    from typing import Self
-else:
-    from backports.strenum import StrEnum
-    from typing_extensions import Self
-
-
-class TransformationRuleType(StrEnum):
-    rdfpath = "rdfpath"
-    rawlookup = "rawlookup"
-    sparql = "sparql"
-
-
-class Lookup(StrEnum):
-    table = "table"
-    key = "key"
-    value = "value"  # type: ignore
-
-
-class EntityTypes(StrEnum):
-    class_ = "class"
-    property_ = "property"
-    undefined = "undefined"
-
-
-# FOR PARSING STRINGS:
-PREFIX_REGEX = r"[a-zA-Z]+[a-zA-Z0-9-_.]*[a-zA-Z0-9]+"
-SUFFIX_REGEX = r"[a-zA-Z0-9-_.]+[a-zA-Z0-9]|[-_.]*[a-zA-Z0-9]+"
-VERSION_REGEX = r"[a-zA-Z0-9]([.a-zA-Z0-9_-]{0,41}[a-zA-Z0-9])?"
-
-ENTITY_ID_REGEX = rf"{PREFIX_REGEX}:({SUFFIX_REGEX})"
-ENTITY_ID_REGEX_COMPILED = re.compile(rf"^(?P<prefix>{PREFIX_REGEX}):(?P<suffix>{SUFFIX_REGEX})$")
-VERSIONED_ENTITY_REGEX_COMPILED = re.compile(
-    rf"^(?P<prefix>{PREFIX_REGEX}):(?P<suffix>{SUFFIX_REGEX})\(version=(?P<version>{VERSION_REGEX})\)$"
-)
-CLASS_ID_REGEX = rf"(?P<{EntityTypes.class_}>{ENTITY_ID_REGEX})"
-CLASS_ID_REGEX_COMPILED = re.compile(rf"^{CLASS_ID_REGEX}$")
-PROPERTY_ID_REGEX = rf"\((?P<{EntityTypes.property_}>{ENTITY_ID_REGEX})\)"
-
-# traversal direction
-DIRECTION_REGEX = r"(?P<direction>(->|<-))"
-
-# steps
-STEP_REGEX = rf"((->|<-){CLASS_ID_REGEX}({PROPERTY_ID_REGEX})?)"
-STEP_REGEX_COMPILED = re.compile(STEP_REGEX)
-STEP_CLASS_REGEX_COMPILED = re.compile(rf"(^{DIRECTION_REGEX}{CLASS_ID_REGEX})$")
-STEP_CLASS_AND_PROPERTY_REGEX_COMPILED = re.compile(rf"(^{DIRECTION_REGEX}{CLASS_ID_REGEX}{PROPERTY_ID_REGEX}$)")
-
-
-_traversal = "traversal"
-ORIGIN_REGEX = rf"(?P<origin>{ENTITY_ID_REGEX})"
-
-HOP_REGEX_COMPILED = re.compile(rf"^{ORIGIN_REGEX}(?P<{_traversal}>{STEP_REGEX}+)$")
-
-# grabbing specific property for a class, property can be either object, annotation or data property
-SINGLE_PROPERTY_REGEX_COMPILED = re.compile(rf"^{CLASS_ID_REGEX}{PROPERTY_ID_REGEX}$")
-
-# grabbing all properties for a class
-ALL_PROPERTIES_REGEX_COMPILED = re.compile(rf"^{CLASS_ID_REGEX}\(\*\)$")
-
-ALL_TRAVERSAL_REGEX_COMPILED = (
-    rf"({CLASS_ID_REGEX}\(\*\)|{CLASS_ID_REGEX}{PROPERTY_ID_REGEX}|{ORIGIN_REGEX}(?P<{_traversal}>{STEP_REGEX}+))"
-)
-
-TABLE_REGEX_COMPILED = re.compile(
-    rf"^(?P<{Lookup.table}>{SUFFIX_REGEX})\((?P<{Lookup.key}>{SUFFIX_REGEX}),\s*(?P<{Lookup.value}>{SUFFIX_REGEX})\)$"
-)
-
-
-StepDirection = Literal["source", "target", "origin"]
-_direction_by_symbol: dict[str, StepDirection] = {"->": "target", "<-": "source"}
-_symbol_by_direction: dict[StepDirection, str] = {"source": "<-", "target": "->"}
-
-Undefined = type(object())
-Unknown = type(object())
-
-
-# mypy does not like the sentinel value, and it is not possible to ignore only the line with it below.
-# so we ignore all errors beyond this point.
-# mypy: ignore-errors
-@total_ordering
-class Entity(BaseModel, arbitrary_types_allowed=True):
-    """Entity is a class or property in OWL/RDF sense."""
-
-    type_: ClassVar[EntityTypes] = EntityTypes.undefined
-    prefix: str | Undefined = Undefined
-    suffix: str | Unknown
-    version: str | None = None
-    name: str | None = None
-    description: str | None = None
-
-    def __lt__(self, other: object) -> bool:
-        if type(self) is not type(other) or not isinstance(other, Entity):
-            return NotImplemented
-        return self.versioned_id < other.versioned_id
-
-    def __eq__(self, other: object) -> bool:
-        if type(self) is not type(other) or not isinstance(other, Entity):
-            return NotImplemented
-        return self.versioned_id == other.versioned_id
-
-    def __hash__(self) -> int:
-        return hash(self.versioned_id)
-
-    def as_non_versioned_entity(self) -> Self:
-        return self.from_string(f"{self.prefix}:{self.suffix}")
-
-    @property
-    def id(self) -> str:
-        if self.suffix is Unknown:
-            return "#N/A"
-        elif self.prefix is Undefined:
-            return self.suffix
-        else:
-            return f"{self.prefix}:{self.suffix}"
-
-    @property
-    def versioned_id(self) -> str:
-        if self.version is None:
-            return self.id
-        else:
-            return f"{self.id}(version={self.version})"
-
-    @property
-    def space(self) -> str:
-        """Returns entity space in CDF."""
-        return self.prefix
-
-    @property
-    def external_id(self) -> str:
-        """Returns entity external id in CDF."""
-        return self.suffix
-
-    def __repr__(self):
-        return self.versioned_id
-
-    def __str__(self):
-        return self.versioned_id
-
-    @classmethod
-    def from_string(cls, entity_string: str, base_prefix: str | None = None) -> Self:
-        if entity_string == "#N/A":
-            return cls(prefix=Undefined, suffix=Unknown)
-        elif result := VERSIONED_ENTITY_REGEX_COMPILED.match(entity_string):
-            return cls(
-                prefix=result.group("prefix"),
-                suffix=result.group("suffix"),
-                version=result.group("version"),
-            )
-        elif result := ENTITY_ID_REGEX_COMPILED.match(entity_string):
-            return cls(prefix=result.group("prefix"), suffix=result.group("suffix"))
-        elif base_prefix and re.match(SUFFIX_REGEX, entity_string) and re.match(PREFIX_REGEX, base_prefix):
-            return cls(prefix=base_prefix, suffix=entity_string)
-        else:
-            raise ValueError(f"{cls.__name__} is expected to be prefix:suffix, got {entity_string}")
-
-    @classmethod
-    def from_list(cls, entity_strings: list[str], base_prefix: str | None = None) -> list[Self]:
-        return [
-            cls.from_string(entity_string=entity_string, base_prefix=base_prefix) for entity_string in entity_strings
-        ]
-
-
-class Step(BaseModel):
-    class_: Entity
-    property: Entity | None = None  # only terminal step has property
-    direction: StepDirection
-
-    @classmethod
-    def from_string(cls, raw: str, **kwargs) -> Self:
-        if result := STEP_CLASS_AND_PROPERTY_REGEX_COMPILED.match(raw):
-            return cls(
-                class_=Entity.from_string(result.group(EntityTypes.class_)),
-                property=Entity.from_string(result.group(EntityTypes.property_)),
-                direction=_direction_by_symbol[result.group("direction")],
-                **kwargs,
-            )
-        elif result := STEP_CLASS_REGEX_COMPILED.match(raw):
-            return cls(
-                class_=Entity.from_string(result.group(EntityTypes.class_)),
-                direction=_direction_by_symbol[result.group("direction")],
-            )  # type: ignore
-        msg = f"Invalid step {raw}, expected in one of the following forms:"
-        msg += " ->prefix:suffix, <-prefix:suffix, ->prefix:suffix(prefix:suffix) or <-prefix:suffix(prefix:suffix)"
-        raise ValueError(msg)
-
-    def __str__(self) -> str:
-        if self.property:
-            return f"{self.class_}({self.property})"
-        else:
-            return f"{_symbol_by_direction[self.direction]}{self.class_}"
-
-    def __repr__(self) -> str:
-        return self.__str__()
-
-
-class Traversal(BaseModel):
-    class_: Entity
-
-    def __str__(self) -> str:
-        return f"{self.class_}"
-
-    def __repr__(self) -> str:
-        return self.__str__()
-
-    @model_serializer(when_used="unless-none", return_type=str)
-    def as_str(self) -> str:
-        return str(self)
-
-
-class SingleProperty(Traversal):
-    property: Entity
-
-    @classmethod
-    def from_string(cls, class_: str, property_: str) -> Self:
-        return cls(class_=Entity.from_string(class_), property=Entity.from_string(property_))
-
-    def __str__(self) -> str:
-        return f"{self.class_}({self.property})"
-
-
-class SelfReferenceProperty(Traversal):
-    @classmethod
-    def from_string(cls, class_: str) -> Self:
-        return cls(class_=Entity.from_string(class_))
-
-
-class Origin(BaseModel):
-    class_: Entity
-
-    @field_validator("class_", mode="before")
-    def process_if_string(cls, value):
-        return Entity.from_string(value) if isinstance(value, str) else value
-
-
-class Hop(Traversal):
-    """Multi or single hop traversal through graph"""
-
-    traversal: list[Step]
-
-    @classmethod
-    def from_string(cls, class_: str, traversal: str | list[Step]) -> Self:
-        return cls(
-            class_=Entity.from_string(class_),
-            traversal=(
-                [Step.from_string(result[0]) for result in STEP_REGEX_COMPILED.findall(traversal)]
-                if isinstance(traversal, str)
-                else traversal
-            ),
-        )
-
-    def __str__(self) -> str:
-        return f"{self.class_}{''.join([str(step) for step in self.traversal])}"
-
-
-class TableLookup(BaseModel):
-    name: str
-    key: str
-    value: str
-
-
-class Rule(BaseModel):
-    pass
-
-
-class Query(BaseModel):
-    query: str
-
-
-class RDFPath(Rule):
-    traversal: SingleProperty | SelfReferenceProperty | Hop
-
-    def __str__(self) -> str:
-        return f"{self.traversal}"
-
-    def __repr__(self) -> str:
-        return self.__str__()
-
-    @model_serializer(when_used="unless-none", return_type=str)
-    def as_str(self) -> str:
-        return str(self)
-
-
-class RawLookup(RDFPath):
-    table: TableLookup
-
-
-class SPARQLQuery(RDFPath):
-    traversal: Query
-
-
-def parse_traversal(raw: str) -> SelfReferenceProperty | SingleProperty | Hop:
-    if result := CLASS_ID_REGEX_COMPILED.match(raw):
-        return SelfReferenceProperty.from_string(class_=result.group(EntityTypes.class_))
-    elif result := SINGLE_PROPERTY_REGEX_COMPILED.match(raw):
-        return SingleProperty.from_string(
-            class_=result.group(EntityTypes.class_),
-            property_=result.group(EntityTypes.property_),
-        )
-    elif result := HOP_REGEX_COMPILED.match(raw):
-        return Hop.from_string(class_=result.group("origin"), traversal=result.group(_traversal))
-    else:
-        raise NeatValueError(f"Invalid RDF Path: {raw!r}")
-
-
-def parse_table_lookup(raw: str) -> TableLookup:
-    if result := TABLE_REGEX_COMPILED.match(raw):
-        return TableLookup(
-            name=result.group(Lookup.table),
-            key=result.group(Lookup.key),
-            value=result.group(Lookup.value),
-        )
-    raise NeatValueError(f"Invalid table lookup: {raw!r}")
-
-
-def parse_rule(rule_raw: str, rule_type: TransformationRuleType | None) -> RDFPath:
-    rule_raw = urllib.parse.unquote(rule_raw)
-    match rule_type:
-        case TransformationRuleType.rdfpath:
-            rule_raw = rule_raw.replace(" ", "")
-            return RDFPath(traversal=parse_traversal(rule_raw))
-        case TransformationRuleType.rawlookup:
-            rule_raw = rule_raw.replace(" ", "")
-            if Counter(rule_raw).get("|") != 1:
-                raise NeatValueError(f"Invalid rawlookup rule: {rule_raw!r}")
-            traversal, table_lookup = rule_raw.split("|")
-            return RawLookup(
-                traversal=parse_traversal(traversal),
-                table=parse_table_lookup(table_lookup),
-            )
-        case TransformationRuleType.sparql:
-            return SPARQLQuery(traversal=Query(query=rule_raw))
-        case None:
-            raise ValueError("Rule type must be specified")
-
-
-def is_valid_rule(rule_type: TransformationRuleType, rule_raw: str) -> bool:
-    is_valid_rule = {
-        TransformationRuleType.rdfpath: is_rdfpath,
-        TransformationRuleType.rawlookup: is_rawlookup,
-    }[rule_type]
-    return is_valid_rule(rule_raw)
-
-
-def is_rdfpath(raw: str) -> bool:
-    try:
-        parse_traversal(raw)
-    except ValueError:
-        return False
-    return True
-
-
-def is_rawlookup(raw: str) -> bool:
-    try:
-        parse_rule(raw, TransformationRuleType.rawlookup)
-    except ValueError:
-        return False
-    return True