cognite-neat 0.92.2__py3-none-any.whl → 0.93.0__py3-none-any.whl

cognite/neat/{issues → _issues}/warnings/_properties.py

@@ -1,19 +1,19 @@
 from dataclasses import dataclass
 from typing import Generic
 
-from cognite.neat.issues._base import ResourceType
+from cognite.neat._issues._base import ResourceType
 
 from ._resources import ResourceNeatWarning, T_Identifier, T_ReferenceIdentifier
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class PropertyWarning(ResourceNeatWarning[T_Identifier]):
     """Base class for property warnings {resource_type} with identifier {identifier}.{property_name}"""
 
     property_name: str
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class PropertyTypeNotSupportedWarning(PropertyWarning[T_Identifier]):
     """The {resource_type} with identifier {identifier} has a property {property_name}
     of unsupported type {property_type}. This will be ignored."""
@@ -21,7 +21,7 @@ class PropertyTypeNotSupportedWarning(PropertyWarning[T_Identifier]):
     property_type: str
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class PropertyNotFoundWarning(PropertyWarning, Generic[T_Identifier, T_ReferenceIdentifier]):
     """The {resource_type} with identifier {identifier} does not have a property {property_name} referred
     to by {referred_type} {referred_by} does not exist. This will be ignored.
@@ -32,7 +32,7 @@ class PropertyNotFoundWarning(PropertyWarning, Generic[T_Identifier, T_Reference
     referred_type: ResourceType
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class PropertyDefinitionDuplicatedWarning(PropertyWarning[T_Identifier]):
     """Got multiple values for the {resource_type} {identifier}.{property_name} {values}.
     {default_action}"""
@@ -44,7 +44,7 @@ class PropertyDefinitionDuplicatedWarning(PropertyWarning[T_Identifier]):
     recommended_action: str | None = None
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class PropertyValueTypeUndefinedWarning(PropertyWarning[T_Identifier]):
     """The {resource_type} with identifier {identifier} has a property {property_name}
     which has undefined value type. This may result in unexpected behavior when exporting rules.

cognite/neat/{issues → _issues}/warnings/_resources.py

@@ -1,11 +1,11 @@
 from dataclasses import dataclass
 from typing import Generic
 
-from cognite.neat.issues._base import NeatWarning, ResourceType, T_Identifier, T_ReferenceIdentifier
+from cognite.neat._issues._base import NeatWarning, ResourceType, T_Identifier, T_ReferenceIdentifier
 
 
 # Name ResourceNeatWarning to avoid conflicts with the built-in ResourceWarning
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class ResourceNeatWarning(NeatWarning, Generic[T_Identifier]):
     """Base class for resource warnings {resource_type} with identifier {identifier}"""
 
@@ -13,7 +13,7 @@ class ResourceNeatWarning(NeatWarning, Generic[T_Identifier]):
     resource_type: ResourceType
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class ResourceNotFoundWarning(ResourceNeatWarning, Generic[T_Identifier, T_ReferenceIdentifier]):
     """The {resource_type} with identifier {identifier} referred by {referred_type} {referred_by} does not exist.
     This will be ignored."""
@@ -24,7 +24,7 @@ class ResourceNotFoundWarning(ResourceNeatWarning, Generic[T_Identifier, T_Refer
     referred_type: str
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class ResourcesDuplicatedWarning(NeatWarning, Generic[T_Identifier]):
     """Duplicated {resource_type} with identifiers {resources} were found. {default_action}"""
 
@@ -35,7 +35,7 @@ class ResourcesDuplicatedWarning(NeatWarning, Generic[T_Identifier]):
     default_action: str
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class ResourceRetrievalWarning(NeatWarning, Generic[T_Identifier]):
     """Failed to retrieve {resource_type} with identifiers {resources}. Continuing without
     these resources."""

cognite/neat/{issues → _issues}/warnings/user_modeling.py

@@ -7,7 +7,7 @@ from dataclasses import dataclass
 
 from cognite.client.data_classes.data_modeling import ContainerId, ViewId
 
-from cognite.neat.constants import DMS_CONTAINER_PROPERTY_SIZE_LIMIT
+from cognite.neat._constants import DMS_CONTAINER_PROPERTY_SIZE_LIMIT
 
 from ._models import UserModelingWarning
 
@@ -23,7 +23,7 @@ __all__ = [
 ]
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class DirectRelationMissingSourceWarning(UserModelingWarning):
     """The view {view_id}.{prop_name} is a direct relation without a source.
     Direct relations in views should point to a single other view, if not, you end up
@@ -35,7 +35,7 @@ class DirectRelationMissingSourceWarning(UserModelingWarning):
     prop_name: str
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class ParentInDifferentSpaceWarning(UserModelingWarning):
     """The view {view_id} has multiple parents in different spaces.
     Neat recommends maximum one implementation of a view from another space."""
@@ -45,7 +45,7 @@ class ParentInDifferentSpaceWarning(UserModelingWarning):
     view_id: ViewId
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class EmptyContainerWarning(UserModelingWarning):
     """Container {container_id} is empty and will be skipped.
     The container does not have any properties."""
@@ -55,7 +55,7 @@ class EmptyContainerWarning(UserModelingWarning):
     container_id: ContainerId
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class HasDataFilterOnNoPropertiesViewWarning(UserModelingWarning):
     """Cannot set hasData filter on view {view_id}.
     The view does not have properties in any containers.
@@ -66,7 +66,7 @@ class HasDataFilterOnNoPropertiesViewWarning(UserModelingWarning):
     view_id: ViewId
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class NodeTypeFilterOnParentViewWarning(UserModelingWarning):
     """Setting a node type filter on parent view {view_id}.
     This is not recommended as parent views are typically used for multiple types of nodes."""
@@ -76,7 +76,7 @@ class NodeTypeFilterOnParentViewWarning(UserModelingWarning):
     view_id: ViewId
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class HasDataFilterOnViewWithReferencesWarning(UserModelingWarning):
     """Setting a hasData filter on view {view_id} which references other views {references}.
     This is not recommended as it will lead to no nodes being returned when querying the solution view.
@@ -88,7 +88,7 @@ class HasDataFilterOnViewWithReferencesWarning(UserModelingWarning):
     references: frozenset[ViewId]
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class ViewPropertyLimitWarning(UserModelingWarning):
     """The number of properties in the {view_id} view is {count} which
     is more than the API limit {limit} properties.
@@ -102,7 +102,7 @@ class ViewPropertyLimitWarning(UserModelingWarning):
     limit: int = DMS_CONTAINER_PROPERTY_SIZE_LIMIT
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class NotNeatSupportedFilterWarning(UserModelingWarning):
     """The view {view_id} uses a non-standard filter.
     This will not be validated by Neat, and is thus not recommended.

cognite/neat/_rules/_constants.py

@@ -0,0 +1,190 @@
+import re
+import sys
+from functools import cached_property
+
+if sys.version_info >= (3, 11):
+    from enum import StrEnum
+else:
+    from backports.strenum import StrEnum
+
+
+class EntityTypes(StrEnum):
+    view_non_versioned = "view_non_versioned"
+    subject = "subject"
+    predicate = "predicate"
+    object = "object"
+    class_ = "class"
+    parent_class = "parent_class"
+    property_ = "property"
+    dms_property = "dms_property"
+    information_property = "information_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"
+    dms_node = "dms_node"
+    view = "view"
+    reference_entity = "reference_entity"
+    container = "container"
+    datamodel = "datamodel"
+    undefined = "undefined"
+    multi_value_type = "multi_value_type"
+    asset = "asset"
+    relationship = "relationship"
+    edge = "edge"
+    reverse = "reverse"
+    unit = "unit"
+    version = "version"
+    prefix = "prefix"
+    space = "space"
+
+
+def get_reserved_words() -> dict[str, list[str]]:
+    return {
+        "class": ["Class", "class"],
+        "view": [
+            "Query",
+            "Mutation",
+            "Subscription",
+            "String",
+            "Int32",
+            "Int64",
+            "Int",
+            "Float32",
+            "Float64",
+            "Float",
+            "Timestamp",
+            "JSONObject",
+            "Date",
+            "Numeric",
+            "Boolean",
+            "PageInfo",
+            "File",
+            "Sequence",
+            "TimeSeries",
+        ],
+        "property": [
+            "property",
+            "space",
+            "externalId",
+            "createdTime",
+            "lastUpdatedTime",
+            "deletedTime",
+            "edge_id",
+            "node_id",
+            "project_id",
+            "property_group",
+            "seq",
+            "tg_table_name",
+            "extensions",
+        ],
+        "space": ["space", "cdf", "dms", "pg3", "shared", "system", "node", "edge"],
+    }
+
+
+ENTITY_PATTERN = re.compile(r"^(?P<prefix>.*?):?(?P<suffix>[^(:]*)(\((?P<content>.+)\))?$")
+
+
+# REGEX FOR VALIDATIONS
+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]*)$"
+
+SPACE_COMPLIANCE_REGEX = (
+    rf"(?!^({'|'.join(get_reserved_words()['space'])})$)" r"(^[a-zA-Z][a-zA-Z0-9_-]{0,41}[a-zA-Z0-9]?$)"
+)
+
+
+DATA_MODEL_COMPLIANCE_REGEX = r"^[a-zA-Z]([a-zA-Z0-9_]{0,253}[a-zA-Z0-9])?$"
+
+VIEW_ID_COMPLIANCE_REGEX = (
+    rf"(?!^({'|'.join(get_reserved_words()['view'])})$)" r"(^[a-zA-Z][a-zA-Z0-9_]{0,253}[a-zA-Z0-9]?$)"
+)
+DMS_PROPERTY_ID_COMPLIANCE_REGEX = (
+    rf"(?!^({'|'.join(get_reserved_words()['property'])})$)" r"(^[a-zA-Z][a-zA-Z0-9_]{0,253}[a-zA-Z0-9]?$)"
+)
+CLASS_ID_COMPLIANCE_REGEX = (
+    rf"(?!^({'|'.join(get_reserved_words()['class'])})$)" r"(^[a-zA-Z][a-zA-Z0-9._-]{0,253}[a-zA-Z0-9]?$)"
+)
+
+INFORMATION_PROPERTY_ID_COMPLIANCE_REGEX = (
+    r"^(\*)|(?!^(Property|property)$)(^[a-zA-Z][a-zA-Z0-9._-]{0,253}[a-zA-Z0-9]?$)"
+)
+VERSION_COMPLIANCE_REGEX = r"^[a-zA-Z0-9]([.a-zA-Z0-9_-]{0,41}[a-zA-Z0-9])?$"
+
+
+# This pattern ignores commas inside brackets
+SPLIT_ON_COMMA_PATTERN = re.compile(r",(?![^(]*\))")
+# This pattern ignores equal signs inside brackets
+SPLIT_ON_EQUAL_PATTERN = re.compile(r"=(?![^(]*\))")
+
+
+class _Patterns:
+    @cached_property
+    def more_than_one_alphanumeric(self) -> re.Pattern:
+        return re.compile(MORE_THAN_ONE_NONE_ALPHANUMERIC_REGEX)
+
+    @cached_property
+    def prefix_compliance(self) -> re.Pattern[str]:
+        return re.compile(PREFIX_COMPLIANCE_REGEX)
+
+    @cached_property
+    def space_compliance(self) -> re.Pattern[str]:
+        return re.compile(SPACE_COMPLIANCE_REGEX)
+
+    @cached_property
+    def view_id_compliance(self) -> re.Pattern[str]:
+        return re.compile(VIEW_ID_COMPLIANCE_REGEX)
+
+    @cached_property
+    def dms_property_id_compliance(self) -> re.Pattern[str]:
+        return re.compile(DMS_PROPERTY_ID_COMPLIANCE_REGEX)
+
+    @cached_property
+    def class_id_compliance(self) -> re.Pattern[str]:
+        return re.compile(CLASS_ID_COMPLIANCE_REGEX)
+
+    @cached_property
+    def information_property_id_compliance(self) -> re.Pattern[str]:
+        return re.compile(INFORMATION_PROPERTY_ID_COMPLIANCE_REGEX)
+
+    @cached_property
+    def version_compliance(self) -> re.Pattern[str]:
+        return re.compile(VERSION_COMPLIANCE_REGEX)
+
+    def entity_pattern(
+        self,
+        entity: EntityTypes,
+    ) -> re.Pattern:
+        if entity == EntityTypes.class_:
+            return self.class_id_compliance
+
+        elif entity == EntityTypes.information_property:
+            return self.information_property_id_compliance
+
+        elif entity == EntityTypes.view:
+            return self.view_id_compliance
+
+        # container regex same as view regex
+        elif entity == EntityTypes.container:
+            return self.view_id_compliance
+
+        elif entity == EntityTypes.dms_property:
+            return self.dms_property_id_compliance
+
+        elif entity == EntityTypes.version:
+            return self.version_compliance
+
+        elif entity == EntityTypes.prefix:
+            return self.prefix_compliance
+
+        elif entity == EntityTypes.space:
+            return self.space_compliance
+
+        else:
+            raise ValueError(f"Unsupported entity type {entity}")
+
+
+PATTERNS = _Patterns()

cognite/neat/{rules → _rules}/_shared.py

@@ -2,16 +2,16 @@ from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from typing import Any, Generic, TypeAlias, TypeVar
 
-from cognite.neat.issues import IssueList
-from cognite.neat.rules.models import (
+from cognite.neat._issues import IssueList
+from cognite.neat._rules.models import (
     AssetRules,
     DMSRules,
     DomainRules,
     InformationRules,
 )
-from cognite.neat.rules.models.asset._rules_input import AssetInputRules
-from cognite.neat.rules.models.dms._rules_input import DMSInputRules
-from cognite.neat.rules.models.information._rules_input import InformationInputRules
+from cognite.neat._rules.models.asset._rules_input import AssetInputRules
+from cognite.neat._rules.models.dms._rules_input import DMSInputRules
+from cognite.neat._rules.models.information._rules_input import InformationInputRules
 
 VerifiedRules: TypeAlias = DomainRules | InformationRules | DMSRules | AssetRules
 InputRules: TypeAlias = AssetInputRules | DMSInputRules | InformationInputRules

cognite/neat/_rules/analysis/__init__.py

@@ -0,0 +1,5 @@
+from ._asset import AssetAnalysis
+from ._dms import DMSAnalysis
+from ._information import InformationAnalysis
+
+__all__ = ["InformationAnalysis", "AssetAnalysis", "DMSAnalysis"]

cognite/neat/{rules → _rules}/analysis/_asset.py

@@ -2,14 +2,14 @@ import warnings
 from graphlib import TopologicalSorter
 from typing import cast
 
-from cognite.neat.rules.models import AssetRules
-from cognite.neat.rules.models._rdfpath import RDFPath
-from cognite.neat.rules.models.asset import AssetClass, AssetProperty
-from cognite.neat.rules.models.entities import (
+from cognite.neat._rules._constants import EntityTypes
+from cognite.neat._rules.models import AssetRules
+from cognite.neat._rules.models._rdfpath import RDFPath
+from cognite.neat._rules.models.asset import AssetClass, AssetProperty
+from cognite.neat._rules.models.entities import (
     AssetEntity,
     AssetFields,
     ClassEntity,
-    EntityTypes,
     ReferenceEntity,
     RelationshipEntity,
 )

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

@@ -9,15 +9,15 @@ from typing import Generic, TypeVar
 import pandas as pd
 from pydantic import BaseModel
 
-from cognite.neat.rules.models._base_rules import BaseRules
-from cognite.neat.rules.models._rdfpath import RDFPath
-from cognite.neat.rules.models.entities import (
+from cognite.neat._rules.models._base_rules import BaseRules
+from cognite.neat._rules.models._rdfpath import RDFPath
+from cognite.neat._rules.models.entities import (
     ClassEntity,
     Entity,
     ReferenceEntity,
 )
-from cognite.neat.rules.models.information import InformationProperty
-from cognite.neat.utils.rdf_ import get_inheritance_path
+from cognite.neat._rules.models.information import InformationProperty
+from cognite.neat._utils.rdf_ import get_inheritance_path
 
 T_Rules = TypeVar("T_Rules", bound=BaseRules)
 T_Property = TypeVar("T_Property", bound=BaseModel)

cognite/neat/_rules/analysis/_dms.py

@@ -0,0 +1,43 @@
+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 ReferenceEntity, 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_reference(self, class_or_property: DMSView | DMSProperty) -> ReferenceEntity | None:
+        return class_or_property.reference if isinstance(class_or_property.reference, ReferenceEntity) else None
+
+    def _get_cls_entity(self, class_: DMSView | DMSProperty) -> ViewEntity:
+        return class_.view
+
+    def _get_prop_entity(self, property_: DMSProperty) -> str:
+        return property_.property_
+
+    def _get_cls_parents(self, class_: DMSView) -> list[ViewEntity] | None:
+        return list(class_.implements) if class_.implements else None
+
+    def _get_reference_rules(self) -> DMSRules | None:
+        return self.rules.reference
+
+    @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()

cognite/neat/{rules → _rules}/analysis/_information.py

@@ -4,21 +4,23 @@ from typing import Any, cast
 from pydantic import ValidationError
 from rdflib import URIRef
 
-from cognite.neat.rules.models import SchemaCompleteness
-from cognite.neat.rules.models._rdfpath import (
+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, EntityTypes, ReferenceEntity
-from cognite.neat.rules.models.information import (
+from cognite.neat._rules.models.entities import ClassEntity, ReferenceEntity
+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 cognite.neat._utils.collection_ import most_occurring_element
+from cognite.neat._utils.rdf_ import get_inheritance_path
 
 from ._base import BaseAnalysis
 
@@ -226,3 +228,7 @@ class InformationAnalysis(BaseAnalysis[InformationRules, InformationClass, Infor
         # 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/catalog/__init__.py

@@ -0,0 +1,6 @@
+"""Shortcut to rules catalog files"""
+
+from pathlib import Path
+
+_CATALOG = Path(__file__).parent
+imf_attributes = _CATALOG / "info-rules-imf.xlsx"

cognite/neat/{rules → _rules}/exporters/__init__.py

@@ -1,6 +1,7 @@
 from ._base import BaseExporter, CDFExporter
 from ._rules2dms import DMSExporter
 from ._rules2excel import ExcelExporter
+from ._rules2instance_template import InstanceTemplateExporter
 from ._rules2ontology import GraphExporter, OWLExporter, SemanticDataModelExporter, SHACLExporter
 from ._rules2yaml import YAMLExporter
 
@@ -14,6 +15,7 @@ __all__ = [
     "SHACLExporter",
     "ExcelExporter",
     "YAMLExporter",
+    "InstanceTemplateExporter",
 ]
 
 

cognite/neat/{rules → _rules}/exporters/_base.py

@@ -5,9 +5,9 @@ from typing import Generic, TypeVar
 
 from cognite.client import CogniteClient
 
-from cognite.neat.rules._shared import T_VerifiedRules
-from cognite.neat.utils.auxiliary import class_html_doc
-from cognite.neat.utils.upload import UploadResult, UploadResultList
+from cognite.neat._rules._shared import T_VerifiedRules
+from cognite.neat._utils.auxiliary import class_html_doc
+from cognite.neat._utils.upload import UploadResult, UploadResultList
 
 T_Export = TypeVar("T_Export")
 

cognite/neat/{rules → _rules}/exporters/_rules2dms.py

@@ -15,13 +15,13 @@ from cognite.client.data_classes.data_modeling import (
 )
 from cognite.client.exceptions import CogniteAPIError
 
-from cognite.neat.issues import IssueList
-from cognite.neat.issues.warnings import (
+from cognite.neat._issues import IssueList
+from cognite.neat._issues.warnings import (
     PrincipleOneModelOneSpaceWarning,
     ResourceRetrievalWarning,
 )
-from cognite.neat.rules.models.dms import DMSRules, DMSSchema, PipelineSchema
-from cognite.neat.utils.cdf.loaders import (
+from cognite.neat._rules.models.dms import DMSRules, DMSSchema, PipelineSchema
+from cognite.neat._utils.cdf.loaders import (
     ContainerLoader,
     DataModelingLoader,
     DataModelLoader,
@@ -32,7 +32,7 @@ from cognite.neat.utils.cdf.loaders import (
     TransformationLoader,
     ViewLoader,
 )
-from cognite.neat.utils.upload import UploadResult
+from cognite.neat._utils.upload import UploadResult
 
 from ._base import CDFExporter
 

cognite/neat/{rules → _rules}/exporters/_rules2excel.py

@@ -11,20 +11,24 @@ from openpyxl import Workbook
 from openpyxl.cell import MergedCell
 from openpyxl.styles import Alignment, Border, Font, PatternFill, Side
 from openpyxl.worksheet.worksheet import Worksheet
+from rdflib import Namespace
 
-from cognite.neat.rules._shared import VerifiedRules
-from cognite.neat.rules.models import (
+from cognite.neat._rules._shared import VerifiedRules
+from cognite.neat._rules.models import (
     DataModelType,
     ExtensionCategory,
     SchemaCompleteness,
     SheetRow,
 )
-from cognite.neat.rules.models.dms import DMSMetadata
-from cognite.neat.rules.models.domain import DomainMetadata
-from cognite.neat.rules.models.information import InformationMetadata
+from cognite.neat._rules.models.dms import DMSMetadata
+from cognite.neat._rules.models.domain import DomainMetadata
+from cognite.neat._rules.models.information import InformationMetadata
+from cognite.neat._rules.models.information._rules import InformationRules
 
 from ._base import BaseExporter
 
+MAX_COLUMN_WIDTH = 70.0
+
 
 class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
     """Export rules to Excel.
@@ -133,6 +137,9 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
             self._write_sheets(workbook, dumped_reference_rules, rules, sheet_prefix="Ref")
             self._write_metadata_sheet(workbook, dumped_reference_rules["Metadata"], sheet_prefix="Ref")
 
+        if isinstance(rules, InformationRules) and rules.prefixes:
+            self._write_prefixes_sheet(workbook, rules.prefixes)
+
         if self._styling_level > 0:
             self._adjust_column_widths(workbook)
 
@@ -209,6 +216,16 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
             for cell in metadata_sheet["A"]:
                 cell.font = Font(bold=True, size=12)
 
+    def _write_prefixes_sheet(self, workbook: Workbook, prefixes: dict[str, Namespace]) -> None:
+        metadata_sheet = workbook.create_sheet("Prefixes")
+        metadata_sheet.append(["Prefix", "Namespace"])
+        for key, value in prefixes.items():
+            metadata_sheet.append([key, value])
+
+        if self._styling_level > 1:
+            for cell in metadata_sheet["A"]:
+                cell.font = Font(bold=True, size=12)
+
     @classmethod
     def _get_item_class(cls, annotation: GenericAlias) -> type[SheetRow]:
         if not isinstance(annotation, GenericAlias):
@@ -236,7 +253,9 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
                     selected_column = column_cells[1]
 
                 current = sheet.column_dimensions[selected_column.column_letter].width or (max_length + 0.5)
-                sheet.column_dimensions[selected_column.column_letter].width = max(current, max_length + 0.5)
+                sheet.column_dimensions[selected_column.column_letter].width = min(
+                    max(current, max_length + 0.5), MAX_COLUMN_WIDTH
+                )
         return None
 
 
@@ -274,7 +293,7 @@ class _MetadataCreator:
 
         new_metadata = self._create_new_info(now)
         if isinstance(metadata, DMSMetadata):
-            from cognite.neat.rules.transformers._converters import _InformationRulesConverter
+            from cognite.neat._rules.transformers._converters import _InformationRulesConverter
 
             output_metadata: DMSMetadata | InformationMetadata = _InformationRulesConverter._convert_metadata_to_dms(
                 new_metadata