cognite-neat 0.121.0__py3-none-any.whl → 0.121.2__py3-none-any.whl

cognite/neat/core/{_rules → _data_model}/models/data_types.py

@@ -11,12 +11,12 @@ from pydantic.functional_validators import ModelWrapValidatorHandler
 from rdflib import URIRef
 
 from cognite.neat.core._constants import XML_SCHEMA_NAMESPACE
-from cognite.neat.core._rules._constants import (
+from cognite.neat.core._data_model._constants import (
     SPLIT_ON_COMMA_PATTERN,
     SPLIT_ON_EQUAL_PATTERN,
 )
-from cognite.neat.core._rules.models.entities._single_value import (
-    ClassEntity,
+from cognite.neat.core._data_model.models.entities._single_value import (
+    ConceptEntity,
     UnitEntity,
 )
 
@@ -397,7 +397,7 @@ class Enum(DataType):
 
     name: typing.Literal["enum"] = "enum"
 
-    collection: ClassEntity
+    collection: ConceptEntity
     unknown_value: str | None = Field(None, alias="unknownValue")
 
 

cognite/neat/core/{_rules → _data_model}/models/entities/__init__.py

@@ -4,15 +4,15 @@ from ._multi_value import MultiValueTypeInfo
 from ._single_value import (
     AssetEntity,
     AssetFields,
-    ClassEntity,
+    ConceptEntity,
+    ConceptualEntity,
     ContainerEntity,
     DataModelEntity,
-    DMSEntity,
     DMSNodeEntity,
-    DMSUnknownEntity,
     DMSVersionedEntity,
     EdgeEntity,
-    Entity,
+    PhysicalEntity,
+    PhysicalUnknownEntity,
     ReferenceEntity,
     RelationshipEntity,
     ReverseConnectionEntity,
@@ -28,21 +28,21 @@ __all__ = [
     "AssetEntity",
     "AssetFields",
     "CdfResourceEntityList",
-    "ClassEntity",
     "ClassEntityList",
+    "ConceptEntity",
+    "ConceptualEntity",
     "ContainerEntity",
     "ContainerEntityList",
-    "DMSEntity",
     "DMSFilter",
     "DMSNodeEntity",
-    "DMSUnknownEntity",
     "DMSVersionedEntity",
     "DataModelEntity",
     "EdgeEntity",
-    "Entity",
     "HasDataFilter",
     "MultiValueTypeInfo",
     "NodeTypeFilter",
+    "PhysicalEntity",
+    "PhysicalUnknownEntity",
     "RawFilter",
     "ReferenceEntity",
     "RelationshipEntity",

cognite/neat/core/{_rules → _data_model}/models/entities/_loaders.py

@@ -1,13 +1,13 @@
 from typing import Literal
 
+from cognite.neat.core._data_model.models.data_types import DataType
 from cognite.neat.core._issues.errors import NeatTypeError
-from cognite.neat.core._rules.models.data_types import DataType
 
 from ._multi_value import MultiValueTypeInfo
 from ._single_value import (
-    ClassEntity,
-    DMSUnknownEntity,
+    ConceptEntity,
     EdgeEntity,
+    PhysicalUnknownEntity,
     ReverseConnectionEntity,
     Unknown,
     UnknownEntity,
@@ -16,9 +16,10 @@ from ._single_value import (
 
 
 def load_value_type(
-    raw: str | MultiValueTypeInfo | DataType | ClassEntity | UnknownEntity, default_prefix: str
-) -> MultiValueTypeInfo | DataType | ClassEntity | UnknownEntity:
-    if isinstance(raw, MultiValueTypeInfo | DataType | ClassEntity | UnknownEntity):
+    raw: str | MultiValueTypeInfo | DataType | ConceptEntity | UnknownEntity,
+    default_prefix: str,
+) -> MultiValueTypeInfo | DataType | ConceptEntity | UnknownEntity:
+    if isinstance(raw, MultiValueTypeInfo | DataType | ConceptEntity | UnknownEntity):
         return raw
     elif isinstance(raw, str):
         # property holding xsd data type
@@ -36,23 +37,23 @@ def load_value_type(
 
         # property holding link to class
         else:
-            return ClassEntity.load(raw, prefix=default_prefix)
+            return ConceptEntity.load(raw, prefix=default_prefix)
     else:
         raise NeatTypeError(f"Invalid value type: {type(raw)}")
 
 
 def load_dms_value_type(
-    raw: str | DataType | ViewEntity | DMSUnknownEntity,
+    raw: str | DataType | ViewEntity | PhysicalUnknownEntity,
     default_space: str,
     default_version: str,
-) -> DataType | ViewEntity | DMSUnknownEntity:
-    if isinstance(raw, DataType | ViewEntity | DMSUnknownEntity):
+) -> DataType | ViewEntity | PhysicalUnknownEntity:
+    if isinstance(raw, DataType | ViewEntity | PhysicalUnknownEntity):
         return raw
     elif isinstance(raw, str):
         if DataType.is_data_type(raw):
             return DataType.load(raw)
         elif raw == str(Unknown):
-            return DMSUnknownEntity()
+            return PhysicalUnknownEntity()
         else:
             return ViewEntity.load(raw, space=default_space, version=default_version)
     raise NeatTypeError(f"Invalid value type: {type(raw)}")

cognite/neat/core/{_rules → _data_model}/models/entities/_multi_value.py

@@ -6,16 +6,16 @@ from pydantic import (
     model_validator,
 )
 
-from cognite.neat.core._rules._constants import EntityTypes
-from cognite.neat.core._rules.models.data_types import DataType
+from cognite.neat.core._data_model._constants import EntityTypes
+from cognite.neat.core._data_model.models.data_types import DataType
 
 from ._constants import _PARSE, Undefined
-from ._single_value import ClassEntity, UnknownEntity
+from ._single_value import ConceptEntity, UnknownEntity
 
 
 class MultiValueTypeInfo(BaseModel):
     type_: ClassVar[EntityTypes] = EntityTypes.multi_value_type
-    types: list[DataType | ClassEntity]
+    types: list[DataType | ConceptEntity]
 
     def __str__(self) -> str:
         return ", ".join([str(t) for t in self.types])
@@ -57,19 +57,19 @@ class MultiValueTypeInfo(BaseModel):
         else:
             return {
                 "types": [
-                    (DataType.load(type_) if DataType.is_data_type(type_) else ClassEntity.load(type_))
+                    (DataType.load(type_) if DataType.is_data_type(type_) else ConceptEntity.load(type_))
                     for type_ in types
                 ]
             }
 
     def set_default_prefix(self, prefix: str) -> None:
         for type_ in self.types:
-            if isinstance(type_, ClassEntity) and type_.prefix is Undefined:
+            if isinstance(type_, ConceptEntity) and type_.prefix is Undefined:
                 type_.prefix = prefix
 
     def is_multi_object_type(self) -> bool:
         """Will signalize to DMS converter to create connection to unknown Node type"""
-        return all(isinstance(t, ClassEntity) for t in self.types)
+        return all(isinstance(t, ConceptEntity) for t in self.types)
 
     def is_multi_data_type(self) -> bool:
         """Will signalize to DMS converter to attempt to find the best data type for value"""

cognite/neat/core/{_rules → _data_model}/models/entities/_single_value.py

@@ -32,7 +32,7 @@ else:
     from backports.strenum import StrEnum
     from typing_extensions import Self
 
-from cognite.neat.core._rules._constants import (
+from cognite.neat.core._data_model._constants import (
     ENTITY_PATTERN,
     SPLIT_ON_COMMA_PATTERN,
     SPLIT_ON_EDGE_ENTITY_ARGS_PATTERN,
@@ -50,8 +50,8 @@ from ._constants import (
 
 
 @total_ordering
-class Entity(BaseModel, extra="ignore"):
-    """Entity is a class or property in OWL/RDF sense."""
+class ConceptualEntity(BaseModel, extra="ignore"):
+    """Conceptual Entity is a concept, class or property in semantics sense."""
 
     type_: ClassVar[EntityTypes] = EntityTypes.undefined
     prefix: str | _UndefinedType = Undefined
@@ -64,7 +64,10 @@ class Entity(BaseModel, extra="ignore"):
     @classmethod
     @overload
     def load(
-        cls: "type[T_Entity]", data: Any, strict: Literal[False] = False, **defaults: Any
+        cls: "type[T_Entity]",
+        data: Any,
+        strict: Literal[False] = False,
+        **defaults: Any,
     ) -> "T_Entity | UnknownEntity": ...
 
     @classmethod
@@ -85,7 +88,7 @@ class Entity(BaseModel, extra="ignore"):
             return cls.model_validate(data)
 
     @model_validator(mode="before")
-    def _load(cls, data: Any) -> "dict | Entity":
+    def _load(cls, data: Any) -> "dict | ConceptualEntity":
         defaults = {}
         if isinstance(data, dict) and _PARSE in data:
             defaults = data.get("defaults", {})
@@ -157,7 +160,7 @@ class Entity(BaseModel, extra="ignore"):
             if isinstance(annotation, UnionType) or get_origin(annotation) is Union:
                 annotation = get_args(annotation)[0]
 
-            if inspect.isclass(annotation) and issubclass(annotation, Entity):  # type: ignore[arg-type]
+            if inspect.isclass(annotation) and issubclass(annotation, ConceptualEntity):  # type: ignore[arg-type]
                 extra_args[key] = annotation.load(extra_args[key], **defaults)  # type: ignore[union-attr, assignment]
         return dict(prefix=prefix, suffix=suffix, **extra_args)
 
@@ -179,12 +182,12 @@ class Entity(BaseModel, extra="ignore"):
             return self.prefix, str(self.suffix), *extra
 
     def __lt__(self, other: object) -> bool:
-        if not isinstance(other, Entity):
+        if not isinstance(other, ConceptualEntity):
             return NotImplemented
         return self.as_tuple() < other.as_tuple()
 
     def __eq__(self, other: object) -> bool:
-        if not isinstance(other, Entity):
+        if not isinstance(other, ConceptualEntity):
             return NotImplemented
         return self.as_tuple() == other.as_tuple()
 
@@ -207,7 +210,7 @@ class Entity(BaseModel, extra="ignore"):
     def _as_str(self, **defaults: Any) -> str:
         # We have overwritten the serialization to str, so we need to do it manually
         model_dump = {
-            field.alias or field_name: v.dump(**defaults) if isinstance(v, Entity) else v
+            field.alias or field_name: v.dump(**defaults) if isinstance(v, ConceptualEntity) else v
             for field_name, field in self.model_fields.items()
             if (v := getattr(self, field_name)) is not None and field_name not in {"prefix", "suffix"}
         }
@@ -263,11 +266,11 @@ class Entity(BaseModel, extra="ignore"):
         return new_entity
 
 
-T_Entity = TypeVar("T_Entity", bound=Entity)
+T_Entity = TypeVar("T_Entity", bound=ConceptualEntity)
 
 
-class ClassEntity(Entity):
-    type_: ClassVar[EntityTypes] = EntityTypes.class_
+class ConceptEntity(ConceptualEntity):
+    type_: ClassVar[EntityTypes] = EntityTypes.concept
     version: str | None = None
 
     def as_view_entity(self, default_space: str, default_version: str) -> "ViewEntity":
@@ -283,7 +286,7 @@ class ClassEntity(Entity):
         return ContainerEntity(space=space, externalId=str(self.suffix))
 
 
-class UnknownEntity(ClassEntity):
+class UnknownEntity(ConceptEntity):
     type_: ClassVar[EntityTypes] = EntityTypes.undefined
     prefix: _UndefinedType = Undefined
     suffix: _UnknownType = Unknown  # type: ignore[assignment]
@@ -293,7 +296,7 @@ class UnknownEntity(ClassEntity):
         return str(Unknown)
 
 
-class UnitEntity(Entity):
+class UnitEntity(ConceptualEntity):
     type_: ClassVar[EntityTypes] = EntityTypes.unit
     prefix: str
     suffix: str
@@ -310,14 +313,14 @@ class AssetFields(StrEnum):
     metadata = "metadata"
 
 
-class AssetEntity(Entity):
+class AssetEntity(ConceptualEntity):
     type_: ClassVar[EntityTypes] = EntityTypes.asset
     suffix: str = "Asset"
     prefix: _UndefinedType = Undefined
     property_: AssetFields = Field(alias="property")
 
 
-class RelationshipEntity(Entity):
+class RelationshipEntity(ConceptualEntity):
     type_: ClassVar[EntityTypes] = EntityTypes.relationship
     suffix: str = "Relationship"
     prefix: _UndefinedType = Undefined
@@ -327,7 +330,7 @@ class RelationshipEntity(Entity):
 T_ID = TypeVar("T_ID", bound=ContainerId | ViewId | DataModelId | PropertyId | NodeId | None)
 
 
-class DMSEntity(Entity, Generic[T_ID], ABC):
+class PhysicalEntity(ConceptualEntity, Generic[T_ID], ABC):
     type_: ClassVar[EntityTypes] = EntityTypes.undefined
     prefix: str = Field(alias="space")
     suffix: str = Field(alias="externalId")
@@ -344,17 +347,20 @@ class DMSEntity(Entity, Generic[T_ID], ABC):
     @classmethod
     @overload
     def load(
-        cls: "type[T_DMSEntity]", data: Any, strict: Literal[False] = False, **defaults: Any
-    ) -> "T_DMSEntity | DMSUnknownEntity": ...
+        cls: "type[T_DMSEntity]",
+        data: Any,
+        strict: Literal[False] = False,
+        **defaults: Any,
+    ) -> "T_DMSEntity | PhysicalUnknownEntity": ...
 
     @classmethod
     def load(
         cls: "type[T_DMSEntity]", data: Any, strict: bool = False, **defaults: Any
-    ) -> "T_DMSEntity | DMSUnknownEntity":  # type: ignore
+    ) -> "T_DMSEntity | PhysicalUnknownEntity":  # type: ignore
         if isinstance(data, str) and data == str(Unknown):
             if strict:
                 raise NeatValueError(f"Failed to load entity {data!s}")
-            return DMSUnknownEntity.from_id(None)
+            return PhysicalUnknownEntity.from_id(None)
         return cast(T_DMSEntity, super().load(data, **defaults))
 
     @property
@@ -376,8 +382,8 @@ class DMSEntity(Entity, Generic[T_ID], ABC):
     def from_id(cls, id: T_ID) -> Self:
         raise NotImplementedError("Method from_id must be implemented in subclasses")
 
-    def as_class(self) -> ClassEntity:
-        return ClassEntity(prefix=self.space, suffix=self.external_id)
+    def as_concept_entity(self) -> ConceptEntity:
+        return ConceptEntity(prefix=self.space, suffix=self.external_id)
 
     def as_dms_compliant_entity(self) -> "Self":
         new_entity = self.model_copy(deep=True)
@@ -385,10 +391,10 @@ class DMSEntity(Entity, Generic[T_ID], ABC):
         return new_entity
 
 
-T_DMSEntity = TypeVar("T_DMSEntity", bound=DMSEntity)
+T_DMSEntity = TypeVar("T_DMSEntity", bound=PhysicalEntity)
 
 
-class ContainerEntity(DMSEntity[ContainerId]):
+class ContainerEntity(PhysicalEntity[ContainerId]):
     type_: ClassVar[EntityTypes] = EntityTypes.container
 
     def as_id(self) -> ContainerId:
@@ -399,13 +405,13 @@ class ContainerEntity(DMSEntity[ContainerId]):
         return cls(space=id.space, externalId=id.external_id)
 
 
-class DMSVersionedEntity(DMSEntity[T_ID], ABC):
+class DMSVersionedEntity(PhysicalEntity[T_ID], ABC):
     version: str
 
-    def as_class(self, skip_version: bool = False) -> ClassEntity:
+    def as_concept_entity(self, skip_version: bool = False) -> ConceptEntity:
         if skip_version:
-            return ClassEntity(prefix=self.space, suffix=self.external_id)
-        return ClassEntity(prefix=self.space, suffix=self.external_id, version=self.version)
+            return ConceptEntity(prefix=self.space, suffix=self.external_id)
+        return ConceptEntity(prefix=self.space, suffix=self.external_id, version=self.version)
 
 
 class ViewEntity(DMSVersionedEntity[ViewId]):
@@ -429,7 +435,7 @@ class ViewEntity(DMSVersionedEntity[ViewId]):
             raise ValueError("Version must be specified")
 
 
-class DMSUnknownEntity(DMSEntity[None]):
+class PhysicalUnknownEntity(PhysicalEntity[None]):
     """This is a special entity that represents an unknown entity.
 
     The use case is for direct relations where the source is not known."""
@@ -442,7 +448,7 @@ class DMSUnknownEntity(DMSEntity[None]):
         return None
 
     @classmethod
-    def from_id(cls, id: None) -> "DMSUnknownEntity":
+    def from_id(cls, id: None) -> "PhysicalUnknownEntity":
         return cls(space=Undefined, externalId=Unknown)
 
     @property
@@ -463,7 +469,7 @@ class DataModelEntity(DMSVersionedEntity[DataModelId]):
         return cls(space=id.space, externalId=id.external_id, version=id.version)
 
 
-class DMSNodeEntity(DMSEntity[NodeId]):
+class DMSNodeEntity(PhysicalEntity[NodeId]):
     type_: ClassVar[EntityTypes] = EntityTypes.dms_node
 
     def as_id(self) -> NodeId:
@@ -481,7 +487,7 @@ class DMSNodeEntity(DMSEntity[NodeId]):
         return cls(space=ref.space, externalId=ref.external_id)
 
 
-class EdgeEntity(DMSEntity[None]):
+class EdgeEntity(PhysicalEntity[None]):
     type_: ClassVar[EntityTypes] = EntityTypes.edge
     prefix: _UndefinedType = Undefined  # type: ignore[assignment]
     suffix: Literal["edge"] = "edge"
@@ -501,21 +507,21 @@ class EdgeEntity(DMSEntity[None]):
         return cls()
 
 
-class ReverseConnectionEntity(Entity):
+class ReverseConnectionEntity(ConceptualEntity):
     type_: ClassVar[EntityTypes] = EntityTypes.reverse
     prefix: _UndefinedType = Undefined
     suffix: Literal["reverse"] = "reverse"
     property_: str = Field(alias="property")
 
 
-class ReferenceEntity(ClassEntity):
+class ReferenceEntity(ConceptEntity):
     type_: ClassVar[EntityTypes] = EntityTypes.reference_entity
     prefix: str
     property_: str | None = Field(None, alias="property")
 
     @classmethod
-    def from_entity(cls, entity: Entity, property_: str) -> "ReferenceEntity":
-        if isinstance(entity, ClassEntity):
+    def from_entity(cls, entity: ConceptualEntity, property_: str) -> "ReferenceEntity":
+        if isinstance(entity, ConceptEntity):
             return cls(
                 prefix=str(entity.prefix),
                 suffix=entity.suffix,
@@ -541,5 +547,5 @@ class ReferenceEntity(ClassEntity):
     def as_node_entity(self) -> DMSNodeEntity:
         return DMSNodeEntity(space=self.prefix, externalId=self.suffix)
 
-    def as_class_entity(self) -> ClassEntity:
-        return ClassEntity(prefix=self.prefix, suffix=self.suffix, version=self.version)
+    def as_concept_entity(self) -> ConceptEntity:
+        return ConceptEntity(prefix=self.prefix, suffix=self.suffix, version=self.version)

cognite/neat/core/{_rules → _data_model}/models/entities/_types.py

@@ -6,7 +6,13 @@ from pydantic import (
     PlainSerializer,
 )
 
-from ._single_value import AssetEntity, ClassEntity, ContainerEntity, RelationshipEntity, ViewEntity
+from ._single_value import (
+    AssetEntity,
+    ConceptEntity,
+    ContainerEntity,
+    RelationshipEntity,
+    ViewEntity,
+)
 
 
 def _split_str(v: Any) -> list[str]:
@@ -15,7 +21,7 @@ def _split_str(v: Any) -> list[str]:
     return v
 
 
-def _join_str(v: list[ClassEntity]) -> str | None:
+def _join_str(v: list[ConceptEntity]) -> str | None:
     return ",".join([entry.id for entry in v]) if v else None
 
 
@@ -39,7 +45,7 @@ def _generate_cdf_resource_list(v: Any) -> list[AssetEntity | RelationshipEntity
 
 
 ClassEntityList = Annotated[
-    list[ClassEntity],
+    list[ConceptEntity],
     BeforeValidator(_split_str),
 ]
 

cognite/neat/core/{_rules → _data_model}/models/entities/_wrapped.py

@@ -8,14 +8,14 @@ from cognite.client import data_modeling as dm
 from cognite.client.data_classes.data_modeling import ContainerId, NodeId
 from pydantic import BaseModel, model_serializer, model_validator
 
-from ._single_value import ContainerEntity, DMSNodeEntity, Entity, ViewEntity
+from ._single_value import ConceptualEntity, ContainerEntity, DMSNodeEntity, ViewEntity
 
 
 @total_ordering
 class WrappedEntity(BaseModel, ABC):
     name: ClassVar[str]
-    _inner_cls: ClassVar[type[Entity]]
-    inner: list[Entity] | None
+    _inner_cls: ClassVar[type[ConceptualEntity]]
+    inner: list[ConceptualEntity] | None
 
     @classmethod
     def load(cls: "type[T_WrappedEntity]", data: Any) -> "T_WrappedEntity":

cognite/neat/core/{_rules → _data_model}/models/mapping/_classic2core.py

@@ -3,9 +3,12 @@ from pathlib import Path
 
 import yaml
 
+from cognite.neat.core._data_model._shared import ImportedDataModel
+from cognite.neat.core._data_model.models.physical import (
+    PhysicalDataModel,
+    UnverifiedPhysicalDataModel,
+)
 from cognite.neat.core._issues.errors import NeatValueError
-from cognite.neat.core._rules._shared import ReadRules
-from cognite.neat.core._rules.models.dms import DMSInputRules, DMSRules
 
 _CLASSIC_TO_CORE_MAPPING = Path(__file__).resolve().parent / "_classic2core.yaml"
 
@@ -15,9 +18,9 @@ def _read_source_file() -> str:
     return _CLASSIC_TO_CORE_MAPPING.read_text()
 
 
-def load_classic_to_core_mapping(org_name: str | None, source_space: str, source_version: str) -> DMSRules:
-    from cognite.neat.core._rules.importers import YAMLImporter
-    from cognite.neat.core._rules.transformers import VerifyDMSRules
+def load_classic_to_core_mapping(org_name: str | None, source_space: str, source_version: str) -> PhysicalDataModel:
+    from cognite.neat.core._data_model.importers import DictImporter
+    from cognite.neat.core._data_model.transformers import VerifyPhysicalDataModel
 
     raw_str = _read_source_file()
     if org_name is not None:
@@ -27,10 +30,10 @@ def load_classic_to_core_mapping(org_name: str | None, source_space: str, source
     loaded["metadata"]["space"] = source_space
     loaded["metadata"]["version"] = source_version
 
-    read: ReadRules[DMSInputRules] = YAMLImporter(loaded).to_rules()
-    if not isinstance(read.rules, DMSInputRules):
-        raise NeatValueError(f"Expected DMS rules, but got {type(read.rules).__name__}")
+    read: ImportedDataModel[UnverifiedPhysicalDataModel] = DictImporter(loaded).to_data_model()
+    if not isinstance(read.unverified_data_model, UnverifiedPhysicalDataModel):
+        raise NeatValueError(f"Expected DMS rules, but got {type(read.unverified_data_model).__name__}")
 
-    verified = VerifyDMSRules(validate=False).transform(read)
+    verified = VerifyPhysicalDataModel(validate=False).transform(read)
 
     return verified

cognite/neat/core/_data_model/models/physical/__init__.py

@@ -0,0 +1,40 @@
+from cognite.neat.core._client.data_classes.schema import DMSSchema
+
+from ._unverified import (
+    UnverifiedPhysicalContainer,
+    UnverifiedPhysicalDataModel,
+    UnverifiedPhysicalEnum,
+    UnverifiedPhysicalMetadata,
+    UnverifiedPhysicalNodeType,
+    UnverifiedPhysicalProperty,
+    UnverifiedPhysicalView,
+)
+from ._validation import PhysicalValidation
+from ._verified import (
+    PhysicalContainer,
+    PhysicalDataModel,
+    PhysicalEnum,
+    PhysicalMetadata,
+    PhysicalNodeType,
+    PhysicalProperty,
+    PhysicalView,
+)
+
+__all__ = [
+    "DMSSchema",
+    "PhysicalContainer",
+    "PhysicalDataModel",
+    "PhysicalEnum",
+    "PhysicalMetadata",
+    "PhysicalNodeType",
+    "PhysicalProperty",
+    "PhysicalValidation",
+    "PhysicalView",
+    "UnverifiedPhysicalContainer",
+    "UnverifiedPhysicalDataModel",
+    "UnverifiedPhysicalEnum",
+    "UnverifiedPhysicalMetadata",
+    "UnverifiedPhysicalNodeType",
+    "UnverifiedPhysicalProperty",
+    "UnverifiedPhysicalView",
+]