cognite-neat 0.82.0__tar.gz → 0.82.1__tar.gz

{cognite_neat-0.82.0 → cognite_neat-0.82.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cognite-neat
-Version: 0.82.0
+Version: 0.82.1
 Summary: Knowledge graph transformation
 Home-page: https://cognite-neat.readthedocs-hosted.com/
 License: Apache-2.0

cognite_neat-0.82.1/cognite/neat/_version.py

@@ -0,0 +1 @@
+__version__ = "0.82.1"

cognite_neat-0.82.1/cognite/neat/rules/_shared.py

@@ -0,0 +1,5 @@
+from typing import TypeAlias
+
+from cognite.neat.rules.models import AssetRules, DMSRules, DomainRules, InformationRules
+
+Rules: TypeAlias = DomainRules | InformationRules | DMSRules | AssetRules

{cognite_neat-0.82.0 → cognite_neat-0.82.1}/cognite/neat/rules/importers/_spreadsheet2rules.py

@@ -15,12 +15,14 @@ from cognite.neat.rules import issues
 from cognite.neat.rules.issues import IssueList
 from cognite.neat.rules.models import (
     RULES_PER_ROLE,
+    AssetRules,
     DMSRules,
     DomainRules,
     InformationRules,
     RoleTypes,
     SchemaCompleteness,
 )
+from cognite.neat.rules.models.asset import AssetRulesInput
 from cognite.neat.rules.models.dms import DMSRulesInput
 from cognite.neat.rules.models.information import InformationRulesInput
 from cognite.neat.utils.auxiliary import local_import
@@ -35,6 +37,7 @@ SOURCE_SHEET__TARGET_FIELD__HEADERS = [
         {
             RoleTypes.domain_expert: "Property",
             RoleTypes.information_architect: "Property",
+            RoleTypes.asset_architect: "Property",
             RoleTypes.dms_architect: "View Property",
         },
     ),
@@ -266,6 +269,8 @@ class ExcelImporter(BaseImporter):
                 rules = DMSRulesInput.load(sheets).as_rules()
             elif rules_cls is InformationRules:
                 rules = InformationRulesInput.load(sheets).as_rules()
+            elif rules_cls is AssetRules:
+                rules = AssetRulesInput.load(sheets).as_rules()
             else:
                 rules = rules_cls.model_validate(sheets)  # type: ignore[attr-defined]
 
@@ -300,7 +305,7 @@ class GoogleSheetImporter(BaseImporter):
         import gspread  # type: ignore[import]
 
         role = role or RoleTypes.domain_expert
-        rules_model = cast(DomainRules | InformationRules | DMSRules, RULES_PER_ROLE[role])
+        rules_model = cast(DomainRules | InformationRules | AssetRules | DMSRules, RULES_PER_ROLE[role])
 
         client_google = gspread.service_account()
         google_sheet = client_google.open_by_key(self.sheet_id)

{cognite_neat-0.82.0 → cognite_neat-0.82.1}/cognite/neat/rules/models/__init__.py

@@ -1,3 +1,4 @@
+from cognite.neat.rules.models.asset import AssetRules
 from cognite.neat.rules.models.domain import DomainRules
 from cognite.neat.rules.models.information._rules import InformationRules
 
@@ -5,9 +6,10 @@ from ._base import DataModelType, ExtensionCategory, RoleTypes, SchemaCompletene
 from .dms._rules import DMSRules
 from .dms._schema import DMSSchema
 
-RULES_PER_ROLE: dict[RoleTypes, type[DomainRules] | type[InformationRules] | type[DMSRules]] = {
+RULES_PER_ROLE: dict[RoleTypes, type[DomainRules] | type[InformationRules] | type[AssetRules] | type[DMSRules]] = {
     RoleTypes.domain_expert: DomainRules,
     RoleTypes.information_architect: InformationRules,
+    RoleTypes.asset_architect: AssetRules,
     RoleTypes.dms_architect: DMSRules,
 }
 
@@ -15,6 +17,7 @@ RULES_PER_ROLE: dict[RoleTypes, type[DomainRules] | type[InformationRules] | typ
 __all__ = [
     "DomainRules",
     "InformationRules",
+    "AssetRules",
     "DMSRules",
     "RULES_PER_ROLE",
     "DMSSchema",

{cognite_neat-0.82.0 → cognite_neat-0.82.1}/cognite/neat/rules/models/_base.py

@@ -151,6 +151,7 @@ class DataModelType(StrEnum):
 class RoleTypes(StrEnum):
     domain_expert = "domain expert"
     information_architect = "information architect"
+    asset_architect = "asset architect"
     dms_architect = "DMS Architect"
 
 

cognite_neat-0.82.1/cognite/neat/rules/models/asset/__init__.py

@@ -0,0 +1,10 @@
+from ._rules import AssetClass, AssetMetadata, AssetProperty, AssetRules
+from ._rules_input import AssetRulesInput
+
+__all__ = [
+    "AssetRules",
+    "AssetMetadata",
+    "AssetClass",
+    "AssetProperty",
+    "AssetRulesInput",
+]

cognite_neat-0.82.1/cognite/neat/rules/models/asset/_converter.py

@@ -0,0 +1,4 @@
+from cognite.neat.rules.models.information._converter import _InformationRulesConverter
+
+
+class _AssetRulesConverter(_InformationRulesConverter): ...

cognite_neat-0.82.1/cognite/neat/rules/models/asset/_rules.py

@@ -0,0 +1,156 @@
+import sys
+from typing import TYPE_CHECKING, Any, ClassVar, Literal, cast
+
+from pydantic import Field, field_validator, model_validator
+from pydantic.main import IncEx
+from rdflib import Namespace
+
+from cognite.neat.constants import PREFIXES
+from cognite.neat.issues import MultiValueError
+from cognite.neat.rules import issues
+from cognite.neat.rules.models._base import BaseRules, RoleTypes, SheetList
+from cognite.neat.rules.models.domain import DomainRules
+from cognite.neat.rules.models.entities import (
+    CdfResourceEntityList,
+    ClassEntity,
+    MultiValueTypeInfo,
+    ParentClassEntity,
+    Undefined,
+)
+from cognite.neat.rules.models.information import (
+    InformationClass,
+    InformationMetadata,
+    InformationProperty,
+    InformationRules,
+)
+
+if TYPE_CHECKING:
+    from cognite.neat.rules.models.dms._rules import DMSRules
+
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
+
+class AssetMetadata(InformationMetadata):
+    role: ClassVar[RoleTypes] = RoleTypes.asset_architect
+
+
+class AssetClass(InformationClass): ...
+
+
+class AssetProperty(InformationProperty):
+    """
+    A property is a characteristic of a class. It is a named attribute of a class that describes a range of values
+    or a relationship to another class.
+
+    Args:
+        class_: Class ID to which property belongs
+        property_: Property ID of the property
+        name: Property name.
+        value_type: Type of value property will hold (data or link to another class)
+        min_count: Minimum count of the property values. Defaults to 0
+        max_count: Maximum count of the property values. Defaults to None
+        default: Default value of the property
+        reference: Reference to the source of the information, HTTP URI
+        match_type: The match type of the resource being described and the source entity.
+        transformation: Actual rule for the transformation from source to target representation of
+              knowledge graph. Defaults to None (no transformation)
+        implementation: Details on how given class-property is implemented in the classic CDF
+    """
+
+    implementation: CdfResourceEntityList | None = Field(alias="Implementation", default=None)
+
+
+class AssetRules(BaseRules):
+    metadata: AssetMetadata = Field(alias="Metadata")
+    properties: SheetList[AssetProperty] = Field(alias="Properties")
+    classes: SheetList[AssetClass] = Field(alias="Classes")
+    prefixes: dict[str, Namespace] = Field(default_factory=lambda: PREFIXES.copy())
+    last: "AssetRules | None" = Field(None, alias="Last")
+    reference: "AssetRules | None" = Field(None, alias="Reference")
+
+    @field_validator("prefixes", mode="before")
+    def parse_str(cls, values: Any) -> Any:
+        if isinstance(values, dict):
+            return {key: Namespace(value) if isinstance(value, str) else value for key, value in values.items()}
+        return values
+
+    @model_validator(mode="after")
+    def update_entities_prefix(self) -> Self:
+        # update expected_value_types
+        for property_ in self.properties:
+            if isinstance(property_.value_type, ClassEntity) and property_.value_type.prefix is Undefined:
+                property_.value_type.prefix = self.metadata.prefix
+
+            if isinstance(property_.value_type, MultiValueTypeInfo):
+                property_.value_type.set_default_prefix(self.metadata.prefix)
+
+            if property_.class_.prefix is Undefined:
+                property_.class_.prefix = self.metadata.prefix
+
+        # update parent classes
+        for class_ in self.classes:
+            if class_.parent:
+                for parent in cast(list[ParentClassEntity], class_.parent):
+                    if not isinstance(parent.prefix, str):
+                        parent.prefix = self.metadata.prefix
+            if class_.class_.prefix is Undefined:
+                class_.class_.prefix = self.metadata.prefix
+
+        return self
+
+    @model_validator(mode="after")
+    def post_validation(self) -> "AssetRules":
+        from ._validation import AssetPostValidation
+
+        issue_list = AssetPostValidation(cast(InformationRules, self)).validate()
+        if issue_list.warnings:
+            issue_list.trigger_warnings()
+        if issue_list.has_errors:
+            raise MultiValueError([error for error in issue_list if isinstance(error, issues.NeatValidationError)])
+        return self
+
+    def dump(
+        self,
+        mode: Literal["python", "json"] = "python",
+        by_alias: bool = False,
+        exclude: IncEx = None,
+        exclude_none: bool = False,
+        exclude_unset: bool = False,
+        exclude_defaults: bool = False,
+        as_reference: bool = False,
+    ) -> dict[str, Any]:
+        from ._serializer import _AssetRulesSerializer
+
+        dumped = self.model_dump(
+            mode=mode,
+            by_alias=by_alias,
+            exclude=exclude,
+            exclude_none=exclude_none,
+            exclude_unset=exclude_unset,
+            exclude_defaults=exclude_defaults,
+        )
+        prefix = self.metadata.prefix
+        serializer = _AssetRulesSerializer(by_alias, prefix)
+        cleaned = serializer.clean(dumped, as_reference)
+        last = "Last" if by_alias else "last"
+        if last_dump := cleaned.get(last):
+            cleaned[last] = serializer.clean(last_dump, False)
+        reference = "Reference" if by_alias else "reference"
+        if self.reference and (ref_dump := cleaned.get(reference)):
+            prefix = self.reference.metadata.prefix
+            cleaned[reference] = _AssetRulesSerializer(by_alias, prefix).clean(ref_dump, True)
+        return cleaned
+
+    def as_domain_rules(self) -> DomainRules:
+        from ._converter import _AssetRulesConverter
+
+        return _AssetRulesConverter(cast(InformationRules, self)).as_domain_rules()
+
+    def as_dms_architect_rules(self) -> "DMSRules":
+        from ._converter import _AssetRulesConverter
+
+        return _AssetRulesConverter(cast(InformationRules, self)).as_dms_architect_rules()

cognite_neat-0.82.1/cognite/neat/rules/models/asset/_rules_input.py

@@ -0,0 +1,171 @@
+from collections.abc import Sequence
+from dataclasses import dataclass
+from typing import Any, cast, overload
+
+from cognite.neat.rules.models._base import _add_alias
+from cognite.neat.rules.models.data_types import DataType
+from cognite.neat.rules.models.entities import (
+    ClassEntity,
+    MultiValueTypeInfo,
+    Unknown,
+    UnknownEntity,
+)
+from cognite.neat.rules.models.information._rules_input import InformationClassInput, InformationMetadataInput
+
+from ._rules import AssetProperty, AssetRules
+
+
+@dataclass
+class AssetMetadataInput(InformationMetadataInput): ...
+
+
+@dataclass
+class AssetPropertyInput:
+    class_: str
+    property_: str
+    value_type: str
+    name: str | None = None
+    description: str | None = None
+    comment: str | None = None
+    min_count: int | None = None
+    max_count: int | float | None = None
+    default: Any | None = None
+    reference: str | None = None
+    match_type: str | None = None
+    transformation: str | None = None
+    implementation: str | None = None
+
+    @classmethod
+    @overload
+    def load(cls, data: None) -> None: ...
+
+    @classmethod
+    @overload
+    def load(cls, data: dict[str, Any]) -> "AssetPropertyInput": ...
+
+    @classmethod
+    @overload
+    def load(cls, data: list[dict[str, Any]]) -> list["AssetPropertyInput"]: ...
+
+    @classmethod
+    def load(
+        cls, data: dict[str, Any] | list[dict[str, Any]] | None
+    ) -> "AssetPropertyInput | list[AssetPropertyInput] | None":
+        if data is None:
+            return None
+        if isinstance(data, list) or (isinstance(data, dict) and isinstance(data.get("data"), list)):
+            items = cast(list[dict[str, Any]], data.get("data") if isinstance(data, dict) else data)
+            return [loaded for item in items if (loaded := cls.load(item)) is not None]
+
+        _add_alias(data, AssetProperty)
+        return cls(
+            class_=data.get("class_"),  # type: ignore[arg-type]
+            property_=data.get("property_"),  # type: ignore[arg-type]
+            name=data.get("name", None),
+            description=data.get("description", None),
+            comment=data.get("comment", None),
+            value_type=data.get("value_type"),  # type: ignore[arg-type]
+            min_count=data.get("min_count", None),
+            max_count=data.get("max_count", None),
+            default=data.get("default", None),
+            reference=data.get("reference", None),
+            match_type=data.get("match_type", None),
+            transformation=data.get("transformation", None),
+            implementation=data.get("implementation", None),
+        )
+
+    def dump(self, default_prefix: str) -> dict[str, Any]:
+        value_type: MultiValueTypeInfo | DataType | ClassEntity | UnknownEntity
+
+        # property holding xsd data type
+        # check if it is multi value type
+        if "|" in self.value_type:
+            value_type = MultiValueTypeInfo.load(self.value_type)
+            value_type.set_default_prefix(default_prefix)
+
+        elif DataType.is_data_type(self.value_type):
+            value_type = DataType.load(self.value_type)
+
+        # unknown value type
+        elif self.value_type == str(Unknown):
+            value_type = UnknownEntity()
+
+        # property holding link to class
+        else:
+            value_type = ClassEntity.load(self.value_type, prefix=default_prefix)
+
+        return {
+            "Class": ClassEntity.load(self.class_, prefix=default_prefix),
+            "Property": self.property_,
+            "Name": self.name,
+            "Description": self.description,
+            "Comment": self.comment,
+            "Value Type": value_type,
+            "Min Count": self.min_count,
+            "Max Count": self.max_count,
+            "Default": self.default,
+            "Reference": self.reference,
+            "Match Type": self.match_type,
+            "Transformation": self.transformation,
+            "Implementation": self.implementation,
+        }
+
+
+class AssetClassInput(InformationClassInput): ...
+
+
+@dataclass
+class AssetRulesInput:
+    metadata: AssetMetadataInput
+    properties: Sequence[AssetPropertyInput]
+    classes: Sequence[AssetClassInput]
+    last: "AssetRulesInput | AssetRules | None" = None
+    reference: "AssetRulesInput | AssetRules | None" = None
+
+    @classmethod
+    @overload
+    def load(cls, data: dict[str, Any]) -> "AssetRulesInput": ...
+
+    @classmethod
+    @overload
+    def load(cls, data: None) -> None: ...
+
+    @classmethod
+    def load(cls, data: dict | None) -> "AssetRulesInput | None":
+        if data is None:
+            return None
+        _add_alias(data, AssetRules)
+
+        return cls(
+            metadata=AssetMetadataInput.load(data.get("metadata")),  # type: ignore[arg-type]
+            properties=AssetPropertyInput.load(data.get("properties")),  # type: ignore[arg-type]
+            classes=InformationClassInput.load(data.get("classes")),  # type: ignore[arg-type]
+            last=AssetRulesInput.load(data.get("last")),
+            reference=AssetRulesInput.load(data.get("reference")),
+        )
+
+    def as_rules(self) -> AssetRules:
+        return AssetRules.model_validate(self.dump())
+
+    def dump(self) -> dict[str, Any]:
+        default_prefix = self.metadata.prefix
+        reference: dict[str, Any] | None = None
+        if isinstance(self.reference, AssetRulesInput):
+            reference = self.reference.dump()
+        elif isinstance(self.reference, AssetRules):
+            # We need to load through the AssetRulesInput to set the correct default space and version
+            reference = AssetRulesInput.load(self.reference.model_dump()).dump()
+        last: dict[str, Any] | None = None
+        if isinstance(self.last, AssetRulesInput):
+            last = self.last.dump()
+        elif isinstance(self.last, AssetRules):
+            # We need to load through the AssetRulesInput to set the correct default space and version
+            last = AssetRulesInput.load(self.last.model_dump()).dump()
+
+        return dict(
+            Metadata=self.metadata.dump(),
+            Properties=[prop.dump(default_prefix) for prop in self.properties],
+            Classes=[class_.dump(default_prefix) for class_ in self.classes],
+            Last=last,
+            Reference=reference,
+        )

cognite_neat-0.82.1/cognite/neat/rules/models/asset/_serializer.py

@@ -0,0 +1,73 @@
+from typing import Any, ClassVar
+
+from cognite.neat.rules.models.entities import ClassEntity, ReferenceEntity
+
+from ._rules import AssetClass, AssetProperty, AssetRules
+
+
+class _AssetRulesSerializer:
+    # These are the fields that need to be cleaned from the default space and version
+    PROPERTIES_FIELDS: ClassVar[list[str]] = ["class_", "value_type"]
+    CLASSES_FIELDS: ClassVar[list[str]] = ["class_"]
+
+    def __init__(self, by_alias: bool, default_prefix: str) -> None:
+        self.default_prefix = f"{default_prefix}:"
+
+        self.properties_fields = self.PROPERTIES_FIELDS
+        self.classes_fields = self.CLASSES_FIELDS
+
+        self.prop_name = "properties"
+        self.class_name = "classes"
+        self.metadata_name = "metadata"
+        self.class_parent = "parent"
+
+        self.prop_property = "property_"
+        self.prop_class = "class_"
+
+        self.reference = "Reference" if by_alias else "reference"
+        if by_alias:
+            self.properties_fields = [
+                AssetProperty.model_fields[field].alias or field for field in self.properties_fields
+            ]
+            self.classes_fields = [AssetClass.model_fields[field].alias or field for field in self.classes_fields]
+            self.prop_name = AssetRules.model_fields[self.prop_name].alias or self.prop_name
+            self.class_name = AssetRules.model_fields[self.class_name].alias or self.class_name
+            self.class_parent = AssetClass.model_fields[self.class_parent].alias or self.class_parent
+            self.metadata_name = AssetRules.model_fields[self.metadata_name].alias or self.metadata_name
+
+            self.prop_property = AssetProperty.model_fields[self.prop_property].alias or self.prop_property
+            self.prop_class = AssetProperty.model_fields[self.prop_class].alias or self.prop_class
+
+    def clean(self, dumped: dict[str, Any], as_reference: bool) -> dict[str, Any]:
+        # Sorting to get a deterministic order
+        dumped[self.prop_name] = sorted(
+            dumped[self.prop_name]["data"], key=lambda p: (p[self.prop_class], p[self.prop_property])
+        )
+        dumped[self.class_name] = sorted(dumped[self.class_name]["data"], key=lambda v: v[self.prop_class])
+
+        for prop in dumped[self.prop_name]:
+            if as_reference:
+                class_entity = ClassEntity.load(prop[self.prop_class])
+                prop[self.reference] = str(
+                    ReferenceEntity(
+                        prefix=str(class_entity.prefix), suffix=class_entity.suffix, property=prop[self.prop_property]
+                    )
+                )
+
+            for field_name in self.properties_fields:
+                if value := prop.get(field_name):
+                    prop[field_name] = value.removeprefix(self.default_prefix)
+
+        for class_ in dumped[self.class_name]:
+            if as_reference:
+                class_[self.reference] = class_[self.prop_class]
+            for field_name in self.classes_fields:
+                if value := class_.get(field_name):
+                    class_[field_name] = value.removeprefix(self.default_prefix)
+
+            if value := class_.get(self.class_parent):
+                class_[self.class_parent] = ",".join(
+                    parent.strip().removeprefix(self.default_prefix) for parent in value.split(",")
+                )
+
+        return dumped

cognite_neat-0.82.1/cognite/neat/rules/models/asset/_validation.py

@@ -0,0 +1,4 @@
+from cognite.neat.rules.models.information._validation import InformationPostValidation
+
+
+class AssetPostValidation(InformationPostValidation): ...

{cognite_neat-0.82.0 → cognite_neat-0.82.1}/cognite/neat/rules/models/entities.py

@@ -48,6 +48,8 @@ class EntityTypes(StrEnum):
     datamodel = "datamodel"
     undefined = "undefined"
     multi_value_type = "multi_value_type"
+    asset = "asset"
+    relationship = "relationship"
 
 
 # ALLOWED
@@ -204,7 +206,7 @@ class Entity(BaseModel, extra="ignore"):
             if (v := getattr(self, field_name)) is not None and field_name not in {"prefix", "suffix"}
         )
         args = ",".join([f"{k}={v}" for k, v in model_dump])
-        if self.prefix is Undefined:
+        if self.prefix == Undefined:
             base_id = str(self.suffix)
         else:
             base_id = f"{self.prefix}:{self.suffix!s}"
@@ -267,6 +269,28 @@ class UnknownEntity(ClassEntity):
         return str(Unknown)
 
 
+class AssetFields(StrEnum):
+    external_id = "external_id"
+    name = "name"
+    parent_external_id = "parent_external_id"
+    description = "description"
+    metadata = "metadata"
+
+
+class AssetEntity(Entity):
+    type_: ClassVar[EntityTypes] = EntityTypes.asset
+    suffix: str = "Asset"
+    prefix: _UndefinedType = Undefined
+    property_: AssetFields = Field(alias="property")
+
+
+class RelationshipEntity(Entity):
+    type_: ClassVar[EntityTypes] = EntityTypes.relationship
+    suffix: str = "Relationship"
+    prefix: _UndefinedType = Undefined
+    label: str | None = None
+
+
 T_ID = TypeVar("T_ID", bound=ContainerId | ViewId | DataModelId | PropertyId | NodeId | None)
 
 
@@ -505,6 +529,25 @@ def _join_str(v: list[ClassEntity]) -> str | None:
     return ",".join([entry.id for entry in v]) if v else None
 
 
+def _generate_cdf_resource_list(v: Any) -> list[AssetEntity | RelationshipEntity]:
+    results = []
+    for item in _split_str(v):
+        if isinstance(item, str):
+            if "relationship" in item.lower():
+                results.append(RelationshipEntity.load(item))
+            elif "asset" in item.lower():
+                results.append(AssetEntity.load(item))  # type: ignore
+            else:
+                raise ValueError(f"Unsupported implementation definition: {item}")
+
+        elif isinstance(item, AssetEntity | RelationshipEntity):
+            results.append(item)
+        else:
+            raise ValueError(f"Unsupported implementation definition: {item}")
+
+    return results  # type: ignore
+
+
 ParentEntityList = Annotated[
     list[ParentClassEntity],
     BeforeValidator(_split_str),
@@ -515,6 +558,18 @@ ParentEntityList = Annotated[
     ),
 ]
 
+
+CdfResourceEntityList = Annotated[
+    list[AssetEntity | RelationshipEntity],
+    BeforeValidator(_generate_cdf_resource_list),
+    PlainSerializer(
+        _join_str,
+        return_type=str,
+        when_used="unless-none",
+    ),
+]
+
+
 ContainerEntityList = Annotated[
     list[ContainerEntity],
     BeforeValidator(_split_str),

{cognite_neat-0.82.0 → cognite_neat-0.82.1}/cognite/neat/workflows/steps/data_contracts.py

@@ -7,7 +7,7 @@ from cognite.client.data_classes.data_modeling import EdgeApply, NodeApply
 from cognite.neat.legacy.graph.stores import NeatGraphStoreBase
 from cognite.neat.legacy.rules.exporters._rules2dms import DMSSchemaComponents
 from cognite.neat.legacy.rules.models.rules import Rules
-from cognite.neat.rules.models import DMSRules, DomainRules, InformationRules
+from cognite.neat.rules.models import AssetRules, DMSRules, DomainRules, InformationRules
 from cognite.neat.workflows.steps.step_model import DataContract
 
 
@@ -25,14 +25,17 @@ class RulesData(DataContract):
 class MultiRuleData(DataContract):
     domain: DomainRules | None = None
     information: InformationRules | None = None
+    asset: AssetRules | None = None
     dms: DMSRules | None = None
 
     @classmethod
-    def from_rules(cls, rules: DomainRules | InformationRules | DMSRules):
+    def from_rules(cls, rules: DomainRules | InformationRules | AssetRules | DMSRules):
         if isinstance(rules, DomainRules):
             return cls(domain=rules)
         elif isinstance(rules, InformationRules):
             return cls(information=rules)
+        elif isinstance(rules, AssetRules):
+            return cls(asset=rules)
         elif isinstance(rules, DMSRules):
             return cls(dms=rules)
         else:

{cognite_neat-0.82.0 → cognite_neat-0.82.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "cognite-neat"
-version = "0.82.0"
+version = "0.82.1"
 readme = "README.md"
 description = "Knowledge graph transformation"
 authors = [
@@ -147,9 +147,7 @@ types-PyYAML = "^6"
 types-openpyxl = "^3"
 types-requests = "^2"
 types-setuptools = "^68"
-# Temporarily removing cognite-toolkit as we need version 0.1.2 to be released due to the
-# current strict upper bound on cognite-sdk.
-#cognite-toolkit = {git = "https://github.com/cognitedata/cdf-project-templates.git", branch = "main"}
+cognite-toolkit = "^0.2.4"
 
 
 [build-system]

cognite_neat-0.82.0/cognite/neat/_version.py

@@ -1 +0,0 @@
-__version__ = "0.82.0"

cognite_neat-0.82.0/cognite/neat/rules/_shared.py

@@ -1,5 +0,0 @@
-from typing import TypeAlias
-
-from cognite.neat.rules.models import DMSRules, DomainRules, InformationRules
-
-Rules: TypeAlias = DomainRules | InformationRules | DMSRules