cognite-neat 0.123.38__tar.gz → 0.123.40__tar.gz

cognite_neat-0.123.40/.github/CODEOWNERS

@@ -0,0 +1,3 @@
+* @cognitedata/accelerate @cognitedata/velocity
+
+

{cognite_neat-0.123.38 → cognite_neat-0.123.40}/.pre-commit-config.yaml

@@ -23,7 +23,7 @@ repos:
   - hooks:
     - id: mypy
       name: mypy
-      entry: dmypy run -- cognite/neat/ tests/tests_unit_v1/
+      entry: dmypy run -- cognite/neat/ tests/
       files: ^.*.(py|pyi)$
       language: system
       pass_filenames: false

{cognite_neat-0.123.38 → cognite_neat-0.123.40}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite-neat
-Version: 0.123.38
+Version: 0.123.40
 Summary: Knowledge graph transformation
 Project-URL: Documentation, https://cognite-neat.readthedocs-hosted.com/
 Project-URL: Homepage, https://cognite-neat.readthedocs-hosted.com/

cognite_neat-0.123.40/cognite/neat/_data_model/models/conceptual/_concept.py

@@ -0,0 +1,67 @@
+from collections import Counter
+
+from pydantic import Field, ValidationInfo, field_validator
+from pyparsing import cast
+
+from cognite.neat._data_model.models.entities import ConceptEntity
+from cognite.neat._data_model.models.entities._constants import PREFIX_PATTERN, SUFFIX_PATTERN, VERSION_PATTERN
+from cognite.neat._utils.text import humanize_collection
+
+from ._base import ResourceMetadata
+from ._property import Property
+
+
+class Concept(ResourceMetadata):
+    space: str = Field(
+        description="Id of the space that the concept belongs to.",
+        min_length=1,
+        max_length=43,
+        pattern=PREFIX_PATTERN,
+        alias="prefix",
+    )
+    external_id: str = Field(
+        description="External-id of the concept.",
+        min_length=1,
+        max_length=255,
+        pattern=SUFFIX_PATTERN,
+        alias="suffix",
+    )
+    version: str | None = Field(
+        default=None,
+        description="Version of the concept.",
+        max_length=43,
+        pattern=VERSION_PATTERN,
+    )
+
+    implements: list[ConceptEntity] | None = Field(
+        default=None,
+        description="References to the concepts from where this concept will inherit properties.",
+    )
+
+    properties: dict[str, Property] | None = Field(default=None, description="Properties associated with the concept.")
+
+    @field_validator("implements", mode="after")
+    def cannot_implement_itself(cls, value: list[ConceptEntity], info: ValidationInfo) -> list[ConceptEntity]:
+        if not value:
+            return value
+
+        this_concept = ConceptEntity(
+            prefix=info.data["space"],
+            suffix=info.data["external_id"],
+            version=cast(str, info.data.get("version")),
+        )
+
+        if this_concept in value:
+            raise ValueError("A concept cannot implement itself.")
+
+        return value
+
+    @field_validator("implements", mode="after")
+    def cannot_have_duplicates(cls, value: list[ConceptEntity], info: ValidationInfo) -> list[ConceptEntity]:
+        counts = Counter(value)
+        duplicates = {concept for concept, count in counts.items() if count > 1}
+
+        if duplicates:
+            raise ValueError(f"Duplicate concepts found: {humanize_collection(duplicates)}")
+
+        return value

cognite_neat-0.123.40/cognite/neat/_data_model/models/conceptual/_property.py

@@ -0,0 +1,104 @@
+from typing import Any
+
+from pydantic import Field, ValidationInfo, field_validator, model_validator
+
+from cognite.neat._data_model.models.entities import URI, ConceptEntity, DataType, UnknownEntity
+
+from ._base import ResourceMetadata
+
+
+class Property(ResourceMetadata):
+    value_type: DataType | ConceptEntity | UnknownEntity = Field(
+        union_mode="left_to_right",
+        description="Value type that the property can hold. It takes either subset of XSD type or a class defined.",
+    )
+    min_count: int | None = Field(
+        default=None,
+        ge=0,
+        description="Minimum number of values that the property can hold. "
+        "If no value is provided, the default value is None meaning `0`, "
+        "which means that the property is optional.",
+    )
+    max_count: int | None = Field(
+        default=None,
+        ge=0,
+        description="Maximum number of values that the property can hold. "
+        "If no value is provided, the default value is None meaning `inf`, "
+        "which means that the property can hold any number of values (listable).",
+    )
+    default: Any | None = Field(alias="Default", default=None, description="Default value of the property.")
+    instance_reference: list[URI] | None = Field(
+        default=None,
+        description="The URI(s) in the graph to get the value of the property.",
+    )
+
+    @model_validator(mode="after")
+    def check_min_max_count(self) -> "Property":
+        if self.min_count is not None and self.max_count is not None:
+            if self.min_count > self.max_count:
+                raise ValueError("min_count must be less than or equal to max_count")
+        return self
+
+    @field_validator("default", mode="after")
+    def check_default_value_primitive_type(cls, value: Any, info: ValidationInfo) -> Any:
+        if not value:
+            return value
+
+        value_type = info.data.get("value_type")
+        if not isinstance(value_type, DataType):
+            raise ValueError("Setting default value is only supported for primitive value types.")
+        return value
+
+    @field_validator("default", mode="after")
+    def check_default_value_python_type_exists(cls, value: Any, info: ValidationInfo) -> Any:
+        if not value:
+            return value
+
+        value_type = info.data.get("value_type")
+
+        if isinstance(value_type, DataType) and not hasattr(value_type, "python"):
+            raise ValueError(
+                f"DataType {value_type} does not have a python type defined."
+                " Setting default value for property is not possible."
+            )
+        return value
+
+    @field_validator("default", mode="after")
+    def check_default_value_not_list(cls, value: Any, info: ValidationInfo) -> Any:
+        if not value:
+            return value
+
+        if isinstance(value, list):
+            raise ValueError("Setting list as default value is not supported.")
+        return value
+
+    @field_validator("default", mode="after")
+    def check_default_value_single_valued(cls, value: Any, info: ValidationInfo) -> Any:
+        if not value:
+            return value
+
+        max_count = info.data.get("max_count")
+
+        if max_count is None or max_count > 1:
+            raise ValueError(
+                "Setting default value is only supported for single-valued properties."
+                f" Property has max_count={max_count or 'Inf'}."
+            )
+        return value
+
+    @field_validator("default", mode="after")
+    def check_default_value_type_match(cls, value: Any, info: ValidationInfo) -> Any:
+        if not value:
+            return value
+
+        value_type = info.data.get("value_type")
+
+        if (
+            isinstance(value_type, DataType)
+            and hasattr(value_type, "python")
+            and not isinstance(value, value_type.python)
+        ):
+            raise ValueError(
+                f"Default value type is {type(value)}, which does not match expected value type {value_type.python}."
+            )
+        return value

{cognite_neat-0.123.38 → cognite_neat-0.123.40}/cognite/neat/_data_model/models/dms/__init__.py

@@ -32,15 +32,50 @@ from cognite.neat._data_model.models.dms._data_types import (
 from cognite.neat._data_model.models.dms._indexes import BtreeIndex, Index, IndexDefinition, InvertedIndex
 from cognite.neat._data_model.models.dms._space import Space, SpaceRequest, SpaceResponse
 
+from ._data_model import DataModelRequest, DataModelResponse
+from ._references import (
+    ContainerDirectReference,
+    ContainerReference,
+    NodeReference,
+    ViewDirectReference,
+    ViewReference,
+)
+from ._view_property import (
+    ConnectionPropertyDefinition,
+    ConstraintOrIndexState,
+    MultiEdgeProperty,
+    MultiReverseDirectRelationPropertyRequest,
+    MultiReverseDirectRelationPropertyResponse,
+    SingleEdgeProperty,
+    SingleReverseDirectRelationPropertyRequest,
+    SingleReverseDirectRelationPropertyResponse,
+    ViewCorePropertyRequest,
+    ViewCorePropertyResponse,
+    ViewPropertyDefinition,
+    ViewRequestProperty,
+    ViewResponseProperty,
+)
+from ._views import (
+    View,
+    ViewRequest,
+    ViewResponse,
+)
+
 __all__ = [
     "BooleanProperty",
     "BtreeIndex",
+    "ConnectionPropertyDefinition",
     "Constraint",
     "ConstraintDefinition",
+    "ConstraintOrIndexState",
     "Container",
+    "ContainerDirectReference",
     "ContainerPropertyDefinition",
+    "ContainerReference",
     "ContainerRequest",
     "ContainerResponse",
+    "DataModelRequest",
+    "DataModelResponse",
     "DataType",
     "DateProperty",
     "DirectNodeRelation",
@@ -54,16 +89,38 @@ __all__ = [
     "InvertedIndex",
     "JSONProperty",
     "ListablePropertyTypeDefinition",
+    "MultiEdgeProperty",
+    "MultiReverseDirectRelationPropertyRequest",
+    "MultiReverseDirectRelationPropertyResponse",
+    "NodeReference",
     "PropertyTypeDefinition",
     "RequiresConstraintDefinition",
     "Resource",
     "SequenceCDFExternalIdReference",
+    "SequenceCDFExternalIdReference",
+    "SingleEdgeProperty",
+    "SingleReverseDirectRelationPropertyRequest",
+    "SingleReverseDirectRelationPropertyResponse",
     "Space",
     "SpaceRequest",
     "SpaceResponse",
     "TextProperty",
+    "TextProperty",
+    "TimeseriesCDFExternalIdReference",
     "TimeseriesCDFExternalIdReference",
     "TimestampProperty",
+    "TimestampProperty",
+    "UniquenessConstraintDefinition",
     "UniquenessConstraintDefinition",
+    "View",
+    "ViewCorePropertyRequest",
+    "ViewCorePropertyResponse",
+    "ViewDirectReference",
+    "ViewPropertyDefinition",
+    "ViewReference",
+    "ViewRequest",
+    "ViewRequestProperty",
+    "ViewResponse",
+    "ViewResponseProperty",
     "WriteableResource",
 ]

{cognite_neat-0.123.38 → cognite_neat-0.123.40}/cognite/neat/_data_model/models/dms/_constants.py

@@ -3,6 +3,7 @@ DM_EXTERNAL_ID_PATTERN = r"^[a-zA-Z]([a-zA-Z0-9_]{0,253}[a-zA-Z0-9])?$"
 CONTAINER_AND_VIEW_PROPERTIES_IDENTIFIER_PATTERN = r"^[a-zA-Z0-9][a-zA-Z0-9_-]{0,253}[a-zA-Z0-9]?$"
 INSTANCE_ID_PATTERN = r"^[^\\x00]{1,256}$"
 ENUM_VALUE_IDENTIFIER_PATTERN = r"^[_A-Za-z][_0-9A-Za-z]{0,127}$"
+DM_VERSION_PATTERN = r"^[a-zA-Z0-9]([.a-zA-Z0-9_-]{0,41}[a-zA-Z0-9])?$"
 FORBIDDEN_ENUM_VALUES = frozenset({"true", "false", "null"})
 FORBIDDEN_SPACES = frozenset(["space", "cdf", "dms", "pg3", "shared", "system", "node", "edge"])
 FORBIDDEN_CONTAINER_AND_VIEW_EXTERNAL_IDS = frozenset(

{cognite_neat-0.123.38 → cognite_neat-0.123.40}/cognite/neat/_data_model/models/dms/_container.py

@@ -18,6 +18,7 @@ from ._constants import (
 from ._constraints import Constraint
 from ._data_types import DataType
 from ._indexes import Index
+from ._references import ContainerReference
 
 KEY_PATTERN = re.compile(CONTAINER_AND_VIEW_PROPERTIES_IDENTIFIER_PATTERN)
 
@@ -132,6 +133,12 @@ class Container(Resource, ABC):
             )
         return val
 
+    def as_reference(self) -> ContainerReference:
+        return ContainerReference(
+            space=self.space,
+            externalId=self.external_id,
+        )
+
 
 class ContainerRequest(Container): ...
 

cognite_neat-0.123.40/cognite/neat/_data_model/models/dms/_data_model.py

@@ -0,0 +1,71 @@
+from abc import ABC
+
+from pydantic import Field
+
+from ._base import Resource, WriteableResource
+from ._constants import (
+    DM_EXTERNAL_ID_PATTERN,
+    DM_VERSION_PATTERN,
+    SPACE_FORMAT_PATTERN,
+)
+from ._references import ViewReference
+
+
+class DataModel(Resource, ABC):
+    """Cognite Data Model resource.
+
+    Data models group and structure views into reusable collections.
+    A data model contains a set of views where the node types can
+    refer to each other with direct relations and edges.
+    """
+
+    space: str = Field(
+        description="The workspace for the data model, a unique identifier for the space.",
+        min_length=1,
+        max_length=43,
+        pattern=SPACE_FORMAT_PATTERN,
+    )
+    external_id: str = Field(
+        description="External-id of the data model.",
+        min_length=1,
+        max_length=255,
+        pattern=DM_EXTERNAL_ID_PATTERN,
+    )
+    version: str = Field(
+        description="Version of the data model.",
+        max_length=43,
+        pattern=DM_VERSION_PATTERN,
+    )
+    name: str | None = Field(
+        default=None,
+        description="Human readable name for the data model.",
+        max_length=255,
+    )
+    description: str | None = Field(
+        default=None,
+        description="Description of the data model.",
+        max_length=1024,
+    )
+    # The API supports View here, but in Neat we will only use ViewReference
+    views: list[ViewReference] | None = Field(
+        description="List of views included in this data model.",
+        default=None,
+    )
+
+
+class DataModelRequest(DataModel): ...
+
+
+class DataModelResponse(DataModel, WriteableResource[DataModelRequest]):
+    created_time: int = Field(
+        description="When the data model was created. The number of milliseconds since 00:00:00 Thursday, "
+        "1 January 1970, Coordinated Universal Time (UTC), minus leap seconds."
+    )
+    last_updated_time: int = Field(
+        description="When the data model was last updated. The number of milliseconds since 00:00:00 Thursday, "
+        "1 January 1970, Coordinated Universal Time (UTC), minus leap seconds."
+    )
+    is_global: bool = Field(description="Is this a global data model.")
+
+    def as_request(self) -> DataModelRequest:
+        return DataModelRequest.model_validate(self.model_dump(by_alias=True))

cognite_neat-0.123.40/cognite/neat/_data_model/models/dms/_references.py

@@ -0,0 +1,91 @@
+from typing import Literal
+
+from pydantic import Field
+
+from ._base import BaseModelObject
+from ._constants import (
+    CONTAINER_AND_VIEW_PROPERTIES_IDENTIFIER_PATTERN,
+    DM_EXTERNAL_ID_PATTERN,
+    DM_VERSION_PATTERN,
+    INSTANCE_ID_PATTERN,
+    SPACE_FORMAT_PATTERN,
+)
+
+
+class ReferenceObject(BaseModelObject, frozen=True): ...
+
+
+class ContainerReference(ReferenceObject):
+    type: Literal["container"] = "container"
+    space: str = Field(
+        description="Id of the space hosting (containing) the container.",
+        min_length=1,
+        max_length=43,
+        pattern=SPACE_FORMAT_PATTERN,
+    )
+    external_id: str = Field(
+        description="External-id of the container.",
+        min_length=1,
+        max_length=255,
+        pattern=DM_EXTERNAL_ID_PATTERN,
+    )
+
+
+class ViewReference(BaseModelObject):
+    type: Literal["view"] = "view"
+    space: str = Field(
+        description="Id of the space that the view belongs to.",
+        min_length=1,
+        max_length=43,
+        pattern=SPACE_FORMAT_PATTERN,
+    )
+    external_id: str = Field(
+        description="External-id of the view.",
+        min_length=1,
+        max_length=255,
+        pattern=DM_EXTERNAL_ID_PATTERN,
+    )
+    version: str = Field(
+        description="Version of the view.",
+        max_length=43,
+        pattern=DM_VERSION_PATTERN,
+    )
+
+
+class NodeReference(BaseModelObject):
+    space: str = Field(
+        description="Id of the space hosting (containing) the node.",
+        min_length=1,
+        max_length=43,
+        pattern=SPACE_FORMAT_PATTERN,
+    )
+    external_id: str = Field(
+        description="External-id of the node.",
+        min_length=1,
+        max_length=255,
+        pattern=INSTANCE_ID_PATTERN,
+    )
+
+
+class ContainerDirectReference(BaseModelObject):
+    source: ContainerReference = Field(
+        description="Reference to the container from where this relation is inherited.",
+    )
+    identifier: str = Field(
+        description="Identifier of the relation in the source container.",
+        min_length=1,
+        max_length=255,
+        pattern=CONTAINER_AND_VIEW_PROPERTIES_IDENTIFIER_PATTERN,
+    )
+
+
+class ViewDirectReference(BaseModelObject):
+    source: ViewReference = Field(
+        description="Reference to the view from where this relation is inherited.",
+    )
+    identifier: str = Field(
+        description="Identifier of the relation in the source view.",
+        min_length=1,
+        max_length=255,
+        pattern=CONTAINER_AND_VIEW_PROPERTIES_IDENTIFIER_PATTERN,
+    )

cognite_neat-0.123.40/cognite/neat/_data_model/models/dms/_view_property.py

@@ -0,0 +1,198 @@
+from abc import ABC
+from typing import Annotated, Literal
+
+from pydantic import Field, Json
+
+from ._base import BaseModelObject, Resource, WriteableResource
+from ._constants import CONTAINER_AND_VIEW_PROPERTIES_IDENTIFIER_PATTERN
+from ._data_types import DataType
+from ._references import ContainerDirectReference, ContainerReference, NodeReference, ViewDirectReference, ViewReference
+
+
+class ViewPropertyDefinition(Resource, ABC):
+    connection_type: str
+
+
+class ViewCoreProperty(ViewPropertyDefinition, ABC):
+    # Core properties do not have connection type in the API, but we add it here such that
+    # we can use it as a discriminator in unions. The exclude=True ensures that it is not
+    # sent to the API.
+    connection_type: Literal["primary_property"] = Field(default="primary_property", exclude=True)
+    name: str | None = Field(
+        default=None,
+        description="Readable property name.",
+        max_length=255,
+    )
+    description: str | None = Field(
+        default=None,
+        description="Description of the content and suggested use for this property..",
+        max_length=1024,
+    )
+    container: ContainerReference = Field(
+        description="Reference to the container where this property is defined.",
+    )
+    container_property_identifier: str = Field(
+        description="Identifier of the property in the container.",
+        min_length=1,
+        max_length=255,
+        pattern=CONTAINER_AND_VIEW_PROPERTIES_IDENTIFIER_PATTERN,
+    )
+    source: ViewReference | None = Field(
+        default=None,
+        description="Indicates on what type a referenced direct relation is expected to be. "
+        "Only applicable for direct relation properties.",
+    )
+
+
+class ViewCorePropertyRequest(ViewCoreProperty): ...
+
+
+class ConstraintOrIndexState(BaseModelObject):
+    nullability: Literal["current", "pending", "failed"] | None = Field(
+        description="""For properties that have isNullable set to false, this field describes the validity of the
+not-null constraint. It is not specified for nullable properties.
+
+Possible values are:
+
+"failed": The property contains null values, violating the constraint. This can occur if a property with
+          existing nulls was made non-nullable. New null values will still be rejected.
+"current": The constraint is satisfied; all values in the property are not null.
+"pending": The constraint validity has not yet been computed.
+        """
+    )
+
+
+class ViewCorePropertyResponse(ViewCoreProperty, WriteableResource[ViewCorePropertyRequest]):
+    immutable: bool | None = Field(
+        default=None,
+        description="Should updates to this property be rejected after the initial population?",
+    )
+    nullable: bool | None = Field(
+        default=None,
+        description="Does this property need to be set to a value, or not?",
+    )
+    auto_increment: bool | None = Field(
+        default=None,
+        description="Increment the property based on its highest current value (max value).",
+    )
+    default_value: str | int | bool | dict[str, Json] | None = Field(
+        default=None,
+        description="Default value to use when you do not specify a value for the property.",
+    )
+    constraint_state: ConstraintOrIndexState = Field(
+        description="Describes the validity of constraints defined on this property"
+    )
+    type: DataType = Field(description="The type of data you can store in this property.")
+
+    def as_request(self) -> ViewCorePropertyRequest:
+        return ViewCorePropertyRequest.model_validate(self.model_dump(by_alias=True))
+
+
+class ConnectionPropertyDefinition(ViewPropertyDefinition, ABC):
+    name: str | None = Field(
+        default=None,
+        description="Readable property name.",
+        max_length=255,
+    )
+    description: str | None = Field(
+        default=None,
+        description="Description of the content and suggested use for this property..",
+        max_length=1024,
+    )
+
+
+class EdgeProperty(ConnectionPropertyDefinition, ABC):
+    source: ViewReference = Field(
+        description="The target node(s) of this connection can be read through the view specified in 'source'."
+    )
+    type: NodeReference = Field(
+        description="Reference to the node pointed to by the direct relation. The reference consists of a "
+        "space and an external-id."
+    )
+    edge_source: ViewReference | None = Field(
+        None, description="The edge(s) of this connection can be read through the view specified in 'edgeSource'."
+    )
+    direction: Literal["outwards", "inwards"] = Field(
+        "outwards", description="The direction of the edge(s) of this connection."
+    )
+
+
+class SingleEdgeProperty(EdgeProperty):
+    connection_type: Literal["single_edge_connection"] = "single_edge_connection"
+
+
+class MultiEdgeProperty(EdgeProperty):
+    connection_type: Literal["multi_edge_connection"] = "multi_edge_connection"
+
+
+class ReverseDirectRelationProperty(ConnectionPropertyDefinition, ABC):
+    source: ViewReference = Field(
+        description="The node(s) containing the direct relation property can be read "
+        "through the view specified in 'source'."
+    )
+
+
+class SingleReverseDirectRelationPropertyRequest(ReverseDirectRelationProperty):
+    connection_type: Literal["single_reverse_direct_relation"] = "single_reverse_direct_relation"
+    # The API support through as either ViewDirectReference or ContainerDirectReference. However, in Neat
+    # we only use ContainerDirectReference. This is for simplicity and it improves performance as the server
+    # does not have to resolve the view to a container first.
+    through: ContainerDirectReference = Field(
+        description="The view of the node containing the direct relation property."
+    )
+
+
+class SingleReverseDirectRelationPropertyResponse(
+    ReverseDirectRelationProperty, WriteableResource[SingleReverseDirectRelationPropertyRequest]
+):
+    connection_type: Literal["single_reverse_direct_relation"] = "single_reverse_direct_relation"
+    through: ContainerDirectReference | ViewDirectReference = Field(
+        description="The view of the node containing the direct relation property."
+    )
+
+    def as_request(self) -> SingleReverseDirectRelationPropertyRequest:
+        if isinstance(self.through, ViewDirectReference):
+            raise TypeError("Cannot convert to request when 'through' is a ViewDirectReference.")
+        return SingleReverseDirectRelationPropertyRequest.model_validate(self.model_dump(by_alias=True))
+
+
+class MultiReverseDirectRelationPropertyRequest(ReverseDirectRelationProperty):
+    connection_type: Literal["multi_reverse_direct_relation"] = "multi_reverse_direct_relation"
+    # The API support through as either ViewDirectReference or ContainerDirectReference. However, in Neat
+    # we only use ContainerDirectReference. This is for simplicity and it improves performance as the server
+    # does not have to resolve the view to a container first.
+    through: ContainerDirectReference = Field(
+        description="The view of the node containing the direct relation property."
+    )
+
+
+class MultiReverseDirectRelationPropertyResponse(
+    ReverseDirectRelationProperty, WriteableResource[MultiReverseDirectRelationPropertyRequest]
+):
+    connection_type: Literal["multi_reverse_direct_relation"] = "multi_reverse_direct_relation"
+    through: ContainerDirectReference | ViewDirectReference = Field(
+        description="The view of the node containing the direct relation property."
+    )
+
+    def as_request(self) -> MultiReverseDirectRelationPropertyRequest:
+        if isinstance(self.through, ViewDirectReference):
+            raise TypeError("Cannot convert to request when 'through' is a ViewDirectReference.")
+        return MultiReverseDirectRelationPropertyRequest.model_validate(self.model_dump(by_alias=True))
+
+
+ViewRequestProperty = Annotated[
+    SingleEdgeProperty
+    | MultiEdgeProperty
+    | SingleReverseDirectRelationPropertyRequest
+    | MultiReverseDirectRelationPropertyRequest
+    | ViewCorePropertyRequest,
+    Field(discriminator="connection_type"),
+]
+ViewResponseProperty = Annotated[
+    SingleEdgeProperty
+    | MultiEdgeProperty
+    | SingleReverseDirectRelationPropertyResponse
+    | MultiReverseDirectRelationPropertyResponse
+    | ViewCorePropertyResponse,
+    Field(discriminator="connection_type"),
+]