cognite-toolkit 0.6.82__py3-none-any.whl → 0.6.83__py3-none-any.whl

cognite_toolkit/_builtin_modules/inrobot/cdf_inrobot_common/functions/fn_get_ir_data_from_ir_raw/common/README.md

@@ -1,58 +0,0 @@
-# Shared-code folder: `common`
-
-## TL;DR
-
-> This entire folder hierarchy of `common` is copied into all functions automatically.
-
-## No, I wan't to read the long story
-
-A common use case when you deal with the deployment of multiple functions simultaneously, is that you do not want to
-replicate shared code between all the function folders. In order to accomodate this, as part of the workflow
-`function-action` this template relies on, we copy all the contents in this folder (can be specified by `common_folder`
-in the workflow files, see below) the functions we upload to Cognite Functions. If this is not specified, we check if
-`common/` exists in the root folder and if so, _**we use it automatically**_ :rocket:
-
-### Handling imports
-
-A typical setup looks like this:
-
-```bash
-├── common
-│   └── utils.py
-└── my_function
-    └── handler.py
-```
-
-The code we zip and send off to the FilesAPI will look like this:
-
-```bash
-├── common
-│   └── utils.py
-└── handler.py
-```
-
-This means your `handler.py`-file should do imports from `common/utils.py` like this:
-
-```python
-from common.utils import my_helper1, my_helper2
-import common.utils as utils  # alternative
-```
-
-## No, I want `common` to be named `snowflake_utilities`
-
-No problem mate, locate `.github/workflow` and open the following files:
-
-- `deploy-pr.yaml`
-- `deploy-push.yaml`
-
-Then, in each file, scroll down until you see:
-
-```yaml
-
-- name: Deploy and schedule ${{ matrix.function }}
-  uses: cognitedata/function-action@v2
-  with:
-    function_name: ...
-    common_folder: snowflake_utilities  # <-- add it here
-    ...
-```

cognite_toolkit/_builtin_modules/inrobot/cdf_inrobot_common/functions/fn_get_ir_data_from_ir_raw/common/apm_helpers.py

@@ -1,269 +0,0 @@
-from __future__ import annotations
-
-import json
-import logging
-from datetime import datetime
-from typing import Any, Optional
-
-import pytz  # type: ignore
-from cognite.client import CogniteClient
-from common.dataclass.common import Vec3f
-
-logger = logging.getLogger(__name__)
-
-
-def create_apm_observation_from_reading(
-    client: CogniteClient,
-    file_external_id: str,
-    timeseries_external_id: str,
-    value: float,
-    timestamp: int,
-    pose: Vec3f,
-    message: str,
-    apm_checklistitem_external_id: Optional[str] = None,
-):
-    """Create an APM observation from a gauge reading.
-
-    NOTE: this is a preliminary implementation, where we're not yet using the
-    gql pygen SDK made by Cognite (which will make this a lot cleaner)
-
-    """
-    apm_config = _get_apm_config(client=client, config_external_id="inrobot")
-    if apm_config is None:
-        logger.error("Could not find APM config")
-        return
-
-    space_id = str(apm_config.get("appDataSpaceId"))
-    appdata_space_version = str(apm_config.get("appDataSpaceVersion"))
-
-    views = _get_views(
-        client=client,
-        space=space_id,
-        datamodel_id=space_id,
-        datamodel_version=appdata_space_version,
-        view_ids=["APM_Measurement", "Vec3f", "APM_Observation"],
-    )
-
-    def _get_view_version(views: list[dict[str, Any]], view_id: str) -> Optional[str]:
-        view = next((item for item in views if item["externalId"] == view_id), None)
-        if view is None:
-            raise ValueError(f"Could not find view {view_id}")
-        return view.get("version")
-
-    # create the APM measurement
-    if isinstance(timestamp, int):
-        timestamp_s = round(timestamp / 1000)
-        timestamp_dt = datetime.fromtimestamp(float(timestamp_s), pytz.UTC)
-    elif isinstance(timestamp, datetime):
-        timestamp_dt = timestamp
-    else:
-        raise ValueError(f"Timestamp is of type {type(timestamp)}, needs to be either `int` or `datetime`.")
-
-    apm_measurement_external_id = f"measurement_{timeseries_external_id}_{timestamp}"
-    apm_measurement = {
-        "timeSeries": timeseries_external_id,
-        "measuredAt": timestamp_dt.isoformat(),
-        "numericValue": value,
-    }
-
-    vec3f_external_id = f"position_{timeseries_external_id}_{timestamp}"
-    vec3f = {"x": pose.x, "y": pose.y, "z": pose.z}
-
-    apm_observation_external_id = f"observation_{timeseries_external_id}_{timestamp}"
-    apm_observation = {
-        "fileIds": [file_external_id],
-        "position": {"externalId": vec3f_external_id, "space": space_id},
-        "description": "Gauge reading",
-        "note": message,
-        "createdById": "CDF Gauge Reader Function",
-        "updatedById": "CDF Gauge Reader Function",
-    }
-
-    # edge apm_observation -> apm_measurement
-    edge_apm_observation_apm_measurement = {
-        "instanceType": "edge",
-        "space": space_id,
-        "externalId": f"{apm_observation_external_id}.measurements_{apm_measurement_external_id}",
-        "startNode": {"externalId": apm_observation_external_id, "space": space_id},
-        "endNode": {"externalId": apm_measurement_external_id, "space": space_id},
-        "type": {"externalId": "APM_Observation.measurements", "space": space_id},
-    }
-
-    # assemble all instances (nodes and edges)
-    instances = [
-        {
-            "instanceType": "node",
-            "space": space_id,
-            "externalId": apm_measurement_external_id,
-            "sources": [
-                {
-                    "source": {
-                        "type": "view",
-                        "space": space_id,
-                        "externalId": "APM_Measurement",
-                        "version": _get_view_version(views, "APM_Measurement"),
-                    },
-                    "properties": apm_measurement,
-                }
-            ],
-        },
-        {
-            "instanceType": "node",
-            "space": space_id,
-            "externalId": vec3f_external_id,
-            "sources": [
-                {
-                    "source": {
-                        "type": "view",
-                        "space": space_id,
-                        "externalId": "Vec3f",
-                        "version": _get_view_version(views, "Vec3f"),
-                    },
-                    "properties": vec3f,
-                }
-            ],
-        },
-        {
-            "instanceType": "node",
-            "space": space_id,
-            "externalId": apm_observation_external_id,
-            "sources": [
-                {
-                    "source": {
-                        "type": "view",
-                        "space": space_id,
-                        "externalId": "APM_Observation",
-                        "version": _get_view_version(views, "APM_Observation"),
-                    },
-                    "properties": apm_observation,
-                }
-            ],
-        },
-        edge_apm_observation_apm_measurement,
-    ]
-
-    if apm_checklistitem_external_id is not None:
-        edge_apm_checklist_apm_observation = {
-            "instanceType": "edge",
-            "space": space_id,
-            "externalId": f"{apm_checklistitem_external_id}.observations_{apm_observation_external_id}",
-            "startNode": {"externalId": apm_checklistitem_external_id, "space": space_id},
-            "endNode": {"externalId": apm_observation_external_id, "space": space_id},
-            "type": {"externalId": "APM_ChecklistItem.observations", "space": space_id},
-        }
-        instances.append(edge_apm_checklist_apm_observation)
-
-    logger.debug(f"Creating instances request: {json.dumps(instances, indent=2)}")
-
-    response = client.post(
-        f"/api/v1/projects/{client.config.project}/models/instances", json={"items": instances}
-    ).json()
-
-    logger.debug(f"Creating instances response: {json.dumps(response, indent=2)}")
-
-
-def _get_views(
-    client: CogniteClient, space: str, datamodel_id: str, datamodel_version: Optional[str] = None, view_ids=list[str]
-) -> list[dict[str, Any]]:
-    response = client.post(
-        f"/api/v1/projects/{client.config.project}/models/datamodels/byids",
-        json={
-            "items": [{"space": space, "externalId": datamodel_id, "version": datamodel_version}],
-        },
-    ).json()
-
-    # get latest datamodel, if no version is specified
-    datamodel = max(response["items"], key=lambda item: item["createdTime"], default=None)
-    if datamodel is None:
-        raise ValueError(f"No datamodels with id {datamodel_id} found with version {datamodel_version}.")
-
-    views = datamodel.get("views")
-    if views is None or views == []:
-        raise ValueError(f"Datamodel {datamodel_id} has no views.")
-
-    available_views = {view.get("externalId"): view.get("version") for view in views}
-
-    items = [
-        {"space": space, "externalId": requested_view_id, "version": available_views.get(requested_view_id)}
-        for requested_view_id in view_ids
-        if available_views.get(requested_view_id) is not None
-    ]
-
-    if len(items) != len(view_ids):
-        missing_views = set(view_ids) - set([item["externalId"] for item in items])
-        raise ValueError(f"Views {', '.join(missing_views)} not found in datamodel {datamodel_id}.")
-
-    views = client.post(
-        f"/api/v1/projects/{client.config.project}/models/views/byids",
-        json={
-            "items": items,
-        },
-    ).json()
-
-    return views["items"]
-
-
-def _get_apm_config(client: CogniteClient, config_external_id: str) -> Optional[dict[str, Any]]:
-    space = "APM_Config"
-    datamodel_id = "APM_Config"
-    view_id = "APM_Config"
-    instance_external_ids = [config_external_id, "default-config"]
-
-    views = _get_views(client=client, space=space, datamodel_id=datamodel_id, view_ids=[view_id])
-
-    if len(views) != 1:
-        raise ValueError(f"Expected to find exactly one view for {view_id}, found {len(views)}.")
-
-    view = views[0]
-
-    response = client.post(
-        f"/api/v1/projects/{client.config.project}/models/instances/byids",
-        json={
-            "items": [
-                {"instanceType": "node", "externalId": external_id, "space": space}
-                for external_id in instance_external_ids
-            ],
-            "sources": [
-                {
-                    "source": {
-                        "type": "view",
-                        "space": space,
-                        "externalId": view.get("externalId"),
-                        "version": view.get("version"),
-                    }
-                }
-            ],
-        },
-    ).json()
-
-    if response.get("items") == []:
-        logger.error("Could not find APM config, not upserting any APM_Observations now.")
-        return None
-
-    # Try to find the first item with "externalId" == config_external_id
-    apm_config = next((item for item in response["items"] if item["externalId"] == config_external_id), None)
-
-    # If no such item is found, try to find the first item with "externalId" == "default"
-    if apm_config is None:
-        apm_config = next((item for item in response["items"] if item["externalId"] == "default-config"), None)
-        if apm_config is None:
-            raise ValueError(f"Could not find APM config with externalId {config_external_id} or `default-config`.")
-
-    apm_config = apm_config.get("properties").get(space).get(f"{view.get('externalId')}/{view.get('version')}")
-
-    return apm_config
-
-
-def _get_position_from_metadata_to_vec3f(metadata: dict[str, Any]) -> Vec3f:
-    """Get position from metadata."""
-    x = metadata.get("waypoint_tform_body_x")
-    y = metadata.get("waypoint_tform_body_x")
-    z = metadata.get("waypoint_tform_body_x")
-
-    if not x or not y or not z:
-        raise ValueError(
-            f"Missing metadata field. Required metadata fields \
-            are waypoint_tform_body_x, waypoint_tform_body_x, waypoint_tform_body_x. File metadata keys: {metadata.keys()}"
-        )
-
-    return Vec3f(x=float(x), y=float(y), z=float(z))

cognite_toolkit/_builtin_modules/inrobot/cdf_inrobot_common/functions/fn_get_ir_data_from_ir_raw/common/cdf_helpers.py

@@ -1,112 +0,0 @@
-from __future__ import annotations
-
-import logging
-import time
-from typing import Any, Optional
-
-from cognite.client import CogniteClient
-from cognite.client.data_classes import Annotation, LabelDefinition
-
-logger = logging.getLogger(__name__)
-
-
-def call_vision_api_endpoint(
-    client: CogniteClient,
-    url: str,
-    input_data: dict,
-    max_get_job_attempts: int = 20,
-    headers: Optional[dict[str, Any]] = None,
-):
-    """Post to an API endpoint, wait for response and return response."""
-    # TODO: Use this function in people detector function (https://cognitedata.atlassian.net/browse/DMVP-855)
-    res = client.post(url=url, json=input_data, headers=headers).json()
-
-    job_id = res.get("jobId")
-    for i in range(max_get_job_attempts):
-        logger.info(f"Attempt nr. {i} to get job status.")
-        res = client.get(url=f"{url}/{job_id}").json()
-        if res.get("status") in ["Queued", "Running"]:
-            logger.info(f"API job status: {res.get('status')}")
-            time.sleep(10)
-        elif res.get("status") == "Completed":
-            logger.info("API job completed")
-            break
-    else:  # Use for/else in case of failed job or timeout
-        logger.info(f"API job failed or timed out: {res}")
-        return None
-
-    return res
-
-
-def create_missing_labels(client: CogniteClient, label_ids: list[str]):
-    """Create missing labels from a list of label IDs."""
-    for label_id in label_ids:
-        if not check_label_exists(client, label_id):
-            client.labels.create([LabelDefinition(external_id=label_id, name=label_id)])
-
-
-def check_label_exists(client: CogniteClient, label_id: str):
-    """Check if a label exists in CDF given its external_id (label_id)."""
-    labels = client.labels.list(external_id_prefix=label_id)
-    return any(label.external_id == label_id for label in labels)
-
-
-def create_annotations(
-    client: CogniteClient,
-    gauge_reading_result: dict,
-    file_id: int,
-    gauge_type: str,
-    bounding_box_label: str,
-    keypoint_label: str,
-):
-    annotations = gauge_reading_result["items"][0]["predictions"][gauge_type + "GaugePredictions"]
-    annotations_list = []
-
-    for annotation in annotations:
-        print(f"ANNOTATION TYPE: {annotation}")
-        if gauge_type == "digital":
-            bounding_box = annotation["boundingBox"]
-        else:
-            keypoints = annotation["keypointCollection"]["keypoints"]
-            bounding_box = annotation["objectDetection"]["boundingBox"]
-        # Create bounding box annotation
-        bounding_box_annotation = Annotation(
-            annotation_type="images.ObjectDetection",
-            status="suggested",
-            creating_user="cognite-functions",
-            creating_app="sdk",
-            creating_app_version="4.5.2",
-            annotated_resource_type="file",
-            annotated_resource_id=file_id,
-            data={
-                "label": bounding_box_label,
-                "boundingBox": bounding_box,
-            },
-        )
-        annotations_list.append(bounding_box_annotation)
-
-        if gauge_type in ["level", "dial"]:
-            # Create keypoint annotation
-            keypoint_names = list(keypoints.keys())
-            keypoint_data = {}
-            for i in range(len(keypoint_names)):
-                keypoint_name = keypoint_names[i]
-                print(keypoint_name)
-                point = keypoints[keypoint_name]["point"]
-                print(point)
-                keypoint_data[keypoint_name] = {"point": point}
-                print(keypoint_data)
-
-            keypoint_annotation = Annotation(
-                annotation_type="images.KeypointCollection",
-                status="suggested",
-                creating_user="cognite-functions",
-                creating_app="sdk",
-                creating_app_version="4.5.2",
-                annotated_resource_type="file",
-                annotated_resource_id=file_id,
-                data={"label": keypoint_label, "keypoints": keypoint_data},
-            )
-            annotations_list.append(keypoint_annotation)
-
-    client.annotations.create(annotations_list)

cognite_toolkit/_builtin_modules/inrobot/cdf_inrobot_common/functions/fn_get_ir_data_from_ir_raw/common/dataclass/common.py

@@ -1,16 +0,0 @@
-from dataclasses import asdict, dataclass
-
-
-@dataclass
-class Dataclass:
-    def to_dict(self, ignore_none=False):
-        if ignore_none:
-            return asdict(self, dict_factory=lambda x: {k: v for (k, v) in x if v})
-        return asdict(self)
-
-
-@dataclass
-class Vec3f(Dataclass):
-    x: float
-    y: float
-    z: float

cognite_toolkit/_builtin_modules/inrobot/cdf_inrobot_common/functions/fn_get_ir_data_from_ir_raw/common/dataclass/vision.py

@@ -1,66 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Optional
-
-from common.dataclass.common import Dataclass
-
-
-@dataclass
-class File(Dataclass):
-    fileId: int
-    fileExternalId: Optional[str] = None
-
-
-@dataclass
-class RequestCustomModelPrediction(Dataclass):
-    items: list[File]
-    modelFile: File
-    threshold: float
-
-
-@dataclass
-class Vertex(Dataclass):
-    x: float
-    y: float
-
-
-@dataclass
-class Region(Dataclass):
-    shape: str  # points, rectangle, polyline, polygon
-    vertices: list[Vertex]
-
-
-@dataclass
-class VisionAnnotation(Dataclass):
-    text: str
-    confidence: Optional[float] = None
-    region: Optional[Region] = None
-
-
-@dataclass
-class Item(Dataclass):
-    fileId: int
-    annotations: Optional[list[VisionAnnotation]] = None
-    fileExternalId: Optional[str] = None
-    width: Optional[float] = None
-    height: Optional[float] = None
-
-
-@dataclass
-class FailedBatchSchema(Dataclass):
-    errorMessage: Optional[str] = None
-    items: Optional[list[File]] = None
-
-
-@dataclass
-class ResponseCustomModelPrediction(Dataclass):
-    status: str  # "Queued" "Running" "Completed" "Failed"
-    createdTime: int
-    startTime: int
-    statusTime: int
-    jobId: int
-    items: list[Item]
-    modelFile: File
-    threshold: Optional[float] = None
-    failedItems: Optional[list[FailedBatchSchema]] = None

cognite_toolkit/_builtin_modules/inrobot/cdf_inrobot_common/functions/fn_get_ir_data_from_ir_raw/common/utils.py

@@ -1,17 +0,0 @@
-import io
-
-from PIL import Image
-
-
-def batch(iterable, n=1):
-    """Batch iterable."""
-    len_iterable = len(iterable)
-    for ndx in range(0, len_iterable, n):
-        yield iterable[ndx : min(ndx + n, len_iterable)]
-
-
-def image_to_byte_array(image: Image) -> bytes:
-    """Convert PIL image to byte array."""
-    img_byte_arr = io.BytesIO()
-    image.save(img_byte_arr, format=image.format)
-    return img_byte_arr.getvalue()