cognite-toolkit 0.5.97__py3-none-any.whl → 0.7.34__py3-none-any.whl

cognite_toolkit/_cdf_tk/_parameters/functions.py

@@ -1,190 +0,0 @@
-import inspect
-from typing import Any, Literal, get_args, get_origin
-
-from .constants import ANY_INT, ANY_STR, ANYTHING, BASE_TYPES, CONTAINER_TYPES
-from .data_classes import ParameterSet, ParameterSpec, ParameterSpecSet, ParameterValue
-from .get_type_hints import _TypeHints
-from .type_hint import TypeHint
-
-
-def read_parameter_from_init_type_hints(cls_: type) -> ParameterSpecSet:
-    return ParameterFromInitTypeHints().read(cls_)
-
-
-class ParameterFromInitTypeHints:
-    """Finds the parameters of a class by reading the type hints of the __init__ method."""
-
-    def __init__(self) -> None:
-        self.parameter_set = ParameterSpecSet()
-
-    def read(self, cls_: type) -> ParameterSpecSet:
-        self._read(cls_, tuple(), set())
-        return self.parameter_set
-
-    def _read(self, cls_: type, path: tuple[str | int, ...], seen: set[str]) -> None:
-        if not hasattr(cls_, "__init__"):
-            return None
-
-        classes = _TypeHints.get_concrete_classes(cls_)
-        try:
-            seen.add(cls_.__name__)
-        except AttributeError:
-            # Python 3.9
-            if str(cls_) == "typing.Any":
-                return None
-            raise
-        seen.update(cls_.__name__ for cls_ in classes)
-        for cls_ in classes:
-            type_hints_by_name = _TypeHints.get_type_hints_by_name(cls_)
-            for name, parameter in inspect.signature(cls_.__init__).parameters.items():  # type: ignore[misc]
-                if name == "self" or parameter.kind in [parameter.VAR_POSITIONAL, parameter.VAR_KEYWORD]:
-                    continue
-                try:
-                    hint = TypeHint(type_hints_by_name[name])
-                except KeyError:
-                    # Missing type hint
-                    self.parameter_set.is_complete = False
-                    continue
-
-                is_required = parameter.default is inspect.Parameter.empty
-                is_nullable = hint.is_nullable or parameter.default is None
-                self.parameter_set.add(ParameterSpec((*path, name), hint.frozen_types, is_required, is_nullable))
-                for subhint in hint.sub_hints:
-                    if not subhint.is_base_type:
-                        self._create_nested_parameters((name,), is_required, hint, path, seen)
-
-    def _create_nested_parameters(
-        self,
-        parent_name: tuple[str | int, ...],
-        is_parent_required: bool,
-        hint: TypeHint,
-        path: tuple[str | int, ...],
-        seen: set[str],
-    ) -> None:
-        for sub_hint in hint.sub_hints:
-            if sub_hint.is_dict_type:
-                self._create_parameter_spec_dict(sub_hint, parent_name, path, seen)
-            if sub_hint.is_list_type:
-                self._create_parameter_spec_list(sub_hint, parent_name, is_parent_required, path, seen)
-            if sub_hint.is_user_defined_class:
-                self._create_parameter_spec_class(sub_hint, parent_name, is_parent_required, path, seen)
-        return None
-
-    def _create_parameter_spec_dict(
-        self, hint: TypeHint, parent_name: tuple[str | int, ...], path: tuple[str | int, ...], seen: set[str]
-    ) -> None:
-        try:
-            key, value = hint.container_args
-        except ValueError:
-            # There are no type hints for the dict
-            self.parameter_set.add(
-                ParameterSpec(
-                    (*path, *parent_name, ANYTHING), frozenset({"unknown"}), is_required=False, _is_nullable=True
-                )
-            )
-            return
-        if get_origin(key) is Literal:
-            args = get_args(key)
-            key_path = args[0]
-        elif key is str:
-            key_path = ANY_STR
-        else:
-            raise NotImplementedError(
-                f"Only Literal and str are supported for dict keys. {key.__name__} is not supported."
-            )
-        value_hint = TypeHint(value)
-
-        self.parameter_set.add(
-            ParameterSpec(
-                (*path, *parent_name, key_path),
-                value_hint.frozen_types,
-                is_required=False,
-                _is_nullable=value_hint.is_nullable,
-            )
-        )
-        for sub_hint in value_hint.sub_hints:
-            if not (sub_hint.is_base_type or sub_hint.is_any):
-                self._create_nested_parameters(tuple(), False, sub_hint, (*path, *parent_name, ANY_STR), seen.copy())
-        # if not (value_hint.is_base_type or value_hint.is_any):
-        #     self._read(value, (*path, *parent_name, ANY_STR), seen.copy())
-
-    def _create_parameter_spec_list(
-        self,
-        hint: TypeHint,
-        parent_name: tuple[str | int, ...],
-        parent_is_required: bool,
-        path: tuple[str | int, ...],
-        seen: set[str],
-    ) -> None:
-        try:
-            item = hint.container_args[0]
-        except IndexError:
-            # There are no type hints for the list
-            self.parameter_set.add(
-                ParameterSpec(
-                    (*path, *parent_name, ANYTHING), frozenset({"unknown"}), is_required=False, _is_nullable=True
-                )
-            )
-            return
-        item_hint = TypeHint(item)
-        if item_hint.is_base_type:
-            self.parameter_set.add(
-                ParameterSpec(
-                    (*path, *parent_name, ANY_INT),
-                    item_hint.frozen_types,
-                    is_required=False,
-                    _is_nullable=item_hint.is_nullable,
-                )
-            )
-        else:
-            self._create_nested_parameters(
-                tuple(), parent_is_required, item_hint, (*path, *parent_name, ANY_INT), seen.copy()
-            )
-
-    def _create_parameter_spec_class(
-        self,
-        hint: TypeHint,
-        parent_name: tuple[str | int, ...],
-        parent_is_required: bool,
-        path: tuple[str | int, ...],
-        seen: set[str],
-    ) -> None:
-        cls_ = hint.args[0]
-        if cls_.__name__ in seen:
-            # This is to avoid infinite recursion
-            self.parameter_set.add(
-                ParameterSpec(
-                    (*path, *parent_name), frozenset({"dict"}), parent_is_required, _is_nullable=hint.is_nullable
-                )
-            )
-        else:
-            self._read(cls_, (*path, *parent_name), seen.copy())
-
-
-def read_parameters_from_dict(raw: dict) -> ParameterSet[ParameterValue]:
-    return _read_parameters_from_raw(raw, tuple())
-
-
-def _read_parameters_from_raw(raw: dict | list | Any, path: tuple[str | int, ...]) -> ParameterSet[ParameterValue]:
-    parameter_set = ParameterSet[ParameterValue]()
-    if type(raw).__name__ in BASE_TYPES:
-        parameter_set.add(ParameterValue(path, type(raw).__name__, raw))  # type: ignore[arg-type]
-        return parameter_set
-    if isinstance(raw, list):
-        for i, item in enumerate(raw):
-            parameter_set.update(_read_parameters_from_raw(item, (*path, i)))
-        return parameter_set
-    if isinstance(raw, dict):
-        for key, value in raw.items():
-            type_ = type(value).__name__
-            if type_ in BASE_TYPES:
-                parameter_set.add(ParameterValue((*path, key), type_, value))
-            elif type_ in CONTAINER_TYPES:
-                # We cannot include the value type for containers as it is not hashable
-                parameter_set.add(ParameterValue((*path, key), type_, None))
-            if isinstance(value, dict):
-                parameter_set.update(_read_parameters_from_raw(value, (*path, key)))
-            elif isinstance(value, list):
-                for i, item in enumerate(value):
-                    parameter_set.update(_read_parameters_from_raw(item, (*path, key, i)))
-    return parameter_set

cognite_toolkit/_cdf_tk/_parameters/get_type_hints.py

@@ -1,123 +0,0 @@
-import abc
-import importlib
-import inspect
-import typing
-from typing import Any, get_type_hints
-
-from cognite.client.data_classes import TransformationScheduleWrite
-from cognite.client.data_classes.capabilities import UnknownAcl
-from cognite.client.data_classes.data_modeling.instances import (
-    TypedEdge,
-    TypedEdgeApply,
-    TypedNode,
-    TypedNodeApply,
-)
-
-
-class _TypeHints:
-    """
-    This class is used to get type hints from the init function of a CogniteObject.
-
-    After Python 3.10, type hints are treated as strings, so we need to evaluate them to get the actual type.
-    """
-
-    _error_msg: typing.ClassVar[str] = "Please extend this function to support generating fake data for this type"
-
-    @classmethod
-    def get_concrete_classes(cls, resource_cls: type) -> list[type]:
-        """Returns all the concrete classes that are subclasses of the given class.
-        (including the class itself if it is concrete)"""
-        concrete_classes = []
-        to_check = [resource_cls]
-        while to_check:
-            cls_ = to_check.pop()
-            if cls_ in {TypedEdge, TypedNode, TypedEdgeApply, TypedNodeApply}:
-                # These classes are abstract, but are not marked as such as they use  Mixin pattern
-                continue
-
-            to_check.extend(cls_.__subclasses__())
-            is_base_class = inspect.isclass(cls_) and any(base is abc.ABC for base in cls_.__bases__)
-            # UnknownAcl is a special case, it is concrete class, but cannot be instantiated easily
-            if not is_base_class and cls_ is not UnknownAcl:
-                concrete_classes.append(cls_)
-            if cls_ is TransformationScheduleWrite:
-                # TransformationScheduleWrite is wrongly marked as ABC, but it is a concrete class
-                # Fixed after 7.43.1
-                concrete_classes.append(cls_)
-        return concrete_classes
-
-    @classmethod
-    def get_type_hints_by_name(cls, resource_cls: type | list[type]) -> dict[str, Any]:
-        """
-        Get type hints from the init function of a CogniteObject.
-
-        Args:
-            signature: The signature of the init function.
-            resource_cls: The resource class to get type hints from.
-        """
-        if isinstance(resource_cls, list):
-            return {name: hint for cls_ in resource_cls for name, hint in cls.get_type_hints_by_name(cls_).items()}
-        if not hasattr(resource_cls, "__init__"):
-            return {}
-        try:
-            type_hint_by_name = get_type_hints(resource_cls.__init__, localns=cls._type_checking())  # type: ignore[misc]
-        except (TypeError, NameError):
-            # Python 3.10 Type hints cannot be evaluated with get_type_hints,
-            # ref https://stackoverflow.com/questions/66006087/how-to-use-typing-get-type-hints-with-pep585-in-python3-8
-            resource_module_vars = vars(importlib.import_module(resource_cls.__module__))
-            resource_module_vars.update(cls._type_checking())
-            signature = inspect.signature(resource_cls.__init__)  # type: ignore[misc]
-            type_hint_by_name = cls._get_type_hints_3_10(resource_module_vars, signature, dict(vars(resource_cls)))
-        return type_hint_by_name
-
-    @classmethod
-    def _type_checking(cls) -> dict[str, type]:
-        """
-        When calling the get_type_hints function, it imports the module with the function TYPE_CHECKING is set to False.
-
-        This function takes all the special types used in data classes and returns them as a dictionary so it
-        can be used in the local namespaces.
-        """
-        import numpy as np
-        import numpy.typing as npt
-        from cognite.client import CogniteClient
-        from cognite.client.data_classes.data_modeling import ContainerId, ViewId
-
-        return {
-            "CogniteClient": CogniteClient,
-            "NumpyDatetime64NSArray": npt.NDArray[np.datetime64],
-            "NumpyUInt32Array": npt.NDArray[np.uint32],
-            "NumpyInt64Array": npt.NDArray[np.int64],
-            "NumpyFloat64Array": npt.NDArray[np.float64],
-            "NumpyObjArray": npt.NDArray[np.object_],
-            # These are imported locally in the HasData filter classes
-            # and are thus not in the module or class namespace
-            "ViewId": ViewId,
-            "ContainerId": ContainerId,
-        }
-
-    @classmethod
-    def _get_type_hints_3_10(
-        cls, resource_module_vars: dict[str, Any], signature310: inspect.Signature, local_vars: dict[str, Any]
-    ) -> dict[str, Any]:
-        return {
-            name: cls._create_type_hint_3_10(parameter.annotation, resource_module_vars, local_vars)
-            for name, parameter in signature310.parameters.items()
-            if name != "self"
-        }
-
-    @classmethod
-    def _create_type_hint_3_10(
-        cls, annotation: str, resource_module_vars: dict[str, Any], local_vars: dict[str, Any]
-    ) -> Any:
-        if annotation.endswith(" | None"):
-            annotation = annotation[:-7]
-        annotation = annotation.replace("SequenceNotStr", "Sequence")
-        try:
-            return eval(annotation, resource_module_vars, local_vars)
-        except (TypeError, NameError):
-            # Python 3.10 Type Hint
-            if annotation.startswith("Sequence[") and annotation.endswith("]"):
-                return typing.Sequence[cls._create_type_hint_3_10(annotation[9:-1], resource_module_vars, local_vars)]  # type: ignore[misc]
-            else:
-                raise

cognite_toolkit/_cdf_tk/_parameters/type_hint.py

@@ -1,116 +0,0 @@
-import enum
-import inspect
-import itertools
-import types
-import typing
-from collections.abc import Iterable, Mapping, MutableMapping, MutableSequence, Sequence
-from typing import Any, get_origin
-
-from .constants import BASE_TYPES, TYPES
-
-
-class TypeHint:
-    _DICT_TYPES = {dict, typing.Dict, MutableSequence, MutableMapping, typing.Mapping, Mapping}  # noqa UP006
-    _LIST_TYPES = {list, typing.Sequence, Sequence, typing.List, MutableSequence}  # noqa UP006
-
-    def __init__(self, raw: Any) -> None:
-        self.raw = raw
-        self._container_type = get_origin(raw)
-        self.is_union = self._is_union(self._container_type)
-        if self.is_union:
-            self.args = typing.get_args(raw)
-        else:
-            self.args = (raw,)
-
-    def __str__(self) -> str:
-        return ",".join(self.types)
-
-    @classmethod
-    def _is_union(cls, x: Any) -> bool:
-        try:
-            return x in [types.UnionType, typing.Union]  # type: ignore[attr-defined]
-        except AttributeError:
-            # Python 3.9
-            return x is typing.Union
-
-    @classmethod
-    def _is_none_type(cls, x: Any) -> bool:
-        try:
-            return x in [None, types.NoneType]  # type: ignore[attr-defined]
-        except AttributeError:
-            # Python 3.9
-            return x is None
-
-    @classmethod
-    def _as_str(cls, arg: Any) -> str:
-        try:
-            value = arg.__name__
-        except AttributeError:
-            # Python 3.9
-            value = str(arg).removeprefix("typing.")
-            if "[" in value:
-                value = value.split("[")[0]
-        if value.casefold() in TYPES:
-            return value.casefold()
-        elif value == "Literal":
-            return "str"
-        elif value == "Sequence":
-            return "list"
-        elif value == "Any":
-            return "unknown"
-        elif inspect.isclass(arg) and issubclass(arg, enum.Enum):
-            return "str"
-        return "dict"
-
-    @property
-    def types(self) -> list[str]:
-        return list({self._as_str(arg) for arg in self.args if not self._is_none_type(arg)})
-
-    @property
-    def frozen_types(self) -> frozenset[str]:
-        return frozenset(self.types)
-
-    @property
-    def is_base_type(self) -> bool:
-        return any(type_ in BASE_TYPES for type_ in self.types)
-
-    @property
-    def is_nullable(self) -> bool:
-        return any(self._is_none_type(arg) for arg in self.args)
-
-    @property
-    def is_any(self) -> bool:
-        return any(arg is typing.Any for arg in self.args)
-
-    @property
-    def is_user_defined_class(self) -> bool:
-        return any(
-            inspect.isclass(arg) and arg.__module__ not in {"typing", "builtins", "collections.abc"}
-            for arg in self.args
-        )
-
-    @property
-    def _get_origins(self) -> tuple[Any, ...]:
-        return tuple(get_origin(arg) for arg in self.args)
-
-    @property
-    def is_dict_type(self) -> bool:
-        return any(arg in self._DICT_TYPES for arg in itertools.chain(self._get_origins, self.args))
-
-    @property
-    def is_list_type(self) -> bool:
-        return any(arg in self._LIST_TYPES for arg in itertools.chain(self._get_origins, self.args))
-
-    @property
-    def container_args(self) -> tuple[Any, ...]:
-        return typing.get_args(self.args[0])
-
-    def __repr__(self) -> str:
-        return repr(self.raw)
-
-    @property
-    def sub_hints(self) -> "Iterable[TypeHint]":
-        for arg in self.args:
-            if self._is_none_type(arg):
-                continue
-            yield TypeHint(arg)

cognite_toolkit/_cdf_tk/apps/_populate_app.py

@@ -1,80 +0,0 @@
-from pathlib import Path
-from typing import Annotated, Any
-
-import typer
-from rich import print
-
-from cognite_toolkit._cdf_tk.commands import PopulateCommand
-from cognite_toolkit._cdf_tk.utils.auth import EnvironmentVariables
-
-
-class PopulateApp(typer.Typer):
-    def __init__(self, *args: Any, **kwargs: Any) -> None:
-        super().__init__(*args, **kwargs)
-        self.callback(invoke_without_command=True)(self.main)
-        self.command("view")(self.populate_view)
-
-    def main(self, ctx: typer.Context) -> None:
-        """Commands populate functionality"""
-        if ctx.invoked_subcommand is None:
-            print("Use [bold yellow]cdf populate --help[/] for more information.")
-
-    def populate_view(
-        self,
-        ctx: typer.Context,
-        view_id: Annotated[
-            list[str] | None,
-            typer.Argument(
-                help="View ID to populate. Format space external ID version, for example 'cdf_cdm CogniteAsset v1'"
-                " If not provided, interactive mode will be used.",
-            ),
-        ] = None,
-        table: Annotated[
-            Path | None,
-            typer.Option(
-                "--table",
-                "-t",
-                help="Path to the file containing the data to populate the view with. This is required unless interactive"
-                " mode is used",
-            ),
-        ] = None,
-        instance_space: Annotated[
-            str | None,
-            typer.Option(
-                "--space",
-                "-s",
-                help="The space to write the nodes to. This is required unless interactive mode is used",
-            ),
-        ] = None,
-        external_id_column: Annotated[
-            str | None,
-            typer.Option(
-                "--external-id-column",
-                "-e",
-                help="The name of the column in the table that contains the external IDs of the nodes. The column"
-                " must be present in the table and must contain unique values. This is required unless interactive"
-                " mode is used",
-            ),
-        ] = None,
-        verbose: Annotated[
-            bool,
-            typer.Option(
-                "--verbose",
-                "-v",
-                help="Turn on to get more verbose output when running the command",
-            ),
-        ] = False,
-    ) -> None:
-        """This command will populate a given view with data from a local table."""
-        cmd = PopulateCommand()
-        client = EnvironmentVariables.create_from_environment().get_client()
-        cmd.run(
-            lambda: cmd.view(
-                client,
-                view_id,
-                table,
-                instance_space,
-                external_id_column,
-                verbose,
-            )
-        )

cognite_toolkit/_cdf_tk/commands/_migrate/assets.py

@@ -1,144 +0,0 @@
-from collections.abc import Callable, Iterable
-from pathlib import Path
-
-from cognite.client.data_classes import Asset, Label, LabelDefinition
-from cognite.client.data_classes.capabilities import (
-    AssetsAcl,
-    Capability,
-    DataSetScope,
-)
-from cognite.client.data_classes.data_modeling import NodeApply, NodeOrEdgeData, ViewId
-from cognite.client.exceptions import CogniteException
-from rich import print
-
-from cognite_toolkit._cdf_tk.client import ToolkitClient
-from cognite_toolkit._cdf_tk.client._constants import DATA_MODELING_MAX_WRITE_WORKERS
-from cognite_toolkit._cdf_tk.exceptions import (
-    ResourceCreationError,
-    ResourceRetrievalError,
-)
-from cognite_toolkit._cdf_tk.utils.collection import chunker_sequence
-from cognite_toolkit._cdf_tk.utils.producer_worker import ProducerWorkerExecutor
-
-from .base import BaseMigrateCommand
-from .data_classes import MigrationMapping, MigrationMappingList
-from .data_model import INSTANCE_SOURCE_VIEW_ID
-
-
-class MigrateAssetsCommand(BaseMigrateCommand):
-    cdf_cdm = "cdf_cdm"
-    asset_id = ViewId(cdf_cdm, "CogniteAsset", "v1")
-
-    # This is the number of timeseries that can be written in parallel.
-    chunk_size = 1000 * DATA_MODELING_MAX_WRITE_WORKERS
-
-    @property
-    def schema_spaces(self) -> list[str]:
-        return [f"{self.cdf_cdm}", INSTANCE_SOURCE_VIEW_ID.space]
-
-    def source_acl(self, data_set_id: list[int]) -> Capability:
-        return AssetsAcl(actions=[AssetsAcl.Action.Read], scope=DataSetScope(data_set_id))
-
-    def migrate_assets(
-        self,
-        client: ToolkitClient,
-        mapping_file: Path,
-        dry_run: bool = False,
-        verbose: bool = False,
-    ) -> None:
-        """Migrate resources from Asset-Centric to data modeling in CDF."""
-        mappings = MigrationMappingList.read_mapping_file(mapping_file)
-        self.validate_access(client, list(mappings.spaces()), list(mappings.get_data_set_ids()))
-        self.validate_instance_source_exists(client)
-        self.validate_available_capacity(client, len(mappings))
-        iteration_count = len(mappings) // self.chunk_size + 1
-        executor = ProducerWorkerExecutor[list[tuple[Asset, MigrationMapping]], list[NodeApply]](
-            download_iterable=self._download_assets(client, mappings),
-            process=self._as_cognite_assets,
-            write=self._upload_assets(client, dry_run=dry_run, verbose=verbose),
-            iteration_count=iteration_count,
-            max_queue_size=10,
-            download_description="Downloading assets",
-            process_description="Converting assets to CogniteAssets",
-            write_description="Uploading CogniteAssets",
-        )
-        executor.run()
-        if executor.error_occurred:
-            raise ResourceCreationError(executor.error_message)
-
-        prefix = "Would have" if dry_run else "Successfully"
-        self.console(f"{prefix} migrated {executor.total_items:,} assets to CogniteAssets.")
-
-    def _download_assets(
-        self, client: ToolkitClient, mappings: MigrationMappingList
-    ) -> Iterable[list[tuple[Asset, MigrationMapping]]]:
-        for chunk in chunker_sequence(mappings, self.chunk_size):
-            try:
-                asset_list = client.assets.retrieve_multiple(
-                    chunk.get_ids(), chunk.get_external_ids(), ignore_unknown_ids=True
-                )
-            except CogniteException as e:
-                raise ResourceRetrievalError(f"Failed to retrieve {len(chunk):,} assets: {e!s}") from e
-            mapping_by_id = chunk.as_mapping_by_id()
-            chunk_list: list[tuple[Asset, MigrationMapping]] = []
-            for asset in asset_list:
-                if asset.id in mapping_by_id:
-                    chunk_list.append((asset, mapping_by_id[asset.id]))
-                elif asset.external_id in mapping_by_id:
-                    chunk_list.append((asset, mapping_by_id[asset.external_id]))
-            yield chunk_list
-
-    def _as_cognite_assets(self, assets: list[tuple[Asset, MigrationMapping]]) -> list[NodeApply]:
-        """Convert Asset objects to CogniteAssetApply objects."""
-        return [self.as_cognite_asset(asset, mapping) for asset, mapping in assets]
-
-    @classmethod
-    def _upload_assets(cls, client: ToolkitClient, dry_run: bool, verbose: bool) -> Callable[[list[NodeApply]], None]:
-        def upload_assets(assets: list[NodeApply]) -> None:
-            if dry_run:
-                if verbose:
-                    print(f"Would have created {len(assets):,} CogniteAssets.")
-                return
-            try:
-                created = client.data_modeling.instances.apply_fast(assets)
-            except CogniteException as e:
-                raise ResourceCreationError(f"Failed to upsert CogniteAssets {len(assets):,}: {e!s}") from e
-            if verbose:
-                print(f"Created {len(created):,} CogniteAssets.")
-
-        return upload_assets
-
-    @classmethod
-    def as_cognite_asset(cls, asset: Asset, mapping: MigrationMapping) -> NodeApply:
-        tags: list[str] = []
-        for label in asset.labels or []:
-            if isinstance(label, str):
-                tags.append(label)
-            elif isinstance(label, dict) and "externalId" in label:
-                tags.append(label["externalId"])
-            elif isinstance(label, Label | LabelDefinition) and label.external_id:
-                tags.append(label.external_id)
-
-        return NodeApply(
-            space=mapping.instance_id.space,
-            external_id=mapping.instance_id.external_id,
-            sources=[
-                NodeOrEdgeData(
-                    source=cls.asset_id,
-                    properties={
-                        "name": asset.name,
-                        "description": asset.description,
-                        "tags": tags or None,
-                    },
-                ),
-                NodeOrEdgeData(
-                    source=INSTANCE_SOURCE_VIEW_ID,
-                    properties={
-                        "resourceType": "asset",
-                        "id": asset.id,
-                        "dataSetId": asset.data_set_id,
-                        "classicExternalId": asset.external_id,
-                    },
-                ),
-            ],
-        )