polyaxon 2.5.3__py3-none-any.whl → 2.6.0.post1__py3-none-any.whl

polyaxon/_schemas/agent.py

@@ -2,7 +2,13 @@ import os
 
 from typing import Dict, List, Optional
 
-from clipped.compact.pydantic import Extra, Field, StrictStr, root_validator, validator
+from clipped.compact.pydantic import (
+    Field,
+    StrictStr,
+    field_validator,
+    model_validator,
+    validation_before,
+)
 from clipped.config.schema import skip_partial, to_partial
 from vents.connections import ConnectionCatalog
 
@@ -70,16 +76,18 @@ def validate_agent_config(
 class BaseAgentConfig(ConnectionCatalog, BaseSchemaModel):
     _REQUIRED_ARTIFACTS_STORE = True
 
-    connections: Optional[List[V1Connection]] = Field(alias=ENV_KEYS_AGENT_CONNECTIONS)
+    connections: Optional[List[V1Connection]] = Field(
+        default=None, alias=ENV_KEYS_AGENT_CONNECTIONS
+    )
     artifacts_store: Optional[V1Connection] = Field(
-        alias=ENV_KEYS_AGENT_ARTIFACTS_STORE
+        default=None, alias=ENV_KEYS_AGENT_ARTIFACTS_STORE
     )
-    namespace: Optional[StrictStr] = Field(alias=ENV_KEYS_K8S_NAMESPACE)
+    namespace: Optional[StrictStr] = Field(default=None, alias=ENV_KEYS_K8S_NAMESPACE)
 
     class Config:
-        extra = Extra.ignore
+        extra = "ignore"
 
-    @root_validator(pre=True)
+    @model_validator(**validation_before)
     def handle_camel_case_artifacts_store(cls, values):
         if (
             not values.get("artifacts_store")
@@ -89,7 +97,7 @@ class BaseAgentConfig(ConnectionCatalog, BaseSchemaModel):
             values[ENV_KEYS_AGENT_ARTIFACTS_STORE] = values["artifactsStore"]
         return values
 
-    @validator("connections", pre=True)
+    @field_validator("connections", **validation_before)
     def validate_json_list(cls, v):
         if not isinstance(v, str):
             return v
@@ -103,7 +111,7 @@ class BaseAgentConfig(ConnectionCatalog, BaseSchemaModel):
         except PolyaxonSchemaError as e:
             raise ValueError("Received an invalid connections") from e
 
-    @validator("artifacts_store", pre=True)
+    @field_validator("artifacts_store", **validation_before)
     def validate_store_json(cls, v):
         if not isinstance(v, str):
             return v
@@ -118,9 +126,10 @@ class BaseAgentConfig(ConnectionCatalog, BaseSchemaModel):
                 "Received an invalid artifacts store `{}`".format(v)
             ) from e
 
-    @validator("artifacts_store")
+    @field_validator("artifacts_store")
     @skip_partial
     def validate_agent_config(cls, artifacts_store, values):
+        values = cls.get_data_from_values(values)
         try:
             validate_agent_config(
                 artifacts_store,
@@ -186,38 +195,59 @@ class BaseAgentConfig(ConnectionCatalog, BaseSchemaModel):
 
 class AgentConfig(BaseAgentConfig):
     _IDENTIFIER = "agent"
+    _CUSTOM_DUMP_FIELDS = {
+        "sidecar",
+        "init",
+        "notifier",
+        "cleaner",
+        "default_scheduling",
+    }
 
-    is_replica: Optional[bool] = Field(alias=ENV_KEYS_AGENT_IS_REPLICA)
-    watch_cluster: Optional[bool] = Field(alias=ENV_KEYS_WATCH_CLUSTER)
-    single_namespace: Optional[bool] = Field(alias=ENV_KEYS_SINGLE_NAMESPACE)
+    is_replica: Optional[bool] = Field(default=None, alias=ENV_KEYS_AGENT_IS_REPLICA)
+    watch_cluster: Optional[bool] = Field(default=None, alias=ENV_KEYS_WATCH_CLUSTER)
+    single_namespace: Optional[bool] = Field(
+        default=None, alias=ENV_KEYS_SINGLE_NAMESPACE
+    )
     additional_namespaces: Optional[List[StrictStr]] = Field(
-        alias=ENV_KEYS_ADDITIONAL_NAMESPACES
+        default=None, alias=ENV_KEYS_ADDITIONAL_NAMESPACES
+    )
+    sidecar: Optional[V1PolyaxonSidecarContainer] = Field(
+        default=None, alias=ENV_KEYS_AGENT_SIDECAR
+    )
+    init: Optional[V1PolyaxonInitContainer] = Field(
+        default=None, alias=ENV_KEYS_AGENT_INIT
+    )
+    notifier: Optional[V1PolyaxonNotifier] = Field(
+        default=None, alias=ENV_KEYS_AGENT_NOTIFIER
+    )
+    cleaner: Optional[V1PolyaxonCleaner] = Field(
+        default=None, alias=ENV_KEYS_AGENT_CLEANER
     )
-    sidecar: Optional[V1PolyaxonSidecarContainer] = Field(alias=ENV_KEYS_AGENT_SIDECAR)
-    init: Optional[V1PolyaxonInitContainer] = Field(alias=ENV_KEYS_AGENT_INIT)
-    notifier: Optional[V1PolyaxonNotifier] = Field(alias=ENV_KEYS_AGENT_NOTIFIER)
-    cleaner: Optional[V1PolyaxonCleaner] = Field(alias=ENV_KEYS_AGENT_CLEANER)
     use_proxy_env_vars_use_in_ops: Optional[bool] = Field(
-        alias=ENV_KEYS_AGENT_USE_PROXY_ENV_VARS_IN_OPS
+        default=None, alias=ENV_KEYS_AGENT_USE_PROXY_ENV_VARS_IN_OPS
     )
     default_scheduling: Optional[V1DefaultScheduling] = Field(
-        alias=ENV_KEYS_AGENT_DEFAULT_SCHEDULING
+        default=None, alias=ENV_KEYS_AGENT_DEFAULT_SCHEDULING
     )
     default_image_pull_secrets: Optional[List[StrictStr]] = Field(
-        alias=ENV_KEYS_AGENT_DEFAULT_IMAGE_PULL_SECRETS
+        default=None, alias=ENV_KEYS_AGENT_DEFAULT_IMAGE_PULL_SECRETS
+    )
+    app_secret_name: Optional[StrictStr] = Field(
+        default=None, alias=ENV_KEYS_K8S_APP_SECRET_NAME
     )
-    app_secret_name: Optional[StrictStr] = Field(alias=ENV_KEYS_K8S_APP_SECRET_NAME)
-    agent_secret_name: Optional[StrictStr] = Field(alias=ENV_KEYS_AGENT_SECRET_NAME)
-    runs_sa: Optional[StrictStr] = Field(alias=ENV_KEYS_AGENT_RUNS_SA)
+    agent_secret_name: Optional[StrictStr] = Field(
+        default=None, alias=ENV_KEYS_AGENT_SECRET_NAME
+    )
+    runs_sa: Optional[StrictStr] = Field(default=None, alias=ENV_KEYS_AGENT_RUNS_SA)
     enable_health_checks: Optional[bool] = Field(
-        alias=ENV_KEYS_AGENT_ENABLE_HEALTH_CHECKS
+        default=None, alias=ENV_KEYS_AGENT_ENABLE_HEALTH_CHECKS
     )
     # This refresh logic will mitigate several issues with AKS's numerous networking problems
     executor_refresh_interval: Optional[int] = Field(
-        alias=ENV_KEYS_AGENT_EXECUTOR_REFRESH_INTERVAL
+        default=None, alias=ENV_KEYS_AGENT_EXECUTOR_REFRESH_INTERVAL
     )
 
-    @root_validator(pre=True)
+    @model_validator(**validation_before)
     def handle_camel_case_agent(cls, values):
         if (
             not values.get("is_replica")
@@ -307,6 +337,8 @@ class AgentConfig(BaseAgentConfig):
     ):
         if not default_scheduling and default_image_pull_secrets:
             default_scheduling = V1DefaultScheduling()
+        if default_scheduling and isinstance(default_scheduling, dict):
+            default_scheduling = V1DefaultScheduling.from_dict(default_scheduling)
         if default_scheduling and not default_scheduling.image_pull_secrets:
             default_scheduling.image_pull_secrets = default_image_pull_secrets
         super().__init__(
@@ -315,42 +347,42 @@ class AgentConfig(BaseAgentConfig):
             **data,
         )
 
-    @validator(
+    @field_validator(
         "artifacts_store",
         "sidecar",
         "init",
         "cleaner",
         "notifier",
         "default_scheduling",
-        pre=True,
+        **validation_before,
     )
     def validate_json(cls, v, field):
         if not isinstance(v, str):
             return v
+        key = cls.get_alias_for_field(field)
         try:
             return ConfigParser.parse(Dict)(
-                key=field.name,
+                key=key,
                 value=v,
                 is_optional=True,
             )
         except PolyaxonSchemaError as e:
-            raise ValueError(
-                "Received an invalid {} `{}`".format(field.alias, v)
-            ) from e
+            raise ValueError("Received an invalid {} `{}`".format(key, v)) from e
 
-    @validator("additional_namespaces", "default_image_pull_secrets", pre=True)
+    @field_validator(
+        "additional_namespaces", "default_image_pull_secrets", **validation_before
+    )
     def validate_str_list(cls, v, field):
+        key = cls.get_alias_for_field(field)
         try:
             return ConfigParser.parse(str)(
-                key=field.alias,
+                key=key,
                 value=v,
                 is_optional=True,
                 is_list=True,
             )
         except PolyaxonSchemaError as e:
-            raise ValueError(
-                "Received an invalid {} `{}`".format(field.alias, v)
-            ) from e
+            raise ValueError("Received an invalid {} `{}`".format(key, v)) from e
 
     def get_executor_refresh_interval(self) -> int:
         return self.executor_refresh_interval or 60 * 5

polyaxon/_schemas/authentication.py

@@ -1,6 +1,6 @@
 from typing import Optional
 
-from clipped.compact.pydantic import Extra, Field, StrictStr
+from clipped.compact.pydantic import Field, StrictStr
 
 from polyaxon._env_vars.keys import ENV_KEYS_AUTH_TOKEN, ENV_KEYS_AUTH_USERNAME
 from polyaxon._schemas.base import BaseSchemaModel
@@ -18,11 +18,11 @@ class AccessTokenConfig(BaseSchemaModel):
 
     _IDENTIFIER = "token"
 
-    username: Optional[StrictStr] = Field(alias=ENV_KEYS_AUTH_USERNAME)
-    token: Optional[StrictStr] = Field(alias=ENV_KEYS_AUTH_TOKEN)
+    username: Optional[StrictStr] = Field(default=None, alias=ENV_KEYS_AUTH_USERNAME)
+    token: Optional[StrictStr] = Field(default=None, alias=ENV_KEYS_AUTH_TOKEN)
 
     class Config:
-        extra = Extra.ignore
+        extra = "ignore"
 
 
 class V1Credentials(BaseSchemaModel):

polyaxon/_schemas/base.py

@@ -1,4 +1,6 @@
+from clipped.compact.pydantic import PYDANTIC_VERSION
 from clipped.config.schema import BaseSchemaModel as _BaseSchemaModel
+from clipped.config.schema import RootModel as _RootModel
 
 from polyaxon import pkg
 from polyaxon._config.spec import ConfigSpec
@@ -11,5 +13,27 @@ class BaseSchemaModel(_BaseSchemaModel):
     _CONFIG_SPEC = ConfigSpec
 
 
-NAME_REGEX = r"^[-a-zA-Z0-9_]+\Z"
-FULLY_QUALIFIED_NAME_REGEX = r"^[-a-zA-Z0-9_]+(:[-a-zA-Z0-9_.]+)?\Z"
+class RootModel(_RootModel):
+    _VERSION = pkg.SCHEMA_VERSION
+    _SCHEMA_EXCEPTION = PolyaxonSchemaError
+    _CONFIG_SPEC = ConfigSpec
+
+    @property
+    def _root(self):
+        return self.__root__ if hasattr(self, "__root__") else self.root
+
+    def set_root(self, value):
+        if hasattr(self, "__root__"):
+            self.__root__ = value
+        else:
+            self.root = value
+        return self
+
+    def get_root(self):
+        return self._root
+
+    @classmethod
+    def make(cls, value):
+        if PYDANTIC_VERSION.startswith("2."):
+            return cls(root=value)
+        return cls(__root__=value)

polyaxon/_schemas/checks.py

@@ -1,7 +1,7 @@
 import os
 
 from datetime import datetime, timedelta
-from typing import Optional
+from typing import ClassVar, Optional
 
 from clipped.utils.tz import now
 
@@ -11,9 +11,9 @@ from polyaxon._schemas.base import BaseSchemaModel
 
 class ChecksConfig(BaseSchemaModel):
     _IDENTIFIER = "checks"
-    _INTERVAL = 30 * 60
+    _INTERVAL: ClassVar[int] = 30 * 60
 
-    last_check: Optional[datetime]
+    last_check: Optional[datetime] = None
 
     def __init__(
         self,

polyaxon/_schemas/cli.py

@@ -11,13 +11,11 @@ from polyaxon._schemas.log_handler import V1LogHandler
 
 class CliConfig(ChecksConfig):
     _IDENTIFIER = "cli"
-    _DIST = "dist"
-    _INTERVAL = 30 * 60
 
-    current_version: Optional[StrictStr]
-    installation: Optional[V1Installation]
-    compatibility: Optional[V1Compatibility]
-    log_handler: Optional[V1LogHandler]
+    current_version: Optional[StrictStr] = None
+    installation: Optional[V1Installation] = None
+    compatibility: Optional[V1Compatibility] = None
+    log_handler: Optional[V1LogHandler] = None
 
     @property
     def min_version(self) -> Optional[str]:

polyaxon/_schemas/client.py

@@ -4,7 +4,7 @@ from typing import Dict, Optional, Union
 
 import urllib3
 
-from clipped.compact.pydantic import Extra, Field, StrictStr
+from clipped.compact.pydantic import Field, StrictStr
 from clipped.utils.http import clean_host
 
 from polyaxon._contexts import paths as ctx_paths
@@ -55,10 +55,10 @@ class ClientConfig(BaseSchemaModel):
     _PAGE_SIZE = 20
     _BASE_URL = "{}/api/{}"
 
-    host: Optional[StrictStr] = Field(alias=ENV_KEYS_HOST)
+    host: Optional[StrictStr] = Field(default=None, alias=ENV_KEYS_HOST)
     version: Optional[StrictStr] = Field(default="v1", alias=ENV_KEYS_API_VERSION)
     debug: Optional[bool] = Field(default=False, alias=ENV_KEYS_DEBUG)
-    log_level: Optional[StrictStr] = Field(alias=ENV_KEYS_LOG_LEVEL)
+    log_level: Optional[StrictStr] = Field(default=None, alias=ENV_KEYS_LOG_LEVEL)
     authentication_type: Optional[StrictStr] = Field(
         default=AuthenticationTypes.TOKEN, alias=ENV_KEYS_AUTHENTICATION_TYPE
     )
@@ -70,40 +70,42 @@ class ClientConfig(BaseSchemaModel):
     tracking_timeout: Optional[float] = Field(
         default=1, alias=ENV_KEYS_TRACKING_TIMEOUT
     )
-    timezone: Optional[StrictStr] = Field(alias=ENV_KEYS_TIME_ZONE)
+    timezone: Optional[StrictStr] = Field(default=None, alias=ENV_KEYS_TIME_ZONE)
     watch_interval: Optional[int] = Field(default=5, alias=ENV_KEYS_WATCH_INTERVAL)
     interval: Optional[float] = Field(default=5, alias=ENV_KEYS_INTERVAL)
-    verify_ssl: Optional[bool] = Field(alias=ENV_KEYS_VERIFY_SSL)
-    ssl_ca_cert: Optional[StrictStr] = Field(alias=ENV_KEYS_SSL_CA_CERT)
-    cert_file: Optional[StrictStr] = Field(alias=ENV_KEYS_CERT_FILE)
-    key_file: Optional[StrictStr] = Field(alias=ENV_KEYS_KEY_FILE)
-    assert_hostname: Optional[bool] = Field(alias=ENV_KEYS_ASSERT_HOSTNAME)
+    verify_ssl: Optional[bool] = Field(default=None, alias=ENV_KEYS_VERIFY_SSL)
+    ssl_ca_cert: Optional[StrictStr] = Field(default=None, alias=ENV_KEYS_SSL_CA_CERT)
+    cert_file: Optional[StrictStr] = Field(default=None, alias=ENV_KEYS_CERT_FILE)
+    key_file: Optional[StrictStr] = Field(default=None, alias=ENV_KEYS_KEY_FILE)
+    assert_hostname: Optional[bool] = Field(
+        default=None, alias=ENV_KEYS_ASSERT_HOSTNAME
+    )
     connection_pool_maxsize: Optional[int] = Field(
-        alias=ENV_KEYS_CONNECTION_POOL_MAXSIZE
+        default=None, alias=ENV_KEYS_CONNECTION_POOL_MAXSIZE
     )
     archives_root: Optional[StrictStr] = Field(
         default=ctx_paths.CONTEXT_ARCHIVES_ROOT, alias=ENV_KEYS_ARCHIVES_ROOT
     )
     header: Optional[Union[StrictStr, PolyaxonServiceHeaders]] = Field(
-        alias=ENV_KEYS_HEADER
+        default=None, alias=ENV_KEYS_HEADER
     )
     header_service: Optional[Union[StrictStr, PolyaxonServices]] = Field(
-        alias=ENV_KEYS_HEADER_SERVICE
+        default=None, alias=ENV_KEYS_HEADER_SERVICE
     )
-    namespace: Optional[StrictStr] = Field(alias=ENV_KEYS_K8S_NAMESPACE)
+    namespace: Optional[StrictStr] = Field(default=None, alias=ENV_KEYS_K8S_NAMESPACE)
     no_api: Optional[bool] = Field(default=False, alias=ENV_KEYS_NO_API)
     disable_errors_reporting: Optional[bool] = Field(
         default=False, alias=ENV_KEYS_DISABLE_ERRORS_REPORTING
     )
     compatibility_check_interval: Optional[int] = Field(
-        alias=ENV_KEYS_INTERVALS_COMPATIBILITY_CHECK
+        default=None, alias=ENV_KEYS_INTERVALS_COMPATIBILITY_CHECK
     )
-    retries: Optional[int] = Field(alias=ENV_KEYS_RETRIES)
-    token: Optional[StrictStr]
-    client_header: Optional[Dict]
+    retries: Optional[int] = Field(default=None, alias=ENV_KEYS_RETRIES)
+    token: Optional[StrictStr] = None
+    client_header: Optional[Dict] = None
 
     class Config:
-        extra = Extra.ignore
+        extra = "ignore"
 
     def __init__(
         self,

polyaxon/_schemas/compatibility.py

@@ -5,7 +5,7 @@ from polyaxon._schemas.version import V1Version
 
 
 class V1Compatibility(BaseSchemaModel):
-    cli: Optional[V1Version]
-    platform: Optional[V1Version]
-    agent: Optional[V1Version]
-    ui: Optional[V1Version]
+    cli: Optional[V1Version] = None
+    platform: Optional[V1Version] = None
+    agent: Optional[V1Version] = None
+    ui: Optional[V1Version] = None

polyaxon/_schemas/container_resources.py

@@ -25,7 +25,7 @@ class ContainerGPUResourcesConfig(BaseSchemaModel):
     memory_used: StrictIntOrFloat
     memory_total: StrictIntOrFloat
     memory_utilization: StrictIntOrFloat
-    processes: Optional[List[Dict]]
+    processes: Optional[List[Dict]] = None
 
 
 class ContainerResourcesConfig(BaseSchemaModel):

polyaxon/_schemas/home.py

@@ -1,6 +1,6 @@
 from typing import Optional
 
-from clipped.compact.pydantic import Extra, Field, StrictStr
+from clipped.compact.pydantic import Field, StrictStr
 
 from polyaxon._env_vars.keys import ENV_KEYS_HOME
 from polyaxon._schemas.base import BaseSchemaModel
@@ -17,7 +17,7 @@ class HomeConfig(BaseSchemaModel):
 
     _IDENTIFIER = "home"
 
-    path: Optional[StrictStr] = Field(alias=ENV_KEYS_HOME)
+    path: Optional[StrictStr] = Field(alias=ENV_KEYS_HOME, default=None)
 
     class Config:
-        extra = Extra.ignore
+        extra = "ignore"

polyaxon/_schemas/installation.py

@@ -5,15 +5,15 @@ from clipped.config.schema import BaseAllowSchemaModel
 
 
 class V1Installation(BaseAllowSchemaModel):
-    key: Optional[StrictStr]
-    version: Optional[StrictStr]
-    dist: Optional[StrictStr]
-    host: Optional[StrictStr]
-    hmac: Optional[StrictStr]
-    mode: Optional[StrictStr]
-    org: Optional[bool]
+    key: Optional[StrictStr] = None
+    version: Optional[StrictStr] = None
+    dist: Optional[StrictStr] = None
+    host: Optional[StrictStr] = None
+    hmac: Optional[StrictStr] = None
+    mode: Optional[StrictStr] = None
+    org: Optional[bool] = None
+    auth: Optional[List[StrictStr]] = None
     single_url: Optional[bool] = Field(alias="singleUrl", default=None)
     default_streams_url: Optional[StrictStr] = Field(
         alias="defaultStreamsUrl", default=None
     )
-    auth: Optional[List[StrictStr]]

polyaxon/_schemas/lifecycle.py

@@ -332,36 +332,36 @@ class BaseCondition(BaseAllowSchemaModel):
 
 
 class V1StatusCondition(BaseCondition):
-    type: Optional[V1Statuses]
-    status: Optional[Union[bool, str]]
-    reason: Optional[StrictStr]
-    message: Optional[StrictStr]
-    last_update_time: Optional[datetime.datetime]
-    last_transition_time: Optional[datetime.datetime]
-    meta_info: Optional[Dict[str, Any]]
+    type: Optional[V1Statuses] = None
+    status: Optional[Union[bool, str]] = None
+    reason: Optional[StrictStr] = None
+    message: Optional[StrictStr] = None
+    last_update_time: Optional[datetime.datetime] = None
+    last_transition_time: Optional[datetime.datetime] = None
+    meta_info: Optional[Dict[str, Any]] = None
 
 
 class V1Status(BaseSchemaModel):
-    uuid: Optional[StrictStr]
-    status: Optional[V1Statuses]
-    status_conditions: Optional[List[V1StatusCondition]]
-    meta_info: Optional[Dict[str, Any]]
+    uuid: Optional[StrictStr] = None
+    status: Optional[V1Statuses] = None
+    status_conditions: Optional[List[V1StatusCondition]] = None
+    meta_info: Optional[Dict[str, Any]] = None
 
 
 class V1StageCondition(BaseCondition):
-    type: Optional[V1Stages]
-    status: Optional[Union[bool, str]]
-    reason: Optional[StrictStr]
-    message: Optional[StrictStr]
-    last_update_time: Optional[datetime.datetime]
-    last_transition_time: Optional[datetime.datetime]
-    meta_info: Optional[Dict[str, Any]]
+    type: Optional[V1Stages] = None
+    status: Optional[Union[bool, str]] = None
+    reason: Optional[StrictStr] = None
+    message: Optional[StrictStr] = None
+    last_update_time: Optional[datetime.datetime] = None
+    last_transition_time: Optional[datetime.datetime] = None
+    meta_info: Optional[Dict[str, Any]] = None
 
 
 class V1Stage(BaseSchemaModel):
-    uuid: Optional[StrictStr]
-    stage: Optional[V1Stages]
-    stage_conditions: Optional[List[V1StageCondition]]
+    uuid: Optional[StrictStr] = None
+    stage: Optional[V1Stages] = None
+    stage_conditions: Optional[List[V1StageCondition]] = None
 
 
 class V1ProjectVersionKind(str, PEnum):

polyaxon/_schemas/log_handler.py

@@ -9,8 +9,8 @@ from clipped.config.schema import BaseAllowSchemaModel
 class V1LogHandler(BaseAllowSchemaModel):
     _IDENTIFIER = "log_handler"
 
-    dsn: Optional[StrictStr]
-    environment: Optional[StrictStr]
+    dsn: Optional[StrictStr] = None
+    environment: Optional[StrictStr] = None
 
     @property
     def decoded_dsn(self):

polyaxon/_schemas/services.py

@@ -1,6 +1,12 @@
 from typing import 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._containers.pull_policy import PullPolicy
 from polyaxon._k8s import k8s_schemas, k8s_validation
@@ -14,25 +20,31 @@ class BaseServiceConfig(BaseSchemaModel):
         "tolerations",
     }
 
-    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]]
-    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")
-    hpa: Optional[Dict]
-
-    @validator("resources", always=True, pre=True)
+    image: Optional[StrictStr] = None
+    image_tag: Optional[StrictStr] = Field(default=None, alias="imageTag")
+    image_pull_policy: Optional[PullPolicy] = Field(
+        default=None, alias="imagePullPolicy"
+    )
+    resources: Optional[Union[k8s_schemas.V1ResourceRequirements, Dict]] = None
+    node_selector: Optional[Dict[StrictStr, StrictStr]] = Field(
+        default=None, alias="nodeSelector"
+    )
+    affinity: Optional[Union[k8s_schemas.V1Affinity, Dict]] = None
+    tolerations: Optional[List[Union[k8s_schemas.V1Toleration, Dict]]] = None
+    image_pull_secrets: Optional[List[StrictStr]] = Field(
+        default=None, alias="imagePullSecrets"
+    )
+    hpa: Optional[Dict] = None
+
+    @field_validator("resources", **validation_always, **validation_before)
     def validate_resources(cls, v):
         return k8s_validation.validate_k8s_resource_requirements(v)
 
-    @validator("affinity", always=True, pre=True)
+    @field_validator("affinity", **validation_always, **validation_before)
     def validate_affinity(cls, v):
         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):
         if not v:
             return v

polyaxon/_schemas/types/artifacts.py

@@ -154,6 +154,6 @@ class V1ArtifactsType(BaseTypeConfig):
 
     _IDENTIFIER = "artifacts"
 
-    files: Optional[Union[List[Union[str, List[str]]], RefField]]
-    dirs: Optional[Union[List[Union[str, List[str]]], RefField]]
-    workers: Optional[Union[StrictInt, RefField]]
+    files: Optional[Union[List[Union[str, List[str]]], RefField]] = None
+    dirs: Optional[Union[List[Union[str, List[str]]], RefField]] = None
+    workers: Optional[Union[StrictInt, RefField]] = None

polyaxon/_schemas/types/dockerfile.py

@@ -1,6 +1,6 @@
 from typing import Any, Dict, List, Optional, Tuple, Union
 
-from clipped.compact.pydantic import Field, StrictStr, validator
+from clipped.compact.pydantic import Field, StrictStr, field_validator
 from clipped.config.schema import skip_partial
 from clipped.types.docker_image import validate_image
 from clipped.types.ref_or_obj import RefField
@@ -179,31 +179,33 @@ class V1DockerfileType(BaseTypeConfig):
     _IDENTIFIER = "dockerfile"
 
     image: StrictStr
-    env: Optional[Union[Dict[StrictStr, Any], RefField]]
-    path: Optional[Union[List[StrictStr], RefField]]
+    env: Optional[
+        Union[Dict[str, Any], List[Union[Tuple[str, str], List[str]]], RefField]
+    ] = None
+    path: Optional[Union[List[StrictStr], RefField]] = None
     copy_: Optional[
         Union[
             List[Union[StrictStr, List[StrictStr], Tuple[StrictStr, StrictStr]]],
             RefField,
         ]
-    ] = Field(alias="copy")
+    ] = Field(alias="copy", default=None)
     post_run_copy: Optional[
         Union[
             List[Union[StrictStr, List[StrictStr], Tuple[StrictStr, StrictStr]]],
             RefField,
         ]
-    ] = Field(alias="postRunCopy")
-    run: Optional[Union[List[StrictStr], RefField]]
-    lang_env: Optional[StrictStr] = Field(alias="langEnv")
-    uid: Optional[Union[int, RefField]]
-    gid: Optional[Union[int, RefField]]
-    username: Optional[StrictStr]
+    ] = Field(alias="postRunCopy", default=None)
+    run: Optional[Union[List[StrictStr], RefField]] = None
+    lang_env: Optional[StrictStr] = Field(alias="langEnv", default=None)
+    uid: Optional[Union[int, RefField]] = None
+    gid: Optional[Union[int, RefField]] = None
+    username: Optional[StrictStr] = None
     filename: Optional[StrictStr] = Field(default=POLYAXON_DOCKERFILE_NAME)
     workdir: Optional[StrictStr] = Field(default=POLYAXON_DOCKER_WORKDIR)
-    workdir_path: Optional[StrictStr] = Field(alias="workdirPath")
+    workdir_path: Optional[StrictStr] = Field(alias="workdirPath", default=None)
     shell: Optional[StrictStr] = Field(default=POLYAXON_DOCKER_SHELL)
 
-    @validator("image")
+    @field_validator("image")
     @skip_partial
     def check_image(cls, image):
         validate_image(image)

polyaxon/_schemas/types/event.py

@@ -8,5 +8,5 @@ from polyaxon._schemas.types.base import BaseTypeConfig
 class V1EventType(BaseTypeConfig):
     _IDENTIFIER = "event"
 
-    name: Optional[StrictStr]
-    kind: Optional[StrictStr]
+    name: Optional[StrictStr] = None
+    kind: Optional[StrictStr] = None