cognite-neat 0.103.1__tar.gz → 0.105.0__tar.gz

{cognite_neat-0.103.1 → cognite_neat-0.105.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: cognite-neat
-Version: 0.103.1
+Version: 0.105.0
 Summary: Knowledge graph transformation
 Home-page: https://cognite-neat.readthedocs-hosted.com/
 License: Apache-2.0
@@ -29,6 +29,7 @@ Requires-Dist: google-auth-oauthlib ; extra == "google"
 Requires-Dist: gspread ; extra == "google"
 Requires-Dist: jsonpath-python (>=1.0.6,<2.0.0)
 Requires-Dist: lxml (>=5.3.0,<6.0.0) ; extra == "all"
+Requires-Dist: mistune (==3.0.2) ; extra == "docs"
 Requires-Dist: mixpanel (>=4.10.1,<5.0.0)
 Requires-Dist: mkdocs ; extra == "docs"
 Requires-Dist: mkdocs-autorefs (>=0.5.0,<0.6.0) ; extra == "docs"

{cognite_neat-0.103.1 → cognite_neat-0.105.0}/cognite/neat/_client/_api/data_modeling_loaders.py

@@ -3,7 +3,7 @@ from abc import ABC, abstractmethod
 from collections.abc import Callable, Collection, Iterable, Sequence
 from dataclasses import dataclass, field
 from graphlib import TopologicalSorter
-from typing import TYPE_CHECKING, Any, ClassVar, Generic, Literal, TypeVar, cast
+from typing import TYPE_CHECKING, Any, ClassVar, Generic, Literal, TypeVar, cast, overload
 
 from cognite.client.data_classes import filters
 from cognite.client.data_classes._base import (
@@ -124,23 +124,37 @@ class ResourceLoader(
 
         return created
 
-    def retrieve(self, ids: SequenceNotStr[T_ID]) -> T_WritableCogniteResourceList:
+    @overload
+    def retrieve(
+        self, ids: SequenceNotStr[T_ID], format: Literal["read"] = "read"
+    ) -> T_WritableCogniteResourceList: ...
+
+    @overload
+    def retrieve(self, ids: SequenceNotStr[T_ID], format: Literal["write"] = "write") -> T_CogniteResourceList: ...
+
+    def retrieve(
+        self, ids: SequenceNotStr[T_ID], format: Literal["read", "write"] = "read"
+    ) -> T_WritableCogniteResourceList | T_CogniteResourceList:
         if not self.cache:
             # We now that SequenceNotStr = Sequence
-            return self._fallback_one_by_one(self._retrieve, ids)  # type: ignore[arg-type]
-        exception: MultiCogniteAPIError[T_ID, T_WritableCogniteResourceList] | None = None
-        missing_ids = [id for id in ids if id not in self._items_by_id.keys()]
-        if missing_ids:
-            try:
-                retrieved = self._retrieve(missing_ids)
-            except MultiCogniteAPIError as e:
-                retrieved = e.success
-                exception = e
-            self._items_by_id.update({self.get_id(item): item for item in retrieved})
-        if exception is not None:
-            raise exception
-        # We need to check the cache again, in case we didn't retrieve all the items.
-        return self._create_list([self._items_by_id[id] for id in ids if id in self._items_by_id])
+            output = self._fallback_one_by_one(self._retrieve, ids)  # type: ignore[arg-type]
+        else:
+            exception: MultiCogniteAPIError[T_ID, T_WritableCogniteResourceList] | None = None
+            missing_ids = [id for id in ids if id not in self._items_by_id.keys()]
+            if missing_ids:
+                try:
+                    retrieved = self._retrieve(missing_ids)
+                except MultiCogniteAPIError as e:
+                    retrieved = e.success
+                    exception = e
+                self._items_by_id.update({self.get_id(item): item for item in retrieved})
+            if exception is not None:
+                raise exception
+            # We need to check the cache again, in case we didn't retrieve all the items.
+            output = self._create_list([self._items_by_id[id] for id in ids if id in self._items_by_id])
+        if format == "write":
+            return cast(T_CogniteResourceList, output.as_write())
+        return output
 
     def update(
         self, items: Sequence[T_WriteClass], force: bool = False, drop_data: bool = False
@@ -404,11 +418,30 @@ class ContainerLoader(DataModelingLoader[ContainerId, ContainerApply, Container,
     def _create(self, items: Sequence[ContainerApply]) -> ContainerList:
         return self._client.data_modeling.containers.apply(items)
 
-    def retrieve(self, ids: SequenceNotStr[ContainerId], include_connected: bool = False) -> ContainerList:
+    @overload
+    def retrieve(
+        self, ids: SequenceNotStr[ContainerId], format: Literal["read"] = "read", include_connected: bool = False
+    ) -> ContainerList: ...
+
+    @overload
+    def retrieve(
+        self, ids: SequenceNotStr[ContainerId], format: Literal["write"] = "write", include_connected: bool = False
+    ) -> ContainerApplyList: ...
+
+    def retrieve(
+        self,
+        ids: SequenceNotStr[ContainerId],
+        format: Literal["read", "write"] = "read",
+        include_connected: bool = False,
+    ) -> ContainerList | ContainerApplyList:
         if not include_connected:
             return super().retrieve(ids)
+
         # Retrieve recursively updates the cache.
-        return self._retrieve_recursive(ids)
+        output = self._retrieve_recursive(ids)
+        if format == "write":
+            return output.as_write()
+        return output
 
     def _retrieve(self, ids: SequenceNotStr[ContainerId]) -> ContainerList:
         return self._client.data_modeling.containers.retrieve(cast(Sequence, ids))
@@ -531,13 +564,40 @@ class ViewLoader(DataModelingLoader[ViewId, ViewApply, View, ViewApplyList, View
     def _create(self, items: Sequence[ViewApply]) -> ViewList:
         return self._client.data_modeling.views.apply(items)
 
+    @overload
     def retrieve(
-        self, ids: SequenceNotStr[ViewId], include_connected: bool = False, include_ancestor: bool = False
-    ) -> ViewList:
+        self,
+        ids: SequenceNotStr[ViewId],
+        format: Literal["read"] = "read",
+        include_connected: bool = False,
+        include_ancestor: bool = False,
+    ) -> ViewList: ...
+
+    @overload
+    def retrieve(
+        self,
+        ids: SequenceNotStr[ViewId],
+        format: Literal["write"] = "write",
+        include_connected: bool = False,
+        include_ancestor: bool = False,
+    ) -> ViewApplyList: ...
+
+    def retrieve(
+        self,
+        ids: SequenceNotStr[ViewId],
+        format: Literal["read", "write"] = "read",
+        include_connected: bool = False,
+        include_ancestor: bool = False,
+    ) -> ViewList | ViewApplyList:
         if not include_connected and not include_ancestor:
-            return super().retrieve(ids)
-        # Retrieve recursively updates the cache.
-        return self._retrieve_recursive(ids, include_connected, include_ancestor)
+            # Default .as_write() method does not work for views as they include parent properties.
+            output = super().retrieve(ids)
+        else:
+            # Retrieve recursively updates the cache.
+            output = self._retrieve_recursive(ids, include_connected, include_ancestor)
+        if format == "write":
+            return ViewApplyList([self.as_write(view) for view in output])
+        return output
 
     def _retrieve(self, ids: SequenceNotStr[ViewId]) -> ViewList:
         return self._client.data_modeling.views.retrieve(cast(Sequence, ids))

{cognite_neat-0.103.1 → cognite_neat-0.105.0}/cognite/neat/_client/_api/schema.py

@@ -27,7 +27,8 @@ class SchemaAPI:
         if data_model_id.version is None:
             raise NeatValueError("Data model version must be specified")
         read_views = self._client.loaders.views.retrieve(
-            view_ids,  # type: ignore[arg-type]
+            list(view_ids),
+            format="read",
             include_connected=include_connections,
             include_ancestor=include_ancestors,
         )

cognite_neat-0.105.0/cognite/neat/_client/data_classes/neat_sequence.py

@@ -0,0 +1,261 @@
+"""Neat sequence combines the CogniteClient sequence and the SequenceRows"""
+
+import sys
+import warnings
+from abc import ABC
+from collections.abc import Sequence
+from typing import Any, cast
+
+import cognite.client.data_classes as cdc
+from cognite.client import CogniteClient
+from cognite.client.data_classes import (
+    SequenceColumn,
+    SequenceColumnList,
+    SequenceColumnWrite,
+    SequenceColumnWriteList,
+    SequenceRow,
+)
+from cognite.client.data_classes._base import (
+    CogniteResourceList,
+    ExternalIDTransformerMixin,
+    IdTransformerMixin,
+    WriteableCogniteResource,
+    WriteableCogniteResourceList,
+)
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
+
+class NeatSequenceCore(WriteableCogniteResource["NeatSequenceWrite"], ABC):
+    """Information about the sequence stored in the database
+
+    Args:
+        name (str | None): Name of the sequence
+        description (str | None): Description of the sequence
+        asset_id (int | None): Optional asset this sequence is associated with
+        external_id (str | None): The external ID provided by the client. Must be unique for the resource type.
+        metadata (dict[str, Any] | None): Custom, application-specific metadata. String key -> String value.
+            The maximum length of the key is 32 bytes, the value 512 bytes, with up to 16 key-value pairs.
+        data_set_id (int | None): Data set that this sequence belongs to
+        rows (typing.Sequence[SequenceRow] | None): The rows in the sequence.
+    """
+
+    def __init__(
+        self,
+        name: str | None = None,
+        description: str | None = None,
+        asset_id: int | None = None,
+        external_id: str | None = None,
+        metadata: dict[str, Any] | None = None,
+        data_set_id: int | None = None,
+        rows: Sequence[SequenceRow] | None = None,
+    ) -> None:
+        self.name = name
+        self.description = description
+        self.asset_id = asset_id
+        self.external_id = external_id
+        self.metadata = metadata
+        self.data_set_id = data_set_id
+        self.rows = rows
+
+
+class NeatSequenceWrite(NeatSequenceCore):
+    """Information about the sequence stored in the database.
+    This is the writing version of the class, it is used for inserting data into the CDF.
+
+    Args:
+        columns (typing.Sequence[SequenceColumnWrite]): List of column definitions
+        name (str | None): Name of the sequence
+        description (str | None): Description of the sequence
+        asset_id (int | None): Optional asset this sequence is associated with
+        external_id (str | None): The external ID provided by the client. Must be unique for the resource type.
+        metadata (dict[str, Any] | None): Custom, application-specific metadata. String key -> String value.
+            The maximum length of key is 32 bytes, value 512 bytes, up to 16 key-value pairs.
+        data_set_id (int | None): Data set that this sequence belongs to
+        rows (typing.Sequence[SequenceRow] | None): The rows in the sequence.
+    """
+
+    def __init__(
+        self,
+        columns: Sequence[SequenceColumnWrite],
+        name: str | None = None,
+        description: str | None = None,
+        asset_id: int | None = None,
+        external_id: str | None = None,
+        metadata: dict[str, Any] | None = None,
+        data_set_id: int | None = None,
+        rows: Sequence[SequenceRow] | None = None,
+    ) -> None:
+        super().__init__(
+            name=name,
+            description=description,
+            asset_id=asset_id,
+            external_id=external_id,
+            metadata=metadata,
+            data_set_id=data_set_id,
+            rows=rows,
+        )
+        self.columns: SequenceColumnWriteList
+        if isinstance(columns, SequenceColumnWriteList):
+            self.columns = columns
+        elif isinstance(columns, Sequence) and all(isinstance(col, SequenceColumnWrite) for col in columns):
+            self.columns = SequenceColumnWriteList(columns)
+        else:
+            raise ValueError(f"columns must be a sequence of SequenceColumnWrite objects not {type(columns)}")
+
+    @classmethod
+    def _load(cls, resource: dict, cognite_client: CogniteClient | None = None) -> Self:
+        return cls(
+            columns=SequenceColumnWriteList._load(resource["columns"]),
+            name=resource.get("name"),
+            description=resource.get("description"),
+            asset_id=resource.get("assetId"),
+            external_id=resource.get("externalId"),
+            metadata=resource.get("metadata"),
+            data_set_id=resource.get("dataSetId"),
+            rows=[SequenceRow._load(row) for row in resource.get("rows", [])],
+        )
+
+    def dump(self, camel_case: bool = True) -> dict[str, Any]:
+        dumped = super().dump(camel_case)
+        dumped["columns"] = self.columns.dump(camel_case)
+        if self.rows is not None:
+            dumped["rows"] = [row.dump(camel_case) for row in self.rows]
+        return dumped
+
+    def as_write(self) -> "NeatSequenceWrite":
+        """Returns this NeatSequenceWrite."""
+        return self
+
+
+class NeatSequence(NeatSequenceCore):
+    """Information about the sequence stored in the database.
+    This is the reading version of the class, it is used for retrieving data from the CDF.
+
+    Args:
+        id (int): Unique cognite-provided identifier for the sequence
+        name (str | None): Name of the sequence
+        created_time (int | None): Time when this sequence was created in CDF in milliseconds since Jan 1, 1970.
+        last_updated_time (int | None): The last time this sequence was updated in CDF,
+            in milliseconds since Jan 1, 1970.
+        description (str | None): Description of the sequence
+        asset_id (int | None): Optional asset this sequence is associated with
+        external_id (str | None): The external ID provided by the client. Must be unique for the resource type.
+        metadata (dict[str, Any] | None): Custom, application-specific metadata. String key -> String value.
+            The maximum length of the key is 32 bytes, the value 512 bytes, with up to 16 key-value pairs.
+        columns (Sequence[SequenceColumn] | None): List of column definitions
+
+        data_set_id (int | None): Data set that this sequence belongs to
+        rows (Sequence[SequenceRow] | None): The rows in the sequence.
+        cognite_client (CogniteClient | None): The client to associate with this object.
+    """
+
+    def __init__(
+        self,
+        id: int,
+        created_time: int,
+        last_updated_time: int,
+        name: str | None = None,
+        description: str | None = None,
+        asset_id: int | None = None,
+        external_id: str | None = None,
+        metadata: dict[str, Any] | None = None,
+        columns: Sequence[SequenceColumn] | None = None,
+        data_set_id: int | None = None,
+        rows: Sequence[SequenceRow] | None = None,
+        cognite_client: CogniteClient | None = None,
+    ) -> None:
+        super().__init__(
+            name=name,
+            description=description,
+            asset_id=asset_id,
+            external_id=external_id,
+            metadata=metadata,
+            data_set_id=data_set_id,
+            rows=rows,
+        )
+        self.id = id
+        self.created_time = created_time
+        self.last_updated_time = last_updated_time
+
+        self.columns: SequenceColumnList | None
+        if columns is None or isinstance(columns, SequenceColumnList):
+            self.columns = columns
+        elif isinstance(columns, Sequence) and all(isinstance(col, SequenceColumn) for col in columns):
+            self.columns = SequenceColumnList(columns)
+        elif isinstance(columns, list):
+            warnings.warn(
+                "Columns is no longer a dict, you should first load the list of dictionaries using "
+                "SequenceColumnList.load([{...}, {...}])",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            self.columns = SequenceColumnList._load(columns)
+        else:
+            raise ValueError(f"columns must be a sequence of SequenceColumn objects not {type(columns)}")
+        self._cognite_client = cast("CogniteClient", cognite_client)
+
+    @classmethod
+    def from_cognite_sequence(
+        cls, sequence: cdc.Sequence, rows: Sequence[cdc.SequenceRow] | None = None
+    ) -> "NeatSequence":
+        """Create a NeatSequence from a Cognite Sequence object."""
+        args = sequence.dump(camel_case=True)
+        if rows is not None:
+            args["rows"] = [row.dump(camel_case=True) for row in rows]
+        return cls._load(args)
+
+    @classmethod
+    def _load(cls, resource: dict, cognite_client: CogniteClient | None = None) -> Self:
+        return cls(
+            id=resource["id"],
+            created_time=resource["createdTime"],
+            last_updated_time=resource["lastUpdatedTime"],
+            name=resource.get("name"),
+            description=resource.get("description"),
+            asset_id=resource.get("assetId"),
+            external_id=resource.get("externalId"),
+            metadata=resource.get("metadata"),
+            columns=SequenceColumnList._load(resource["columns"]) if "columns" in resource else None,
+            data_set_id=resource.get("dataSetId"),
+            rows=[SequenceRow._load(row) for row in resource.get("rows", [])] or None,
+        )
+
+    def as_write(self) -> "NeatSequenceWrite":
+        """Returns a writeable version of this sequence."""
+        if self.columns is None:
+            raise ValueError("Columns must be set for the writing version of the sequence")
+
+        return NeatSequenceWrite(
+            external_id=self.external_id,
+            name=self.name,
+            description=self.description,
+            asset_id=self.asset_id,
+            metadata=self.metadata,
+            data_set_id=self.data_set_id,
+            columns=self.columns.as_write(),
+            rows=self.rows,
+        )
+
+    def dump(self, camel_case: bool = True) -> dict[str, Any]:
+        dumped = super().dump(camel_case)
+        if self.columns is not None:
+            dumped["columns"] = self.columns.dump(camel_case)
+        if self.rows is not None:
+            dumped["rows"] = [row.dump(camel_case) for row in self.rows]
+        return dumped
+
+
+class NeatSequenceWriteList(CogniteResourceList[NeatSequenceWrite], ExternalIDTransformerMixin):
+    _RESOURCE = NeatSequenceWrite
+
+
+class NeatSequenceList(WriteableCogniteResourceList[NeatSequenceWrite, NeatSequence], IdTransformerMixin):
+    _RESOURCE = NeatSequence
+
+    def as_write(self) -> NeatSequenceWriteList:
+        """Returns a writeable version of this sequence list."""
+        return NeatSequenceWriteList([item.as_write() for item in self], cognite_client=self._get_cognite_client())

{cognite_neat-0.103.1 → cognite_neat-0.105.0}/cognite/neat/_client/data_classes/schema.py

@@ -207,7 +207,7 @@ class DMSSchema:
             if "containers" not in exclude_set:
                 for container in self.containers.values():
                     zip_ref.writestr(
-                        f"data_models/containers{container.external_id}.container.yaml", container.dump_yaml()
+                        f"data_models/containers/{container.external_id}.container.yaml", container.dump_yaml()
                     )
             if "node_types" not in exclude_set:
                 for node in self.node_types.values():
@@ -378,6 +378,10 @@ class DMSSchema:
         referenced_containers |= set(self.containers.keys())
         return referenced_containers
 
+    def externally_referenced_containers(self) -> set[dm.ContainerId]:
+        """Get the containers referenced by the schema that are not defined in the schema."""
+        return {container for container in self.referenced_container() if container not in self.containers}
+
     def as_read_model(self) -> dm.DataModel[dm.View]:
         if self.data_model is None:
             raise ValueError("Data model is not defined")

cognite_neat-0.105.0/cognite/neat/_client/testing.py

@@ -0,0 +1,33 @@
+from collections.abc import Iterator
+from contextlib import contextmanager
+from typing import Any
+
+from cognite.client.testing import CogniteClientMock
+
+from cognite.neat._client._api_client import NeatClient
+
+from ._api.data_modeling_loaders import DataModelLoaderAPI
+from ._api.schema import SchemaAPI
+
+
+class NeatClientMock(CogniteClientMock):
+    """Mock for ToolkitClient object
+
+    All APIs are replaced with specked MagicMock objects.
+    """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        if "parent" in kwargs:
+            super().__init__(*args, **kwargs)
+            return None
+        super().__init__(*args, **kwargs)
+        self.schema = SchemaAPI(self)
+        self.loaders = DataModelLoaderAPI(self)
+
+
+@contextmanager
+def monkeypatch_neat_client() -> Iterator[NeatClient]:
+    neat_client_mock = NeatClientMock()
+    NeatClient.__new__ = lambda *args, **kwargs: neat_client_mock  # type: ignore[method-assign]
+    yield neat_client_mock
+    NeatClient.__new__ = lambda cls, *args, **kwargs: object.__new__(cls)  # type: ignore[method-assign]

{cognite_neat-0.103.1 → cognite_neat-0.105.0}/cognite/neat/_constants.py

@@ -1,10 +1,16 @@
+from collections.abc import Mapping
 from pathlib import Path
+from typing import TYPE_CHECKING
 
+from cognite.client import data_modeling as dm
 from cognite.client.data_classes.data_modeling.ids import DataModelId
 from rdflib import DC, DCTERMS, FOAF, OWL, RDF, RDFS, SH, SKOS, XSD, Namespace, URIRef
 
 from cognite import neat
 
+if TYPE_CHECKING:
+    from cognite.neat._rules.models.dms import DMSProperty
+
 
 def _is_in_notebook() -> bool:
     try:
@@ -97,3 +103,53 @@ DEFAULT_DOCS_URL = "https://cognite-neat.readthedocs-hosted.com/en/latest/"
 
 DMS_CONTAINER_PROPERTY_SIZE_LIMIT = 100
 DMS_VIEW_CONTAINER_SIZE_LIMIT = 10
+
+_ASSET_ROOT_PROPERTY = {
+    "connection": "direct",
+    "container": "cdf_cdm:CogniteAsset",
+    "container_property": "assetHierarchy_root",
+    "description": "An automatically updated reference to the top-level asset of the hierarchy.",
+    "immutable": False,
+    "is_list": False,
+    "name": "Root",
+    "nullable": True,
+    "value_type": "cdf_cdm:CogniteAsset(version=v1)",
+    "view": "cdf_cdm:CogniteAsset(version=v1)",
+    "view_property": "root",
+}
+
+_ASSET_PATH_PROPERTY = {
+    "connection": "direct",
+    "container": "cdf_cdm:CogniteAsset",
+    "container_property": "assetHierarchy_path",
+    "description": (
+        "An automatically updated ordered list of this asset's ancestors, starting with the root asset. "
+        "Enables subtree filtering to find all assets under a parent."
+    ),
+    "immutable": False,
+    "is_list": True,
+    "name": "Path",
+    "nullable": True,
+    "value_type": "cdf_cdm:CogniteAsset(version=v1)",
+    "view": "cdf_cdm:CogniteAsset(version=v1)",
+    "view_property": "path",
+}
+
+
+def get_asset_read_only_properties_with_connection() -> "list[DMSProperty]":
+    """Gets the asset read-only properties with connection, i.e. Root and Path."""
+    from cognite.neat._rules.models.dms import DMSProperty
+
+    return [DMSProperty.model_validate(item) for item in (_ASSET_ROOT_PROPERTY, _ASSET_PATH_PROPERTY)]
+
+
+READONLY_PROPERTIES_BY_CONTAINER: Mapping[dm.ContainerId, frozenset[str]] = {
+    dm.ContainerId("cdf_cdm", "CogniteAsset"): frozenset(
+        {"assetHierarchy_root", "assetHierarchy_path", "assetHierarchy_path_last_updated_time"}
+    ),
+    dm.ContainerId("cdf_cdm", "CogniteFile"): frozenset({"isUploaded", "uploadedTime"}),
+}
+
+
+def is_readonly_property(container: dm.ContainerId, property_: str) -> bool:
+    return container in READONLY_PROPERTIES_BY_CONTAINER and property_ in READONLY_PROPERTIES_BY_CONTAINER[container]

{cognite_neat-0.103.1 → cognite_neat-0.105.0}/cognite/neat/_graph/extractors/_classic_cdf/_base.py

@@ -139,11 +139,8 @@ class ClassicCDFBaseExtractor(BaseExtractor, ABC, Generic[T_CogniteResource]):
         dumped.pop("parentExternalId", None)
         if "metadata" in dumped:
             triples.extend(self._metadata_to_triples(id_, dumped.pop("metadata")))
-        if "columns" in dumped:
-            columns = dumped.pop("columns")
-            triples.append(
-                (id_, self.namespace.columns, Literal(json.dumps({"columns": columns}), datatype=XSD._NS["json"]))
-            )
+
+        triples.extend(self._item2triples_special_cases(id_, dumped))
 
         for key, value in dumped.items():
             if value is None or value == []:
@@ -153,6 +150,10 @@ class ClassicCDFBaseExtractor(BaseExtractor, ABC, Generic[T_CogniteResource]):
                 triples.append((id_, self.namespace[key], self._as_object(raw, key)))
         return triples
 
+    def _item2triples_special_cases(self, id_: URIRef, dumped: dict[str, Any]) -> list[Triple]:
+        """This can be overridden to handle special cases for the item."""
+        return []
+
     def _fallback_id(self, item: T_CogniteResource) -> str | None:
         raise AttributeError(
             f"Item of type {type(item)} does not have an id attribute. "