cognite-neat 0.102.0__py3-none-any.whl → 0.103.1__py3-none-any.whl

cognite/neat/_session/_read.py

@@ -1,7 +1,7 @@
 import tempfile
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Any, Literal
+from typing import Any, Literal, cast
 
 from cognite.client.data_classes.data_modeling import DataModelId, DataModelIdentifier
 
@@ -11,7 +11,7 @@ from cognite.neat._graph import examples as instances_examples
 from cognite.neat._graph import extractors
 from cognite.neat._issues import IssueList
 from cognite.neat._issues.errors import NeatValueError
-from cognite.neat._rules import importers
+from cognite.neat._rules import catalog, importers
 from cognite.neat._rules._shared import ReadRules
 from cognite.neat._rules.importers import BaseImporter
 from cognite.neat._store._provenance import Activity as ProvenanceActivity
@@ -27,6 +27,8 @@ from .exceptions import NeatSessionError, session_class_wrapper
 
 @session_class_wrapper
 class ReadAPI:
+    """Read from a data source into NeatSession graph store."""
+
     def __init__(self, state: SessionState, client: NeatClient | None, verbose: bool) -> None:
         self._state = state
         self._verbose = verbose
@@ -68,6 +70,11 @@ class BaseReadAPI:
 
 @session_class_wrapper
 class CDFReadAPI(BaseReadAPI):
+    """Reads from CDF Data Models.
+    Use the `.data_model()` method to load a CDF Data Model to the knowledge graph.
+
+    """
+
     def __init__(self, state: SessionState, client: NeatClient | None, verbose: bool) -> None:
         super().__init__(state, client, verbose)
         self.classic = CDFClassicAPI(state, client, verbose)
@@ -79,6 +86,18 @@ class CDFReadAPI(BaseReadAPI):
         return self._client
 
     def data_model(self, data_model_id: DataModelIdentifier) -> IssueList:
+        """Reads a Data Model from CDF to the knowledge graph.
+
+        Args:
+            data_model_id: Tuple of strings with the id of a CDF Data Model.
+            Notation as follows (<name_of_space>, <name_of_data_model>, <data_model_version>)
+
+        Example:
+            ```python
+            neat.read.cdf.data_model(("example_data_model_space", "EXAMPLE_DATA_MODEL", "v1"))
+            ```
+        """
+
         data_model_id = DataModelId.load(data_model_id)
 
         if not data_model_id.version:
@@ -113,6 +132,11 @@ class CDFReadAPI(BaseReadAPI):
 
 @session_class_wrapper
 class CDFClassicAPI(BaseReadAPI):
+    """Reads from the Classic Data Model from CDF.
+    Use the `.graph()` method to load CDF core resources to the knowledge graph.
+
+    """
+
     @property
     def _get_client(self) -> NeatClient:
         if self._client is None:
@@ -124,12 +148,12 @@ class CDFClassicAPI(BaseReadAPI):
 
         The Classic Graph consists of the following core resource type.
 
-        Classic Node CDF Resources:
-         - Assets
-         - TimeSeries
-         - Sequences
-         - Events
-         - Files
+        !!! note "Classic Node CDF Resources"
+             - Assets
+             - TimeSeries
+             - Sequences
+             - Events
+             - Files
 
         All the classic node CDF resources can have one or more connections to one or more assets. This
         will match a direct relationship in the data modeling of CDF.
@@ -144,13 +168,12 @@ class CDFClassicAPI(BaseReadAPI):
         This extractor will extract the classic CDF graph into Neat starting from either a data set or a root asset.
 
         It works as follows:
-
-        1. Extract all core nodes (assets, time series, sequences, events, files) filtered by the given data set or
-           root asset.
-        2. Extract all relationships starting from any of the extracted core nodes.
-        3. Extract all core nodes that are targets of the relationships that are not already extracted.
-        4. Extract all labels that are connected to the extracted core nodes/relationships.
-        5. Extract all data sets that are connected to the extracted core nodes/relationships.
+            1. Extract all core nodes (assets, time series, sequences, events, files) filtered by the given data set or
+               root asset.
+            2. Extract all relationships starting from any of the extracted core nodes.
+            3. Extract all core nodes that are targets of the relationships that are not already extracted.
+            4. Extract all labels that are connected to the extracted core nodes/relationships.
+            5. Extract all data sets that are connected to the extracted core nodes/relationships.
 
         Args:
             root_asset_external_id: The external id of the root asset
@@ -168,7 +191,29 @@ class CDFClassicAPI(BaseReadAPI):
 
 @session_class_wrapper
 class ExcelReadAPI(BaseReadAPI):
+    """Reads a Neat Excel Rules sheet to the graph store. The rules sheet may stem from an Information architect,
+    or a DMS Architect.
+
+    Args:
+        io: file path to the Excel sheet
+
+    Example:
+        ```python
+        neat.read.excel("information_or_dms_rules_sheet.xlsx")
+        ```
+    """
+
+    def __init__(self, state: SessionState, client: NeatClient | None, verbose: bool) -> None:
+        super().__init__(state, client, verbose)
+        self.examples = ExcelExampleAPI(state, client, verbose)
+
     def __call__(self, io: Any) -> IssueList:
+        """Reads a Neat Excel Rules sheet to the graph store. The rules sheet may stem from an Information architect,
+        or a DMS Architect.
+
+        Args:
+            io: file path to the Excel sheet
+        """
         reader = NeatReader.create(io)
         start = datetime.now(timezone.utc)
         if not isinstance(reader, PathReader):
@@ -190,8 +235,45 @@ class ExcelReadAPI(BaseReadAPI):
         return input_rules.issues
 
 
+@session_class_wrapper
+class ExcelExampleAPI(BaseReadAPI):
+    """Used as example for reading some data model into the NeatSession."""
+
+    @property
+    def pump_example(self) -> IssueList:
+        """Reads the Nordic 44 knowledge graph into the NeatSession graph store."""
+        start = datetime.now(timezone.utc)
+        importer: importers.ExcelImporter = importers.ExcelImporter(catalog.hello_world_pump)
+        input_rules: ReadRules = importer.to_rules()
+        end = datetime.now(timezone.utc)
+
+        if input_rules.rules:
+            change = Change.from_rules_activity(
+                input_rules,
+                importer.agent,
+                start,
+                end,
+                description="Pump Example read as unverified data model",
+            )
+            self._store_rules(input_rules, change)
+        self._state.data_model.issue_lists.append(input_rules.issues)
+        return input_rules.issues
+
+
 @session_class_wrapper
 class YamlReadAPI(BaseReadAPI):
+    """Reads a yaml with either neat rules, or several toolkit yaml files to import Data Model(s) into NeatSession.
+
+    Args:
+        io: file path to the Yaml file in the case of "neat" yaml, or path to a zip folder or directory with several
+        Yaml files in the case of "toolkit".
+
+    Example:
+        ```python
+        neat.read.yaml("path_to_toolkit_yamls")
+        ```
+    """
+
     def __call__(self, io: Any, format: Literal["neat", "toolkit"] = "neat") -> IssueList:
         reader = NeatReader.create(io)
         if not isinstance(reader, PathReader):
@@ -242,6 +324,23 @@ class YamlReadAPI(BaseReadAPI):
 
 @session_class_wrapper
 class CSVReadAPI(BaseReadAPI):
+    """Reads a csv that contains a column to use as primary key which will be the unique identifier for the type of
+    data you want to read in. Ex. a csv can hold information about assets, and their identifiers are specified in
+    a "ASSET_TAG" column.
+
+    Args:
+        io: file path or url to the csv
+        type: string that specifies what type of data the csv contains. For instance "Asset" or "Equipment"
+        primary_key: string name of the column that should be used as the unique identifier for each row of data
+
+    Example:
+        ```python
+        type_described_in_table = "Turbine"
+        column_with_identifier = "UNIQUE_TAG_NAME"
+        neat.read.csv("url_or_path_to_csv_file", type=type_described_in_table, primary_key=column_with_identifier)
+        ```
+    """
+
     def __call__(self, io: Any, type: str, primary_key: str) -> None:
         reader = NeatReader.create(io)
         if isinstance(reader, HttpFileReader):
@@ -263,6 +362,13 @@ class CSVReadAPI(BaseReadAPI):
 
 @session_class_wrapper
 class XMLReadAPI(BaseReadAPI):
+    """Reads an XML file that is either of DEXPI or AML format.
+
+    Args:
+        io: file path or url to the XML
+        format: can be either "dexpi" or "aml" are the currenly supported XML source types.
+    """
+
     def __call__(
         self,
         io: Any,
@@ -289,6 +395,16 @@ class XMLReadAPI(BaseReadAPI):
             raise NeatValueError("Only support XML files of DEXPI format at the moment.")
 
     def dexpi(self, path):
+        """Reads a DEXPI file into the NeatSession.
+
+        Args:
+            io: file path or url to the DEXPI file
+
+        Example:
+            ```python
+            neat.read.xml.dexpi("url_or_path_to_dexpi_file")
+            ```
+        """
         engine = import_engine()
         engine.set.format = "dexpi"
         engine.set.file = path
@@ -296,6 +412,16 @@ class XMLReadAPI(BaseReadAPI):
         self._state.instances.store.write(extractor)
 
     def aml(self, path):
+        """Reads an AML file into NeatSession.
+
+        Args:
+            io: file path or url to the AML file
+
+        Example:
+            ```python
+            neat.read.xml.aml("url_or_path_to_aml_file")
+            ```
+        """
         engine = import_engine()
         engine.set.format = "aml"
         engine.set.file = path
@@ -305,11 +431,27 @@ class XMLReadAPI(BaseReadAPI):
 
 @session_class_wrapper
 class RDFReadAPI(BaseReadAPI):
+    """Reads an RDF source into NeatSession. Supported sources are "ontology" or "imf".
+
+    Args:
+        io: file path or url to the RDF source
+    """
+
     def __init__(self, state: SessionState, client: NeatClient | None, verbose: bool) -> None:
         super().__init__(state, client, verbose)
         self.examples = RDFExamples(state)
 
     def ontology(self, io: Any) -> IssueList:
+        """Reads an OWL ontology source into NeatSession.
+
+        Args:
+            io: file path or url to the OWL file
+
+        Example:
+            ```python
+            neat.read.rdf.ontology("url_or_path_to_owl_source")
+            ```
+        """
         start = datetime.now(timezone.utc)
         reader = NeatReader.create(io)
         if not isinstance(reader, PathReader):
@@ -331,6 +473,16 @@ class RDFReadAPI(BaseReadAPI):
         return input_rules.issues
 
     def imf(self, io: Any) -> IssueList:
+        """Reads IMF Types provided as SHACL shapes into NeatSession.
+
+        Args:
+            io: file path or url to the IMF file
+
+        Example:
+            ```python
+            neat.read.rdf.imf("url_or_path_to_imf_source")
+            ```
+        """
         start = datetime.now(timezone.utc)
         reader = NeatReader.create(io)
         if not isinstance(reader, PathReader):
@@ -360,16 +512,20 @@ class RDFReadAPI(BaseReadAPI):
         if type is None:
             type = object_wizard()
 
-        if type.lower() == "Data Model".lower():
+        type = type.lower()
+
+        if type == "data model":
             source = source or rdf_dm_wizard("What type of data model is the RDF?")
-            if source == "Ontology":
+            source = cast(str, source).lower()  # type: ignore
+
+            if source == "ontology":
                 return self.ontology(io)
-            elif source == "IMF":
+            elif source == "imf types":
                 return self.imf(io)
             else:
-                raise ValueError(f"Expected ontology, imf or instances, got {source}")
+                raise ValueError(f"Expected ontology, imf types or instances, got {source}")
 
-        elif type.lower() == "Instances".lower():
+        elif type == "instances":
             reader = NeatReader.create(io)
             if not isinstance(reader, PathReader):
                 raise NeatValueError("Only file paths are supported for RDF files")
@@ -380,11 +536,15 @@ class RDFReadAPI(BaseReadAPI):
             raise NeatSessionError(f"Expected data model or instances, got {type}")
 
 
+@session_class_wrapper
 class RDFExamples:
+    """Used as example for reading some triples into the NeatSession knowledge grapgh."""
+
     def __init__(self, state: SessionState) -> None:
         self._state = state
 
     @property
     def nordic44(self) -> IssueList:
+        """Reads the Nordic 44 knowledge graph into the NeatSession graph store."""
         self._state.instances.store.write(extractors.RdfFileExtractor(instances_examples.nordic44_knowledge_graph))
         return IssueList()

cognite/neat/_session/_set.py

@@ -12,12 +12,22 @@ from .exceptions import NeatSessionError, session_class_wrapper
 
 @session_class_wrapper
 class SetAPI:
+    """Used to change the name of the data model from a data model id defined by neat to a user specified name."""
+
     def __init__(self, state: SessionState, verbose: bool) -> None:
         self._state = state
         self._verbose = verbose
 
     def data_model_id(self, new_model_id: dm.DataModelId | tuple[str, str, str]) -> None:
-        """Sets the data model ID of the latest verified data model."""
+        """Sets the data model ID of the latest verified data model. Set the data model id as a tuple of strings
+        following the template (<data_model_space>, <data_model_name>, <data_model_version>).
+
+        Example:
+            Set a new data model id:
+            ```python
+            neat.set.data_model_id(("my_data_model_space", "My_Data_Model", "v1"))
+            ```
+        """
         if res := self._state.data_model.last_verified_dms_rules:
             source_id, rules = res
 

cognite/neat/_session/_show.py

@@ -13,6 +13,7 @@ from cognite.neat._rules.models.dms._rules import DMSRules
 from cognite.neat._rules.models.entities._single_value import ClassEntity, ViewEntity
 from cognite.neat._rules.models.information._rules import InformationRules
 from cognite.neat._session.exceptions import NeatSessionError
+from cognite.neat._utils.io_ import to_directory_compatible
 from cognite.neat._utils.rdf_ import remove_namespace_from_uri
 
 from ._state import SessionState
@@ -21,6 +22,30 @@ from .exceptions import session_class_wrapper
 
 @session_class_wrapper
 class ShowAPI:
+    """Visualise a verified data model or instances contained in the graph store.
+    See, for example, `.data_model()` or `.instances()` for more.
+
+    Example:
+        Show instances
+        ```python
+        from cognite.neat import NeatSession
+        from cognite.neat import get_cognite_client
+
+        client = get_cognite_client(env_file_path=".env")
+        neat = NeatSession(client, storage="oxigraph") # Storage optimised for storage visualisation
+
+        # .... intermediate steps of reading, infering verifying and converting a data model and instances
+
+        neat.show.instances()
+        ```
+
+    Example:
+        Show data model
+        ```python
+        neat.show.data_model()
+        ```
+    """
+
     def __init__(self, state: SessionState) -> None:
         self._state = state
         self.data_model = ShowDataModelAPI(self._state)
@@ -65,6 +90,8 @@ class ShowBaseAPI:
 
 @session_class_wrapper
 class ShowDataModelAPI(ShowBaseAPI):
+    """Visualises the verified data model."""
+
     def __init__(self, state: SessionState) -> None:
         super().__init__(state)
         self._state = state
@@ -80,16 +107,16 @@ class ShowDataModelAPI(ShowBaseAPI):
         rules = self._state.data_model.last_verified_rule[1]
 
         if isinstance(rules, DMSRules):
-            di_graph = self._generate_dms_di_graph(self._state.data_model.last_verified_dms_rules[1])
-            name = "dms_data_model.html"
+            di_graph = self._generate_dms_di_graph(rules)
         elif isinstance(rules, InformationRules):
-            di_graph = self._generate_info_di_graph(self._state.data_model.last_verified_information_rules[1])
-            name = "information_data_model.html"
+            di_graph = self._generate_info_di_graph(rules)
         else:
             # This should never happen, but we need to handle it to satisfy mypy
             raise NeatSessionError(
                 f"Unsupported type {type(rules) }. Make sure you have either information or DMS rules."
             )
+        identifier = to_directory_compatible(str(rules.metadata.identifier))
+        name = f"{identifier}.html"
 
         return self._generate_visualization(di_graph, name)
 
@@ -97,9 +124,18 @@ class ShowDataModelAPI(ShowBaseAPI):
         """Generate a DiGraph from the last verified DMS rules."""
         di_graph = nx.DiGraph()
 
+        # Views with properties or used as ValueType
+        # If a view is not used in properties or as ValueType, it is not added to the graph
+        # as we typically do not have the properties for it.
+        used_views = {prop_.view for prop_ in rules.properties} | {
+            prop_.value_type for prop_ in rules.properties if isinstance(prop_.value_type, ViewEntity)
+        }
+
         # Add nodes and edges from Views sheet
         for view in rules.views:
-            # if possible use human readable label coming from the view name
+            if view.view not in used_views:
+                continue
+            # if possible use humanreadable label coming from the view name
             if not di_graph.has_node(view.view.suffix):
                 di_graph.add_node(view.view.suffix, label=view.view.suffix)
 
@@ -123,7 +159,7 @@ class ShowDataModelAPI(ShowBaseAPI):
 
         # Add nodes and edges from Views sheet
         for class_ in rules.classes:
-            # if possible use human readable label coming from the view name
+            # if possible use humanreadable label coming from the view name
             if not di_graph.has_node(class_.class_.suffix):
                 di_graph.add_node(
                     class_.class_.suffix,
@@ -160,17 +196,16 @@ class ShowDataModelImplementsAPI(ShowBaseAPI):
         rules = self._state.data_model.last_verified_rule[1]
 
         if isinstance(rules, DMSRules):
-            di_graph = self._generate_dms_di_graph(self._state.data_model.last_verified_dms_rules[1])
-            name = "dms_data_model_implements.html"
+            di_graph = self._generate_dms_di_graph(rules)
         elif isinstance(rules, InformationRules):
-            di_graph = self._generate_info_di_graph(self._state.data_model.last_verified_information_rules[1])
-            name = "information_data_model_implements.html"
+            di_graph = self._generate_info_di_graph(rules)
         else:
             # This should never happen, but we need to handle it to satisfy mypy
             raise NeatSessionError(
                 f"Unsupported type {type(rules) }. Make sure you have either information or DMS rules."
             )
-
+        identifier = to_directory_compatible(str(rules.metadata.identifier))
+        name = f"{identifier}_implements.html"
         return self._generate_visualization(di_graph, name)
 
     def _generate_dms_di_graph(self, rules: DMSRules) -> nx.DiGraph:
@@ -228,6 +263,8 @@ class ShowDataModelImplementsAPI(ShowBaseAPI):
 
 @session_class_wrapper
 class ShowDataModelProvenanceAPI(ShowBaseAPI):
+    """Visualises the provenance or steps that have been executed in the NeatSession."""
+
     def __init__(self, state: SessionState) -> None:
         super().__init__(state)
         self._state = state
@@ -288,6 +325,8 @@ class ShowDataModelProvenanceAPI(ShowBaseAPI):
 
 @session_class_wrapper
 class ShowInstanceAPI(ShowBaseAPI):
+    """Visualise the instances contained in the graph store."""
+
     def __init__(self, state: SessionState) -> None:
         super().__init__(state)
         self._state = state

cognite/neat/_session/_to.py

@@ -19,6 +19,11 @@ from .exceptions import NeatSessionError, session_class_wrapper
 
 @session_class_wrapper
 class ToAPI:
+    """API used to write the contents of a NeatSession to a specified destination. For instance writing information
+    rules or DMS rules to a NEAT rules Excel spreadsheet, or writing a verified data model to CDF.
+
+    """
+
     def __init__(self, state: SessionState, client: NeatClient | None, verbose: bool) -> None:
         self._state = state
         self._verbose = verbose
@@ -34,8 +39,22 @@ class ToAPI:
         Args:
             io: The file path or file-like object to write the Excel file to.
             model: The format of the data model to export. Defaults to None.
+
+        Example:
+            Export information model to excel rules sheet
+            ```python
+            information_rules_file_name = "information_rules.xlsx"
+            neat.to.excel(information_rules_file_name, model="information")
+            ```
+
+        Example:
+            Export data model to excel rules sheet
+            ```python
+            dms_rules_file_name = "dms_rules.xlsx"
+            neat.to.excel(information_rules_file_name, model="dms")
+            ```
         """
-        exporter = exporters.ExcelExporter()
+        exporter = exporters.ExcelExporter(styling="maximal")
         rules: VerifiedRules
         if model == "information" or model == "logical":
             rules = self._state.data_model.last_verified_information_rules[1]
@@ -63,13 +82,33 @@ class ToAPI:
             format: The format of the YAML file. Defaults to "neat".
             skip_system_spaces: If True, system spaces will be skipped. Defaults to True.
 
-        ... note::
-
+        !!! note "YAML formats"
             - "neat": This is the format Neat uses to store the data model.
             - "toolkit": This is the format used by Cognite Toolkit, that matches the CDF API.
 
         Returns:
             str | None: If io is None, the YAML string will be returned. Otherwise, None will be returned.
+
+        Example:
+            Export to yaml file in the case of "neat" format
+            ```python
+            your_yaml_file_name = "neat_rules.yaml"
+            neat.to.yaml(your_yaml_file_name, format="neat")
+            ```
+
+        Example:
+            Export yaml files as a zip folder in the case of "toolkit" format
+            ```python
+            your_zip_folder_name = "toolkit_data_model_files.zip"
+            neat.to.yaml(your_zip_folder_name, format="toolkit")
+            ```
+
+        Example:
+            Export yaml files to a folder in the case of "toolkit" format
+            ```python
+            your_folder_name = "my_project/data_model_files"
+            neat.to.yaml(your_folder_name, format="toolkit")
+            ```
         """
         if format == "neat":
             exporter = exporters.YAMLExporter()
@@ -97,12 +136,21 @@ class ToAPI:
 
 @session_class_wrapper
 class CDFToAPI:
+    """Write a verified Data Model and Instances to CDF."""
+
     def __init__(self, state: SessionState, client: NeatClient | None, verbose: bool) -> None:
         self._client = client
         self._state = state
         self._verbose = verbose
 
     def instances(self, space: str | None = None) -> UploadResultList:
+        """Export the verified DMS instances to CDF.
+
+        Args:
+            space: Name of instance space to use. Default is to suffix the schema space with '_instances'.
+            Note this space is required to be different than the space with the data model.
+
+        """
         if not self._client:
             raise NeatSessionError("No CDF client provided!")
 
@@ -120,6 +168,7 @@ class CDFToAPI:
             self._state.data_model.last_verified_dms_rules[1],
             self._state.instances.store,
             instance_space=space,
+            client=self._client,
         )
         result = loader.load_into_cdf(self._client)
         self._state.instances.outcome.append(result)
@@ -144,13 +193,12 @@ class CDFToAPI:
                 Note this only applies to spaces and containers if they contain data.
             components: The components to export. If None, all components will be exported. Defaults to None.
 
-        ... note::
-
-        - "fail": If any component already exists, the export will fail.
-        - "skip": If any component already exists, it will be skipped.
-        - "update": If any component already exists, it will be updated.
-        - "force": If any component already exists, and the update fails, it will be deleted and recreated.
-        - "recreate": All components will be deleted and recreated. The exception is spaces, which will be updated.
+        !!! note "Data Model creation modes"
+            - "fail": If any component already exists, the export will fail.
+            - "skip": If any component already exists, it will be skipped.
+            - "update": If any component already exists, it will be updated.
+            - "force": If any component already exists, and the update fails, it will be deleted and recreated.
+            - "recreate": All components will be deleted and recreated. The exception is spaces, which will be updated.
 
         """
 

cognite/neat/_session/engine/__init__.py

@@ -1,4 +1,4 @@
 from ._import import import_engine
 from ._load import load_neat_engine
 
-__all__ = ["load_neat_engine", "import_engine"]
+__all__ = ["import_engine", "load_neat_engine"]

cognite/neat/_store/__init__.py

@@ -1,3 +1,4 @@
-from ._base import NeatGraphStore
+from ._graph_store import NeatGraphStore
+from ._rules_store import NeatRulesStore
 
-__all__ = ["NeatGraphStore"]
+__all__ = ["NeatGraphStore", "NeatRulesStore"]

cognite/neat/_store/{_base.py → _graph_store.py}

@@ -315,6 +315,39 @@ class NeatGraphStore:
 
         yield from self._read_via_class_entity(class_entity)
 
+    def count_of_id(self, neat_id: URIRef) -> int:
+        """Count the number of instances of a given type
+
+        Args:
+            neat_id: Type for which instances are to be counted
+
+        Returns:
+            Number of instances
+        """
+        if not self.rules:
+            warnings.warn("Rules not found in graph store!", stacklevel=2)
+            return 0
+
+        class_entity = next(
+            (definition.class_ for definition in self.rules.classes if definition.neatId == neat_id), None
+        )
+        if not class_entity:
+            warnings.warn("Desired type not found in graph!", stacklevel=2)
+            return 0
+
+        if not (class_uri := InformationAnalysis(self.rules).class_uri(class_entity)):
+            warnings.warn(
+                f"Class {class_entity.suffix} does not have namespace defined for prefix {class_entity.prefix} Rules!",
+                stacklevel=2,
+            )
+            return 0
+
+        return self.count_of_type(class_uri)
+
+    def count_of_type(self, class_uri: URIRef) -> int:
+        query = f"SELECT (COUNT(?instance) AS ?instanceCount) WHERE {{ ?instance a <{class_uri}> }}"
+        return int(next(iter(self.graph.query(query)))[0])  # type: ignore[arg-type, index]
+
     def _parse_file(
         self,
         filepath: Path,