cognite-neat 0.73.4__py3-none-any.whl → 0.75.1__py3-none-any.whl

cognite/neat/{rules/exporter → legacy/rules/exporters}/_base.py

@@ -3,8 +3,8 @@ from abc import ABC, abstractmethod
 from pathlib import Path
 from typing import Generic, TypeVar
 
-from cognite.neat.rules.models.raw_rules import RawRules
-from cognite.neat.rules.models.rules import Rules
+from cognite.neat.legacy.rules.models.raw_rules import RawRules
+from cognite.neat.legacy.rules.models.rules import Rules
 
 if sys.version_info >= (3, 11):
     from typing import Self

cognite/neat/{rules/exporter → legacy/rules/exporters}/_core/rules2labels.py

@@ -1,4 +1,4 @@
-from cognite.neat.rules.models.rules import Rules
+from cognite.neat.legacy.rules.models.rules import Rules
 
 
 def get_labels(transformation_rules: Rules) -> set[str]:

cognite/neat/{rules/exporter → legacy/rules/exporters}/_rules2dms.py

@@ -10,7 +10,7 @@ from typing import ClassVar, Literal, cast, no_type_check
 
 import yaml
 
-from cognite.neat.rules.models.value_types import ValueTypeMapping
+from cognite.neat.legacy.rules.models.value_types import ValueTypeMapping
 
 if sys.version_info >= (3, 11):
     from typing import Self
@@ -41,11 +41,11 @@ from cognite.client.data_classes.data_modeling.views import (
 from cognite.client.exceptions import CogniteAPIError
 from pydantic import BaseModel, ConfigDict, field_validator
 
-from cognite.neat.rules import exceptions
-from cognite.neat.rules.exporter._base import BaseExporter
-from cognite.neat.rules.exporter._validation import are_entity_names_dms_compliant
-from cognite.neat.rules.models._base import ContainerEntity, EntityTypes, ParentClass
-from cognite.neat.rules.models.rules import Class, Property, Rules
+from cognite.neat.legacy.rules import exceptions
+from cognite.neat.legacy.rules.exporters._base import BaseExporter
+from cognite.neat.legacy.rules.exporters._validation import are_entity_names_dms_compliant
+from cognite.neat.legacy.rules.models._base import ContainerEntity, EntityTypes, ParentClass
+from cognite.neat.legacy.rules.models.rules import Class, Property, Rules
 from cognite.neat.utils.utils import generate_exception_report
 
 if sys.version_info < (3, 11):

cognite/neat/{rules/exporter → legacy/rules/exporters}/_rules2excel.py

@@ -6,7 +6,7 @@ from openpyxl.cell import Cell
 from openpyxl.styles import Alignment, Border, Font, NamedStyle, PatternFill, Side
 from openpyxl.worksheet.worksheet import Worksheet
 
-from cognite.neat.rules.models._base import EntityTypes
+from cognite.neat.legacy.rules.models._base import EntityTypes
 
 from ._base import BaseExporter
 

cognite/neat/{rules/exporter → legacy/rules/exporters}/_rules2graphql.py

@@ -9,11 +9,11 @@ if sys.version_info >= (3, 11):
 else:
     from typing_extensions import Self
 
-from cognite.neat.rules import exceptions
-from cognite.neat.rules.analysis import to_class_property_pairs
-from cognite.neat.rules.exporter._validation import are_entity_names_dms_compliant, are_properties_redefined
-from cognite.neat.rules.models.rules import Rules
-from cognite.neat.rules.models.value_types import XSD_VALUE_TYPE_MAPPINGS
+from cognite.neat.legacy.rules import exceptions
+from cognite.neat.legacy.rules.analysis import to_class_property_pairs
+from cognite.neat.legacy.rules.exporters._validation import are_entity_names_dms_compliant, are_properties_redefined
+from cognite.neat.legacy.rules.models.rules import Rules
+from cognite.neat.legacy.rules.models.value_types import XSD_VALUE_TYPE_MAPPINGS
 from cognite.neat.utils.utils import generate_exception_report
 
 from ._base import BaseExporter

cognite/neat/{rules/exporter → legacy/rules/exporters}/_rules2ontology.py

@@ -8,12 +8,12 @@ from pydantic import BaseModel, ConfigDict, ValidationInfo, field_validator
 from rdflib import DCTERMS, OWL, RDF, RDFS, XSD, BNode, Graph, Literal, Namespace, URIRef
 from rdflib.collection import Collection as GraphCollection
 
-from cognite.neat.rules import exceptions
-from cognite.neat.rules.analysis import to_class_property_pairs, to_property_dict
-from cognite.neat.rules.exporter._base import BaseExporter
-from cognite.neat.rules.exporter._validation import are_properties_redefined
-from cognite.neat.rules.models.rules import Class, Metadata, Property, Rules
-from cognite.neat.rules.models.value_types import XSD_VALUE_TYPE_MAPPINGS
+from cognite.neat.legacy.rules import exceptions
+from cognite.neat.legacy.rules.analysis import to_class_property_pairs, to_property_dict
+from cognite.neat.legacy.rules.exporters._base import BaseExporter
+from cognite.neat.legacy.rules.exporters._validation import are_properties_redefined
+from cognite.neat.legacy.rules.models.rules import Class, Metadata, Property, Rules
+from cognite.neat.legacy.rules.models.value_types import XSD_VALUE_TYPE_MAPPINGS
 from cognite.neat.utils.utils import generate_exception_report, remove_namespace
 
 if sys.version_info >= (3, 11):

cognite/neat/{rules/exporter → legacy/rules/exporters}/_rules2pydantic_models.py

@@ -13,14 +13,14 @@ from pydantic._internal._model_construction import ModelMetaclass
 from rdflib import Graph, URIRef
 from typing_extensions import TypeAliasType
 
-from cognite.neat.graph.loader.core.rdf_to_assets import NeatMetadataKeys
-from cognite.neat.graph.transformation.query_generator.sparql import build_construct_query, triples2dictionary
-from cognite.neat.rules import exceptions
-from cognite.neat.rules.analysis import define_class_asset_mapping, to_class_property_pairs
-from cognite.neat.rules.exporter._rules2dms import DMSSchemaComponents
-from cognite.neat.rules.exporter._validation import are_entity_names_dms_compliant
-from cognite.neat.rules.models.rules import Property, Rules
-from cognite.neat.rules.models.value_types import ValueTypeMapping
+from cognite.neat.legacy.graph.loaders.core.rdf_to_assets import NeatMetadataKeys
+from cognite.neat.legacy.graph.transformations.query_generator.sparql import build_construct_query, triples2dictionary
+from cognite.neat.legacy.rules import exceptions
+from cognite.neat.legacy.rules.analysis import define_class_asset_mapping, to_class_property_pairs
+from cognite.neat.legacy.rules.exporters._rules2dms import DMSSchemaComponents
+from cognite.neat.legacy.rules.exporters._validation import are_entity_names_dms_compliant
+from cognite.neat.legacy.rules.models.rules import Property, Rules
+from cognite.neat.legacy.rules.models.value_types import ValueTypeMapping
 from cognite.neat.utils.utils import generate_exception_report
 
 if sys.version_info >= (3, 11):

cognite/neat/{rules/exporter → legacy/rules/exporters}/_rules2rules.py

@@ -4,13 +4,14 @@ to TransformationRules for purpose of for example:
 - subsetting the data model to only include desired classes and their properties
 - converting classes/properties ids/names to DMS compliant format
 """
+
 import logging
 import re
 import warnings
 from typing import Any
 
-from cognite.neat.rules.analysis import get_defined_classes
-from cognite.neat.rules.models.rules import Rules
+from cognite.neat.legacy.rules.analysis import get_defined_classes
+from cognite.neat.legacy.rules.models.rules import Rules
 
 
 def subset_rules(rules: Rules, desired_classes: set, skip_validation: bool = False) -> Rules:

cognite/neat/{rules/exporter → legacy/rules/exporters}/_rules2triples.py

@@ -2,8 +2,9 @@ from pathlib import Path
 
 from rdflib.term import Node
 
-from cognite.neat.rules.exporter._base import BaseExporter
-from cognite.neat.rules.models.rules import Rules
+from cognite.neat.legacy.rules.models.rules import Rules
+
+from ._base import BaseExporter
 
 
 class TripleExporter(BaseExporter[list[tuple[Node, Node, Node]]]):

cognite/neat/{rules/exporter → legacy/rules/exporters}/_validation.py

@@ -3,8 +3,8 @@ import warnings
 from typing import Literal, overload
 
 from cognite.neat.exceptions import wrangle_warnings
-from cognite.neat.rules import exceptions
-from cognite.neat.rules.models.rules import (
+from cognite.neat.legacy.rules import exceptions
+from cognite.neat.legacy.rules.models.rules import (
     Rules,
     dms_property_id_compliance_regex,
     value_id_compliance_regex,

cognite/neat/{rules/importer → legacy/rules/importers}/_base.py

@@ -5,8 +5,8 @@ from datetime import datetime
 import pandas as pd
 from pydantic_core import ErrorDetails
 
-from cognite.neat.rules.models.raw_rules import RawRules
-from cognite.neat.rules.models.rules import Rules
+from cognite.neat.legacy.rules.models.raw_rules import RawRules
+from cognite.neat.legacy.rules.models.rules import Rules
 
 
 class BaseImporter(ABC):

cognite/neat/{rules/importer → legacy/rules/importers}/_dict2rules.py

@@ -3,7 +3,7 @@ from typing import Any, Literal
 
 import pandas as pd
 
-from cognite.neat.rules.models.tables import Tables
+from cognite.neat.legacy.rules.models.tables import Tables
 
 from ._base import BaseImporter
 

cognite/neat/{rules/importer → legacy/rules/importers}/_dms2rules.py

@@ -15,8 +15,8 @@ from cognite.client.data_classes.data_modeling import (
 )
 from cognite.client.data_classes.data_modeling.ids import DataModelIdentifier, ViewId
 
-from cognite.neat.rules.models.tables import Tables
-from cognite.neat.rules.models.value_types import DMS_VALUE_TYPE_MAPPINGS, XSD_VALUE_TYPE_MAPPINGS
+from cognite.neat.legacy.rules.models.tables import Tables
+from cognite.neat.legacy.rules.models.value_types import DMS_VALUE_TYPE_MAPPINGS, XSD_VALUE_TYPE_MAPPINGS
 
 from ._base import BaseImporter
 

cognite/neat/{rules/importer → legacy/rules/importers}/_graph2rules.py

@@ -11,12 +11,13 @@ import pandas as pd
 from rdflib import Graph, Literal, Namespace, URIRef
 
 from cognite.neat.constants import PREFIXES
-from cognite.neat.rules import exceptions
-from cognite.neat.rules.exporter._rules2rules import to_dms_name
-from cognite.neat.rules.importer._base import BaseImporter
-from cognite.neat.rules.models.tables import Tables
+from cognite.neat.legacy.rules import exceptions
+from cognite.neat.legacy.rules.exporters._rules2rules import to_dms_name
+from cognite.neat.legacy.rules.models.tables import Tables
 from cognite.neat.utils.utils import get_namespace, remove_namespace, uri_to_short_form
 
+from ._base import BaseImporter
+
 
 class GraphImporter(BaseImporter):
     """

cognite/neat/{rules/importer → legacy/rules/importers}/_owl2rules/_owl2metadata.py

@@ -4,7 +4,7 @@ import re
 import pandas as pd
 from rdflib import Graph, Namespace
 
-from cognite.neat.rules.models.rules import (
+from cognite.neat.legacy.rules.models.rules import (
     cdf_space_compliance_regex,
     data_model_id_compliance_regex,
     prefix_compliance_regex,
@@ -66,12 +66,16 @@ def parse_owl_metadata(graph: Graph, make_compliant: bool = False) -> pd.DataFra
             "updated": results[7].pop(),
             "title": results[8].pop(),
             "description": results[9].pop(),
-            "creator": ", ".join(remove_none_elements_from_set(results[10]))
-            if remove_none_elements_from_set(results[10])
-            else None,
-            "contributor": ", ".join(remove_none_elements_from_set(results[11]))
-            if remove_none_elements_from_set(results[11])
-            else None,
+            "creator": (
+                ", ".join(remove_none_elements_from_set(results[10]))
+                if remove_none_elements_from_set(results[10])
+                else None
+            ),
+            "contributor": (
+                ", ".join(remove_none_elements_from_set(results[11]))
+                if remove_none_elements_from_set(results[11])
+                else None
+            ),
             "rights": results[12].pop(),
             "license": results[13].pop(),
         }

cognite/neat/{rules/importer → legacy/rules/importers}/_owl2rules/_owl2rules.py

@@ -9,11 +9,11 @@ import pandas as pd
 from pydantic_core import ErrorDetails
 from rdflib import DC, DCTERMS, OWL, RDF, RDFS, SKOS, Graph
 
-from cognite.neat.rules.importer._base import BaseImporter
-from cognite.neat.rules.models.raw_rules import RawRules
-from cognite.neat.rules.models.rules import Rules
-from cognite.neat.rules.models.tables import Tables
-from cognite.neat.rules.models.value_types import XSD_VALUE_TYPE_MAPPINGS
+from cognite.neat.legacy.rules.importers._base import BaseImporter
+from cognite.neat.legacy.rules.models.raw_rules import RawRules
+from cognite.neat.legacy.rules.models.rules import Rules
+from cognite.neat.legacy.rules.models.tables import Tables
+from cognite.neat.legacy.rules.models.value_types import XSD_VALUE_TYPE_MAPPINGS
 
 from ._owl2classes import parse_owl_classes
 from ._owl2metadata import parse_owl_metadata

cognite/neat/{rules/importer → legacy/rules/importers}/_spreadsheet2rules.py

@@ -3,15 +3,15 @@ In more details, it traverses the graph and abstracts class and properties, basi
 generating a list of rules based on which nodes that form the graph are made.
 """
 
-
 from pathlib import Path
 
 import pandas as pd
 from openpyxl import Workbook, load_workbook
 
-from cognite.neat.rules.importer._base import BaseImporter
 from cognite.neat.utils.auxiliary import local_import
 
+from ._base import BaseImporter
+
 
 class ExcelImporter(BaseImporter):
     def __init__(self, filepath: Path):

cognite/neat/{rules/importer → legacy/rules/importers}/_xsd2rules.py

@@ -2,7 +2,7 @@ from pathlib import Path
 
 import pandas as pd
 
-from cognite.neat.rules.importer._base import BaseImporter
+from ._base import BaseImporter
 
 
 class XSDImporter(BaseImporter):

cognite/neat/{rules/importer → legacy/rules/importers}/_yaml2rules.py

@@ -3,7 +3,7 @@ from typing import Literal
 
 import yaml
 
-from cognite.neat.rules.importer._dict2rules import ArbitraryDictImporter
+from ._dict2rules import ArbitraryDictImporter
 
 
 class ArbitraryYAMLImporter(ArbitraryDictImporter):

cognite/neat/{rules → legacy/rules}/models/raw_rules.py

@@ -12,12 +12,12 @@ from rdflib import Namespace
 from cognite.neat.constants import 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
-
-# rules model and model components:
-from cognite.neat.rules.models.rules import Class, Metadata, Property, RuleModel, Rules
-from cognite.neat.rules.models.tables import Tables
 from cognite.neat.utils.utils import generate_exception_report
 
 __all__ = ["RawRules"]

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

@@ -0,0 +1,238 @@
+"""
+"""
+
+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

cognite/neat/{rules → legacy/rules}/models/rules.py

@@ -30,15 +30,15 @@ from pydantic.fields import FieldInfo
 from rdflib import XSD, Literal, Namespace, URIRef
 
 from cognite.neat.constants import PREFIXES
-from cognite.neat.rules import exceptions
-from cognite.neat.rules.models._base import (
+from cognite.neat.legacy.rules import exceptions
+from cognite.neat.legacy.rules.models._base import (
     ENTITY_ID_REGEX_COMPILED,
     VERSIONED_ENTITY_REGEX_COMPILED,
     ContainerEntity,
     EntityTypes,
     ParentClass,
 )
-from cognite.neat.rules.models.rdfpath import (
+from cognite.neat.legacy.rules.models.rdfpath import (
     AllReferences,
     Entity,
     Hop,
@@ -49,7 +49,7 @@ from cognite.neat.rules.models.rdfpath import (
     Traversal,
     parse_rule,
 )
-from cognite.neat.rules.models.value_types import XSD_VALUE_TYPE_MAPPINGS, ValueType
+from cognite.neat.legacy.rules.models.value_types import XSD_VALUE_TYPE_MAPPINGS, ValueType
 
 if sys.version_info >= (3, 11):
     from typing import Self

cognite/neat/{rules → legacy/rules}/models/value_types.py

@@ -19,7 +19,7 @@ from cognite.client.data_classes.data_modeling import (
 )
 from pydantic import BaseModel
 
-from cognite.neat.rules.models._base import Entity, EntityTypes
+from cognite.neat.legacy.rules.models._base import Entity, EntityTypes
 
 
 class ValueTypeMapping(BaseModel):

cognite/neat/rules/_shared.py

@@ -1,5 +1,5 @@
 from typing import TypeAlias
 
-from cognite.neat.rules.models._rules import DMSRules, DomainRules, InformationRules
+from cognite.neat.rules.models.rules import DMSRules, DomainRules, InformationRules
 
 Rules: TypeAlias = DomainRules | InformationRules | DMSRules

cognite/neat/rules/analysis/__init__.py

@@ -0,0 +1,3 @@
+from ._information_rules import InformationArchitectRulesAnalysis
+
+__all__ = ["InformationArchitectRulesAnalysis"]

cognite/neat/rules/{_analysis → analysis}/_base.py

@@ -3,7 +3,7 @@ from abc import ABC, abstractmethod
 from typing import Generic, TypeVar
 
 from cognite.neat.rules._shared import Rules
-from cognite.neat.rules.models._rules._types import ClassEntity
+from cognite.neat.rules.models.rules._types import ClassEntity
 
 if sys.version_info >= (3, 11):
     from enum import StrEnum

cognite/neat/rules/{_analysis → analysis}/_information_rules.py

@@ -7,10 +7,10 @@ from typing import Any, cast
 import pandas as pd
 from pydantic import ValidationError
 
-from cognite.neat.rules.models._rules._types._base import ClassEntity, EntityTypes, ParentClassEntity, ReferenceEntity
-from cognite.neat.rules.models._rules.base import SchemaCompleteness
-from cognite.neat.rules.models._rules.information_rules import InformationClass, InformationProperty, InformationRules
 from cognite.neat.rules.models.rdfpath import TransformationRuleType
+from cognite.neat.rules.models.rules._base import SchemaCompleteness
+from cognite.neat.rules.models.rules._information_rules import InformationClass, InformationProperty, InformationRules
+from cognite.neat.rules.models.rules._types._base import ClassEntity, EntityTypes, ParentClassEntity, ReferenceEntity
 from cognite.neat.utils.utils import get_inheritance_path
 
 from ._base import BaseAnalysis, DataModelingScenario

cognite/neat/rules/examples/__init__.py

@@ -6,13 +6,4 @@ from pathlib import Path
 # Currently there are simple paths to the examples which are then easily loaded in the notebooks
 
 _EXAMPLES = Path(__file__).parent
-
-power_grid_model = _EXAMPLES / "power-grid-example.xlsx"
-power_grid_containers = _EXAMPLES / "power-grid-containers.yaml"
-power_grid_data_model = _EXAMPLES / "power-grid-model.yaml"
-simple_example = _EXAMPLES / "sheet2cdf-transformation-rules.xlsx"
-source_to_solution_mapping = _EXAMPLES / "source-to-solution-mapping-rules.xlsx"
-nordic44 = _EXAMPLES / "Rules-Nordic44-to-TNT.xlsx"
-nordic44_graphql = _EXAMPLES / "Rules-Nordic44-to-graphql.xlsx"
-skos = _EXAMPLES / "skos-rules.xlsx"
 wind_energy_ontology = _EXAMPLES / "wind-energy.owl"