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

cognite_toolkit/_builtin_modules/inrobot/cdf_inrobot_common/functions/fn_contextualize_robot_data/handler.py

@@ -1,269 +0,0 @@
-"""Contextualize handler."""
-
-import logging
-import sys
-
-from cognite.client.data_classes import FileMetadataUpdate, TimeSeries
-from common.cdf_helpers import create_missing_labels
-
-MAX_GET_JOB_ATTEMPTS = 10
-logger = logging.getLogger(__name__)
-
-
-def get_time_series_label(camera_type):
-    if camera_type == "ir":
-        time_series_label = "IR_TIME_SERIES"
-    else:
-        time_series_label = "ANALOG_GAUGE_TIME_SERIES"
-    return time_series_label
-
-
-def has_label(label_list, label_external_id):
-    """Check if the label_external_id is in a list of labels."""
-    for label in label_list:
-        if label.external_id == label_external_id:
-            return True
-    return False
-
-
-def create_timeseries(
-    client,
-    asset,
-    data_set_external_id,
-    time_series_label,
-    gauge_number=1,
-    total_number_of_gauges=1,
-    time_series_naming_tag="",
-):
-    """Create time series on the correct format."""
-    if time_series_label == "IR_TIME_SERIES":
-        ts_external_id = (
-            f"{time_series_label}_{asset.external_id}_{time_series_naming_tag}"
-            if asset.external_id is not None
-            else f"{asset.id}_{time_series_label}_{time_series_naming_tag}"
-        )
-        ts_name = f"{asset.name}_ir_{time_series_naming_tag}"
-
-    elif gauge_number <= 1 and total_number_of_gauges <= 1:
-        ts_external_id = (
-            f"{time_series_label}_{asset.external_id}_0"
-            if asset.external_id is not None
-            else f"{asset.id}_{time_series_label}_0"
-        )
-        ts_name = f"{asset.name}_gauge_values"
-    else:
-        ts_external_id = (
-            f"{time_series_label}_{asset.external_id}_{gauge_number}"
-            if asset.external_id is not None
-            else f"{asset.id}_{time_series_label}_{gauge_number}"
-        )
-        ts_name = f"{asset.name}_gauge_values_{gauge_number}"
-
-    logger.info(f"Creates timeseries with name: {ts_name}")
-    data_set_id = client.data_sets.retrieve(external_id=data_set_external_id).id
-    return client.time_series.create(
-        TimeSeries(
-            metadata={"TYPE": time_series_label},
-            asset_id=asset.id,
-            external_id=ts_external_id,
-            data_set_id=data_set_id,
-            name=ts_name,
-        )
-    )
-
-
-def get_asset(client, file):
-    """Get asset from metadata field."""
-    if file.metadata.get("asset_id") not in [None, "0", "None"]:
-        try:
-            asset_id = int(file.metadata["asset_id"])
-            asset = client.assets.retrieve(asset_id)
-        except Exception as e:
-            logger.exception(e)
-            return None
-        return asset
-
-
-def get_timeseries_external_id(client, asset, data_set_external_id, time_series_label, number_of_gauges=1):
-    """Get time series external id."""
-    ts = client.time_series.list(metadata={"TYPE": time_series_label}, asset_ids=[asset.id])
-    number_of_timeseries = len(ts)
-    ts_external_ids = []
-    logger.info(f"{ts}")
-
-    # Create one timeseries for min temperature and one for max temperature for IR images
-    if time_series_label == "IR_TIME_SERIES":
-        if number_of_timeseries == 0:
-            print("CREATE IR TIMESERIES")
-            ir_ts_naming_tags = ["min", "max"]
-            for naming_tag in ir_ts_naming_tags:
-                ts = create_timeseries(
-                    client,
-                    asset,
-                    data_set_external_id,
-                    time_series_label,
-                    time_series_naming_tag=naming_tag,
-                )
-                ts_external_ids.append(ts.external_id)
-        else:
-            ts_external_ids = [ts[i].external_id for i in range(number_of_timeseries)]
-
-    # Logic for creating gauge timeseries
-    elif number_of_timeseries >= 1 and number_of_gauges == number_of_timeseries:
-        ts_external_ids = [ts[i].external_id for i in range(number_of_timeseries)]
-    elif number_of_timeseries >= 1 and number_of_gauges > number_of_timeseries:
-        ts_external_ids.append(ts[0].external_id)
-        diff = number_of_gauges - number_of_timeseries
-        for gauge_number in range(diff):
-            logger.info("CREATE GAUGE TIMESERIES")
-            new_gauge_number = gauge_number + number_of_timeseries
-            ts = create_timeseries(
-                client, asset, data_set_external_id, time_series_label, new_gauge_number, number_of_gauges
-            )
-            ts_external_ids.append(ts.external_id)
-    elif number_of_timeseries == 0:
-        logger.info("CREATE GAUGE TIMESERIES")
-        if number_of_gauges <= 1:
-            ts = create_timeseries(client, asset, data_set_external_id, time_series_label)
-            ts_external_ids.append(ts.external_id)
-        else:
-            for gauge_number in range(number_of_gauges):
-                ts = create_timeseries(
-                    client, asset, data_set_external_id, time_series_label, gauge_number, number_of_gauges
-                )
-                ts_external_ids.append(ts.external_id)
-
-    return ts_external_ids
-
-
-def get_number_of_gauges(client, asset):
-    """Get the total number of gauges associated with an asset."""
-    try:
-        asset_data = client.assets.retrieve(id=asset.id)
-        asset_metadata = asset_data.metadata
-        if "number_of_gauges" in asset_metadata:
-            return int(asset_metadata["number_of_gauges"])
-        else:
-            return 1
-    except Exception as e:
-        logger.exception(e)
-        return 1
-
-
-def handle(data, client):
-    """Contextualize robot data."""
-    print("Start gauge reading.")
-    required_input_data_fields = {
-        "data_set_external_id",
-        "read_dial_gauge_label",
-        "read_multiple_dial_gauges_label",
-        "read_digital_gauge_label",
-        "read_level_gauge_label",
-        "read_valve_label",
-        "read_ir_raw_label",
-        "spill_detection_label",
-        "gauge_context_label",
-    }
-    if not required_input_data_fields <= data.keys():
-        raise RuntimeError(f"Data should contain all keys:  {required_input_data_fields}. Current data: {data}")
-
-    logging.basicConfig(stream=sys.stdout, level=logging.INFO, format=logging.BASIC_FORMAT)
-    create_missing_labels(
-        client,
-        [
-            data["read_dial_gauge_label"],
-            data["read_multiple_dial_gauges_label"],
-            data["read_digital_gauge_label"],
-            data["read_level_gauge_label"],
-            data["read_valve_label"],
-            data["read_ir_raw_label"],
-            data["spill_detection_label"],
-            "threesixty",
-        ],
-    )
-    files = client.files.list(
-        data_set_external_ids=[data["data_set_external_id"]],
-        metadata={"processed": "false"},
-        limit=-1,
-        uploaded=True,
-    )
-
-    logger.info(f"Number of files to process in dataset  {data['data_set_external_id']}: {len(files)}")
-    print(f"Number of files to process in dataset  {data['data_set_external_id']}: {len(files)}")
-
-    for file in files:
-        number_of_gauges = 1  # Default is one gauge per image
-        metadata = file.metadata
-        logger.info(f"Processing file with external id: {file.external_id}, id: {file.id}")
-
-        update = FileMetadataUpdate(file.id)
-        asset = get_asset(client, file)
-        update.asset_ids.add([asset.id]) if asset else None
-
-        print(f"The labels on this file are: {file.labels}")
-        if file.labels and has_label(file.labels, data["gauge_context_label"]):
-            gauge_type = metadata.get("gauge_type", "dial")  # Default gauge type from robot is dial
-            print(f"This file has gauge type: {gauge_type}")
-
-            camera_type = metadata.get("camera", None)
-            time_series_label = get_time_series_label(camera_type)
-
-            if gauge_type == "valve":
-                current_action_label = "read_valve_label"
-            elif gauge_type == "dial":
-                if asset:
-                    number_of_gauges = get_number_of_gauges(client, asset)
-                if number_of_gauges <= 1:
-                    current_action_label = "read_dial_gauge_label"
-                else:
-                    current_action_label = "read_multiple_dial_gauges_label"
-            else:
-                current_action_label = f"read_{gauge_type}_gauge_label"
-
-            logger.info(f"Setting action label to {data[current_action_label]}")
-            print(f"Setting action label to {data[current_action_label]}")
-
-            update.labels.add(data[current_action_label])
-            update.labels.remove(data["gauge_context_label"])
-
-            if asset and gauge_type != "spill":
-                logger.info(f"Number of gauges: {number_of_gauges}.")
-                ts_eid = get_timeseries_external_id(
-                    client, asset, data["data_set_external_id"], time_series_label, number_of_gauges
-                )
-                logger.info(f"Time series linked to asset: {ts_eid}.")
-                if ts_eid:
-                    if time_series_label == "IR_TIME_SERIES":
-                        for i in range(len(ts_eid)):
-                            metadata[f"ts_external_id_{i}"] = ts_eid[i]
-                    elif number_of_gauges <= 1:
-                        metadata["ts_external_id"] = ts_eid[0]
-                    else:
-                        for gauge_number in range(number_of_gauges):
-                            if metadata.get("ts_external_id", None):
-                                if gauge_number == 0:
-                                    continue
-                                else:
-                                    metadata[f"ts_external_id_{gauge_number}"] = ts_eid[gauge_number]
-                            else:
-                                metadata[f"ts_external_id_{gauge_number}"] = ts_eid[gauge_number]
-        elif "threesixty" in file.external_id:
-            print("This is a 360 image, adding threesixty label.")
-            update.labels.add(["threesixty"])
-
-        elif asset and metadata.get("method") == "process_ir_raw":
-            current_action_label = "read_ir_raw_label"
-            time_series_label = "IR_TIME_SERIES"
-            print(f"this is the asset: {asset}")
-
-            ts_eid = get_timeseries_external_id(
-                client, asset, data["data_set_external_id"], time_series_label, number_of_gauges
-            )
-            if time_series_label == "IR_TIME_SERIES":
-                for i in range(len(ts_eid)):
-                    metadata[f"ts_external_id_{i}"] = ts_eid[i]
-
-        metadata["processed"] = "true"
-        update.metadata.add(metadata)
-        client.files.update(update)
-    return {}

cognite_toolkit/_builtin_modules/inrobot/cdf_inrobot_common/functions/fn_contextualize_robot_data/requirements.txt

@@ -1,22 +0,0 @@
-arrow==1.0.3
-certifi==2023.11.17
-chardet==4.0.0
-cognite-extractor-utils==1.4.2
-cognite-sdk==2.56.1
-dacite==1.8.1
-decorator==4.4.2
-idna==3.7
-numpy==1.20.1
-oauthlib==3.1.0
-pandas==1.2.3
-prometheus-client==0.9.0
-psutil==5.8.0
-py==1.10.0
-python-dateutil==2.8.1
-pytz==2021.1
-PyYAML==5.4.1
-requests==2.32.0
-requests-oauthlib==1.3.1
-retry==0.9.2
-six==1.15.0
-urllib3==1.26.19

cognite_toolkit/_builtin_modules/inrobot/cdf_inrobot_common/functions/fn_gauge_reading/README.md

@@ -1,56 +0,0 @@
-# Gauge reading
-
-Uses the API endpoint.
-Takes all files with the specified label and reads an analog gauge in the image.
-
-## Input parameters
-
-- *gauge_type*: The gauge type to use in the API call
-- *input_label*: Label to list files by
-- *output_label*: Label for processed files.
-- *success_label*: The label added to files where the gauge reading was successful.
-- *failed_label*: The label added to files where the gauge reading has failed.
-
-## Gauge reading
-
-- The function performs gauge reading on all files with the input label defined in the schedule file.
-- Each input file can contain none, some of or all the metadata fields:
-
-  - min_level
-  - max_level
-  - unit
-  - dead_angle
-  - ts_external_id
-
-- If the file has the ts_external_id metadata field, we first try to use the metadata from the time series as input
-  metadata (min_level, max_level, unit, dead_angle). If the ts do not contain all these fields and the file contains
-  a complete metadata set (min_level, max_level, unit, dead_angle), the timeseries is updated with the correct metadata.
-- If the file does not have the ts_external_id metadata field or no complete metadata set is found, the existing file
-  metadata fields are used as input metadata to the API. For exmaple if the file has a metadata field "unit",
-  but not "min_level" etc, only unit is given as input to the API.
-- If the reading returns a complete metadata reading and the timeseries did not have metadata, the time series is
-  updated with metadata.
-- After the file is read the input_label is removed and the output_label is added.
-- If the reading fails, the failed_label is added to the image.
-- If the reading succeeds, the success_label is added to the image and value and metadata is added til file metadata.
-- If the file contains the ts_external_id field in metadata, the value is written to the timeseries.
-- If the reading fails, all attributes that are read are still written to the image. If for example unit and min_level
-- is read from the image, unit and min_level are added in the file metadata.
-
-## Lables
-
-- The function checks that all labels exist, and creates the fields that do not exist.
-- The funtion removes the input label from the image and adds the output label for processed files to the file
-  as well as the success or fail label.
-
-## Timestamp
-
-Timestamp is found from
-
-1. Metadata field called timestamp
-2. Source created time
-3. Uploaded time
-
-## Example request and response from the gauge reading endpoint
-
-[cognitedata/context-api-workers/pull/981](https://github.com/cognitedata/context-api-workers/pull/981)

cognite_toolkit/_builtin_modules/inrobot/cdf_inrobot_common/functions/fn_gauge_reading/__init__.py

@@ -1 +0,0 @@
-"""Gauge reader."""

cognite_toolkit/_builtin_modules/inrobot/cdf_inrobot_common/functions/fn_gauge_reading/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_gauge_reading/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))