fix code

Author: giancarloromeo

services/autoscaling/src/simcore_service_autoscaling/_meta.py

@@ -2,6 +2,7 @@
 
 from models_library.basic_types import VersionStr, VersionTag
 from packaging.version import Version
+from pydantic import TypeAdapter
 from servicelib.utils_meta import PackageInfo
 
 info: Final = PackageInfo(package_name="simcore-service-autoscaling")
@@ -10,7 +11,9 @@
 APP_NAME: Final[str] = info.project_name
 API_VERSION: Final[VersionStr] = info.__version__
 VERSION: Final[Version] = info.version
-API_VTAG: Final[VersionTag] = VersionTag(info.api_prefix_path_tag)
+API_VTAG: Final[VersionTag] = TypeAdapter(VersionTag).validate_python(
+    info.api_prefix_path_tag
+)
 SUMMARY: Final[str] = info.get_summary()
 
 

services/autoscaling/src/simcore_service_autoscaling/constants.py

@@ -2,32 +2,32 @@
 from typing import Final
 
 from aws_library.ec2._models import AWSTagKey, AWSTagValue, EC2Tags
-from pydantic import parse_obj_as
+from pydantic import TypeAdapter
 
-BUFFER_MACHINE_PULLING_EC2_TAG_KEY: Final[AWSTagKey] = parse_obj_as(
-    AWSTagKey, "pulling"
-)
-BUFFER_MACHINE_PULLING_COMMAND_ID_EC2_TAG_KEY: Final[AWSTagKey] = parse_obj_as(
-    AWSTagKey, "ssm-command-id"
-)
+BUFFER_MACHINE_PULLING_EC2_TAG_KEY: Final[AWSTagKey] = TypeAdapter(
+    AWSTagKey
+).validate_python("pulling")
+BUFFER_MACHINE_PULLING_COMMAND_ID_EC2_TAG_KEY: Final[AWSTagKey] = TypeAdapter(
+    AWSTagKey
+).validate_python("ssm-command-id")
 PREPULL_COMMAND_NAME: Final[str] = "docker images pulling"
 
 DOCKER_PULL_COMMAND: Final[
     str
 ] = "docker compose -f /docker-pull.compose.yml -p buffering pull"
 
-PRE_PULLED_IMAGES_EC2_TAG_KEY: Final[AWSTagKey] = parse_obj_as(
-    AWSTagKey, "io.simcore.autoscaling.pre_pulled_images"
-)
+PRE_PULLED_IMAGES_EC2_TAG_KEY: Final[AWSTagKey] = TypeAdapter(
+    AWSTagKey
+).validate_python("io.simcore.autoscaling.pre_pulled_images")
 
-BUFFER_MACHINE_TAG_KEY: Final[AWSTagKey] = parse_obj_as(
-    AWSTagKey, "io.simcore.autoscaling.buffer_machine"
+BUFFER_MACHINE_TAG_KEY: Final[AWSTagKey] = TypeAdapter(AWSTagKey).validate_python(
+    "io.simcore.autoscaling.buffer_machine"
 )
 DEACTIVATED_BUFFER_MACHINE_EC2_TAGS: Final[EC2Tags] = {
-    BUFFER_MACHINE_TAG_KEY: parse_obj_as(AWSTagValue, "true")
+    BUFFER_MACHINE_TAG_KEY: TypeAdapter(AWSTagValue).validate_python("true")
 }
 ACTIVATED_BUFFER_MACHINE_EC2_TAGS: Final[EC2Tags] = {
-    BUFFER_MACHINE_TAG_KEY: parse_obj_as(AWSTagValue, "false")
+    BUFFER_MACHINE_TAG_KEY: TypeAdapter(AWSTagValue).validate_python("false")
 }
 PRE_PULLED_IMAGES_RE: Final[re.Pattern] = re.compile(
     rf"{PRE_PULLED_IMAGES_EC2_TAG_KEY}_\((\d+)\)"

services/autoscaling/src/simcore_service_autoscaling/core/errors.py

@@ -1,12 +1,7 @@
-from typing import Any
-
-from models_library.errors_classes import OsparcErrorMixin
+from common_library.errors_classes import OsparcErrorMixin
 
 
 class AutoscalingRuntimeError(OsparcErrorMixin, RuntimeError):
-    def __init__(self, **ctx: Any) -> None:
-        super().__init__(**ctx)
-
     msg_template: str = "Autoscaling unexpected error"
 
 

services/autoscaling/src/simcore_service_autoscaling/core/settings.py

@@ -1,6 +1,6 @@
 import datetime
 from functools import cached_property
-from typing import Any, ClassVar, Final, cast
+from typing import Annotated, Final, cast
 
 from aws_library.ec2 import EC2InstanceBootSpecific, EC2Tags
 from fastapi import FastAPI
@@ -14,14 +14,16 @@
 from models_library.clusters import InternalClusterAuthentication
 from models_library.docker import DockerLabelKey
 from pydantic import (
+    AliasChoices,
     AnyUrl,
     Field,
     NonNegativeInt,
     PositiveInt,
-    parse_obj_as,
-    root_validator,
-    validator,
+    TypeAdapter,
+    field_validator,
+    model_validator,
 )
+from pytest_simcore.helpers.dict_tools import ConfigDict
 from settings_library.base import BaseCustomSettings
 from settings_library.docker_registry import RegistrySettings
 from settings_library.ec2 import EC2Settings
@@ -41,10 +43,9 @@ class AutoscalingSSMSettings(SSMSettings):
 
 
 class AutoscalingEC2Settings(EC2Settings):
-    class Config(EC2Settings.Config):
-        env_prefix = AUTOSCALING_ENV_PREFIX
-
-        schema_extra: ClassVar[dict[str, Any]] = {  # type: ignore[misc]
+    model_config = ConfigDict(
+        env_prefix=AUTOSCALING_ENV_PREFIX,
+        json_schema_extra={
             "examples": [
                 {
                     f"{AUTOSCALING_ENV_PREFIX}EC2_ACCESS_KEY_ID": "my_access_key_id",
@@ -53,7 +54,8 @@ class Config(EC2Settings.Config):
                     f"{AUTOSCALING_ENV_PREFIX}EC2_SECRET_ACCESS_KEY": "my_secret_access_key",
                 }
             ],
-        }
+        },
+    )
 
 
 class EC2InstancesSettings(BaseCustomSettings):
@@ -93,7 +95,7 @@ class EC2InstancesSettings(BaseCustomSettings):
 
     EC2_INSTANCES_SECURITY_GROUP_IDS: list[str] = Field(
         ...,
-        min_items=1,
+        min_length=1,
         description="A security group acts as a virtual firewall for your EC2 instances to control incoming and outgoing traffic"
         " (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-security-groups.html), "
         " this is required to start a new EC2 instance",
@@ -130,7 +132,7 @@ class EC2InstancesSettings(BaseCustomSettings):
         description="ARN the EC2 instance should be attached to (example: arn:aws:iam::XXXXX:role/NAME), to disable pass an empty string",
     )
 
-    @validator("EC2_INSTANCES_TIME_BEFORE_DRAINING")
+    @field_validator("EC2_INSTANCES_TIME_BEFORE_DRAINING")
     @classmethod
     def ensure_draining_delay_time_is_in_range(
         cls, value: datetime.timedelta
@@ -141,7 +143,7 @@ def ensure_draining_delay_time_is_in_range(
             value = datetime.timedelta(minutes=1)
         return value
 
-    @validator("EC2_INSTANCES_TIME_BEFORE_TERMINATION")
+    @field_validator("EC2_INSTANCES_TIME_BEFORE_TERMINATION")
     @classmethod
     def ensure_termination_delay_time_is_in_range(
         cls, value: datetime.timedelta
@@ -152,14 +154,14 @@ def ensure_termination_delay_time_is_in_range(
             value = datetime.timedelta(minutes=59)
         return value
 
-    @validator("EC2_INSTANCES_ALLOWED_TYPES")
+    @field_validator("EC2_INSTANCES_ALLOWED_TYPES")
     @classmethod
     def check_valid_instance_names(
         cls, value: dict[str, EC2InstanceBootSpecific]
     ) -> dict[str, EC2InstanceBootSpecific]:
         # NOTE: needed because of a flaw in BaseCustomSettings
         # issubclass raises TypeError if used on Aliases
-        parse_obj_as(list[InstanceTypeType], list(value))
+        TypeAdapter(list[InstanceTypeType]).validate_python(list(value))
         return value
 
 
@@ -181,7 +183,7 @@ class NodesMonitoringSettings(BaseCustomSettings):
 
 
 class DaskMonitoringSettings(BaseCustomSettings):
-    DASK_MONITORING_URL: AnyUrl = Field(
+    DASK_MONITORING_URL: Annotated[str, AnyUrl] = Field(
         ..., description="the url to the osparc-dask-scheduler"
     )
     DASK_SCHEDULER_AUTH: InternalClusterAuthentication = Field(
@@ -217,36 +219,39 @@ class ApplicationSettings(BaseCustomSettings, MixinLoggingSettings):
 
     # RUNTIME  -----------------------------------------------------------
     AUTOSCALING_DEBUG: bool = Field(
-        default=False, description="Debug mode", env=["AUTOSCALING_DEBUG", "DEBUG"]
+        default=False,
+        description="Debug mode",
+        validation_alias=AliasChoices("AUTOSCALING_DEBUG", "DEBUG"),
     )
-    AUTOSCALING_REMOTE_DEBUG_PORT: PortInt = PortInt(3000)
+    AUTOSCALING_REMOTE_DEBUG_PORT: PortInt = 3000
 
     AUTOSCALING_LOGLEVEL: LogLevel = Field(
-        LogLevel.INFO, env=["AUTOSCALING_LOGLEVEL", "LOG_LEVEL", "LOGLEVEL"]
+        LogLevel.INFO,
+        validation_alias=AliasChoices("AUTOSCALING_LOGLEVEL", "LOG_LEVEL", "LOGLEVEL"),
     )
     AUTOSCALING_LOG_FORMAT_LOCAL_DEV_ENABLED: bool = Field(
         default=False,
-        env=[
+        validation_alias=AliasChoices(
             "AUTOSCALING_LOG_FORMAT_LOCAL_DEV_ENABLED",
             "LOG_FORMAT_LOCAL_DEV_ENABLED",
-        ],
+        ),
         description="Enables local development log format. WARNING: make sure it is disabled if you want to have structured logs!",
     )
 
     AUTOSCALING_EC2_ACCESS: AutoscalingEC2Settings | None = Field(
-        auto_default_from_env=True
+        json_schema_extra={"auto_default_from_env": True}
     )
 
     AUTOSCALING_SSM_ACCESS: AutoscalingSSMSettings | None = Field(
-        auto_default_from_env=True
+        json_schema_extra={"auto_default_from_env": True}
     )
 
     AUTOSCALING_EC2_INSTANCES: EC2InstancesSettings | None = Field(
-        auto_default_from_env=True
+        json_schema_extra={"auto_default_from_env": True}
     )
 
     AUTOSCALING_NODES_MONITORING: NodesMonitoringSettings | None = Field(
-        auto_default_from_env=True
+        json_schema_extra={"auto_default_from_env": True}
     )
 
     AUTOSCALING_POLL_INTERVAL: datetime.timedelta = Field(
@@ -255,13 +260,21 @@ class ApplicationSettings(BaseCustomSettings, MixinLoggingSettings):
         "(default to seconds, or see https://pydantic-docs.helpmanual.io/usage/types/#datetime-types for string formating)",
     )
 
-    AUTOSCALING_RABBITMQ: RabbitSettings | None = Field(auto_default_from_env=True)
+    AUTOSCALING_RABBITMQ: RabbitSettings | None = Field(
+        json_schema_extra={"auto_default_from_env": True}
+    )
 
-    AUTOSCALING_REDIS: RedisSettings = Field(auto_default_from_env=True)
+    AUTOSCALING_REDIS: RedisSettings = Field(
+        json_schema_extra={"auto_default_from_env": True}
+    )
 
-    AUTOSCALING_REGISTRY: RegistrySettings | None = Field(auto_default_from_env=True)
+    AUTOSCALING_REGISTRY: RegistrySettings | None = Field(
+        json_schema_extra={"auto_default_from_env": True}
+    )
 
-    AUTOSCALING_DASK: DaskMonitoringSettings | None = Field(auto_default_from_env=True)
+    AUTOSCALING_DASK: DaskMonitoringSettings | None = Field(
+        json_schema_extra={"auto_default_from_env": True}
+    )
 
     AUTOSCALING_PROMETHEUS_INSTRUMENTATION_ENABLED: bool = True
 
@@ -276,12 +289,12 @@ class ApplicationSettings(BaseCustomSettings, MixinLoggingSettings):
     def LOG_LEVEL(self):  # noqa: N802
         return self.AUTOSCALING_LOGLEVEL
 
-    @validator("AUTOSCALING_LOGLEVEL")
+    @field_validator("AUTOSCALING_LOGLEVEL")
     @classmethod
     def valid_log_level(cls, value: str) -> str:
         return cls.validate_log_level(value)
 
-    @root_validator()
+    @model_validator(mode="after")
     @classmethod
     def exclude_both_dynamic_computational_mode(cls, values):
         if (

services/autoscaling/src/simcore_service_autoscaling/modules/auto_scaling_mode_computational.py

@@ -151,10 +151,10 @@ async def compute_cluster_used_resources(
                 for i in instances
             )
         )
-        counter = collections.Counter({k: 0 for k in Resources.__fields__})
+        counter = collections.Counter({k: 0 for k in Resources.model_fields})
         for result in list_of_used_resources:
             counter.update(result.dict())
-        return Resources.parse_obj(dict(counter))
+        return Resources.model_validate(dict(counter))
 
     @staticmethod
     async def compute_cluster_total_resources(

services/autoscaling/src/simcore_service_autoscaling/utils/buffer_machines_pool_core.py

@@ -1,11 +1,11 @@
 from collections.abc import Iterable
 from operator import itemgetter
 
-from aws_library.ec2 import AWSTagKey, AWSTagValue, EC2Tags
+from aws_library.ec2 import AWS_TAG_VALUE_MAX_LENGTH, AWSTagKey, AWSTagValue, EC2Tags
 from fastapi import FastAPI
 from models_library.docker import DockerGenericTag
 from models_library.utils.json_serialization import json_dumps
-from pydantic import parse_obj_as, parse_raw_as
+from pydantic import TypeAdapter
 
 from ..constants import (
     ACTIVATED_BUFFER_MACHINE_EC2_TAGS,
@@ -29,8 +29,10 @@ def get_deactivated_buffer_ec2_tags(
     base_ec2_tags = (
         auto_scaling_mode.get_ec2_tags(app) | DEACTIVATED_BUFFER_MACHINE_EC2_TAGS
     )
-    base_ec2_tags[AWSTagKey("Name")] = AWSTagValue(
-        f"{base_ec2_tags[AWSTagKey('Name')]}-buffer"
+    base_ec2_tags[TypeAdapter(AWSTagKey).validate_python("Name")] = TypeAdapter(
+        AWSTagValue
+    ).validate_python(
+        f"{base_ec2_tags[TypeAdapter(AWSTagKey).validate_python('Name')]}-buffer"
     )
     return base_ec2_tags
 
@@ -43,28 +45,36 @@ def dump_pre_pulled_images_as_tags(images: Iterable[DockerGenericTag]) -> EC2Tag
     # AWS Tag Values are limited to 256 characaters so we chunk the images
     # into smaller chunks
     jsonized_images = json_dumps(images)
-    assert AWSTagValue.max_length  # nosec
-    if len(jsonized_images) > AWSTagValue.max_length:
+    assert AWS_TAG_VALUE_MAX_LENGTH  # nosec
+    if len(jsonized_images) > AWS_TAG_VALUE_MAX_LENGTH:
         # let's chunk the string
-        chunk_size = AWSTagValue.max_length
+        chunk_size = AWS_TAG_VALUE_MAX_LENGTH
         chunks = [
             jsonized_images[i : i + chunk_size]
             for i in range(0, len(jsonized_images), chunk_size)
         ]
         return {
-            AWSTagKey(f"{PRE_PULLED_IMAGES_EC2_TAG_KEY}_({i})"): AWSTagValue(c)
+            TypeAdapter(AWSTagKey)
+            .validate_python(f"{PRE_PULLED_IMAGES_EC2_TAG_KEY}_({i})"): TypeAdapter(
+                AWSTagValue
+            )
+            .validate_python(c)
             for i, c in enumerate(chunks)
         }
     return {
-        PRE_PULLED_IMAGES_EC2_TAG_KEY: parse_obj_as(AWSTagValue, json_dumps(images))
+        PRE_PULLED_IMAGES_EC2_TAG_KEY: TypeAdapter(AWSTagValue).validate_python(
+            json_dumps(images)
+        )
     }
 
 
 def load_pre_pulled_images_from_tags(tags: EC2Tags) -> list[DockerGenericTag]:
     # AWS Tag values are limited to 256 characters so we chunk the images
     if PRE_PULLED_IMAGES_EC2_TAG_KEY in tags:
         # read directly
-        return parse_raw_as(list[DockerGenericTag], tags[PRE_PULLED_IMAGES_EC2_TAG_KEY])
+        return TypeAdapter(list[DockerGenericTag]).validate_json(
+            tags[PRE_PULLED_IMAGES_EC2_TAG_KEY]
+        )
 
     assembled_json = "".join(
         map(
@@ -80,5 +90,5 @@ def load_pre_pulled_images_from_tags(tags: EC2Tags) -> list[DockerGenericTag]:
         )
     )
     if assembled_json:
-        return parse_raw_as(list[DockerGenericTag], assembled_json)
+        return TypeAdapter(list[DockerGenericTag]).validate_json(assembled_json)
     return []

services/autoscaling/src/simcore_service_autoscaling/utils/utils_docker.py

@@ -264,7 +264,7 @@ async def compute_cluster_total_resources(nodes: list[Node]) -> Resources:
             }
         )
 
-    return Resources.parse_obj(dict(cluster_resources_counter))
+    return Resources.model_validate(dict(cluster_resources_counter))
 
 
 def get_max_resources_from_docker_task(task: Task) -> Resources:
@@ -370,7 +370,7 @@ async def compute_node_used_resources(
                     "cpus": task_reservations.get("NanoCPUs", 0) / _NANO_CPU,
                 }
             )
-    return Resources.parse_obj(dict(cluster_resources_counter))
+    return Resources.model_validate(dict(cluster_resources_counter))
 
 
 async def compute_cluster_used_resources(
@@ -380,11 +380,11 @@ async def compute_cluster_used_resources(
     list_of_used_resources = await logged_gather(
         *(compute_node_used_resources(docker_client, node) for node in nodes)
     )
-    counter = collections.Counter({k: 0 for k in Resources.__fields__})
+    counter = collections.Counter({k: 0 for k in Resources.model_fields})
     for result in list_of_used_resources:
         counter.update(result.dict())
 
-    return Resources.parse_obj(dict(counter))
+    return Resources.model_validate(dict(counter))
 
 
 _COMMAND_TIMEOUT_S = 10