mlrun 1.3.2rc1__py3-none-any.whl → 1.3.2rc2__py3-none-any.whl

mlrun/api/schemas/model_endpoints.py

@@ -12,87 +12,52 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-
-import enum
-import json
-import typing
 from typing import Any, Dict, List, Optional, Tuple, Union
 
 from pydantic import BaseModel, Field
 from pydantic.main import Extra
 
-import mlrun.model_monitoring
+import mlrun.api.utils.helpers
 from mlrun.api.schemas.object import ObjectKind, ObjectSpec, ObjectStatus
+from mlrun.utils.model_monitoring import EndpointType, create_model_endpoint_id
 
 
 class ModelMonitoringStoreKinds:
-    # TODO: do changes in examples & demos In 1.5.0 remove
     ENDPOINTS = "endpoints"
     EVENTS = "events"
 
 
 class ModelEndpointMetadata(BaseModel):
-    project: Optional[str] = ""
+    project: Optional[str]
     labels: Optional[dict] = {}
-    uid: Optional[str] = ""
+    uid: Optional[str]
 
     class Config:
         extra = Extra.allow
 
-    @classmethod
-    def from_flat_dict(cls, endpoint_dict: dict, json_parse_values: typing.List = None):
-        """Create a `ModelEndpointMetadata` object from an endpoint dictionary
-
-        :param endpoint_dict:     Model endpoint dictionary.
-        :param json_parse_values: List of dictionary keys with a JSON string value that will be parsed into a
-                                  dictionary using json.loads().
-        """
-        new_object = cls()
-        if json_parse_values is None:
-            json_parse_values = [mlrun.model_monitoring.EventFieldType.LABELS]
-
-        return _mapping_attributes(
-            base_model=new_object,
-            flattened_dictionary=endpoint_dict,
-            json_parse_values=json_parse_values,
-        )
+
+class ModelMonitoringMode(mlrun.api.utils.helpers.StrEnum):
+    enabled = "enabled"
+    disabled = "disabled"
 
 
 class ModelEndpointSpec(ObjectSpec):
-    function_uri: Optional[str] = ""  # <project_name>/<function_name>:<tag>
-    model: Optional[str] = ""  # <model_name>:<version>
-    model_class: Optional[str] = ""
-    model_uri: Optional[str] = ""
-    feature_names: Optional[List[str]] = []
-    label_names: Optional[List[str]] = []
-    stream_path: Optional[str] = ""
-    algorithm: Optional[str] = ""
+    function_uri: Optional[str]  # <project_name>/<function_name>:<tag>
+    model: Optional[str]  # <model_name>:<version>
+    model_class: Optional[str]
+    model_uri: Optional[str]
+    feature_names: Optional[List[str]]
+    label_names: Optional[List[str]]
+    stream_path: Optional[str]
+    algorithm: Optional[str]
     monitor_configuration: Optional[dict] = {}
-    active: Optional[bool] = True
-    monitoring_mode: Optional[
-        mlrun.model_monitoring.ModelMonitoringMode
-    ] = mlrun.model_monitoring.ModelMonitoringMode.disabled.value
+    active: Optional[bool]
+    monitoring_mode: Optional[str] = ModelMonitoringMode.disabled
 
-    @classmethod
-    def from_flat_dict(cls, endpoint_dict: dict, json_parse_values: typing.List = None):
-        """Create a `ModelEndpointSpec` object from an endpoint dictionary
-
-        :param endpoint_dict:     Model endpoint dictionary.
-        :param json_parse_values: List of dictionary keys with a JSON string value that will be parsed into a
-                                  dictionary using json.loads().
-        """
-        new_object = cls()
-        if json_parse_values is None:
-            json_parse_values = [
-                mlrun.model_monitoring.EventFieldType.FEATURE_NAMES,
-                mlrun.model_monitoring.EventFieldType.LABEL_NAMES,
-                mlrun.model_monitoring.EventFieldType.MONITOR_CONFIGURATION,
-            ]
-        return _mapping_attributes(
-            base_model=new_object,
-            flattened_dictionary=endpoint_dict,
-            json_parse_values=json_parse_values,
-        )
+
+class Metric(BaseModel):
+    name: str
+    values: List[Tuple[str, float]]
 
 
 class Histogram(BaseModel):
@@ -143,60 +108,28 @@ class Features(BaseModel):
 class ModelEndpointStatus(ObjectStatus):
     feature_stats: Optional[dict] = {}
     current_stats: Optional[dict] = {}
-    first_request: Optional[str] = ""
-    last_request: Optional[str] = ""
-    error_count: Optional[int] = 0
-    drift_status: Optional[str] = ""
+    first_request: Optional[str]
+    last_request: Optional[str]
+    accuracy: Optional[float]
+    error_count: Optional[int]
+    drift_status: Optional[str]
     drift_measures: Optional[dict] = {}
-    metrics: Optional[Dict[str, Dict[str, Any]]] = {
-        mlrun.model_monitoring.EventKeyMetrics.GENERIC: {
-            mlrun.model_monitoring.EventLiveStats.LATENCY_AVG_1H: 0,
-            mlrun.model_monitoring.EventLiveStats.PREDICTIONS_PER_SECOND: 0,
-        }
-    }
-    features: Optional[List[Features]] = []
-    children: Optional[List[str]] = []
-    children_uids: Optional[List[str]] = []
-    endpoint_type: Optional[
-        mlrun.model_monitoring.EndpointType
-    ] = mlrun.model_monitoring.EndpointType.NODE_EP.value
-    monitoring_feature_set_uri: Optional[str] = ""
-    state: Optional[str] = ""
+    metrics: Optional[Dict[str, Metric]]
+    features: Optional[List[Features]]
+    children: Optional[List[str]]
+    children_uids: Optional[List[str]]
+    endpoint_type: Optional[EndpointType]
+    monitoring_feature_set_uri: Optional[str]
 
     class Config:
         extra = Extra.allow
 
-    @classmethod
-    def from_flat_dict(cls, endpoint_dict: dict, json_parse_values: typing.List = None):
-        """Create a `ModelEndpointStatus` object from an endpoint dictionary
-
-        :param endpoint_dict:     Model endpoint dictionary.
-        :param json_parse_values: List of dictionary keys with a JSON string value that will be parsed into a
-                                  dictionary using json.loads().
-        """
-        new_object = cls()
-        if json_parse_values is None:
-            json_parse_values = [
-                mlrun.model_monitoring.EventFieldType.FEATURE_STATS,
-                mlrun.model_monitoring.EventFieldType.CURRENT_STATS,
-                mlrun.model_monitoring.EventFieldType.DRIFT_MEASURES,
-                mlrun.model_monitoring.EventFieldType.METRICS,
-                mlrun.model_monitoring.EventFieldType.CHILDREN,
-                mlrun.model_monitoring.EventFieldType.CHILDREN_UIDS,
-                mlrun.model_monitoring.EventFieldType.ENDPOINT_TYPE,
-            ]
-        return _mapping_attributes(
-            base_model=new_object,
-            flattened_dictionary=endpoint_dict,
-            json_parse_values=json_parse_values,
-        )
-
 
 class ModelEndpoint(BaseModel):
     kind: ObjectKind = Field(ObjectKind.model_endpoint, const=True)
-    metadata: ModelEndpointMetadata = ModelEndpointMetadata()
-    spec: ModelEndpointSpec = ModelEndpointSpec()
-    status: ModelEndpointStatus = ModelEndpointStatus()
+    metadata: ModelEndpointMetadata
+    spec: ModelEndpointSpec
+    status: ModelEndpointStatus
 
     class Config:
         extra = Extra.allow
@@ -204,68 +137,15 @@ class ModelEndpoint(BaseModel):
     def __init__(self, **data: Any):
         super().__init__(**data)
         if self.metadata.uid is None:
-            uid = mlrun.model_monitoring.create_model_endpoint_uid(
+            uid = create_model_endpoint_id(
                 function_uri=self.spec.function_uri,
                 versioned_model=self.spec.model,
             )
             self.metadata.uid = str(uid)
 
-    def flat_dict(self):
-        """Generate a flattened `ModelEndpoint` dictionary. The flattened dictionary result is important for storing
-        the model endpoint object in the database.
-
-        :return: Flattened `ModelEndpoint` dictionary.
-        """
-        # Convert the ModelEndpoint object into a dictionary using BaseModel dict() function
-        # In addition, remove the BaseModel kind as it is not required by the DB schema
-        model_endpoint_dictionary = self.dict(exclude={"kind"})
-
-        # Initialize a flattened dictionary that will be filled with the model endpoint dictionary attributes
-        flatten_dict = {}
-        for k_object in model_endpoint_dictionary:
-            for key in model_endpoint_dictionary[k_object]:
-                # Extract the value of the current field
-                current_value = model_endpoint_dictionary[k_object][key]
-
-                # If the value is not from type str or bool (e.g. dict), convert it into a JSON string
-                # for matching the database required format
-                if not isinstance(current_value, (str, bool, int)) or isinstance(
-                    current_value, enum.IntEnum
-                ):
-                    flatten_dict[key] = json.dumps(current_value)
-                else:
-                    flatten_dict[key] = current_value
-
-        if mlrun.model_monitoring.EventFieldType.METRICS not in flatten_dict:
-            # Initialize metrics dictionary
-            flatten_dict[mlrun.model_monitoring.EventFieldType.METRICS] = {
-                mlrun.model_monitoring.EventKeyMetrics.GENERIC: {
-                    mlrun.model_monitoring.EventLiveStats.LATENCY_AVG_1H: 0,
-                    mlrun.model_monitoring.EventLiveStats.PREDICTIONS_PER_SECOND: 0,
-                }
-            }
-
-        # Remove the features from the dictionary as this field will be filled only within the feature analysis process
-        flatten_dict.pop(mlrun.model_monitoring.EventFieldType.FEATURES, None)
-        return flatten_dict
-
-    @classmethod
-    def from_flat_dict(cls, endpoint_dict: dict):
-        """Create a `ModelEndpoint` object from an endpoint flattened dictionary. Because the provided dictionary
-        is flattened, we pass it as is to the subclasses without splitting the keys into spec, metadata, and status.
-
-        :param endpoint_dict:     Model endpoint dictionary.
-        """
-
-        return cls(
-            metadata=ModelEndpointMetadata.from_flat_dict(endpoint_dict=endpoint_dict),
-            spec=ModelEndpointSpec.from_flat_dict(endpoint_dict=endpoint_dict),
-            status=ModelEndpointStatus.from_flat_dict(endpoint_dict=endpoint_dict),
-        )
-
 
 class ModelEndpointList(BaseModel):
-    endpoints: List[ModelEndpoint] = []
+    endpoints: List[ModelEndpoint]
 
 
 class GrafanaColumn(BaseModel):
@@ -303,40 +183,3 @@ class GrafanaTimeSeriesTarget(BaseModel):
 
     def add_data_point(self, data_point: GrafanaDataPoint):
         self.datapoints.append((data_point.value, data_point.timestamp))
-
-
-def _mapping_attributes(
-    base_model: BaseModel,
-    flattened_dictionary: dict,
-    json_parse_values: typing.List = None,
-):
-    """Generate a `BaseModel` object with the provided dictionary attributes.
-
-    :param base_model:           `BaseModel` object (e.g. `ModelEndpointMetadata`).
-    :param flattened_dictionary: Flattened dictionary that contains the model endpoint attributes.
-    :param json_parse_values:    List of dictionary keys with a JSON string value that will be parsed into a
-                                 dictionary using json.loads().
-    """
-    # Get the fields of the provided base model object. These fields will be used to filter to relevent keys
-    # from the flattened dictionary.
-    wanted_keys = base_model.__fields__.keys()
-
-    # Generate a filtered flattened dictionary that will be parsed into the BaseModel object
-    dict_to_parse = {}
-    for field_key in wanted_keys:
-        if field_key in flattened_dictionary:
-            if field_key in json_parse_values:
-                # Parse the JSON value into a valid dictionary
-                dict_to_parse[field_key] = _json_loads_if_not_none(
-                    flattened_dictionary[field_key]
-                )
-            else:
-                dict_to_parse[field_key] = flattened_dictionary[field_key]
-
-    return base_model.parse_obj(dict_to_parse)
-
-
-def _json_loads_if_not_none(field: Any) -> Any:
-    return (
-        json.loads(field) if field and field != "null" and field is not None else None
-    )

mlrun/api/schemas/schedule.py

@@ -36,8 +36,8 @@ class ScheduleCronTrigger(BaseModel):
     hour: Optional[Union[int, str]]
     minute: Optional[Union[int, str]]
     second: Optional[Union[int, str]]
-    start_date: Union[datetime, str] = None
-    end_date: Union[datetime, str] = None
+    start_date: Optional[Union[datetime, str]]
+    end_date: Optional[Union[datetime, str]]
 
     # APScheduler also supports datetime.tzinfo type, but Pydantic doesn't - so we don't
     timezone: Optional[str]

mlrun/api/utils/clients/log_collector.py

@@ -152,6 +152,11 @@ class LogCollectorClient(
         try:
             has_logs = await self.has_logs(run_uid, project, verbose, raise_on_error)
             if not has_logs:
+                logger.debug(
+                    "Run has no logs to collect",
+                    run_uid=run_uid,
+                    project=project,
+                )
 
                 # run has no logs - return empty logs and exit so caller won't wait for logs or retry
                 yield b""

mlrun/builder.py

@@ -11,7 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-import os.path
+
 import pathlib
 import re
 import tarfile
@@ -55,20 +55,20 @@ def make_dockerfile(
         dock += f"ARG {build_arg_key}={build_arg_value}\n"
 
     if source:
+        dock += f"RUN mkdir -p {workdir}\n"
         dock += f"WORKDIR {workdir}\n"
         # 'ADD' command does not extract zip files - add extraction stage to the dockerfile
         if source.endswith(".zip"):
-            source_dir = os.path.join(workdir, "source")
             stage1 = f"""
             FROM {base_image} AS extractor
             RUN apt-get update -qqy && apt install --assume-yes unzip
-            RUN mkdir -p {source_dir}
-            COPY {source} {source_dir}
-            RUN cd {source_dir} && unzip {source} && rm {source}
+            RUN mkdir -p /source
+            COPY {source} /source
+            RUN cd /source && unzip {source} && rm {source}
             """
             dock = stage1 + "\n" + dock
 
-            dock += f"COPY --from=extractor {source_dir}/ {workdir}\n"
+            dock += f"COPY --from=extractor /source/ {workdir}\n"
         else:
             dock += f"ADD {source} {workdir}\n"
 
@@ -221,21 +221,7 @@ def make_kaniko_pod(
         if end == -1:
             end = len(dest)
         repo = dest[dest.find("/") + 1 : end]
-
-        # if no secret is given, assume ec2 instance has attached role which provides read/write access to ECR
-        assume_instance_role = not config.httpdb.builder.docker_registry_secret
-        configure_kaniko_ecr_init_container(kpod, registry, repo, assume_instance_role)
-
-        # project secret might conflict with the attached instance role
-        # ensure "AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY" have no values or else kaniko will fail
-        # due to credentials conflict / lack of permission on given credentials
-        if assume_instance_role:
-            kpod.pod.spec.containers[0].env.extend(
-                [
-                    client.V1EnvVar(name="AWS_ACCESS_KEY_ID", value=""),
-                    client.V1EnvVar(name="AWS_SECRET_ACCESS_KEY", value=""),
-                ]
-            )
+        configure_kaniko_ecr_init_container(kpod, registry, repo)
 
     # mount regular docker config secret
     elif secret_name:
@@ -245,9 +231,7 @@ def make_kaniko_pod(
     return kpod
 
 
-def configure_kaniko_ecr_init_container(
-    kpod, registry, repo, assume_instance_role=True
-):
+def configure_kaniko_ecr_init_container(kpod, registry, repo):
     region = registry.split(".")[3]
 
     # fail silently in order to ignore "repository already exists" errors
@@ -258,13 +242,12 @@ def configure_kaniko_ecr_init_container(
     )
     init_container_env = {}
 
-    if assume_instance_role:
+    if not config.httpdb.builder.docker_registry_secret:
 
         # assume instance role has permissions to register and store a container image
         # https://github.com/GoogleContainerTools/kaniko#pushing-to-amazon-ecr
         # we only need this in the kaniko container
         kpod.env.append(client.V1EnvVar(name="AWS_SDK_LOAD_CONFIG", value="true"))
-
     else:
         aws_credentials_file_env_key = "AWS_SHARED_CREDENTIALS_FILE"
         aws_credentials_file_env_value = "/tmp/credentials"
@@ -413,20 +396,6 @@ def build_image(
         user_unix_id = runtime.spec.security_context.run_as_user
         enriched_group_id = runtime.spec.security_context.run_as_group
 
-    if source_to_copy and (
-        not runtime.spec.clone_target_dir
-        or not os.path.isabs(runtime.spec.clone_target_dir)
-    ):
-        # use a temp dir for permissions and set it as the workdir
-        tmpdir = tempfile.mkdtemp()
-        relative_workdir = runtime.spec.clone_target_dir or ""
-        if relative_workdir.startswith("./"):
-            # TODO: use 'removeprefix' when we drop python 3.7 support
-            # relative_workdir.removeprefix("./")
-            relative_workdir = relative_workdir[2:]
-
-        runtime.spec.clone_target_dir = path.join(tmpdir, "mlrun", relative_workdir)
-
     dock = make_dockerfile(
         base_image,
         commands,
@@ -435,7 +404,6 @@ def build_image(
         extra=extra,
         user_unix_id=user_unix_id,
         enriched_group_id=enriched_group_id,
-        workdir=runtime.spec.clone_target_dir,
     )
 
     kpod = make_kaniko_pod(

mlrun/config.py

@@ -376,24 +376,14 @@ default_config = {
     "model_endpoint_monitoring": {
         "serving_stream_args": {"shard_count": 1, "retention_period_hours": 24},
         "drift_thresholds": {"default": {"possible_drift": 0.5, "drift_detected": 0.7}},
-        # Store prefixes are used to handle model monitoring storing policies based on project and kind, such as events,
-        # stream, and endpoints.
         "store_prefixes": {
             "default": "v3io:///users/pipelines/{project}/model-endpoints/{kind}",
             "user_space": "v3io:///projects/{project}/model-endpoints/{kind}",
-            "stream": "",
         },
-        # Offline storage path can be either relative or a full path. This path is used for general offline data
-        # storage such as the parquet file which is generated from the monitoring stream function for the drift analysis
-        "offline_storage_path": "model-endpoints/{kind}",
-        # Default http path that points to the monitoring stream nuclio function. Will be used as a stream path
-        # when the user is working in CE environment and has not provided any stream path.
-        "default_http_sink": "http://nuclio-{project}-model-monitoring-stream.mlrun.svc.cluster.local:8080",
         "batch_processing_function_branch": "master",
         "parquet_batching_max_events": 10000,
         # See mlrun.api.schemas.ModelEndpointStoreType for available options
-        "store_type": "v3io-nosql",
-        "endpoint_store_connection": "",
+        "store_type": "kv",
     },
     "secret_stores": {
         "vault": {
@@ -936,68 +926,6 @@ class Config:
         # Get v3io access key from the environment
         return os.environ.get("V3IO_ACCESS_KEY")
 
-    def get_model_monitoring_file_target_path(
-        self,
-        project: str = "",
-        kind: str = "",
-        target: str = "online",
-        artifact_path: str = None,
-    ) -> str:
-        """Get the full path from the configuration based on the provided project and kind.
-
-        :param project:        Project name.
-        :param kind:           Kind of target path (e.g. events, log_stream, endpoints, etc.)
-        :param target:         Can be either online or offline. If the target is online, then we try to get a specific
-                               path for the provided kind. If it doesn't exist, use the default path.
-                               If the target path is offline and the offline path is already a full path in the
-                               configuration, then the result will be that path as-is. If the offline path is a
-                               relative path, then the result will be based on the project artifact path and the offline
-                               relative path. If project artifact path wasn't provided, then we use MLRun artifact
-                               path instead.
-        :param artifact_path:  Optional artifact path that will be used as a relative path. If not provided, the
-                               relative artifact path will be taken from the global MLRun artifact path.
-
-        :return: Full configured path for the provided kind.
-        """
-
-        if target != "offline":
-            store_prefix_dict = (
-                mlrun.mlconf.model_endpoint_monitoring.store_prefixes.to_dict()
-            )
-            if store_prefix_dict.get(kind):
-                # Target exist in store prefix and has a valid string value
-                return store_prefix_dict[kind].format(project=project)
-            return mlrun.mlconf.model_endpoint_monitoring.store_prefixes.default.format(
-                project=project, kind=kind
-            )
-
-        # Get the current offline path from the configuration
-        file_path = mlrun.mlconf.model_endpoint_monitoring.offline_storage_path.format(
-            project=project, kind=kind
-        )
-
-        # Absolute path
-        if any(value in file_path for value in ["://", ":///"]) or os.path.isabs(
-            file_path
-        ):
-            return file_path
-
-        # Relative path
-        else:
-            artifact_path = artifact_path or config.artifact_path
-            if artifact_path[-1] != "/":
-                artifact_path += "/"
-
-            return mlrun.utils.helpers.fill_artifact_path_template(
-                artifact_path=artifact_path + file_path, project=project
-            )
-
-    def is_ce_mode(self) -> bool:
-        # True if the setup is in CE environment
-        return isinstance(mlrun.mlconf.ce, mlrun.config.Config) and any(
-            ver in mlrun.mlconf.ce.mode for ver in ["lite", "full"]
-        )
-
 
 # Global configuration
 config = Config.from_dict(default_config)
@@ -1120,18 +1048,15 @@ def read_env(env=None, prefix=env_prefix):
         cfg[path[0]] = value
 
     env_dbpath = env.get("MLRUN_DBPATH", "")
-    # expected format: https://mlrun-api.tenant.default-tenant.app.some-system.some-namespace.com
     is_remote_mlrun = (
         env_dbpath.startswith("https://mlrun-api.") and "tenant." in env_dbpath
     )
-
     # It's already a standard to set this env var to configure the v3io api, so we're supporting it (instead
     # of MLRUN_V3IO_API), in remote usage this can be auto detected from the DBPATH
     v3io_api = env.get("V3IO_API")
     if v3io_api:
         config["v3io_api"] = v3io_api
     elif is_remote_mlrun:
-        # in remote mlrun we can't use http, so we'll use https
         config["v3io_api"] = env_dbpath.replace("https://mlrun-api.", "https://webapi.")
 
     # It's already a standard to set this env var to configure the v3io framesd, so we're supporting it (instead

mlrun/data_types/__init__.py

@@ -14,12 +14,7 @@
 #
 # flake8: noqa  - this is until we take care of the F401 violations with respect to __all__ & sphinx
 
-from .data_types import (
-    InferOptions,
-    ValueType,
-    pd_schema_to_value_type,
-    python_type_to_value_type,
-)
+from .data_types import InferOptions, ValueType, pd_schema_to_value_type
 from .infer import DFDataInfer
 
 

mlrun/data_types/data_types.py

@@ -79,9 +79,7 @@ def pa_type_to_value_type(type_):
 
 
 def python_type_to_value_type(value_type):
-    type_name = (
-        value_type.__name__ if hasattr(value_type, "__name__") else str(value_type)
-    )
+    type_name = value_type.__name__
     type_map = {
         "int": ValueType.INT64,
         "str": ValueType.STRING,

mlrun/datastore/__init__.py

@@ -33,12 +33,7 @@ __all__ = [
 
 import mlrun.datastore.wasbfs
 
-from ..platforms.iguazio import (
-    HTTPOutputStream,
-    KafkaOutputStream,
-    OutputStream,
-    parse_path,
-)
+from ..platforms.iguazio import KafkaOutputStream, OutputStream, parse_path
 from ..utils import logger
 from .base import DataItem
 from .datastore import StoreManager, in_memory_store, uri_to_ipython
@@ -74,7 +69,7 @@ def get_in_memory_items():
 
 
 def get_stream_pusher(stream_path: str, **kwargs):
-    """get a stream pusher object from URL.
+    """get a stream pusher object from URL, currently only support v3io stream
 
     common kwargs::
 
@@ -92,8 +87,6 @@ def get_stream_pusher(stream_path: str, **kwargs):
         return KafkaOutputStream(
             topic, bootstrap_servers, kwargs.get("kafka_producer_options")
         )
-    elif stream_path.startswith("http://") or stream_path.startswith("https://"):
-        return HTTPOutputStream(stream_path=stream_path)
     elif "://" not in stream_path:
         return OutputStream(stream_path, **kwargs)
     elif stream_path.startswith("v3io"):