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

cognite/neat/legacy/rules/models/_base.py

@@ -1,151 +0,0 @@
-import re
-import sys
-from typing import ClassVar
-
-from cognite.client.data_classes.data_modeling import ViewId
-from pydantic import BaseModel, ConfigDict, Field
-from rdflib import Literal, URIRef
-
-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 EntityTypes(StrEnum):
-    subject = "subject"
-    predicate = "predicate"
-    object = "object"
-    class_ = "class"
-    property_ = "property"
-    object_property = "ObjectProperty"
-    data_property = "DatatypeProperty"
-    annotation_property = "AnnotationProperty"
-    data_value_type = "data_value_type"
-    object_value_type = "object_value_type"
-    view = "view"
-    container = "container"
-    undefined = "undefined"
-
-
-# ALLOWED
-ALLOWED_PATTERN = r"[^a-zA-Z0-9-_.]"
-
-# REGEX expressions
-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})\)"
-VERSION_ID_REGEX = rf"\(version=(?P<version>{VERSION_REGEX})\)"
-
-
-class Entity(BaseModel):
-    """Entity is a class or property in OWL/RDF sense."""
-
-    model_config: ClassVar[ConfigDict] = ConfigDict(use_enum_values=True)
-    prefix: str
-    suffix: str
-    type_: EntityTypes = Field(default=EntityTypes.undefined)
-    name: str | None = None
-    description: str | None = None
-    version: str | None = None
-
-    @property
-    def id(self) -> str:
-        return f"{self.prefix}:{self.suffix}"
-
-    @property
-    def versioned_id(self) -> str:
-        if self.version:
-            return f"{self.prefix}:{self.suffix}(version={self.version})"
-        else:
-            return self.id
-
-    @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.id
-
-    @classmethod
-    def from_string(cls, entity_string: str, base_prefix: str | None = None, **kwargs) -> Self:
-        if result := VERSIONED_ENTITY_REGEX_COMPILED.match(entity_string):
-            return cls(
-                prefix=result.group("prefix"),
-                suffix=result.group("suffix"),
-                name=result.group("suffix"),
-                version=result.group("version"),
-                **kwargs,
-            )
-        elif result := ENTITY_ID_REGEX_COMPILED.match(entity_string):
-            return cls(
-                prefix=result.group("prefix"), suffix=result.group("suffix"), name=result.group("suffix"), **kwargs
-            )
-        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, name=entity_string, **kwargs)
-        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, **kwargs) -> list[Self]:
-        return [
-            cls.from_string(entity_string=entity_string, base_prefix=base_prefix, **kwargs)
-            for entity_string in entity_strings
-        ]
-
-
-class ParentClass(Entity):
-    type_: EntityTypes = EntityTypes.class_
-
-    @property
-    def view_id(self) -> ViewId:
-        return ViewId(space=self.space, external_id=self.external_id, version=self.version)
-
-    @classmethod
-    def from_view_id(cls, view_id: ViewId) -> Self:
-        return cls(prefix=view_id.space, suffix=view_id.external_id, version=view_id.version)
-
-
-class ContainerEntity(Entity):
-    type_: EntityTypes = EntityTypes.container
-
-
-class ViewEntity(Entity):
-    type_: EntityTypes = EntityTypes.view
-
-
-class Triple(BaseModel):
-    model_config: ClassVar[ConfigDict] = ConfigDict(
-        populate_by_name=True, arbitrary_types_allowed=True, strict=False, extra="allow"
-    )
-
-    subject: str | URIRef | Entity
-    predicate: str | URIRef | Entity
-    object: str | URIRef | Literal | Entity | None = None
-    optional: bool = Field(
-        description="Indicates whether a triple is optional, used when building SPARQL query",
-        default=False,
-    )
-
-    @classmethod
-    def from_rdflib_triple(cls, triple: tuple[URIRef, URIRef, URIRef | Literal]) -> Self:
-        return cls(subject=triple[0], predicate=triple[1], object=triple[2])

cognite/neat/legacy/rules/models/raw_rules.py

@@ -1,316 +0,0 @@
-import logging
-import warnings
-from collections.abc import Hashable
-from typing import Any, cast, no_type_check
-from warnings import warn
-
-import pandas as pd
-from pydantic import field_validator
-from pydantic_core import ErrorDetails, ValidationError
-from rdflib import Namespace
-
-from cognite.neat.constants import get_default_prefixes
-from cognite.neat.exceptions import wrangle_warnings
-
-# rules model and model components:
-from cognite.neat.legacy.rules.models.rules import (
-    Class,
-    Metadata,
-    Property,
-    RuleModel,
-    Rules,
-)
-from cognite.neat.legacy.rules.models.tables import Tables
-
-# importers:
-from cognite.neat.rules import exceptions
-from cognite.neat.utils.auxiliary import generate_exception_report
-
-__all__ = ["RawRules"]
-
-
-class RawRules(RuleModel):
-    """
-    RawRules represent invalidated form of Rules, which is a core concept in `neat`.
-    RawRules are used as staging area for Rules, and are often used when importing rules
-    from sources other than Excel rules, e.g. from a json schema or owl ontology. Often
-    these sources are not validated, and are missing information to be able to create
-    a valid Rules object.
-
-    Args:
-        Metadata: Data model metadata
-        classes: Classes defined in the data model
-        properties: Class properties defined in the data model with accompanying transformation rules
-                    to transform data from source to target representation
-        prefixes: Prefixes used in the data model. Defaults to internal set of prefixes
-        instances: Instances defined in the data model. Defaults to None
-    """
-
-    Metadata: pd.DataFrame
-    Classes: pd.DataFrame
-    Properties: pd.DataFrame
-    Prefixes: pd.DataFrame = pd.DataFrame()
-    Instances: pd.DataFrame = pd.DataFrame()
-    importer_type: str = "RawTablesImporter"
-
-    @field_validator("Metadata")
-    def has_metadata_mandatory_rows(cls, v: pd.DataFrame):
-        given_rows = set(v.iloc[:, 0].values)
-        mandatory_rows = Metadata.mandatory_fields()
-        mandatory_rows_alias = Metadata.mandatory_fields(use_alias=True)
-
-        if not (mandatory_rows.issubset(given_rows) or mandatory_rows_alias.issubset(given_rows)):
-            missing_rows = mandatory_rows_alias.difference(given_rows)
-            raise exceptions.MetadataSheetMissingMandatoryFields(missing_rows).to_pydantic_custom_error()
-        return v
-
-    @field_validator("Classes")
-    def has_classes_mandatory_columns(cls, v):
-        given_columns = set(v.columns)
-        mandatory_columns = Class.mandatory_fields()
-        mandatory_columns_alias = Class.mandatory_fields(use_alias=True)
-
-        if not (mandatory_columns.issubset(given_columns) or mandatory_columns_alias.issubset(given_columns)):
-            missing_columns = mandatory_columns_alias.difference(given_columns)
-            raise exceptions.ClassesSheetMissingMandatoryColumns(missing_columns).to_pydantic_custom_error()
-        return v
-
-    @field_validator("Properties")
-    def has_properties_mandatory_columns(cls, v):
-        given_columns = set(v.columns)
-        mandatory_columns = Property.mandatory_fields()
-        mandatory_columns_alias = Property.mandatory_fields(use_alias=True)
-
-        if not (mandatory_columns.issubset(given_columns) or mandatory_columns_alias.issubset(given_columns)):
-            missing_columns = mandatory_columns_alias.difference(given_columns)
-            raise exceptions.PropertiesSheetMissingMandatoryColumns(missing_columns).to_pydantic_custom_error()
-        return v
-
-    @field_validator("Prefixes")
-    def has_prefixes_mandatory_columns(cls, v):
-        given_columns = set(v.columns)
-        mandatory_columns = {"Prefix", "URI"}
-
-        if not mandatory_columns.issubset(given_columns):
-            missing_columns = mandatory_columns.difference(given_columns)
-            raise exceptions.PrefixesSheetMissingMandatoryColumns(missing_columns).to_pydantic_custom_error()
-        return v
-
-    @field_validator("Instances")
-    def has_instances_mandatory_columns(cls, v):
-        given_columns = set(v.columns)
-        mandatory_columns = {"Instance", "Property", "Value"}
-
-        if not mandatory_columns.issubset(given_columns):
-            missing_columns = mandatory_columns.difference(given_columns)
-            raise exceptions.InstancesSheetMissingMandatoryColumns(missing_columns).to_pydantic_custom_error()
-        return v
-
-    @staticmethod
-    def _drop_non_string_columns(df: pd.DataFrame) -> pd.DataFrame:
-        """Drop non-string columns as this can cause issue when loading rules
-
-        Args:
-            df: data frame
-
-        Returns:
-            dataframe with removed non string columns
-        """
-        columns = [column for column in df.columns[df.columns.notna()] if isinstance(column, str)]
-
-        return df[columns]
-
-    # mypy complains "RawRules" has incompatible type "**dict[str, DataFrame]"; expected "set[str]" , which is wrong!
-    @no_type_check
-    @classmethod
-    def from_tables(cls, tables: dict[str, pd.DataFrame], importer_type: str = "RawTablesImporter") -> "RawRules":
-        """Create RawRules from raw tables.
-
-        Args:
-            tables: Tables to be converted to RawRules
-
-        Returns:
-            Instance of RawRules
-        """
-
-        expected_tables = cls.mandatory_fields()
-
-        # Validate raw tables
-        if missing_tables := (expected_tables - set(tables)):
-            raise exceptions.SourceObjectDoesNotProduceMandatorySheets(missing_tables)
-
-        tables_dict: dict[str, pd.DataFrame] = {
-            Tables.metadata: tables[Tables.metadata],
-            Tables.classes: cls._drop_non_string_columns(tables[Tables.classes]),
-            Tables.properties: cls._drop_non_string_columns(tables[Tables.properties]),
-        }
-
-        if Tables.prefixes in tables:
-            tables_dict[Tables.prefixes] = cls._drop_non_string_columns(tables[Tables.prefixes])
-        if Tables.instances in tables:
-            tables_dict[Tables.instances] = cls._drop_non_string_columns(tables[Tables.instances])
-
-        return cls(
-            **tables_dict,
-            importer_type=importer_type,
-        )
-
-    # mypy unsatisfied with overload , tried all combination and gave up
-    @no_type_check
-    def to_rules(
-        self,
-        return_report: bool = False,
-        skip_validation: bool = False,
-        validators_to_skip: set[str] | None = None,
-    ) -> tuple[Rules | None, list[ErrorDetails] | None, list | None] | Rules:
-        """Validates RawRules instances and returns Rules instance.
-
-        Args:
-            return_report: To return validation report. Defaults to False.
-            skip_validation: Bypasses Rules validation. Defaults to False.
-            validators_to_skip: List of validators to skip. Defaults to None.
-
-        Returns:
-            Instance of `Rules`, which can be validated or not validated based on
-            `skip_validation` flag, and optional list of errors and warnings if
-            `return_report` is set to True.
-
-        !!! Note
-            `skip_validation` flag should be only used for purpose when `Rules` object
-            is exported to an Excel file. Do not use this flag for any other purpose!
-        """
-
-        rules_dict = _raw_tables_to_rules_dict(self, validators_to_skip)
-        if skip_validation:
-            return _to_invalidated_rules(rules_dict)
-        else:
-            return _to_validated_rules(rules_dict, return_report)
-
-    def validate_rules(self) -> str | None:
-        _, errors, warnings_ = self.to_rules(return_report=True, skip_validation=False)
-
-        report = ""
-        if errors:
-            warnings.warn(
-                exceptions.RulesHasErrors(importer_type=self.importer_type).message,
-                category=exceptions.RulesHasErrors,
-                stacklevel=2,
-            )
-            report = generate_exception_report(cast(list[ErrorDetails], errors), "Errors")
-
-        if warnings_:
-            warnings.warn(
-                exceptions.RulesHasWarnings(importer_type=self.importer_type).message,
-                category=exceptions.RulesHasWarnings,
-                stacklevel=2,
-            )
-            report += generate_exception_report(cast(list[dict], warnings_), "Warnings")
-
-        return report if report else None
-
-
-def _to_validated_rules(
-    rules_dict: dict, return_report: bool = False
-) -> tuple[Rules | None, list[ErrorDetails] | None, list[dict] | None] | Rules:
-    validation_warnings = []
-    try:
-        with warnings.catch_warnings(record=True) as validation_warnings:
-            rules = Rules(**rules_dict)
-        return (rules, None, wrangle_warnings(validation_warnings)) if return_report else rules
-
-    except ValidationError as e:
-        validation_errors = e.errors()
-        if return_report:
-            return None, validation_errors, wrangle_warnings(validation_warnings)
-        else:
-            raise e
-
-
-def _to_invalidated_rules(rules_dict: dict) -> Rules:
-    args = {
-        "metadata": Metadata.model_construct(**rules_dict["metadata"]),
-        "classes": {
-            class_: Class.model_construct(**definition) for class_, definition in rules_dict["classes"].items()
-        },
-        "properties": {
-            property_: Property.model_construct(**definition)
-            for property_, definition in rules_dict["properties"].items()
-        },
-        "prefixes": rules_dict["prefixes"],
-    }
-
-    return cast(Rules, Rules.model_construct(**args))
-
-
-def _raw_tables_to_rules_dict(raw_tables: RawRules, validators_to_skip: set | None = None) -> dict[str, Any]:
-    """Converts raw tables to a dictionary of rules."""
-    rules_dict: dict[str, Any] = {
-        "metadata": _metadata_table2dict(raw_tables.Metadata),
-        "classes": _classes_table2dict(raw_tables.Classes),
-        "properties": _properties_table2dict(raw_tables.Properties),
-        "prefixes": (
-            get_default_prefixes() if raw_tables.Prefixes.empty else _prefixes_table2dict(raw_tables.Prefixes)
-        ),
-    }
-
-    rules_dict["instances"] = (
-        None
-        if raw_tables.Instances.empty
-        else _instances_table2dict(raw_tables.Instances, rules_dict["metadata"], rules_dict["prefixes"])
-    )
-
-    if validators_to_skip:
-        rules_dict["validators_to_skip"] = validators_to_skip
-        rules_dict["metadata"]["validators_to_skip"] = validators_to_skip
-        for class_ in rules_dict["classes"].keys():
-            rules_dict["classes"][class_]["validators_to_skip"] = validators_to_skip
-        for property_ in rules_dict["properties"].keys():
-            rules_dict["properties"][property_]["validators_to_skip"] = validators_to_skip
-
-    return rules_dict
-
-
-def _metadata_table2dict(meta_df: pd.DataFrame) -> dict[str, Any]:
-    assert len(meta_df.columns) == 2
-    col1, col2 = meta_df.columns
-    metadata_dict = dict(zip(meta_df[col1], meta_df[col2], strict=True))
-    metadata_dict["source"] = meta_df.source if "source" in dir(meta_df) else None
-    if "namespace" in metadata_dict:
-        metadata_dict["namespace"] = Namespace(metadata_dict["namespace"])
-    return metadata_dict
-
-
-def _classes_table2dict(
-    classes_df: pd.DataFrame,
-) -> dict[Any | None, dict[Hashable, Any]]:
-    return {class_.get("Class"): class_ for class_ in classes_df.to_dict(orient="records")}
-
-
-def _properties_table2dict(
-    properties_df: pd.DataFrame,
-) -> dict[str, dict[Hashable, Any]]:
-    return {f"row {i+3}": property_ for i, property_ in enumerate(properties_df.to_dict(orient="records"))}
-
-
-def _prefixes_table2dict(prefix_df: pd.DataFrame) -> dict[str, Namespace]:
-    return {row["Prefix"]: Namespace(row["URI"]) for i, row in prefix_df.iterrows()}
-
-
-def _instances_table2dict(
-    instances_df: pd.DataFrame, metadata: dict[str, Any], prefixes: dict[str, Namespace]
-) -> list[dict] | None:
-    if ("prefix" not in metadata and "namespace" not in metadata) or "namespace" not in metadata:
-        logging.warning(exceptions.MissingDataModelPrefixOrNamespace().message)
-        warn(exceptions.MissingDataModelPrefixOrNamespace().message, stacklevel=2)
-        return None
-
-    prefix = metadata["prefix"] if "prefix" in metadata else metadata["space"]
-    prefixes[prefix] = metadata["namespace"]
-
-    instances = []
-    for _, row in instances_df.iterrows():
-        row_as_dict = row.to_dict()
-        row_as_dict["namespace"] = metadata["namespace"]
-        row_as_dict["prefixes"] = prefixes
-        instances.append(row_as_dict)
-    return instances

cognite/neat/legacy/rules/models/rdfpath.py

@@ -1,237 +0,0 @@
-""" """
-
-import re
-import sys
-from collections import Counter
-from typing import Literal
-
-from pydantic import BaseModel, field_validator
-
-from cognite.neat.legacy.rules import exceptions
-
-from ._base import (
-    CLASS_ID_REGEX,
-    CLASS_ID_REGEX_COMPILED,
-    ENTITY_ID_REGEX,
-    PROPERTY_ID_REGEX,
-    SUFFIX_REGEX,
-    Entity,
-    EntityTypes,
-)
-
-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
-
-
-# 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"}
-
-
-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_), type_="class"),
-                property=Entity.from_string(result.group(EntityTypes.property_), type_="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)
-
-
-class Traversal(BaseModel):
-    class_: Entity
-
-
-class SingleProperty(Traversal):
-    property: Entity
-
-    @classmethod
-    def from_string(cls, class_: str, property_: str) -> Self:
-        return cls(
-            class_=Entity.from_string(class_, type_="class"), property=Entity.from_string(property_, type_="property")
-        )
-
-
-class AllReferences(Traversal):
-    @classmethod
-    def from_string(cls, class_: str) -> Self:
-        return cls(class_=Entity.from_string(class_, type_="class"))
-
-
-class AllProperties(Traversal):
-    @classmethod
-    def from_string(cls, class_: str) -> Self:
-        return cls(class_=Entity.from_string(class_, type_="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
-            ),
-        )
-
-
-class TableLookup(BaseModel):
-    name: str
-    key: str
-    value: str
-
-
-class Rule(BaseModel):
-    pass
-
-
-class Query(BaseModel):
-    query: str
-
-
-class RDFPath(Rule):
-    traversal: Traversal | Query
-
-
-class RawLookup(RDFPath):
-    table: TableLookup
-
-
-class SPARQLQuery(RDFPath):
-    traversal: Query
-
-
-def parse_traversal(raw: str) -> AllReferences | AllProperties | SingleProperty | Hop:
-    if result := CLASS_ID_REGEX_COMPILED.match(raw):
-        return AllReferences.from_string(class_=result.group(EntityTypes.class_))
-    elif result := ALL_PROPERTIES_REGEX_COMPILED.match(raw):
-        return AllProperties.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 exceptions.NotValidRDFPath(raw).to_pydantic_custom_error()
-
-
-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 exceptions.NotValidTableLookUp(raw).to_pydantic_custom_error()
-
-
-def parse_rule(rule_raw: str, rule_type: TransformationRuleType | None) -> RDFPath:
-    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 exceptions.NotValidRAWLookUp(rule_raw).to_pydantic_custom_error()
-            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