polyaxon 2.4.0rc1__py3-none-any.whl → 2.6.0__py3-none-any.whl

polyaxon/_auxiliaries/default_scheduling.py

@@ -1,6 +1,12 @@
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
 
-from clipped.compact.pydantic import Field, StrictStr, validator
+from clipped.compact.pydantic import (
+    Field,
+    StrictStr,
+    field_validator,
+    validation_always,
+    validation_before,
+)
 
 from polyaxon._k8s import k8s_schemas, k8s_validation
 from polyaxon._schemas.base import BaseSchemaModel
@@ -13,16 +19,20 @@ class V1DefaultScheduling(BaseSchemaModel):
     _IDENTIFIER = "default_scheduling"
     _SWAGGER_FIELDS = ["affinity", "tolerations"]
 
-    node_selector: Optional[Dict[StrictStr, StrictStr]] = Field(alias="nodeSelector")
-    affinity: Optional[Union[k8s_schemas.V1Affinity, Dict]]
-    tolerations: Optional[List[Union[k8s_schemas.V1Toleration, Dict]]]
-    image_pull_secrets: Optional[List[StrictStr]] = Field(alias="imagePullSecrets")
+    node_selector: Optional[Dict[StrictStr, StrictStr]] = Field(
+        alias="nodeSelector", default=None
+    )
+    affinity: Optional[Union[k8s_schemas.V1Affinity, Dict]] = None
+    tolerations: Optional[List[Union[k8s_schemas.V1Toleration, Dict]]] = None
+    image_pull_secrets: Optional[List[StrictStr]] = Field(
+        alias="imagePullSecrets", default=None
+    )
 
-    @validator("affinity", always=True, pre=True)
+    @field_validator("affinity", **validation_always, **validation_before)
     def validate_affinity(cls, v) -> k8s_schemas.V1Affinity:
         return k8s_validation.validate_k8s_affinity(v)
 
-    @validator("tolerations", always=True, pre=True)
+    @field_validator("tolerations", **validation_always, **validation_before)
     def validate_tolerations(cls, v) -> List[k8s_schemas.V1Toleration]:
         if not v:
             return v

polyaxon/_auxiliaries/init.py

@@ -1,6 +1,12 @@
 from typing import Dict, Optional, Union
 
-from clipped.compact.pydantic import Field, StrictStr, validator
+from clipped.compact.pydantic import (
+    Field,
+    StrictStr,
+    field_validator,
+    validation_always,
+    validation_before,
+)
 from clipped.utils.versions import clean_version_post_suffix
 
 from polyaxon import pkg
@@ -93,12 +99,14 @@ class V1PolyaxonInitContainer(BaseSchemaModel):
     _IDENTIFIER = "container"
     _SWAGGER_FIELDS = ["resources"]
 
-    image: Optional[StrictStr]
-    image_tag: Optional[StrictStr] = Field(alias="imageTag")
-    image_pull_policy: Optional[PullPolicy] = Field(alias="imagePullPolicy")
-    resources: Optional[Union[k8s_schemas.V1ResourceRequirements, Dict]]
+    image: Optional[StrictStr] = None
+    image_tag: Optional[StrictStr] = Field(alias="imageTag", default=None)
+    image_pull_policy: Optional[PullPolicy] = Field(
+        alias="imagePullPolicy", default=None
+    )
+    resources: Optional[Union[k8s_schemas.V1ResourceRequirements, Dict]] = None
 
-    @validator("resources", always=True, pre=True)
+    @field_validator("resources", **validation_always, **validation_before)
     def validate_resources(cls, v) -> k8s_schemas.V1ResourceRequirements:
         return k8s_validation.validate_k8s_resource_requirements(v)
 

polyaxon/_auxiliaries/sidecar.py

@@ -147,14 +147,16 @@ class V1PolyaxonSidecarContainer(BaseSchemaModel):
 
     _IDENTIFIER = "polyaxon_sidecar"
 
-    image: Optional[StrictStr]
-    image_tag: Optional[StrictStr] = Field(alias="imageTag")
-    image_pull_policy: Optional[PullPolicy] = Field(alias="imagePullPolicy")
-    sleep_interval: Optional[IntOrRef] = Field(alias="sleepInterval")
-    sync_interval: Optional[IntOrRef] = Field(alias="syncInterval")
-    monitor_logs: Optional[BoolOrRef] = Field(alias="monitorLogs")
-    monitor_spec: Optional[BoolOrRef] = Field(alias="monitorSpec")
-    resources: Optional[Union[Dict[str, Any], RefField]]
+    image: Optional[StrictStr] = None
+    image_tag: Optional[StrictStr] = Field(alias="imageTag", default=None)
+    image_pull_policy: Optional[PullPolicy] = Field(
+        alias="imagePullPolicy", default=None
+    )
+    sleep_interval: Optional[IntOrRef] = Field(alias="sleepInterval", default=None)
+    sync_interval: Optional[IntOrRef] = Field(alias="syncInterval", default=None)
+    monitor_logs: Optional[BoolOrRef] = Field(alias="monitorLogs", default=None)
+    monitor_spec: Optional[BoolOrRef] = Field(alias="monitorSpec", default=None)
+    resources: Optional[Union[Dict[str, Any], RefField]] = None
 
     def get_image(self):
         image = self.image or "polyaxon/polyaxon-sidecar"

polyaxon/_cli/dashboard.py

@@ -22,11 +22,8 @@ def get_dashboard_url(
     base: str = "ui", subpath: str = "", use_cloud: bool = False, host: str = None
 ) -> str:
     if not host:
-        host = (
-            POLYAXON_CLOUD_HOST
-            if use_cloud
-            else clean_host(settings.CLIENT_CONFIG.host)
-        )
+        host = POLYAXON_CLOUD_HOST if use_cloud else settings.CLIENT_CONFIG.host
+    host = clean_host(host)
     dashboard_url = "{}/{}/".format(host, base)
     if subpath:
         return "{}{}/".format(dashboard_url, subpath.rstrip("/"))

polyaxon/_cli/run.py

@@ -1,4 +1,5 @@
 import sys
+import time
 
 from collections import namedtuple
 from typing import Dict, List, Optional
@@ -56,6 +57,7 @@ def _run(
     upload_to: str,
     upload_from: str,
     watch: bool,
+    approve_after: Optional[int] = None,
     output: Optional[str] = None,
     local: Optional[bool] = False,
     executor: Optional[RunnerKind] = None,
@@ -167,6 +169,9 @@ def _run(
         ctx.invoke(
             run_upload, path_to=upload_to, path_from=upload_from, sync_failure=True
         )
+        if approve_after and approve_after > 0:
+            Printer.print(f"Waiting {approve_after}s to approve the run...")
+            time.sleep(approve_after)
         ctx.invoke(approve)
 
     if not output:
@@ -375,11 +380,18 @@ def _run(
 )
 @click.option(
     "--approved",
+    "-ap",
     help="To enable/disable human in the loop validation without changing the polyaxonfile, "
     "similar to 'isApproved: true/false'. "
     "Can be used with yes/no, y/n, false/true, f/t, 1/0. "
     "e.g. '--approved=1', '--approved=yes', '--approved=false', '--approved=t', ...",
 )
+@click.option(
+    "--approve-after",
+    "-aa",
+    type=int,
+    help="To delay or automatically approve a run after a certain number of seconds.",
+)
 @click.option(
     "--git-preset",
     is_flag=True,
@@ -441,6 +453,7 @@ def run(
     nocache,
     cache,
     approved,
+    approve_after,
     git_preset,
     git_revision,
     ignore_template,
@@ -591,6 +604,7 @@ def run(
         upload_to=upload_to,
         upload_from=upload_from,
         watch=watch,
+        approve_after=approve_after,
         output=output,
         shell=shell,
         local=local,

polyaxon/_cli/version.py

@@ -21,7 +21,10 @@ def pip_upgrade(project_name=PROJECT_CLI_NAME):
 
 
 def get_version(package: str, show_error: bool = True):
-    import pkg_resources
+    try:
+        import pkg_resources
+    except ImportError:
+        return
 
     try:
         return pkg_resources.get_distribution(package).version

polyaxon/_compiler/contexts/contexts.py

@@ -61,6 +61,7 @@ def resolve_globals_contexts(
     cloning_kind: V1CloningKind = None,
     original_uuid: Optional[str] = None,
     is_independent: bool = True,
+    username: Optional[str] = None,
 ) -> Dict:
     resolved_contexts = {
         ctx_sections.GLOBALS: {
@@ -70,6 +71,7 @@ def resolve_globals_contexts(
                 owner_name, project_name
             ),
             ctx_keys.PROJECT_UUID: project_uuid,
+            ctx_keys.USERNAME: username,
             ctx_keys.RUN_INFO: get_run_instance(owner_name, project_name, run_uuid),
             ctx_keys.NAME: run_name,
             ctx_keys.UUID: run_uuid,
@@ -138,6 +140,7 @@ def resolve_contexts(
     cloning_kind: V1CloningKind = None,
     original_uuid: Optional[str] = None,
     is_independent: bool = True,
+    username: Optional[str] = None,
 ) -> Dict:
     run_kind = compiled_operation.get_run_kind()
     if run_kind not in CONTEXTS_MANAGERS:
@@ -168,6 +171,7 @@ def resolve_contexts(
         cloning_kind=cloning_kind,
         original_uuid=original_uuid,
         is_independent=is_independent,
+        username=username,
     )
 
     return CONTEXTS_MANAGERS[run_kind].resolve(

polyaxon/_compiler/resolver/agent.py

@@ -1,7 +1,8 @@
-from typing import Dict, List, Optional
+from typing import Dict, List, Optional, Union
 
 from clipped.compact.pydantic import Field
 from clipped.utils.lists import to_list
+from vents.connections import Connection, ConnectionResource
 
 from polyaxon import settings
 from polyaxon._auxiliaries import (
@@ -18,14 +19,14 @@ from polyaxon.exceptions import PolyaxonCompilerError
 
 
 class AgentResolver(BaseSchemaModel):
-    polyaxon_sidecar: Optional[V1PolyaxonSidecarContainer]
-    polyaxon_init: Optional[V1PolyaxonInitContainer]
-    namespace: Optional[str]
-    secrets: Optional[List[V1ConnectionResource]]
-    config_maps: Optional[List[V1ConnectionResource]]
-    connection_by_names: Optional[Dict[str, V1Connection]]
-    artifacts_store: Optional[V1Connection]
-    default_sa: Optional[str]
+    polyaxon_sidecar: Optional[V1PolyaxonSidecarContainer] = None
+    polyaxon_init: Optional[V1PolyaxonInitContainer] = None
+    namespace: Optional[str] = None
+    secrets: Optional[List[Union[V1ConnectionResource, ConnectionResource]]] = None
+    config_maps: Optional[List[Union[V1ConnectionResource, ConnectionResource]]] = None
+    connection_by_names: Optional[Dict[str, Union[V1Connection, Connection]]] = None
+    artifacts_store: Optional[Union[V1Connection, Connection]] = None
+    default_sa: Optional[str] = None
     internal_auth: Optional[bool] = Field(default=False)
 
     def resolve(

polyaxon/_compiler/resolver/runtime.py

@@ -46,12 +46,14 @@ class BaseResolver:
         cloning_kind: V1CloningKind = None,
         original_uuid: Optional[str] = None,
         is_independent: bool = True,
+        username: Optional[str] = None,
     ):
         if not compiled_operation:
             raise PolyaxonCompilerError("A run spec is required for resolution.")
         self.run = run
         self.compiled_operation = compiled_operation
         self.owner_name = owner_name
+        self.username = username
         self.project_name = project_name
         self.project_uuid = project_uuid
         self.project_uuid = project_uuid or project_name
@@ -105,6 +107,7 @@ class BaseResolver:
             owner_name=self.owner_name,
             project_name=self.project_name,
             project_uuid=self.project_uuid,
+            username=self.username,
             run_uuid=self.run_uuid,
             run_name=self.run_name,
             run_path=self.run_path,
@@ -232,6 +235,7 @@ class BaseResolver:
             cloning_kind=self.cloning_kind,
             original_uuid=self.original_uuid,
             is_independent=self.is_independent,
+            username=self.username,
         )
 
     def _apply_runtime_contexts(self):

polyaxon/_constants/metadata.py

@@ -22,3 +22,4 @@ META_COPY_ARTIFACTS = "copy_artifacts"
 META_DESTINATION_IMAGE = "destination_image"
 META_PROGRESS = "progress"
 META_RECOMPILE = "recompile"
+META_TTL = "ttl"

polyaxon/_contexts/keys.py

@@ -2,6 +2,7 @@ OWNER_NAME = "owner_name"
 PROJECT_NAME = "project_name"
 PROJECT_UUID = "project_uuid"
 PROJECT_UNIQUE_NAME = "project_unique_name"
+USERNAME = "username"
 CONTEXT_PATH = "context_path"
 ARTIFACTS_PATH = "artifacts_path"
 ITERATION = "iteration"

polyaxon/_deploy/schemas/auth.py

@@ -6,6 +6,6 @@ from polyaxon._schemas.base import BaseSchemaModel
 
 
 class AuthConfig(BaseSchemaModel):
-    enabled: Optional[bool]
-    external: Optional[StrictStr]
-    use_resolver: Optional[bool] = Field(alias="useResolver")
+    enabled: Optional[bool] = None
+    external: Optional[StrictStr] = None
+    use_resolver: Optional[bool] = Field(alias="useResolver", default=None)

polyaxon/_deploy/schemas/celery.py

@@ -6,17 +6,19 @@ from polyaxon._schemas.base import BaseSchemaModel
 
 
 class CeleryConfig(BaseSchemaModel):
-    enabled: Optional[bool]
-    task_track_started: Optional[bool] = Field(alias="taskTrackStarted")
-    broker_pool_limit: Optional[StrictInt] = Field(alias="brokerPoolLimit")
-    confirm_publish: Optional[bool] = Field(alias="confirmPublish")
+    enabled: Optional[bool] = None
+    task_track_started: Optional[bool] = Field(alias="taskTrackStarted", default=None)
+    broker_pool_limit: Optional[StrictInt] = Field(
+        alias="brokerPoolLimit", default=None
+    )
+    confirm_publish: Optional[bool] = Field(alias="confirmPublish", default=None)
     worker_prefetch_multiplier: Optional[StrictInt] = Field(
-        alias="workerPrefetchMultiplier"
+        alias="workerPrefetchMultiplier", default=None
     )
     worker_max_tasks_per_child: Optional[StrictInt] = Field(
-        alias="workerMaxTasksPerChild"
+        alias="workerMaxTasksPerChild", default=None
     )
     worker_max_memory_per_child: Optional[StrictInt] = Field(
-        alias="workerMaxMemoryPerChild"
+        alias="workerMaxMemoryPerChild", default=None
     )
-    task_always_eager: Optional[bool] = Field(alias="taskAlwaysEager")
+    task_always_eager: Optional[bool] = Field(alias="taskAlwaysEager", default=None)

polyaxon/_deploy/schemas/deployment.py

@@ -5,8 +5,11 @@ from clipped.compact.pydantic import (
     Field,
     StrictInt,
     StrictStr,
-    root_validator,
-    validator,
+    field_validator,
+    model_validator,
+    validation_after,
+    validation_always,
+    validation_before,
 )
 from clipped.formatting import Printer
 
@@ -187,146 +190,175 @@ class DeploymentConfig(BaseSchemaModel):
         "celeryAffinity",
     ]
 
-    deployment_type: Optional[DeploymentTypes] = Field(alias="deploymentType")
+    deployment_type: Optional[DeploymentTypes] = Field(
+        alias="deploymentType", default=None
+    )
     deployment_chart: Optional[DeploymentCharts] = Field(
         default=DeploymentCharts.PLATFORM, alias="deploymentChart"
     )
-    deployment_version: Optional[StrictStr] = Field(alias="deploymentVersion")
-    release_name: Optional[StrictStr] = Field(alias="releaseName")
-    namespace: Optional[StrictStr]
-    rbac: Optional[RBACConfig]
-    polyaxon_secret: Optional[StrictStr] = Field(alias="polyaxonSecret")
-    internal_token: Optional[StrictStr] = Field(alias="internalToken")
-    password_length: Optional[StrictInt] = Field(alias="passwordLength")
-    password_auth: Optional[bool] = Field(alias="passwordAuth")
-    ssl: Optional[SSLConfig]
-    encryption_secret: Optional[StrictStr] = Field(alias="encryptionSecret")
-    platform_secret: Optional[StrictStr] = Field(alias="platformSecret")
-    agent_secret: Optional[StrictStr] = Field(alias="agentSecret")
-    timezone: Optional[StrictStr]
-    environment: Optional[StrictStr]
-    ingress: Optional[IngressConfig]
-    user: Optional[RootUserConfig]
-    node_selector: Optional[Dict[StrictStr, StrictStr]] = Field(alias="nodeSelector")
-    tolerations: Optional[List[Union[k8s_schemas.V1Toleration, Dict]]]
-    affinity: Optional[Union[k8s_schemas.V1Affinity, Dict]]
-    labels: Optional[Dict[StrictStr, StrictStr]] = Field(alias="labels")
-    annotations: Optional[Dict[StrictStr, StrictStr]] = Field(alias="annotations")
-    priority_class_name: Optional[StrictStr] = Field(alias="priorityClassName")
+    deployment_version: Optional[StrictStr] = Field(
+        alias="deploymentVersion", default=None
+    )
+    release_name: Optional[StrictStr] = Field(alias="releaseName", default=None)
+    namespace: Optional[StrictStr] = Field(default=None)
+    rbac: Optional[RBACConfig] = None
+    polyaxon_secret: Optional[StrictStr] = Field(alias="polyaxonSecret", default=None)
+    internal_token: Optional[StrictStr] = Field(alias="internalToken", default=None)
+    password_length: Optional[StrictInt] = Field(alias="passwordLength", default=None)
+    password_auth: Optional[bool] = Field(alias="passwordAuth", default=None)
+    ssl: Optional[SSLConfig] = None
+    encryption_secret: Optional[StrictStr] = Field(
+        alias="encryptionSecret", default=None
+    )
+    platform_secret: Optional[StrictStr] = Field(alias="platformSecret", default=None)
+    agent_secret: Optional[StrictStr] = Field(alias="agentSecret", default=None)
+    timezone: Optional[StrictStr] = Field(default=None)
+    environment: Optional[StrictStr] = Field(default=None)
+    ingress: Optional[IngressConfig] = None
+    user: Optional[RootUserConfig] = None
+    node_selector: Optional[Dict[StrictStr, StrictStr]] = Field(
+        alias="nodeSelector", default=None
+    )
+    tolerations: Optional[List[Union[k8s_schemas.V1Toleration, Dict]]] = None
+    affinity: Optional[Union[k8s_schemas.V1Affinity, Dict]] = None
+    labels: Optional[Dict[StrictStr, StrictStr]] = Field(alias="labels", default=None)
+    annotations: Optional[Dict[StrictStr, StrictStr]] = Field(
+        alias="annotations", default=None
+    )
+    priority_class_name: Optional[StrictStr] = Field(
+        alias="priorityClassName", default=None
+    )
     celery_node_selector: Optional[Dict[StrictStr, StrictStr]] = Field(
-        alias="celeryNodeSelector"
+        alias="celeryNodeSelector", default=None
     )
     celery_tolerations: Optional[List[Union[k8s_schemas.V1Toleration, Dict]]] = Field(
-        alias="celeryTolerations"
+        alias="celeryTolerations", default=None
     )
     celery_affinity: Optional[Union[k8s_schemas.V1Affinity, Dict]] = Field(
-        alias="celeryAffinity"
+        alias="celeryAffinity", default=None
+    )
+    limit_resources: Optional[bool] = Field(alias="limitResources", default=None)
+    global_replicas: Optional[StrictInt] = Field(alias="globalReplicas", default=None)
+    global_concurrency: Optional[StrictInt] = Field(
+        alias="globalConcurrency", default=None
+    )
+    gateway: Optional[ApiServiceConfig] = None
+    scheduler: Optional[WorkerServiceConfig] = None
+    compiler: Optional[WorkerServiceConfig] = None
+    worker: Optional[WorkerServiceConfig] = None
+    beat: Optional[DeploymentService] = None
+    agent: Optional[AgentServiceConfig] = None
+    operator: Optional[OperatorServiceConfig] = None
+    init: Optional[V1PolyaxonInitContainer] = None
+    sidecar: Optional[V1PolyaxonSidecarContainer] = None
+    notifier: Optional[V1PolyaxonNotifier] = None
+    cleaner: Optional[V1PolyaxonCleaner] = None
+    default_scheduling: Optional[V1DefaultScheduling] = Field(
+        alias="defaultScheduling", default=None
     )
-    limit_resources: Optional[bool] = Field(alias="limitResources")
-    global_replicas: Optional[StrictInt] = Field(alias="globalReplicas")
-    global_concurrency: Optional[StrictInt] = Field(alias="globalConcurrency")
-    gateway: Optional[ApiServiceConfig]
-    scheduler: Optional[WorkerServiceConfig]
-    compiler: Optional[WorkerServiceConfig]
-    worker: Optional[WorkerServiceConfig]
-    beat: Optional[DeploymentService]
-    agent: Optional[AgentServiceConfig]
-    operator: Optional[OperatorServiceConfig]
-    init: Optional[V1PolyaxonInitContainer]
-    sidecar: Optional[V1PolyaxonSidecarContainer]
-    notifier: Optional[V1PolyaxonNotifier]
-    cleaner: Optional[V1PolyaxonCleaner]
-    default_scheduling: Optional[V1DefaultScheduling] = Field(alias="defaultScheduling")
     default_image_pull_secrets: Optional[List[StrictStr]] = Field(
-        alias="defaultImagePullSecrets"
+        alias="defaultImagePullSecrets", default=None
+    )
+    clean_hooks: Optional[HooksConfig] = Field(alias="cleanHooks", default=None)
+    api_hooks: Optional[HooksConfig] = Field(alias="apiHooks", default=None)
+    flower: Optional[DeploymentService] = None
+    postgresql: Optional[PostgresqlConfig] = None
+    redis: Optional[RedisConfig] = None
+    rabbitmq: Optional[RabbitmqConfig] = None
+    broker: Optional[Literal["redis", "rabbitmq"]] = None
+    email: Optional[EmailConfig] = None
+    ldap: Optional[Dict] = None
+    metrics: Optional[Dict] = None
+    image_pull_secrets: Optional[List[StrictStr]] = Field(
+        alias="imagePullSecrets", default=None
+    )
+    host_name: Optional[StrictStr] = Field(alias="hostName", default=None)
+    allowed_hosts: Optional[List[StrictStr]] = Field(alias="allowedHosts", default=None)
+    include_host_ips: Optional[bool] = Field(alias="includeHostIps", default=None)
+    intervals: Optional[IntervalsConfig] = None
+    cleaning_intervals: Optional[Dict] = Field(alias="cleaningIntervals", default=None)
+    artifacts_store: Optional[V1Connection] = Field(
+        alias="artifactsStore", default=None
+    )
+    connections: Optional[List[V1Connection]] = Field(default=None)
+    mount_connections: Optional[List[str]] = Field(
+        alias="mountConnections", default=None
+    )
+    log_level: Optional[StrictStr] = Field(alias="logLevel", default=None)
+    security_context: Optional[SecurityContextConfig] = Field(
+        alias="securityContext", default=None
     )
-    clean_hooks: Optional[HooksConfig] = Field(alias="cleanHooks")
-    api_hooks: Optional[HooksConfig] = Field(alias="apiHooks")
-    flower: Optional[DeploymentService]
-    postgresql: Optional[PostgresqlConfig]
-    redis: Optional[RedisConfig]
-    rabbitmq: Optional[RabbitmqConfig]
-    broker: Optional[Literal["redis", "rabbitmq"]]
-    email: Optional[EmailConfig]
-    ldap: Optional[Dict]
-    metrics: Optional[Dict]
-    image_pull_secrets: Optional[List[StrictStr]] = Field(alias="imagePullSecrets")
-    host_name: Optional[StrictStr] = Field(alias="hostName")
-    allowed_hosts: Optional[List[StrictStr]] = Field(alias="allowedHosts")
-    include_host_ips: Optional[bool] = Field(alias="includeHostIps")
-    intervals: Optional[IntervalsConfig]
-    cleaning_intervals: Optional[Dict] = Field(alias="cleaningIntervals")
-    artifacts_store: Optional[V1Connection] = Field(alias="artifactsStore")
-    connections: Optional[List[V1Connection]]
-    mount_connections: Optional[List[str]] = Field(alias="mountConnections")
-    log_level: Optional[StrictStr] = Field(alias="logLevel")
-    security_context: Optional[SecurityContextConfig] = Field(alias="securityContext")
     external_services: Optional[ExternalServicesConfig] = Field(
-        alias="externalServices"
+        alias="externalServices", default=None
     )
-    debug_mode: Optional[bool] = Field(alias="debugMode")
-    organization_key: Optional[StrictStr] = Field(alias="organizationKey")
-    auth: Optional[AuthConfig]
-    proxy: Optional[ProxyConfig]
-    ui: Optional[UIConfig]
-    include_chart_revision: Optional[bool] = Field(alias="includeChartRevision")
-    operators: Optional[OperatorsConfig]
-    istio: Optional[Dict]
-    dns: Optional[Dict]
-
-    @root_validator
+    debug_mode: Optional[bool] = Field(alias="debugMode", default=None)
+    organization_key: Optional[StrictStr] = Field(alias="organizationKey", default=None)
+    auth: Optional[AuthConfig] = None
+    proxy: Optional[ProxyConfig] = None
+    ui: Optional[UIConfig] = None
+    include_chart_revision: Optional[bool] = Field(
+        alias="includeChartRevision", default=None
+    )
+    operators: Optional[OperatorsConfig] = None
+    istio: Optional[Dict] = None
+    dns: Optional[Dict] = None
+
+    @model_validator(**validation_after)
     def validate_deployment(cls, values):
         validate_deployment_chart(
-            deployment_chart=values.get("deployment_chart"),
-            agent=values.get("agent"),
-            environment=values.get("environment"),
+            deployment_chart=cls.get_value_for_key("deployment_chart", values),
+            agent=cls.get_value_for_key("agent", values),
+            environment=cls.get_value_for_key("environment", values),
         )
         validate_platform_deployment(
-            postgresql=values.get("postgresql"),
-            redis=values.get("redis"),
-            rabbitmq=values.get("rabbitmq"),
-            broker=values.get("broker"),
-            scheduler=values.get("scheduler"),
-            compiler=values.get("compiler"),
-            worker=values.get("worker"),
-            beat=values.get("beat"),
-            external_services=values.get("external_services"),
+            postgresql=cls.get_value_for_key("postgresql", values),
+            redis=cls.get_value_for_key("redis", values),
+            rabbitmq=cls.get_value_for_key("rabbitmq", values),
+            broker=cls.get_value_for_key("broker", values),
+            scheduler=cls.get_value_for_key("scheduler", values),
+            compiler=cls.get_value_for_key("compiler", values),
+            worker=cls.get_value_for_key("worker", values),
+            beat=cls.get_value_for_key("beat", values),
+            external_services=cls.get_value_for_key("external_services", values),
         )
-        if values.get("deployment_chart") == DeploymentCharts.AGENT:
+        if cls.get_value_for_key("deployment_chart", values) == DeploymentCharts.AGENT:
             wrong_agent_deployment_keys(
-                password_length=values.get("password_length"),
-                password_auth=values.get("password_auth"),
-                platform_secret=values.get("platform_secret"),
-                encryption_secret=values.get("encryption_secret"),
-                user=values.get("user"),
-                global_replicas=values.get("global_replicas"),
-                global_concurrency=values.get("global_concurrency"),
-                scheduler=values.get("scheduler"),
-                compiler=values.get("compiler"),
-                worker=values.get("worker"),
-                beat=values.get("beat"),
-                clean_hook=values.get("clean_hook"),
-                api_hooks=values.get("api_hooks"),
-                flower=values.get("flower"),
-                postgresql=values.get("postgresql"),
-                redis=values.get("redis"),
-                rabbitmq=values.get("rabbitmq"),
-                broker=values.get("broker"),
-                email=values.get("email"),
-                ldap=values.get("ldap"),
-                intervals=values.get("intervals"),
-                metrics=values.get("metrics"),
-                organization_key=values.get("organization_key"),
-                ui=values.get("ui"),
+                password_length=cls.get_value_for_key("password_length", values),
+                password_auth=cls.get_value_for_key("password_auth", values),
+                platform_secret=cls.get_value_for_key("platform_secret", values),
+                encryption_secret=cls.get_value_for_key("encryption_secret", values),
+                user=cls.get_value_for_key("user", values),
+                global_replicas=cls.get_value_for_key("global_replicas", values),
+                global_concurrency=cls.get_value_for_key("global_concurrency", values),
+                scheduler=cls.get_value_for_key("scheduler", values),
+                compiler=cls.get_value_for_key("compiler", values),
+                worker=cls.get_value_for_key("worker", values),
+                beat=cls.get_value_for_key("beat", values),
+                clean_hook=cls.get_value_for_key("clean_hook", values),
+                api_hooks=cls.get_value_for_key("api_hooks", values),
+                flower=cls.get_value_for_key("flower", values),
+                postgresql=cls.get_value_for_key("postgresql", values),
+                redis=cls.get_value_for_key("redis", values),
+                rabbitmq=cls.get_value_for_key("rabbitmq", values),
+                broker=cls.get_value_for_key("broker", values),
+                email=cls.get_value_for_key("email", values),
+                ldap=cls.get_value_for_key("ldap", values),
+                intervals=cls.get_value_for_key("intervals", values),
+                metrics=cls.get_value_for_key("metrics", values),
+                organization_key=cls.get_value_for_key("organization_key", values),
             )
 
         return values
 
-    @validator("affinity", "celery_affinity", always=True, pre=True)
+    @field_validator(
+        "affinity", "celery_affinity", **validation_always, **validation_before
+    )
     def validate_affinity(cls, v):
         return k8s_validation.validate_k8s_affinity(v)
 
-    @validator("tolerations", "celery_tolerations", always=True, pre=True)
+    @field_validator(
+        "tolerations", "celery_tolerations", **validation_always, **validation_before
+    )
     def validate_tolerations(cls, v):
         if not v:
             return v