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

cognite/neat/rules/models/{_rules → rules}/_types/_base.py

@@ -1,11 +1,21 @@
 import re
 import sys
-from functools import total_ordering
 from typing import Any, ClassVar, Literal, cast, overload
 
 from cognite.client.data_classes.data_modeling import ContainerId, DataModelId, PropertyId, ViewId
-from pydantic import BaseModel
 
+from cognite.neat.rules.models._entity import (
+    ENTITY_ID_REGEX_COMPILED,
+    PREFIX_REGEX,
+    PROPERTY_REGEX,
+    SUFFIX_REGEX,
+    VERSION_REGEX,
+    VERSIONED_ENTITY_REGEX_COMPILED,
+    Entity,
+    EntityTypes,
+    Undefined,
+    Unknown,
+)
 from cognite.neat.rules.models.rdfpath import (
     SINGLE_PROPERTY_REGEX_COMPILED,
     AllReferences,
@@ -16,56 +26,20 @@ from cognite.neat.rules.models.rdfpath import (
 )
 
 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"
-    parent_class = "parent_class"
-    property_ = "property"
-    object_property = "ObjectProperty"
-    data_property = "DatatypeProperty"
-    annotation_property = "AnnotationProperty"
-    object_value_type = "object_value_type"
-    data_value_type = "data_value_type"  # these are strings, floats, ...
-    xsd_value_type = "xsd_value_type"
-    dms_value_type = "dms_value_type"
-    view = "view"
-    view_prop = "view_prop"
-    reference_entity = "reference_entity"
-    container = "container"
-    datamodel = "datamodel"
-    undefined = "undefined"
-
-
-# ALLOWED
-ALLOWED_PATTERN = r"[^a-zA-Z0-9-_.]"
-
-# 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])?"
-PROPERTY_REGEX = r"[a-zA-Z0-9][a-zA-Z0-9_-]*[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})\)$"
-)
+VERSION_ID_REGEX = rf"\(version=(?P<version>{VERSION_REGEX})\)"
+
+
 PROPERTY_ENTITY_REGEX_COMPILED = re.compile(
     rf"^((?P<prefix>{PREFIX_REGEX}):)?(?P<suffix>{SUFFIX_REGEX})"
     rf"\((version=(?P<version>{VERSION_REGEX}), )?property=(?P<property>{PROPERTY_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})\)"
+
+
 MORE_THAN_ONE_NONE_ALPHANUMERIC_REGEX = r"([_-]{2,})"
 PREFIX_COMPLIANCE_REGEX = r"^([a-zA-Z]+)([a-zA-Z0-9]*[_-]{0,1}[a-zA-Z0-9_-]*)([a-zA-Z0-9]*)$"
 DATA_MODEL_ID_COMPLIANCE_REGEX = r"^[a-zA-Z]([a-zA-Z0-9_]{0,253}[a-zA-Z0-9])?$"
@@ -87,96 +61,6 @@ PROPERTY_ID_COMPLIANCE_REGEX = r"^(\*)|(?!^(Property|property)$)(^[a-zA-Z][a-zA-
 VERSION_COMPLIANCE_REGEX = r"^[a-zA-Z0-9]([.a-zA-Z0-9_-]{0,41}[a-zA-Z0-9])?$"
 
 
-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 ContainerEntity(Entity):
     type_: ClassVar[EntityTypes] = EntityTypes.container
 
@@ -293,7 +177,7 @@ class ViewPropEntity(ViewEntity):
         return ViewPropEntity(
             prefix=prop_id.source.space,
             suffix=prop_id.source.external_id,
-            version=prop_id.source.version,
+            version=cast(ViewId, prop_id.source).version,
             property_=prop_id.property,
         )
 

cognite/neat/workflows/steps/data_contracts.py

@@ -4,10 +4,10 @@ from cognite.client import CogniteClient
 from cognite.client.data_classes import Asset, AssetUpdate, Relationship, RelationshipUpdate
 from cognite.client.data_classes.data_modeling import EdgeApply, NodeApply
 
-from cognite.neat.graph.stores import NeatGraphStoreBase
-from cognite.neat.rules.exporter._rules2dms import DMSSchemaComponents
-from cognite.neat.rules.models._rules import DMSRules, DomainRules, InformationRules
-from cognite.neat.rules.models.rules import Rules
+from cognite.neat.legacy.graph.stores import NeatGraphStoreBase
+from cognite.neat.legacy.rules.exporters._rules2dms import DMSSchemaComponents
+from cognite.neat.legacy.rules.models.rules import Rules
+from cognite.neat.rules.models.rules import DMSRules, DomainRules, InformationRules
 from cognite.neat.workflows.steps.step_model import DataContract
 
 

cognite/neat/workflows/steps/lib/graph_store.py

@@ -3,7 +3,7 @@ from pathlib import Path
 from typing import ClassVar, cast
 
 from cognite.neat.constants import PREFIXES
-from cognite.neat.graph import stores
+from cognite.neat.legacy.graph import stores
 from cognite.neat.workflows._exceptions import StepNotInitialized
 from cognite.neat.workflows.model import FlowMessage
 from cognite.neat.workflows.steps.data_contracts import RulesData, SolutionGraph, SourceGraph

cognite/neat/workflows/steps/lib/rules_exporter.py

@@ -4,7 +4,7 @@ from typing import ClassVar, Literal, cast
 
 from cognite.neat.rules import exporters
 from cognite.neat.rules._shared import DMSRules, InformationRules, Rules
-from cognite.neat.rules.models._rules import RoleTypes
+from cognite.neat.rules.models.rules import RoleTypes
 from cognite.neat.workflows._exceptions import StepNotInitialized
 from cognite.neat.workflows.model import FlowMessage, StepExecutionStatus
 from cognite.neat.workflows.steps.data_contracts import CogniteClient, MultiRuleData
@@ -98,9 +98,11 @@ class RulesToDMS(Step):
 
         dms_exporter = exporters.DMSExporter(
             export_components=frozenset(components_to_create),
-            include_space=None
-            if multi_space_components_create
-            else {input_rules.metadata.space if isinstance(input_rules, DMSRules) else input_rules.metadata.prefix},
+            include_space=(
+                None
+                if multi_space_components_create
+                else {input_rules.metadata.space if isinstance(input_rules, DMSRules) else input_rules.metadata.prefix}
+            ),
             existing_handling=existing_components_handling,
         )
 
@@ -169,6 +171,11 @@ class RulesToExcel(Step):
             "rules will be used.",
             options=["input", *RoleTypes.__members__.keys()],
         ),
+        Configurable(
+            name="File path",
+            value="",
+            label="File path to the generated Excel file.For example: 'staging/exported-rules.xlsx'",
+        ),
     ]
 
     def run(self, rules: MultiRuleData) -> FlowMessage:  # type: ignore[override, syntax]
@@ -200,12 +207,18 @@ class RulesToExcel(Step):
         output_dir.mkdir(parents=True, exist_ok=True)
         file_name = f"exported_rules_{output_role.value}.xlsx"
         filepath = output_dir / file_name
+        if self.configs.get("File path", ""):
+            file_name = self.configs["File path"]
+            filepath = Path(self.data_store_path) / Path(file_name)
+        else:
+            file_name = f"staging/{file_name}"
+
         excel_exporter.export_to_file(rule_instance, filepath)
 
         output_text = (
             "<p></p>"
             f"Download Excel Exported {output_role.value} rules: "
-            f'- <a href="/data/staging/{file_name}?{time.time()}" '
+            f'- <a href="/data/{file_name}?{time.time()}" '
             f'target="_blank">{file_name}</a>'
         )
 

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

@@ -6,8 +6,8 @@ from cognite.client import CogniteClient
 
 from cognite.neat.rules import importers
 from cognite.neat.rules.issues.formatters import FORMATTER_BY_NAME
-from cognite.neat.rules.models._rules import RoleTypes
-from cognite.neat.rules.models._rules._types import DataModelEntity, Undefined
+from cognite.neat.rules.models.rules import RoleTypes
+from cognite.neat.rules.models.rules._types import DataModelEntity, Undefined
 from cognite.neat.workflows._exceptions import StepNotInitialized
 from cognite.neat.workflows.model import FlowMessage, StepExecutionStatus
 from cognite.neat.workflows.steps.data_contracts import MultiRuleData

cognite/neat/workflows/steps/lib/rules_validator.py

@@ -8,8 +8,8 @@ from cognite.client import CogniteClient
 from cognite.neat.rules.issues import IssueList
 from cognite.neat.rules.issues.dms import MissingContainerError, MissingSpaceError, MissingViewError
 from cognite.neat.rules.issues.formatters import FORMATTER_BY_NAME
-from cognite.neat.rules.models._rules import DMSRules
-from cognite.neat.rules.models._rules.base import SchemaCompleteness
+from cognite.neat.rules.models.rules import DMSRules
+from cognite.neat.rules.models.rules._base import SchemaCompleteness
 from cognite.neat.utils import cdf_loaders
 from cognite.neat.workflows._exceptions import StepNotInitialized
 from cognite.neat.workflows.model import FlowMessage, StepExecutionStatus

cognite/neat/workflows/steps/lib/v1/graph_contextualization.py

@@ -1,6 +1,6 @@
 from typing import ClassVar, cast
 
-from cognite.neat.graph.transformation.entity_matcher import simple_entity_matcher
+from cognite.neat.legacy.graph.transformations.entity_matcher import simple_entity_matcher
 from cognite.neat.workflows._exceptions import StepNotInitialized
 from cognite.neat.workflows.model import FlowMessage
 from cognite.neat.workflows.steps.data_contracts import SolutionGraph, SourceGraph

cognite/neat/workflows/steps/lib/v1/graph_extractor.py

@@ -9,9 +9,9 @@ from typing import ClassVar, cast
 from rdflib import RDF, XSD, Literal, Namespace, URIRef
 
 from cognite.neat.constants import PREFIXES
-from cognite.neat.graph import extractor
-from cognite.neat.graph.extractor._mock_graph_generator import generate_triples as generate_mock_triples
-from cognite.neat.rules.exporter._rules2triples import get_instances_as_triples
+from cognite.neat.legacy.graph import extractors
+from cognite.neat.legacy.graph.extractors._mock_graph_generator import generate_triples as generate_mock_triples
+from cognite.neat.legacy.rules.exporters._rules2triples import get_instances_as_triples
 from cognite.neat.utils.utils import create_sha256_hash
 from cognite.neat.workflows._exceptions import StepNotInitialized
 from cognite.neat.workflows.model import FlowMessage, StepExecutionStatus
@@ -114,7 +114,7 @@ class ExtractGraphFromDexpiFile(Step):
         base_namespace = self.configs.get("base_namespace", None)
 
         if file_path:
-            triples = extractor.DexpiXML(self.data_store_path / Path(file_path), base_namespace).extract()
+            triples = extractors.DexpiXML(self.data_store_path / Path(file_path), base_namespace).extract()
             source_graph.graph.add_triples(triples, verbose=True)
 
             logging.info(f"Loaded {file_path} into source graph.")
@@ -162,7 +162,7 @@ class ExtractGraphFromGraphCapturingSheet(Step):
         if file_path:
             logging.info(f"Processing graph capture sheet {self.data_store_path / Path(file_path)}")
 
-            triples = extractor.GraphCapturingSheet(
+            triples = extractors.GraphCapturingSheet(
                 rules=rules.rules,
                 filepath=self.data_store_path / Path(file_path),
                 namespace=self.configs.get("base_namespace", None),

cognite/neat/workflows/steps/lib/v1/graph_loader.py

@@ -8,9 +8,9 @@ from cognite.client import CogniteClient
 from cognite.client.data_classes import Asset, AssetFilter
 from prometheus_client import Gauge
 
-from cognite.neat.graph import loader as graph_loader
-from cognite.neat.graph.loader import upload_labels
-from cognite.neat.graph.loader.core.rdf_to_assets import (
+from cognite.neat.legacy.graph import loaders as graph_loader
+from cognite.neat.legacy.graph.loaders import upload_labels
+from cognite.neat.legacy.graph.loaders.core.rdf_to_assets import (
     NeatMetadataKeys,
     categorize_assets,
     rdf2assets,
@@ -18,14 +18,14 @@ from cognite.neat.graph.loader.core.rdf_to_assets import (
     unique_asset_labels,
     upload_assets,
 )
-from cognite.neat.graph.loader.core.rdf_to_relationships import (
+from cognite.neat.legacy.graph.loaders.core.rdf_to_relationships import (
     categorize_relationships,
     rdf2relationships,
     upload_relationships,
 )
-from cognite.neat.graph.loader.rdf_to_dms import upload_edges, upload_nodes
-from cognite.neat.graph.loader.validator import validate_asset_hierarchy
-from cognite.neat.rules.models.rdfpath import TransformationRuleType
+from cognite.neat.legacy.graph.loaders.rdf_to_dms import upload_edges, upload_nodes
+from cognite.neat.legacy.graph.loaders.validator import validate_asset_hierarchy
+from cognite.neat.legacy.rules.models.rdfpath import TransformationRuleType
 from cognite.neat.utils.utils import generate_exception_report
 from cognite.neat.workflows._exceptions import StepFlowContextNotInitialized, StepNotInitialized
 from cognite.neat.workflows.model import FlowMessage, StepExecutionStatus

cognite/neat/workflows/steps/lib/v1/graph_store.py

@@ -3,7 +3,7 @@ from pathlib import Path
 from typing import ClassVar, cast
 
 from cognite.neat.constants import PREFIXES
-from cognite.neat.graph import stores
+from cognite.neat.legacy.graph import stores
 from cognite.neat.workflows._exceptions import StepNotInitialized
 from cognite.neat.workflows.model import FlowMessage
 from cognite.neat.workflows.steps.data_contracts import RulesData, SolutionGraph, SourceGraph
@@ -262,6 +262,12 @@ class ConfigureGraphStore(Step):
             "neat-tnt",
             internal_storage_dir=store_dir,
         )
+        logging.info(50 * "*")
+        logging.info(50 * "*")
+        logging.info(50 * "*")
+        logging.info(type(new_graph_store))
+        logging.info(50 * "*")
+        logging.info(50 * "*")
 
         return (
             FlowMessage(output_text="Graph store configured successfully"),

cognite/neat/workflows/steps/lib/v1/graph_transformer.py

@@ -2,8 +2,8 @@ from typing import ClassVar
 
 from cognite.client import CogniteClient
 
-from cognite.neat.graph.transformation.transformer import RuleProcessingReport, domain2app_knowledge_graph
-from cognite.neat.rules.exporter._rules2triples import get_instances_as_triples
+from cognite.neat.legacy.graph.transformations.transformer import RuleProcessingReport, domain2app_knowledge_graph
+from cognite.neat.legacy.rules.exporters._rules2triples import get_instances_as_triples
 from cognite.neat.workflows.model import FlowMessage
 from cognite.neat.workflows.steps.data_contracts import RulesData, SolutionGraph, SourceGraph
 from cognite.neat.workflows.steps.step_model import Configurable, Step

cognite/neat/workflows/steps/lib/v1/rules_exporter.py

@@ -6,12 +6,12 @@ from typing import ClassVar, Literal, cast
 
 from cognite.client import data_modeling as dm
 
-import cognite.neat.graph.extractor._graph_capturing_sheet
+import cognite.neat.legacy.graph.extractors._graph_capturing_sheet
 from cognite.neat.exceptions import wrangle_warnings
-from cognite.neat.rules import exporter
-from cognite.neat.rules.exporter._rules2dms import DMSSchemaComponents
-from cognite.neat.rules.exporter._rules2graphql import GraphQLSchema
-from cognite.neat.rules.exporter._rules2ontology import Ontology
+from cognite.neat.legacy.rules import exporters
+from cognite.neat.legacy.rules.exporters._rules2dms import DMSSchemaComponents
+from cognite.neat.legacy.rules.exporters._rules2graphql import GraphQLSchema
+from cognite.neat.legacy.rules.exporters._rules2ontology import Ontology
 from cognite.neat.utils.utils import generate_exception_report
 from cognite.neat.workflows._exceptions import StepNotInitialized
 from cognite.neat.workflows.model import FlowMessage, StepExecutionStatus
@@ -485,7 +485,7 @@ class ExportRulesToGraphCapturingSheet(Step):
 
         data_capture_sheet_path = staging_dir / sheet_name
 
-        cognite.neat.graph.extractor._graph_capturing_sheet.rules2graph_capturing_sheet(
+        cognite.neat.legacy.graph.extractors._graph_capturing_sheet.rules2graph_capturing_sheet(
             rules.rules, data_capture_sheet_path, auto_identifier_type=auto_identifier_type
         )
 
@@ -509,5 +509,5 @@ class ExportRulesToExcel(Step):
 
     def run(self, rules_data: RulesData) -> FlowMessage:  # type: ignore[override, syntax]
         full_path = Path(self.data_store_path) / Path(self.configs["output_file_path"])
-        exporter.ExcelExporter.from_rules(rules=rules_data.rules).export_to_file(filepath=full_path)
+        exporters.ExcelExporter.from_rules(rules=rules_data.rules).export_to_file(filepath=full_path)
         return FlowMessage(output_text="Generated Excel file from rules")

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

@@ -9,10 +9,10 @@ import yaml
 from prometheus_client import Gauge
 from rdflib import Namespace
 
-from cognite.neat.rules import exporter, importer
-from cognite.neat.rules.models.rdfpath import TransformationRuleType
-from cognite.neat.rules.models.rules import Class, Classes, Metadata, Properties, Property, Rules
-from cognite.neat.rules.models.value_types import ValueType
+from cognite.neat.legacy.rules import exporters, importers
+from cognite.neat.legacy.rules.models.rdfpath import TransformationRuleType
+from cognite.neat.legacy.rules.models.rules import Class, Classes, Metadata, Properties, Property, Rules
+from cognite.neat.legacy.rules.models.value_types import ValueType
 from cognite.neat.utils.utils import generate_exception_report
 from cognite.neat.workflows import utils
 from cognite.neat.workflows._exceptions import StepNotInitialized
@@ -93,7 +93,7 @@ class ImportExcelToRules(Step):
         else:
             store.load_rules_file_from_cdf(str(rules_file), version)
 
-        raw_rules = importer.ExcelImporter(rules_file_path).to_raw_rules()
+        raw_rules = importers.ExcelImporter(rules_file_path).to_raw_rules()
         rules, errors, _ = raw_rules.to_rules(return_report=True, skip_validation=False)
         report = "# RULES VALIDATION REPORT\n\n" + generate_exception_report(errors, "Errors")
 
@@ -157,15 +157,15 @@ class ImportOntologyToRules(Step):
 
         make_compliant = self.configs["make_compliant"] == "True"
         try:
-            rules = importer.OWLImporter(ontology_file_path).to_rules(make_compliant=make_compliant)
+            rules = importers.OWLImporter(ontology_file_path).to_rules(make_compliant=make_compliant)
         except Exception:
-            rules = importer.OWLImporter(ontology_file_path).to_rules(
+            rules = importers.OWLImporter(ontology_file_path).to_rules(
                 skip_validation=True, make_compliant=make_compliant
             )
         assert isinstance(rules, Rules)
-        exporter.ExcelExporter.from_rules(rules).export_to_file(excel_file_path)
+        exporters.ExcelExporter.from_rules(rules).export_to_file(excel_file_path)
 
-        if report := importer.ExcelImporter(filepath=excel_file_path).to_raw_rules().validate_rules():
+        if report := importers.ExcelImporter(filepath=excel_file_path).to_raw_rules().validate_rules():
             report_file_path.write_text(report)
 
         relative_excel_file_path = str(excel_file_path).split("/data/")[1]
@@ -581,18 +581,18 @@ class ImportGraphToRules(Step):
         report_file_path = excel_file_path.parent / f"report_{excel_file_path.stem}.txt"
 
         try:
-            rules = importer.GraphImporter(
+            rules = importers.GraphImporter(
                 graph_store.graph.graph, int(self.configs["max_number_of_instances"])
             ).to_rules()
         except Exception:
-            rules = importer.GraphImporter(
+            rules = importers.GraphImporter(
                 graph_store.graph.graph, int(self.configs["max_number_of_instances"])
             ).to_rules(skip_validation=True)
 
         assert isinstance(rules, Rules)
-        exporter.ExcelExporter.from_rules(rules).export_to_file(excel_file_path)
+        exporters.ExcelExporter.from_rules(rules).export_to_file(excel_file_path)
 
-        if report := importer.ExcelImporter(filepath=excel_file_path).to_raw_rules().validate_rules():
+        if report := importers.ExcelImporter(filepath=excel_file_path).to_raw_rules().validate_rules():
             report_file_path.write_text(report)
 
         relative_excel_file_path = str(excel_file_path).split("/data/")[1]

{cognite_neat-0.73.4.dist-info → cognite_neat-0.75.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cognite-neat
-Version: 0.73.4
+Version: 0.75.1
 Summary: Knowledge graph transformation
 Home-page: https://cognite-neat.readthedocs-hosted.com/
 License: Apache-2.0