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

cognite/neat/_rules/exporters/_rules2instance_template.py

@@ -0,0 +1,152 @@
+import uuid
+from pathlib import Path
+from typing import Literal, cast
+
+from openpyxl import Workbook
+from openpyxl.cell import Cell
+from openpyxl.styles import Alignment, Border, Font, NamedStyle, PatternFill, Side
+from openpyxl.utils import get_column_letter
+from openpyxl.worksheet.datavalidation import DataValidation
+
+from cognite.neat._rules._constants import EntityTypes
+from cognite.neat._rules.analysis import InformationAnalysis
+from cognite.neat._rules.models.entities._single_value import ClassEntity
+from cognite.neat._rules.models.information._rules import InformationRules
+
+from ._base import BaseExporter
+
+
+class InstanceTemplateExporter(BaseExporter[InformationRules, Workbook]):
+    """
+    Converts Information Rules to a templated spreadsheet meant for capturing
+    instances based on class definitions in the rules.
+
+    Args:
+        no_rows: number of rows for processing, by default 1000
+        auto_identifier_type: type of automatic identifier, by default "index" based, alternative is "uuid" based
+        add_drop_down_list: Add drop down selection for columns that contain linking properties, by default True
+
+    !!! note "no_rows parameter"
+        no_rows should be set to the maximum expected number of instances of any of the classes.
+        By default, it is set to 1000, increase it accordingly if you have more instances.
+
+    """
+
+    def __init__(
+        self,
+        no_rows: int = 1000,
+        auto_identifier_type: Literal["index", "uuid"] = "index",
+        add_drop_down_list: bool = True,
+    ):
+        self.no_rows = no_rows
+        self.auto_identifier_type = auto_identifier_type
+        self.add_drop_down_list = add_drop_down_list
+
+    def export(
+        self,
+        rules: InformationRules,
+    ):
+        workbook = Workbook()
+
+        # Remove default sheet named "Sheet"
+        workbook.remove(workbook["Sheet"])
+
+        for class_, properties in InformationAnalysis(rules).class_property_pairs().items():
+            workbook.create_sheet(title=class_.suffix)
+
+            # Add header rows
+            workbook[class_.suffix].append(["identifier", *list(properties.keys())])
+
+            if self.auto_identifier_type == "uuid":
+                _add_uuid_identifiers(workbook, class_.suffix, self.no_rows)
+            else:
+                # Default to index-based identifier
+                _add_index_identifiers(workbook, class_.suffix, self.no_rows)
+
+            for i, property_ in enumerate(properties.values()):
+                if property_.type_ == EntityTypes.object_property and self.add_drop_down_list:
+                    _add_drop_down_list(
+                        workbook,
+                        class_.suffix,
+                        get_column_letter(i + 2),
+                        self.no_rows,
+                        cast(ClassEntity, property_.value_type).suffix,
+                        "A",
+                    )
+
+        _adjust_column_width(workbook)
+        _set_header_style(workbook)
+
+        return workbook
+
+    def export_to_file(self, rules: InformationRules, filepath: Path) -> None:
+        """Exports graph capturing sheet to excel file."""
+        data = self.export(rules)
+        try:
+            data.save(filepath)
+        finally:
+            data.close()
+        return None
+
+
+def _add_index_identifiers(workbook: Workbook, sheet: str, no_rows: int):
+    """Adds index-based auto identifier to a sheet identifier column"""
+    for i in range(no_rows):
+        workbook[sheet][f"A{i+2}"] = f'=IF(ISBLANK(B{i+2}), "","{sheet}-{i+1}")'
+
+
+def _add_uuid_identifiers(workbook: Workbook, sheet: str, no_rows: int):
+    """Adds UUID-based auto identifier to a sheet identifier column"""
+    for i in range(no_rows):
+        workbook[sheet][f"A{i+2}"] = f'=IF(ISBLANK(B{i+2}), "","{sheet}-{uuid.uuid4()}")'
+
+
+def _add_drop_down_list(
+    workbook: Workbook,
+    sheet: str,
+    column: str,
+    no_rows: int,
+    value_sheet: str,
+    value_column: str,
+):
+    """Adds a drop down list to a column"""
+    drop_down_list = DataValidation(
+        type="list",
+        formula1=f"={value_sheet}!{value_column}$2:{value_column}${no_rows}",
+    )
+
+    workbook[sheet].add_data_validation(drop_down_list)
+
+    for i in range(no_rows):
+        drop_down_list.add(workbook[sheet][f"{column}{i+2}"])
+
+
+def _adjust_column_width(workbook: Workbook):
+    """Adjusts the column width based on the content"""
+    for sheet in workbook.sheetnames:
+        for cell_tuple in workbook[sheet].columns:
+            # Wrong type annotation in openpyxl
+            cell = cast(Cell, cell_tuple[0])  # type: ignore[index]
+            if cell.value:
+                adjusted_width = (len(str(cell.value)) + 5) * 1.2
+                workbook[sheet].column_dimensions[cell.column_letter].width = adjusted_width
+
+
+def _set_header_style(workbook: Workbook):
+    """Sets the header style for all sheets in the workbook"""
+    style = NamedStyle(name="header style")
+    style.font = Font(bold=True, size=16)
+    side = Side(style="thin", color="000000")
+    style.border = Border(left=side, right=side, top=side, bottom=side)
+    workbook.add_named_style(style)
+
+    for sheet in workbook.sheetnames:
+        for cell_tuple in workbook[sheet].columns:
+            # Wrong type annotation in openpyxl
+            cell = cast(Cell, cell_tuple[0])  # type: ignore[index]
+            workbook[sheet][f"{cell.column_letter}1"].style = style
+            if f"{cell.column_letter}1" == "A1":
+                workbook[sheet][f"{cell.column_letter}1"].fill = PatternFill("solid", start_color="2FB5F2")
+            else:
+                workbook[sheet][f"{cell.column_letter}1"].fill = PatternFill("solid", start_color="FFB202")
+            workbook[sheet][f"{cell.column_letter}1"].alignment = Alignment(horizontal="center", vertical="center")

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

@@ -8,22 +8,23 @@ 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.constants import DEFAULT_NAMESPACE as NEAT_NAMESPACE
-from cognite.neat.issues import MultiValueError
-from cognite.neat.issues.errors import (
+from cognite.neat._constants import DEFAULT_NAMESPACE as NEAT_NAMESPACE
+from cognite.neat._issues import MultiValueError
+from cognite.neat._issues.errors import (
     PropertyDefinitionDuplicatedError,
 )
-from cognite.neat.issues.warnings import PropertyDefinitionDuplicatedWarning
-from cognite.neat.rules.analysis import InformationAnalysis
-from cognite.neat.rules.models.data_types import DataType
-from cognite.neat.rules.models.entities import ClassEntity, EntityTypes
-from cognite.neat.rules.models.information import (
+from cognite.neat._issues.warnings import PropertyDefinitionDuplicatedWarning
+from cognite.neat._rules._constants import EntityTypes
+from cognite.neat._rules.analysis import InformationAnalysis
+from cognite.neat._rules.models.data_types import DataType
+from cognite.neat._rules.models.entities import ClassEntity
+from cognite.neat._rules.models.information import (
     InformationClass,
     InformationMetadata,
     InformationProperty,
     InformationRules,
 )
-from cognite.neat.utils.rdf_ import remove_namespace_from_uri
+from cognite.neat._utils.rdf_ import remove_namespace_from_uri
 
 from ._base import BaseExporter
 from ._validation import duplicated_properties

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

@@ -5,7 +5,7 @@ from typing import Literal, get_args
 
 import yaml
 
-from cognite.neat.rules._shared import VerifiedRules
+from cognite.neat._rules._shared import VerifiedRules
 
 from ._base import BaseExporter
 
@@ -16,8 +16,6 @@ class YAMLExporter(BaseExporter[VerifiedRules, str]):
     Args:
         files: The number of files to output. Defaults to "single".
         output: The format to output the rules. Defaults to "yaml".
-        output_role: The role to output the rules for. Defaults to None, which means that the role
-            of the input rules will be used.
 
     The following formats are available:
 

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

@@ -1,8 +1,8 @@
 from collections import defaultdict
 from collections.abc import Iterable
 
-from cognite.neat.rules.models.entities import ClassEntity
-from cognite.neat.rules.models.information import InformationProperty
+from cognite.neat._rules.models.entities import ClassEntity
+from cognite.neat._rules.models.information import InformationProperty
 
 
 def duplicated_properties(

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

@@ -8,9 +8,9 @@ from typing import Any, Generic, Literal
 from pydantic import ValidationError
 from rdflib import Namespace
 
-from cognite.neat.issues import IssueList, NeatError, NeatWarning
-from cognite.neat.rules._shared import ReadRules, T_InputRules
-from cognite.neat.utils.auxiliary import class_html_doc
+from cognite.neat._issues import IssueList, NeatError, NeatWarning
+from cognite.neat._rules._shared import ReadRules, T_InputRules
+from cognite.neat._utils.auxiliary import class_html_doc
 
 
 class BaseImporter(ABC, Generic[T_InputRules]):

cognite/neat/{rules → _rules}/importers/_dms2rules.py

@@ -19,24 +19,24 @@ from cognite.client.data_classes.data_modeling.views import (
 )
 from cognite.client.utils import ms_to_datetime
 
-from cognite.neat.issues import IssueList, NeatIssue
-from cognite.neat.issues.errors import FileTypeUnexpectedError, ResourceMissingIdentifierError, ResourceRetrievalError
-from cognite.neat.issues.warnings import (
+from cognite.neat._issues import IssueList, NeatIssue
+from cognite.neat._issues.errors import FileTypeUnexpectedError, ResourceMissingIdentifierError, ResourceRetrievalError
+from cognite.neat._issues.warnings import (
     PropertyNotFoundWarning,
     PropertyTypeNotSupportedWarning,
     ResourceNotFoundWarning,
     ResourcesDuplicatedWarning,
 )
-from cognite.neat.rules._shared import ReadRules
-from cognite.neat.rules.importers._base import BaseImporter, _handle_issues
-from cognite.neat.rules.models import (
+from cognite.neat._rules._shared import ReadRules
+from cognite.neat._rules.importers._base import BaseImporter, _handle_issues
+from cognite.neat._rules.models import (
     DataModelType,
     DMSInputRules,
     DMSSchema,
     SchemaCompleteness,
 )
-from cognite.neat.rules.models.data_types import DataType, Enum
-from cognite.neat.rules.models.dms import (
+from cognite.neat._rules.models.data_types import DataType, Enum
+from cognite.neat._rules.models.dms import (
     DMSInputContainer,
     DMSInputEnum,
     DMSInputMetadata,
@@ -44,7 +44,7 @@ from cognite.neat.rules.models.dms import (
     DMSInputProperty,
     DMSInputView,
 )
-from cognite.neat.rules.models.entities import (
+from cognite.neat._rules.models.entities import (
     ClassEntity,
     ContainerEntity,
     DMSNodeEntity,

cognite/neat/{rules → _rules}/importers/_dtdl2rules/dtdl_converter.py

@@ -1,14 +1,14 @@
 from collections import Counter
 from collections.abc import Callable, Sequence
 
-from cognite.neat.issues import IssueList
-from cognite.neat.issues.errors import (
+from cognite.neat._issues import IssueList
+from cognite.neat._issues.errors import (
     PropertyTypeNotSupportedError,
     ResourceMissingIdentifierError,
     ResourceNotFoundError,
 )
-from cognite.neat.issues.warnings import PropertyTypeNotSupportedWarning, ResourceTypeNotSupportedWarning
-from cognite.neat.rules.importers._dtdl2rules.spec import (
+from cognite.neat._issues.warnings import PropertyTypeNotSupportedWarning, ResourceTypeNotSupportedWarning
+from cognite.neat._rules.importers._dtdl2rules.spec import (
     DTMI,
     Command,
     CommandV2,
@@ -25,9 +25,9 @@ from cognite.neat.rules.importers._dtdl2rules.spec import (
     Telemetry,
     TelemetryV2,
 )
-from cognite.neat.rules.models.data_types import _DATA_TYPE_BY_NAME, DataType, Json, String
-from cognite.neat.rules.models.entities import ClassEntity
-from cognite.neat.rules.models.information import (
+from cognite.neat._rules.models.data_types import _DATA_TYPE_BY_NAME, DataType, Json, String
+from cognite.neat._rules.models.entities import ClassEntity
+from cognite.neat._rules.models.information import (
     InformationInputClass,
     InformationInputProperty,
 )

cognite/neat/{rules → _rules}/importers/_dtdl2rules/dtdl_importer.py

@@ -5,21 +5,21 @@ from pathlib import Path
 
 from pydantic import ValidationError
 
-from cognite.neat.issues import IssueList, NeatIssue
-from cognite.neat.issues.warnings import (
+from cognite.neat._issues import IssueList, NeatIssue
+from cognite.neat._issues.warnings import (
     FileItemNotSupportedWarning,
     FileMissingRequiredFieldWarning,
     FileReadWarning,
     FileTypeUnexpectedWarning,
     NeatValueWarning,
 )
-from cognite.neat.rules._shared import ReadRules
-from cognite.neat.rules.importers._base import BaseImporter
-from cognite.neat.rules.importers._dtdl2rules.dtdl_converter import _DTDLConverter
-from cognite.neat.rules.importers._dtdl2rules.spec import DTDL_CLS_BY_TYPE_BY_SPEC, DTDLBase, Interface
-from cognite.neat.rules.models import InformationInputRules, SchemaCompleteness
-from cognite.neat.rules.models.information import InformationInputMetadata
-from cognite.neat.utils.text import humanize_collection, to_pascal
+from cognite.neat._rules._shared import ReadRules
+from cognite.neat._rules.importers._base import BaseImporter
+from cognite.neat._rules.importers._dtdl2rules.dtdl_converter import _DTDLConverter
+from cognite.neat._rules.importers._dtdl2rules.spec import DTDL_CLS_BY_TYPE_BY_SPEC, DTDLBase, Interface
+from cognite.neat._rules.models import InformationInputRules, SchemaCompleteness
+from cognite.neat._rules.models.information import InformationInputMetadata
+from cognite.neat._utils.text import humanize_collection, to_pascal
 
 
 class DTDLImporter(BaseImporter[InformationInputRules]):

cognite/neat/{rules → _rules}/importers/_dtdl2rules/spec.py

@@ -15,7 +15,7 @@ from typing import TYPE_CHECKING, Any, ClassVar, Literal, TypeAlias
 from pydantic import BaseModel, Field, field_validator, model_serializer, model_validator
 from pydantic.fields import FieldInfo
 
-from cognite.neat.rules.models.entities import ClassEntity
+from cognite.neat._rules.models.entities import ClassEntity
 
 if TYPE_CHECKING:
     from pydantic.type_adapter import IncEx

cognite/neat/_rules/importers/_rdf/_base.py

@@ -0,0 +1,144 @@
+from pathlib import Path
+
+from rdflib import DC, DCTERMS, OWL, RDF, RDFS, SH, SKOS, XSD, Graph, Namespace, URIRef
+
+from cognite.neat._issues import IssueList
+from cognite.neat._issues.errors import FileReadError
+from cognite.neat._rules._shared import ReadRules
+from cognite.neat._rules.importers._base import BaseImporter
+from cognite.neat._rules.models.data_types import AnyURI
+from cognite.neat._rules.models.entities import UnknownEntity
+from cognite.neat._rules.models.information import (
+    InformationInputRules,
+)
+from cognite.neat._store import NeatGraphStore
+from cognite.neat._utils.rdf_ import get_namespace, uri_to_short_form
+
+DEFAULT_NON_EXISTING_NODE_TYPE = AnyURI()
+
+
+class BaseRDFImporter(BaseImporter[InformationInputRules]):
+    """Baser RDF importers used for all rules importers that are using RDF as input.
+
+    Args:
+        issue_list: Issue list to store issues
+        graph: Knowledge graph
+        prefix: Prefix to be used for the imported rules
+    """
+
+    def __init__(
+        self,
+        issue_list: IssueList,
+        graph: Graph,
+        prefix: str,
+        max_number_of_instance: int,
+        non_existing_node_type: UnknownEntity | AnyURI,
+    ) -> None:
+        self.issue_list = issue_list
+        self.graph = graph
+        self.prefix = prefix
+        self.max_number_of_instance = max_number_of_instance
+        self.non_existing_node_type = non_existing_node_type
+
+    @classmethod
+    def from_graph_store(
+        cls,
+        store: NeatGraphStore,
+        prefix: str = "neat",
+        max_number_of_instance: int = -1,
+        non_existing_node_type: UnknownEntity | AnyURI = DEFAULT_NON_EXISTING_NODE_TYPE,
+    ):
+        return cls(
+            IssueList(title=f"{cls.__name__} issues"),
+            store.graph,
+            prefix=prefix,
+            max_number_of_instance=max_number_of_instance,
+            non_existing_node_type=non_existing_node_type,
+        )
+
+    @classmethod
+    def from_file(
+        cls,
+        filepath: Path,
+        prefix: str = "neat",
+        max_number_of_instance: int = -1,
+        non_existing_node_type: UnknownEntity | AnyURI = DEFAULT_NON_EXISTING_NODE_TYPE,
+    ):
+        issue_list = IssueList(title=f"{cls.__name__} issues")
+
+        graph = Graph()
+        try:
+            graph.parse(filepath)
+        except Exception as e:
+            issue_list.append(FileReadError(filepath, str(e)))
+
+        # bind key namespaces
+        graph.bind("owl", OWL)
+        graph.bind("rdf", RDF)
+        graph.bind("rdfs", RDFS)
+        graph.bind("dcterms", DCTERMS)
+        graph.bind("dc", DC)
+        graph.bind("skos", SKOS)
+        graph.bind("sh", SH)
+        graph.bind("xsd", XSD)
+        graph.bind("imf", "http://ns.imfid.org/imf#")
+
+        return cls(
+            issue_list,
+            graph,
+            prefix=prefix,
+            max_number_of_instance=max_number_of_instance,
+            non_existing_node_type=non_existing_node_type,
+        )
+
+    def to_rules(
+        self,
+    ) -> ReadRules[InformationInputRules]:
+        """
+        Creates `Rules` object from the data for target role.
+        """
+
+        if self.issue_list.has_errors:
+            # In case there were errors during the import, the to_rules method will return None
+            return ReadRules(None, self.issue_list, {})
+
+        rules_dict = self._to_rules_components()
+
+        rules = InformationInputRules.load(rules_dict)
+
+        self._add_transformation(rules)
+
+        return ReadRules(rules, self.issue_list, {})
+
+    def _to_rules_components(self) -> dict:
+        raise NotImplementedError()
+
+    @classmethod
+    def _add_transformation(cls, rules: InformationInputRules) -> None:
+        rules.prefixes = {}
+
+        rules.prefixes[rules.metadata.prefix] = Namespace(rules.metadata.namespace)
+
+        class_ref_dict = {}
+        for class_ in rules.classes:
+            if class_.reference:
+                cls._add_uri_namespace_to_prefixes(URIRef(class_.reference), rules.prefixes)
+                class_ref_dict[class_.class_] = f"{uri_to_short_form(URIRef(class_.reference), rules.prefixes)}"
+
+        for property_ in rules.properties:
+            if property_.reference:
+                cls._add_uri_namespace_to_prefixes(URIRef(property_.reference), rules.prefixes)
+                if class_id := class_ref_dict.get(property_.class_, None):
+                    property_id = f"{uri_to_short_form(URIRef(property_.reference), rules.prefixes)}"
+                    property_.transformation = f"{class_id}({property_id})"
+
+    @classmethod
+    def _add_uri_namespace_to_prefixes(cls, URI: URIRef, prefixes: dict[str, Namespace]):
+        """Add URI to prefixes dict if not already present
+
+        Args:
+            URI: URI from which namespace is being extracted
+            prefixes: Dict of prefixes and namespaces
+        """
+        if Namespace(get_namespace(URI)) not in prefixes.values():
+            prefixes[f"prefix-{len(prefixes)+1}"] = Namespace(get_namespace(URI))

cognite/neat/{rules → _rules}/importers/_rdf/_imf2rules/_imf2classes.py

@@ -2,7 +2,7 @@ from typing import cast
 
 from rdflib import Graph
 
-from cognite.neat.rules.importers._rdf._shared import (
+from cognite.neat._rules.importers._rdf._shared import (
     clean_up_classes,
     make_classes_compliant,
     parse_raw_classes_dataframe,

cognite/neat/{rules → _rules}/importers/_rdf/_imf2rules/_imf2metadata.py

@@ -1,10 +1,10 @@
 from rdflib import Namespace
 
-from cognite.neat.rules.importers._rdf._shared import make_metadata_compliant
-from cognite.neat.rules.models import RoleTypes, SchemaCompleteness
+from cognite.neat._rules.importers._rdf._shared import make_metadata_compliant
+from cognite.neat._rules.models import RoleTypes, SchemaCompleteness
 
 
-def parse_imf_metadata() -> dict:
+def parse_imf_metadata(prefix: str = "pcaimf") -> dict:
     """Provide hardcoded IMF metadata to dict.
 
     Returns:
@@ -19,7 +19,7 @@ def parse_imf_metadata() -> dict:
     raw_metadata = {
         "role": RoleTypes.information,
         "schema": SchemaCompleteness.partial,
-        "prefix": "pcaimf",
+        "prefix": prefix,
         "namespace": Namespace("https://posccaesar.org/imf/"),
         "version": None,
         "created": None,

cognite/neat/{rules → _rules}/importers/_rdf/_imf2rules/_imf2properties.py

@@ -2,7 +2,7 @@ from typing import cast
 
 from rdflib import Graph
 
-from cognite.neat.rules.importers._rdf._shared import (
+from cognite.neat._rules.importers._rdf._shared import (
     clean_up_properties,
     make_properties_compliant,
     parse_raw_properties_dataframe,
@@ -76,6 +76,7 @@ def parse_imf_to_properties(graph: Graph, language: str = "en") -> list[dict]:
         BIND(REPLACE(?tempClassSegment, "-", "_") AS ?classSegment)
         BIND(IF(CONTAINS(?classString, "imf/"), CONCAT("IMF_", ?classSegment) , ?classSegment) AS ?class)
 
+
         # Finding the last segment of the property IRI
         BIND(STR(?imfProperty) AS ?propertyString)
         BIND(REPLACE(?propertyString, "^.*[/#]([^/#]*)$", "$1") AS ?tempPropertySegment)

cognite/neat/{rules → _rules}/importers/_rdf/_imf2rules/_imf2rules.py

@@ -1,23 +1,15 @@
 """This module performs importing of various formats to one of serializations for which
 there are loaders to TransformationRules pydantic class."""
 
-from pathlib import Path
-
-from rdflib import DC, DCTERMS, OWL, RDF, RDFS, SH, SKOS, Graph
-
-from cognite.neat.issues import IssueList
-from cognite.neat.issues.errors import FileReadError
-from cognite.neat.rules._shared import ReadRules
-from cognite.neat.rules.importers._base import BaseImporter
-from cognite.neat.rules.models import InformationInputRules
-from cognite.neat.rules.models.data_types import _XSD_TYPES
+from cognite.neat._rules.importers._rdf._base import BaseRDFImporter
+from cognite.neat._rules.models.data_types import _XSD_TYPES
 
 from ._imf2classes import parse_imf_to_classes
 from ._imf2metadata import parse_imf_metadata
 from ._imf2properties import parse_imf_to_properties
 
 
-class IMFImporter(BaseImporter[InformationInputRules]):
+class IMFImporter(BaseRDFImporter):
     """Convert SHACL shapes to tables/ transformation rules / Excel file.
 
         Args:
@@ -36,39 +28,16 @@ class IMFImporter(BaseImporter[InformationInputRules]):
 
     """
 
-    def __init__(self, filepath: Path):
-        self.filepath = filepath
-
-    def to_rules(
+    def _to_rules_components(
         self,
-    ) -> ReadRules[InformationInputRules]:
-        graph = Graph()
-        try:
-            graph.parse(self.filepath)
-        except Exception as e:
-            return ReadRules(None, IssueList([FileReadError(self.filepath, f"Could not parse owl file: {e}")]), {})
-
-        # bind key namespaces
-        graph.bind("owl", OWL)
-        graph.bind("rdf", RDF)
-        graph.bind("rdfs", RDFS)
-        graph.bind("dcterms", DCTERMS)
-        graph.bind("dc", DC)
-        graph.bind("skos", SKOS)
-        graph.bind("sh", SH)
-        graph.bind("xsd", _XSD_TYPES)
-        graph.bind("imf", "http://ns.imfid.org/imf#")
-
+    ) -> dict:
         components = {
             "Metadata": parse_imf_metadata(),
-            "Classes": parse_imf_to_classes(graph),
-            "Properties": parse_imf_to_properties(graph),
+            "Classes": parse_imf_to_classes(self.graph),
+            "Properties": parse_imf_to_properties(self.graph),
         }
 
-        components = make_components_compliant(components)
-
-        rules = InformationInputRules.load(components)
-        return ReadRules(rules, IssueList(), {})
+        return make_components_compliant(components)
 
 
 def make_components_compliant(components: dict) -> dict: