cognite-neat 0.97.3__py3-none-any.whl → 0.99.0__py3-none-any.whl

cognite/neat/_session/_mapping.py

@@ -0,0 +1,39 @@
+from datetime import datetime, timezone
+
+from cognite.neat._rules.models.mapping import load_classic_to_core_mapping
+from cognite.neat._rules.transformers import RuleMapper
+from cognite.neat._store._provenance import Change
+
+from ._state import SessionState
+from .exceptions import session_class_wrapper
+
+
+@session_class_wrapper
+class MappingAPI:
+    def __init__(self, state: SessionState):
+        self._state = state
+
+    def classic_to_core(self, org_name: str) -> None:
+        """Map classic types to core types.
+
+        Note this automatically creates an extended CogniteCore model.
+
+        """
+        source_id, rules = self._state.data_model.last_verified_dms_rules
+
+        start = datetime.now(timezone.utc)
+        transformer = RuleMapper(load_classic_to_core_mapping(org_name, rules.metadata.space, rules.metadata.version))
+        output = transformer.transform(rules)
+        end = datetime.now(timezone.utc)
+
+        change = Change.from_rules_activity(
+            output,
+            transformer.agent,
+            start,
+            end,
+            "Mapping classic to core",
+            self._state.data_model.provenance.source_entity(source_id)
+            or self._state.data_model.provenance.target_entity(source_id),
+        )
+
+        self._state.data_model.write(output.rules, change)

cognite/neat/_session/_prepare.py

@@ -1,30 +1,48 @@
+import copy
 from collections.abc import Collection
 from datetime import datetime, timezone
-from typing import Literal
+from typing import Literal, cast
 
 from cognite.client.data_classes.data_modeling import DataModelIdentifier
 from rdflib import URIRef
 
+from cognite.neat._client import NeatClient
+from cognite.neat._constants import DEFAULT_NAMESPACE
+from cognite.neat._graph.transformers import RelationshipToSchemaTransformer
 from cognite.neat._graph.transformers._rdfpath import MakeConnectionOnExactMatch
-from cognite.neat._rules._shared import ReadRules
+from cognite.neat._rules._shared import InputRules, ReadRules
+from cognite.neat._rules.importers import DMSImporter
+from cognite.neat._rules.models import DMSRules
 from cognite.neat._rules.models.information._rules_input import InformationInputRules
-from cognite.neat._rules.transformers import ReduceCogniteModel, ToCompliantEntities, ToExtension
+from cognite.neat._rules.transformers import (
+    PrefixEntities,
+    ReduceCogniteModel,
+    ToCompliantEntities,
+    ToExtension,
+    VerifyDMSRules,
+)
+from cognite.neat._store._provenance import Agent as ProvenanceAgent
 from cognite.neat._store._provenance import Change
 
 from ._state import SessionState
-from .exceptions import NeatSessionError, intercept_session_exceptions
+from .exceptions import NeatSessionError, session_class_wrapper
 
+try:
+    from rich import print
+except ImportError:
+    ...
 
-@intercept_session_exceptions
+
+@session_class_wrapper
 class PrepareAPI:
-    def __init__(self, state: SessionState, verbose: bool) -> None:
+    def __init__(self, client: NeatClient | None, state: SessionState, verbose: bool) -> None:
         self._state = state
         self._verbose = verbose
-        self.data_model = DataModelPrepareAPI(state, verbose)
+        self.data_model = DataModelPrepareAPI(client, state, verbose)
         self.instances = InstancePrepareAPI(state, verbose)
 
 
-@intercept_session_exceptions
+@session_class_wrapper
 class InstancePrepareAPI:
     def __init__(self, state: SessionState, verbose: bool) -> None:
         self._state = state
@@ -94,34 +112,77 @@ class InstancePrepareAPI:
             raise NeatSessionError(f"Property {property_} is not defined for type {type_}. Cannot make connection")
         return type_uri[0], property_uri[0]
 
+    def relationships_as_connections(self, limit: int = 1) -> None:
+        """This assumes that you have read a classic CDF knowledge graph including relationships.
 
-@intercept_session_exceptions
+        This transformer analyzes the relationships in the graph and modifies them to be part of the schema
+        for Assets, Events, Files, Sequences, and TimeSeries. Relationships without any properties
+        are replaced by a simple relationship between the source and target nodes. Relationships with
+        properties are replaced by a schema that contains the properties as attributes.
+
+        Args:
+            limit: The minimum number of relationships that need to be present for it
+                to be converted into a schema. Default is 1.
+
+        """
+        transformer = RelationshipToSchemaTransformer(limit=limit)
+        self._state.instances.store.transform(transformer)
+
+
+@session_class_wrapper
 class DataModelPrepareAPI:
-    def __init__(self, state: SessionState, verbose: bool) -> None:
+    def __init__(self, client: NeatClient | None, state: SessionState, verbose: bool) -> None:
+        self._client = client
         self._state = state
         self._verbose = verbose
 
     def cdf_compliant_external_ids(self) -> None:
         """Convert data model component external ids to CDF compliant entities."""
-        if input := self._state.data_model.last_info_unverified_rule:
-            source_id, rules = input
+        source_id, rules = self._state.data_model.last_info_unverified_rule
+
+        start = datetime.now(timezone.utc)
+        transformer = ToCompliantEntities()
+        output: ReadRules[InformationInputRules] = transformer.transform(rules)
+        end = datetime.now(timezone.utc)
+
+        change = Change.from_rules_activity(
+            output,
+            transformer.agent,
+            start,
+            end,
+            "Converted external ids to CDF compliant entities",
+            self._state.data_model.provenance.source_entity(source_id)
+            or self._state.data_model.provenance.target_entity(source_id),
+        )
 
-            start = datetime.now(timezone.utc)
-            transformer = ToCompliantEntities()
-            output: ReadRules[InformationInputRules] = transformer.transform(rules)
-            end = datetime.now(timezone.utc)
+        self._state.data_model.write(output, change)
 
-            change = Change.from_rules_activity(
-                output,
-                transformer.agent,
-                start,
-                end,
-                "Converted external ids to CDF compliant entities",
-                self._state.data_model.provenance.source_entity(source_id)
-                or self._state.data_model.provenance.target_entity(source_id),
-            )
+    def prefix(self, prefix: str) -> None:
+        """Prefix all views in the data model with the given prefix.
 
-            self._state.data_model.write(output, change)
+        Args:
+            prefix: The prefix to add to the views in the data model.
+
+        """
+        source_id, rules = self._state.data_model.last_unverified_rule
+
+        start = datetime.now(timezone.utc)
+        transformer = PrefixEntities(prefix)
+        new_rules = cast(InputRules, copy.deepcopy(rules.get_rules()))
+        output = transformer.transform(new_rules)
+        end = datetime.now(timezone.utc)
+
+        change = Change.from_rules_activity(
+            output,
+            transformer.agent,
+            start,
+            end,
+            "Added prefix to the data model views",
+            self._state.data_model.provenance.source_entity(source_id)
+            or self._state.data_model.provenance.target_entity(source_id),
+        )
+
+        self._state.data_model.write(output, change)
 
     def to_enterprise(
         self,
@@ -185,7 +246,7 @@ class DataModelPrepareAPI:
         data_model_id: DataModelIdentifier,
         org_name: str = "My",
         mode: Literal["read", "write"] = "read",
-        dummy_property: str = "dummy",
+        dummy_property: str = "GUID",
     ) -> None:
         """Uses the current data model as a basis to create solution data model
 
@@ -235,6 +296,81 @@ class DataModelPrepareAPI:
 
             self._state.data_model.write(output.rules, change)
 
+    def to_data_product(
+        self,
+        data_model_id: DataModelIdentifier,
+        org_name: str = "",
+        include: Literal["same-space", "all"] = "same-space",
+    ) -> None:
+        """Uses the current data model as a basis to create data product data model.
+
+        A data product model is a data model that ONLY maps to containers and do not use implements. This is
+        typically used for defining the data in a data product.
+
+        Args:
+            data_model_id: The data product data model id that is being created.
+            org_name: Organization name to use for the views in the new data model.
+            include: The views to include in the data product data model. Can be either "same-space" or "all".
+                If you set same-space, only the views in the same space as the data model will be included.
+        """
+        source_id, rules = self._state.data_model.last_verified_dms_rules
+
+        dms_ref: DMSRules | None = None
+        view_ids, container_ids = rules.imported_views_and_containers_ids(include_model_views_with_no_properties=True)
+        if view_ids or container_ids:
+            if self._client is None:
+                raise NeatSessionError(
+                    "No client provided. You are referencing unknown views and containers in your data model, "
+                    "NEAT needs a client to lookup the definitions. "
+                    "Please set the client in the session, NeatSession(client=client)."
+                )
+            schema = self._client.schema.retrieve(list(view_ids), list(container_ids))
+
+            importer = DMSImporter(schema)
+            reference_rules = importer.to_rules().rules
+            if reference_rules is not None:
+                imported = VerifyDMSRules("continue").transform(reference_rules)
+                if dms_ref := imported.rules:
+                    rules = rules.model_copy(deep=True)
+                    if rules.containers is None:
+                        rules.containers = dms_ref.containers
+                    else:
+                        existing_containers = {c.container for c in rules.containers}
+                        rules.containers.extend(
+                            [c for c in dms_ref.containers or [] if c.container not in existing_containers]
+                        )
+                    existing_views = {v.view for v in rules.views}
+                    rules.views.extend([v for v in dms_ref.views if v.view not in existing_views])
+                    existing_properties = {(p.view, p.view_property) for p in rules.properties}
+                    rules.properties.extend(
+                        [p for p in dms_ref.properties if (p.view, p.view_property) not in existing_properties]
+                    )
+
+        start = datetime.now(timezone.utc)
+        transformer = ToExtension(
+            new_model_id=data_model_id,
+            org_name=org_name,
+            type_="data_product",
+            include=include,
+        )
+        output = transformer.transform(rules)
+        end = datetime.now(timezone.utc)
+
+        change = Change.from_rules_activity(
+            output,
+            transformer.agent,
+            start,
+            end,
+            (
+                f"Prepared data model {data_model_id} to be data product model "
+                f"on top of {rules.metadata.as_data_model_id()}"
+            ),
+            self._state.data_model.provenance.source_entity(source_id)
+            or self._state.data_model.provenance.target_entity(source_id),
+        )
+
+        self._state.data_model.write(output.rules, change)
+
     def reduce(self, drop: Collection[Literal["3D", "Annotation", "BaseViews"] | str]) -> None:
         """This is a special method that allow you to drop parts of the data model.
         This only applies to Cognite Data Models.
@@ -267,3 +403,62 @@ class DataModelPrepareAPI:
             )
 
             self._state.data_model.write(output.rules, change)
+
+    def include_referenced(self) -> None:
+        """Include referenced views and containers in the data model."""
+        start = datetime.now(timezone.utc)
+
+        source_id, rules = self._state.data_model.last_verified_dms_rules
+        view_ids, container_ids = rules.imported_views_and_containers_ids(include_model_views_with_no_properties=True)
+        if not (view_ids or container_ids):
+            print(
+                f"Data model {rules.metadata.as_data_model_id()} does not have any referenced views or containers."
+                f"that is not already included in the data model."
+            )
+            return
+        if self._client is None:
+            raise NeatSessionError(
+                "No client provided. You are referencing unknown views and containers in your data model, "
+                "NEAT needs a client to lookup the definitions. "
+                "Please set the client in the session, NeatSession(client=client)."
+            )
+        schema = self._client.schema.retrieve(list(view_ids), list(container_ids))
+        copy_ = rules.model_copy(deep=True)
+        copy_.metadata.version = f"{rules.metadata.version}_completed"
+        importer = DMSImporter(schema)
+        imported = importer.to_rules()
+        if imported.rules is None:
+            self._state.data_model.issue_lists.append(imported.issues)
+            raise NeatSessionError(
+                "Could not import the referenced views and containers. "
+                "See `neat.inspect.issues()` for more information."
+            )
+        verified = VerifyDMSRules("continue", post_validate=False).transform(imported.rules)
+        if verified.rules is None:
+            self._state.data_model.issue_lists.append(verified.issues)
+            raise NeatSessionError(
+                "Could not verify the referenced views and containers. "
+                "See `neat.inspect.issues()` for more information."
+            )
+        if copy_.containers is None:
+            copy_.containers = verified.rules.containers
+        else:
+            existing_containers = {c.container for c in copy_.containers}
+            copy_.containers.extend(
+                [c for c in verified.rules.containers or [] if c.container not in existing_containers]
+            )
+        existing_views = {v.view for v in copy_.views}
+        copy_.views.extend([v for v in verified.rules.views if v.view not in existing_views])
+        end = datetime.now(timezone.utc)
+
+        change = Change.from_rules_activity(
+            copy_,
+            ProvenanceAgent(id_=DEFAULT_NAMESPACE["agent/"]),
+            start,
+            end,
+            (f"Included referenced views and containers in the data model {rules.metadata.as_data_model_id()}"),
+            self._state.data_model.provenance.source_entity(source_id)
+            or self._state.data_model.provenance.target_entity(source_id),
+        )
+
+        self._state.data_model.write(copy_, change)

cognite/neat/_session/_read.py

@@ -1,17 +1,19 @@
 import tempfile
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Any
+from typing import Any, Literal
 
-from cognite.client import CogniteClient
 from cognite.client.data_classes.data_modeling import DataModelId, DataModelIdentifier
 
+from cognite.neat._client import NeatClient
+from cognite.neat._constants import COGNITE_SPACES
 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._shared import ReadRules
+from cognite.neat._rules.importers import BaseImporter
 from cognite.neat._store._provenance import Activity as ProvenanceActivity
 from cognite.neat._store._provenance import Change
 from cognite.neat._store._provenance import Entity as ProvenanceEntity
@@ -20,23 +22,24 @@ from cognite.neat._utils.reader import GitHubReader, NeatReader, PathReader
 from ._state import SessionState
 from ._wizard import NeatObjectType, RDFFileType, object_wizard, rdf_dm_wizard
 from .engine import import_engine
-from .exceptions import NeatSessionError, intercept_session_exceptions
+from .exceptions import NeatSessionError, session_class_wrapper
 
 
-@intercept_session_exceptions
+@session_class_wrapper
 class ReadAPI:
-    def __init__(self, state: SessionState, client: CogniteClient | None, verbose: bool) -> None:
+    def __init__(self, state: SessionState, client: NeatClient | None, verbose: bool) -> None:
         self._state = state
         self._verbose = verbose
         self.cdf = CDFReadAPI(state, client, verbose)
         self.rdf = RDFReadAPI(state, client, verbose)
         self.excel = ExcelReadAPI(state, client, verbose)
         self.csv = CSVReadAPI(state, client, verbose)
+        self.yaml = YamlReadAPI(state, client, verbose)
 
 
-@intercept_session_exceptions
+@session_class_wrapper
 class BaseReadAPI:
-    def __init__(self, state: SessionState, client: CogniteClient | None, verbose: bool) -> None:
+    def __init__(self, state: SessionState, client: NeatClient | None, verbose: bool) -> None:
         self._state = state
         self._verbose = verbose
         self._client = client
@@ -62,14 +65,14 @@ class BaseReadAPI:
             raise NeatValueError(f"Expected str or Path, got {type(io)}")
 
 
-@intercept_session_exceptions
+@session_class_wrapper
 class CDFReadAPI(BaseReadAPI):
-    def __init__(self, state: SessionState, client: CogniteClient | None, verbose: bool) -> None:
+    def __init__(self, state: SessionState, client: NeatClient | None, verbose: bool) -> None:
         super().__init__(state, client, verbose)
         self.classic = CDFClassicAPI(state, client, verbose)
 
     @property
-    def _get_client(self) -> CogniteClient:
+    def _get_client(self) -> NeatClient:
         if self._client is None:
             raise NeatValueError("No client provided. Please provide a client to read a data model.")
         return self._client
@@ -107,22 +110,59 @@ class CDFReadAPI(BaseReadAPI):
         return self._store_rules(rules, change)
 
 
-@intercept_session_exceptions
+@session_class_wrapper
 class CDFClassicAPI(BaseReadAPI):
     @property
-    def _get_client(self) -> CogniteClient:
+    def _get_client(self) -> NeatClient:
         if self._client is None:
             raise ValueError("No client provided. Please provide a client to read a data model.")
         return self._client
 
-    def assets(self, root_asset_external_id: str) -> None:
-        extractor = extractors.AssetsExtractor.from_hierarchy(self._get_client, root_asset_external_id)
+    def graph(self, root_asset_external_id: str) -> None:
+        """Reads the classic knowledge graph from CDF.
+
+        The Classic Graph consists of the following core resource type.
+
+        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.
+
+        In addition, you have relationships between the classic node CDF resources. This matches an edge
+        in the data modeling of CDF.
+
+        Finally, you have labels and data sets that to organize the graph. In which data sets have a similar,
+        but different, role as a space in data modeling. While labels can be compared to node types in data modeling,
+        used to quickly filter and find nodes/edges.
+
+        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.
+
+        Args:
+            root_asset_external_id: The external id of the root asset
+
+        """
+        extractor = extractors.ClassicGraphExtractor(self._get_client, root_asset_external_id=root_asset_external_id)
+
         self._state.instances.store.write(extractor)
         if self._verbose:
-            print(f"Asset hierarchy {root_asset_external_id} read successfully")
+            print(f"Classic Graph {root_asset_external_id} read successfully")
 
 
-@intercept_session_exceptions
+@session_class_wrapper
 class ExcelReadAPI(BaseReadAPI):
     def __call__(self, io: Any) -> IssueList:
         reader = NeatReader.create(io)
@@ -142,11 +182,61 @@ class ExcelReadAPI(BaseReadAPI):
                 description=f"Excel file {reader!s} 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):
+    def __call__(self, io: Any, format: Literal["neat", "toolkit"] = "neat") -> IssueList:
+        reader = NeatReader.create(io)
+        if not isinstance(reader, PathReader):
+            raise NeatValueError("Only file paths are supported for YAML files")
+        start = datetime.now(timezone.utc)
+        importer: BaseImporter
+        if format == "neat":
+            importer = importers.YAMLImporter.from_file(reader.path)
+        elif format == "toolkit":
+            if reader.path.is_file():
+                dms_importer = importers.DMSImporter.from_zip_file(reader.path)
+            elif reader.path.is_dir():
+                dms_importer = importers.DMSImporter.from_directory(reader.path)
+            else:
+                raise NeatValueError(f"Unsupported YAML format: {format}")
+            ref_containers = dms_importer.root_schema.referenced_container()
+            if system_container_ids := [
+                container_id for container_id in ref_containers if container_id.space in COGNITE_SPACES
+            ]:
+                if self._client is None:
+                    raise NeatSessionError(
+                        "No client provided. You are referencing Cognite containers in your data model, "
+                        "NEAT needs a client to lookup the container definitions. "
+                        "Please set the client in the session, NeatSession(client=client)."
+                    )
+                system_containers = self._client.loaders.containers.retrieve(system_container_ids)
+                dms_importer.update_referenced_containers(system_containers)
+
+            importer = dms_importer
+        else:
+            raise NeatValueError(f"Unsupported YAML format: {format}")
+        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=f"YAML file {reader!s} read as unverified data model",
+            )
+            self._store_rules(input_rules, change)
 
         return input_rules.issues
 
 
-@intercept_session_exceptions
+@session_class_wrapper
 class CSVReadAPI(BaseReadAPI):
     def __call__(self, io: Any, type: str, primary_key: str) -> None:
         reader = NeatReader.create(io)
@@ -167,9 +257,9 @@ class CSVReadAPI(BaseReadAPI):
         self._state.instances.store.write(extractor)
 
 
-@intercept_session_exceptions
+@session_class_wrapper
 class RDFReadAPI(BaseReadAPI):
-    def __init__(self, state: SessionState, client: CogniteClient | None, verbose: bool) -> None:
+    def __init__(self, state: SessionState, client: NeatClient | None, verbose: bool) -> None:
         super().__init__(state, client, verbose)
         self.examples = RDFExamples(state)
 

cognite/neat/_session/_set.py

@@ -7,10 +7,10 @@ from cognite.neat._rules.transformers import SetIDDMSModel
 from cognite.neat._store._provenance import Change
 
 from ._state import SessionState
-from .exceptions import NeatSessionError, intercept_session_exceptions
+from .exceptions import NeatSessionError, session_class_wrapper
 
 
-@intercept_session_exceptions
+@session_class_wrapper
 class SetAPI:
     def __init__(self, state: SessionState, verbose: bool) -> None:
         self._state = state

cognite/neat/_session/_show.py

@@ -16,10 +16,10 @@ from cognite.neat._session.exceptions import NeatSessionError
 from cognite.neat._utils.rdf_ import remove_namespace_from_uri
 
 from ._state import SessionState
-from .exceptions import intercept_session_exceptions
+from .exceptions import session_class_wrapper
 
 
-@intercept_session_exceptions
+@session_class_wrapper
 class ShowAPI:
     def __init__(self, state: SessionState) -> None:
         self._state = state
@@ -27,7 +27,7 @@ class ShowAPI:
         self.instances = ShowInstanceAPI(self._state)
 
 
-@intercept_session_exceptions
+@session_class_wrapper
 class ShowBaseAPI:
     def __init__(self, state: SessionState) -> None:
         self._state = state
@@ -63,7 +63,7 @@ class ShowBaseAPI:
             return net.show(name)
 
 
-@intercept_session_exceptions
+@session_class_wrapper
 class ShowDataModelAPI(ShowBaseAPI):
     def __init__(self, state: SessionState) -> None:
         super().__init__(state)
@@ -111,7 +111,7 @@ class ShowDataModelAPI(ShowBaseAPI):
                 di_graph.add_edge(
                     prop_.view.suffix,
                     prop_.value_type.suffix,
-                    label=prop_.name or prop_.property_,
+                    label=prop_.name or prop_.view_property,
                 )
 
         return di_graph
@@ -145,7 +145,7 @@ class ShowDataModelAPI(ShowBaseAPI):
         return di_graph
 
 
-@intercept_session_exceptions
+@session_class_wrapper
 class ShowDataModelImplementsAPI(ShowBaseAPI):
     def __init__(self, state: SessionState) -> None:
         super().__init__(state)
@@ -206,27 +206,27 @@ class ShowDataModelImplementsAPI(ShowBaseAPI):
             # if possible use human readable label coming from the view name
 
             # add subClassOff as edges
-            if class_.parent:
+            if class_.implements:
                 if not di_graph.has_node(class_.class_.suffix):
                     di_graph.add_node(
                         class_.class_.suffix,
                         label=class_.name or class_.class_.suffix,
                     )
 
-                for parent in class_.parent:
+                for parent in class_.implements:
                     if not di_graph.has_node(parent.suffix):
                         di_graph.add_node(parent.suffix, label=parent.suffix)
                     di_graph.add_edge(
                         class_.class_.suffix,
                         parent.suffix,
-                        label="subClassOf",
+                        label="implements",
                         dashes=True,
                     )
 
         return di_graph
 
 
-@intercept_session_exceptions
+@session_class_wrapper
 class ShowDataModelProvenanceAPI(ShowBaseAPI):
     def __init__(self, state: SessionState) -> None:
         super().__init__(state)
@@ -286,7 +286,7 @@ class ShowDataModelProvenanceAPI(ShowBaseAPI):
         return remove_namespace_from_uri(thing)
 
 
-@intercept_session_exceptions
+@session_class_wrapper
 class ShowInstanceAPI(ShowBaseAPI):
     def __init__(self, state: SessionState) -> None:
         super().__init__(state)