polyaxon 2.5.3__py3-none-any.whl → 2.6.0.post1__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/_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/_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]
-    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"),
+                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,4 +6,6 @@ from polyaxon._schemas.base import BaseSchemaModel
 
 
 class IntervalsConfig(BaseSchemaModel):
-    compatibility_check: Optional[StrictInt] = Field(alias="compatibilityCheck")
+    compatibility_check: Optional[StrictInt] = Field(
+        alias="compatibilityCheck", default=None
+    )

polyaxon/_deploy/schemas/operators.py

@@ -4,11 +4,11 @@ from polyaxon._schemas.base import BaseSchemaModel
 
 
 class OperatorsConfig(BaseSchemaModel):
-    tfjob: Optional[bool]
-    pytorchjob: Optional[bool]
-    paddlejob: Optional[bool]
-    mpijob: Optional[bool]
-    mxjob: Optional[bool]
-    xgbjob: Optional[bool]
-    daskjob: Optional[bool]
-    rayjob: Optional[bool]
+    tfjob: Optional[bool] = None
+    pytorchjob: Optional[bool] = None
+    paddlejob: Optional[bool] = None
+    mpijob: Optional[bool] = None
+    mxjob: Optional[bool] = None
+    xgbjob: Optional[bool] = None
+    daskjob: Optional[bool] = None
+    rayjob: Optional[bool] = None

polyaxon/_deploy/schemas/proxy.py

@@ -6,12 +6,12 @@ from polyaxon._schemas.base import BaseSchemaModel
 
 
 class ProxyConfig(BaseSchemaModel):
-    enabled: Optional[bool]
-    use_in_ops: Optional[bool] = Field(alias="useInOps")
-    http_proxy: Optional[StrictStr] = Field(alias="httpProxy")
-    https_proxy: Optional[StrictStr] = Field(alias="httpsProxy")
-    no_proxy: Optional[StrictStr] = Field(alias="noProxy")
-    port: Optional[StrictInt]
-    host: Optional[StrictStr]
-    protocol: Optional[StrictStr]
-    kind: Optional[StrictStr]
+    enabled: Optional[bool] = None
+    use_in_ops: Optional[bool] = Field(alias="useInOps", default=None)
+    http_proxy: Optional[StrictStr] = Field(alias="httpProxy", default=None)
+    https_proxy: Optional[StrictStr] = Field(alias="httpsProxy", default=None)
+    no_proxy: Optional[StrictStr] = Field(alias="noProxy", default=None)
+    port: Optional[StrictInt] = None
+    host: Optional[StrictStr] = None
+    protocol: Optional[StrictStr] = None
+    kind: Optional[StrictStr] = None

polyaxon/_deploy/schemas/rbac.py

@@ -4,4 +4,4 @@ from polyaxon._schemas.base import BaseSchemaModel
 
 
 class RBACConfig(BaseSchemaModel):
-    enabled: Optional[bool]
+    enabled: Optional[bool] = None

polyaxon/_deploy/schemas/root_user.py

@@ -1,12 +1,12 @@
 from typing import Optional
 
-from clipped.compact.pydantic import StrictStr, constr
+from clipped.compact.pydantic import NAME_REGEX, StrictStr, patter_constr
 from clipped.types.email import EmailStr
 
-from polyaxon._schemas.base import NAME_REGEX, BaseSchemaModel
+from polyaxon._schemas.base import BaseSchemaModel
 
 
 class RootUserConfig(BaseSchemaModel):
-    username: Optional[constr(regex=NAME_REGEX)]  # type: ignore[valid-type]
-    password: Optional[StrictStr]
-    email: Optional[EmailStr]
+    username: Optional[patter_constr(pattern=NAME_REGEX)] = None  # type: ignore[valid-type]
+    password: Optional[StrictStr] = None
+    email: Optional[EmailStr] = None