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

cognite_toolkit/_cdf_tk/_parameters/functions.py

@@ -1,192 +0,0 @@
-from __future__ import annotations
-
-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,125 +0,0 @@
-from __future__ import annotations
-
-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,118 +0,0 @@
-from __future__ import annotations
-
-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, Optional
-
-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[
-            Optional[list[str]],
-            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[
-            Optional[Path],
-            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[
-            Optional[str],
-            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[
-            Optional[str],
-            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/client/api/agents/agents.py

@@ -1,107 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Iterator, Sequence
-from typing import overload
-
-from cognite.client._api_client import APIClient
-from cognite.client.utils.useful_types import SequenceNotStr
-
-from cognite_toolkit._cdf_tk.client.data_classes.agents import Agent, AgentList, AgentWrite
-
-
-class AgentsAPI(APIClient):
-    _RESOURCE_PATH = "/ai/agents"
-
-    @overload
-    def __call__(self) -> Iterator[Agent]: ...
-
-    @overload
-    def __call__(self, chunk_size: int) -> Iterator[AgentList]: ...
-
-    def __call__(self, chunk_size: int | None = None) -> Iterator[Agent] | Iterator[AgentList]:
-        """Iterate over agents.
-
-        Args:
-            chunk_size: The number of agents to return in each chunk. None will return all agents.
-
-        Yields:
-            Agent or AgentList
-
-        """
-        return self._list_generator(method="GET", resource_cls=Agent, list_cls=AgentList, chunk_size=chunk_size)
-
-    def __iter__(self) -> Iterator[Agent]:
-        return self.__call__()
-
-    @overload
-    def apply(self, agent: AgentWrite) -> Agent: ...
-
-    @overload
-    def apply(self, agent: Sequence[AgentWrite]) -> AgentList: ...
-
-    def apply(self, agent: AgentWrite | Sequence[AgentWrite]) -> Agent | AgentList:
-        """Create a new agent.
-
-        Args:
-            agent: AgentWrite or list of AgentWrite.
-
-        Returns:
-            Agent object.
-
-        """
-        headers = {"cdf-version": "alpha"}
-        return self._create_multiple(
-            list_cls=AgentList,
-            resource_cls=Agent,
-            items=agent,
-            input_resource_cls=AgentWrite,
-            headers=headers,
-        )
-
-    def retrieve(self, external_id: SequenceNotStr[str]) -> AgentList:
-        """Retrieve an agent.
-
-        Args:
-            data_set_id: Data set id of the agent.
-
-        Returns:
-            Agent object.
-
-        """
-        body = self._create_body(external_id, True)
-
-        headers = {"cdf-version": "alpha"}
-        self._cognite_client.config.debug = True
-
-        res = self._post(url_path=self._RESOURCE_PATH + "/byids", json=body, headers=headers)
-        return AgentList._load(res.json()["items"], cognite_client=self._cognite_client)
-
-    @staticmethod
-    def _create_body(external_id: str | SequenceNotStr[str], ignore_unknown_ids: bool = False) -> dict:
-        ids = [external_id] if isinstance(external_id, str) else external_id
-        body = {"items": [{"externalId": external_id} for external_id in ids], "ignoreUnknownIds": ignore_unknown_ids}
-        return body
-
-    def delete(self, external_id: str | SequenceNotStr[str]) -> None:
-        """Delete an agent.
-
-        Args:
-            external_id: External ID of the agent.
-
-        Returns:
-            None
-
-        """
-        body = self._create_body(external_id)
-        headers = {"cdf-version": "alpha"}
-
-        self._post(url_path=self._RESOURCE_PATH + "/delete", json=body, headers=headers)
-
-    def list(self) -> AgentList:
-        """List agents.
-
-        Returns:
-            AgentList
-
-        """
-        return self._list(method="GET", resource_cls=Agent, list_cls=AgentList)

cognite_toolkit/_cdf_tk/client/api/agents/api.py

@@ -1,12 +0,0 @@
-from __future__ import annotations
-
-from cognite.client import ClientConfig, CogniteClient
-from cognite.client._api_client import APIClient
-
-from .agents import AgentsAPI
-
-
-class AtlasAPI(APIClient):
-    def __init__(self, config: ClientConfig, api_version: str | None, cognite_client: CogniteClient) -> None:
-        super().__init__(config, api_version, cognite_client)
-        self.agents = AgentsAPI(config, api_version, cognite_client)