polyaxon 2.1.0rc9__py3-none-any.whl → 2.6.0__py3-none-any.whl

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/contexts/ray_job.py

@@ -33,7 +33,9 @@ class RayJobContextsManager(BaseContextsManager):
                 connection_by_names=connection_by_names,
             )
 
-        return {
+        data = {
             "head": _get_replica(job.head),
-            "workers": {wn: _get_replica(job.workers[wn]) for wn in job.workers},
         }
+        if job.workers:
+            data["workers"] = {wn: _get_replica(job.workers[wn]) for wn in job.workers}
+        return data

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(
@@ -49,7 +50,18 @@ class AgentResolver(BaseSchemaModel):
 
         self.polyaxon_sidecar = agent_config.sidecar or get_default_sidecar_container()
         self.polyaxon_init = agent_config.init or get_default_init_container()
-        self.namespace = compiled_operation.namespace or agent_config.namespace
+        if compiled_operation.namespace:
+            namespaces = agent_config.additional_namespaces or []
+            namespaces.append(agent_config.namespace)
+            if compiled_operation.namespace not in namespaces:
+                raise PolyaxonCompilerError(
+                    "The provided namespace `{}` is not managed by the agent.".format(
+                        compiled_operation.namespace
+                    )
+                )
+            self.namespace = compiled_operation.namespace
+        else:
+            self.namespace = agent_config.namespace
 
     def _resolve_run_connections(
         self, compiled_operation: V1CompiledOperation, agent_config: AgentConfig

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,
@@ -174,14 +177,14 @@ class BaseResolver:
     def resolve_access(self):
         pass
 
-    def resolve_connections(self):
+    def resolve_agent_environment(self):
         agent_env = AgentResolver.construct()
         agent_env.resolve(
             compiled_operation=self.compiled_operation, agent_config=self.agent_config
         )
         self.polyaxon_sidecar = agent_env.polyaxon_sidecar
         self.polyaxon_init = agent_env.polyaxon_init
-        self.namespace = self.compiled_operation.namespace or agent_env.namespace
+        self.namespace = agent_env.namespace
         self.secrets = agent_env.secrets
         self.config_maps = agent_env.config_maps
         self.connection_by_names = agent_env.connection_by_names
@@ -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):
@@ -281,8 +285,8 @@ class BaseResolver:
         self.apply_operation_contexts()
         self.resolve_io()
         self.resolve_init_refs()
+        self.resolve_agent_environment()
         self.resolve_access()
-        self.resolve_connections()
         self.resolve_artifacts_lineage()
         self.clean_init_refs()
         self.resolve_state()

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/_contexts/paths.py

@@ -18,7 +18,7 @@ CONTEXT_RELATED_RUNS = "_related_runs"
 CONTEXT_LOCAL_LINEAGES = "lineages.plx.json"
 CONTEXT_LOCAL_CONTENT = "content.plx.json"
 CONTEXT_LOCAL_README = "readme.plx.md"
-CONTEXT_LOCAL_POLYAXONFILE = "polyaxonfile.plx.md"
+CONTEXT_LOCAL_POLYAXONFILE = "polyaxonfile.plx.json"
 CONTEXT_LOCAL_PROJECT = "project.plx.json"
 CONTEXT_LOCAL_RUN = "run.plx.json"
 CONTEXT_LOCAL_VERSION = "version.plx.json"

polyaxon/_deploy/operators/compose.py

@@ -5,7 +5,7 @@ from polyaxon._env_vars.keys import ENV_KEYS_LOG_LEVEL, ENV_KEYS_SECRET_KEY
 
 
 class ComposeOperator(CmdOperator):
-    CMD = "docker-compose"
+    CMD = "docker compose"
 
     @classmethod
     def params(cls, args):
@@ -112,30 +112,6 @@ class ComposeOperator(CmdOperator):
             )
         return env
 
-    @staticmethod
-    def _generate_intervals(config):
-        template = "{}={}"
-        env = []
-        if config.intervals:
-            env.append(
-                template.format(
-                    "POLYAXON_INTERVALS_RUNS_SCHEDULER", config.intervals.runs_scheduler
-                )
-            )
-            env.append(
-                template.format(
-                    "POLYAXON_INTERVALS_OPERATIONS_DEFAULT_RETRY_DELAY",
-                    config.intervals.operations_default_retry_delay,
-                )
-            )
-            env.append(
-                template.format(
-                    "POLYAXON_INTERVALS_OPERATIONS_MAX_RETRY_DELAY",
-                    config.intervals.operations_max_retry_delay,
-                )
-            )
-        return env
-
     @staticmethod
     def _generate_email(config):
         template = "{}={}"
@@ -195,8 +171,6 @@ class ComposeOperator(CmdOperator):
         if config.allowed_hosts:
             env.append(template.format("POLYAXON_ALLOWED_HOSTS", config.allowed_hosts))
 
-        env += cls._generate_intervals(config)
-
         if config.log_level:
             env.append(template.format(ENV_KEYS_LOG_LEVEL, config.log_level))
         env += cls._generate_postgres(config)

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,145 +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]
-    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

polyaxon/_deploy/schemas/email.py

@@ -6,11 +6,11 @@ from polyaxon._schemas.base import BaseSchemaModel
 
 
 class EmailConfig(BaseSchemaModel):
-    enabled: Optional[bool]
-    email_from: Optional[StrictStr] = Field(alias="from")
-    host: Optional[StrictStr]
-    port: Optional[StrictInt]
-    use_tls: Optional[bool] = Field(alias="useTls")
-    host_user: Optional[StrictStr] = Field(alias="hostUser")
-    host_password: Optional[StrictStr] = Field(alias="hostPassword")
-    backend: Optional[StrictStr]
+    enabled: Optional[bool] = None
+    email_from: Optional[StrictStr] = Field(alias="from", default=None)
+    host: Optional[StrictStr] = None
+    port: Optional[StrictInt] = None
+    use_tls: Optional[bool] = Field(alias="useTls", default=None)
+    host_user: Optional[StrictStr] = Field(alias="hostUser", default=None)
+    host_password: Optional[StrictStr] = Field(alias="hostPassword", default=None)
+    backend: Optional[StrictStr] = None

polyaxon/_deploy/schemas/ingress.py

@@ -1,16 +1,16 @@
 from typing import Dict, List, Optional
 
-from clipped.compact.pydantic import Extra, Field, StrictStr
+from clipped.compact.pydantic import Field, StrictStr
 
 from polyaxon._schemas.base import BaseSchemaModel
 
 
 class IngressConfig(BaseSchemaModel):
-    enabled: Optional[bool]
-    host_name: Optional[StrictStr] = Field(alias="hostName")
-    path: Optional[StrictStr]
-    tls: Optional[List[Dict]]
-    annotations: Optional[Dict]
+    enabled: Optional[bool] = None
+    host_name: Optional[StrictStr] = Field(alias="hostName", default=None)
+    path: Optional[StrictStr] = None
+    tls: Optional[List[Dict]] = None
+    annotations: Optional[Dict] = None
 
     class Config:
-        extra = Extra.ignore
+        extra = "ignore"

polyaxon/_deploy/schemas/intervals.py

@@ -6,11 +6,6 @@ from polyaxon._schemas.base import BaseSchemaModel
 
 
 class IntervalsConfig(BaseSchemaModel):
-    runs_scheduler: Optional[StrictInt] = Field(alias="runsScheduler")
-    operations_default_retry_delay: Optional[StrictInt] = Field(
-        alias="operationsDefaultRetryDelay"
+    compatibility_check: Optional[StrictInt] = Field(
+        alias="compatibilityCheck", default=None
     )
-    operations_max_retry_delay: Optional[StrictInt] = Field(
-        alias="operationsMaxRetryDelay"
-    )
-    compatibility_check: Optional[StrictInt] = Field(alias="compatibilityCheck")