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

polyaxon/_flow/__init__.py

@@ -1,3 +1,5 @@
+from clipped.compact.pydantic import model_rebuild
+
 from polyaxon._flow.builds import V1Build
 from polyaxon._flow.cache import V1Cache
 from polyaxon._flow.component import V1Component
@@ -106,5 +108,4 @@ from polyaxon._flow.termination import V1Termination
 from polyaxon._flow.trigger_policies import V1TriggerPolicy
 
 # Forward references for operations and components
-V1Dag.update_forward_refs(V1Operation=V1Operation)
-V1Dag.update_forward_refs(V1Component=V1Component)
+model_rebuild(V1Dag, V1Operation=V1Operation, V1Component=V1Component)

polyaxon/_flow/builds/__init__.py

@@ -222,13 +222,13 @@ class V1Build(BaseSchemaModel):
 
     _IDENTIFIER = "build"
     hub_ref: StrictStr = Field(alias="hubRef")
-    connection: Optional[StrictStr]
-    presets: Optional[Union[List[StrictStr], RefField]]
-    queue: Optional[StrictStr]
-    namespace: Optional[StrictStr]
-    cache: Optional[Union[V1Cache, RefField]]
-    params: Optional[Dict[str, Union[V1Param, RefField]]]
-    run_patch: Optional[Dict[str, Any]] = Field(alias="runPatch")
+    connection: Optional[StrictStr] = None
+    presets: Optional[Union[List[StrictStr], RefField]] = None
+    queue: Optional[StrictStr] = None
+    namespace: Optional[StrictStr] = None
+    cache: Optional[Union[V1Cache, RefField]] = None
+    params: Optional[Dict[str, Union[V1Param, RefField]]] = None
+    run_patch: Optional[Dict[str, Any]] = Field(alias="runPatch", default=None)
     patch_strategy: Optional[Union[PatchStrategy, RefField]] = Field(
-        alias="patchStrategy"
+        alias="patchStrategy", default=None
     )

polyaxon/_flow/cache/__init__.py

@@ -99,7 +99,7 @@ class V1Cache(BaseSchemaModel):
 
     _IDENTIFIER = "cache"
 
-    disable: Optional[BoolOrRef]
-    ttl: Optional[IntOrRef]
-    io: Optional[Union[List[StrictStr], RefField]]
-    sections: Optional[Union[List[CacheSection], RefField]]
+    disable: Optional[BoolOrRef] = None
+    ttl: Optional[IntOrRef] = None
+    io: Optional[Union[List[StrictStr], RefField]] = None
+    sections: Optional[Union[List[CacheSection], RefField]] = None

polyaxon/_flow/component/base.py

@@ -1,6 +1,13 @@
 from typing import List, Optional, Union
 
-from clipped.compact.pydantic import Field, StrictStr, constr, validator
+from clipped.compact.pydantic import (
+    NAME_REGEX,
+    Field,
+    StrictStr,
+    field_validator,
+    patter_constr,
+    validation_before,
+)
 from clipped.types.ref_or_obj import BoolOrRef, FloatOrRef, RefField
 from clipped.utils.lists import to_list
 
@@ -9,27 +16,27 @@ from polyaxon._flow.cache import V1Cache
 from polyaxon._flow.hooks import V1Hook
 from polyaxon._flow.plugins import V1Plugins
 from polyaxon._flow.termination import V1Termination
-from polyaxon._schemas.base import NAME_REGEX, BaseSchemaModel
+from polyaxon._schemas.base import BaseSchemaModel
 
 
 class BaseComponent(BaseSchemaModel):
-    version: Optional[float]
-    kind: Optional[StrictStr]
-    name: Optional[Union[constr(regex=NAME_REGEX), RefField]]
-    description: Optional[StrictStr]
-    tags: Optional[List[StrictStr]]
-    presets: Optional[List[StrictStr]]
-    queue: Optional[StrictStr]
-    namespace: Optional[StrictStr]
-    cache: Optional[Union[V1Cache, RefField]]
-    termination: Optional[Union[V1Termination, RefField]]
-    plugins: Optional[Union[V1Plugins, RefField]]
-    build: Optional[Union[V1Build, RefField]]
-    hooks: Optional[Union[List[V1Hook], RefField]]
-    is_approved: Optional[BoolOrRef] = Field(alias="isApproved")
-    cost: Optional[FloatOrRef]
+    version: Optional[float] = None
+    kind: Optional[StrictStr] = None
+    name: Optional[Union[patter_constr(pattern=NAME_REGEX), RefField]] = None
+    description: Optional[StrictStr] = None
+    tags: Optional[List[StrictStr]] = None
+    presets: Optional[List[StrictStr]] = None
+    queue: Optional[StrictStr] = None
+    namespace: Optional[StrictStr] = None
+    cache: Optional[Union[V1Cache, RefField]] = None
+    termination: Optional[Union[V1Termination, RefField]] = None
+    plugins: Optional[Union[V1Plugins, RefField]] = None
+    build: Optional[Union[V1Build, RefField]] = None
+    hooks: Optional[Union[List[V1Hook], RefField]] = None
+    is_approved: Optional[BoolOrRef] = Field(alias="isApproved", default=None)
+    cost: Optional[FloatOrRef] = None
 
-    @validator("tags", "presets", pre=True)
+    @field_validator("tags", "presets", **validation_before)
     def validate_str_list(cls, v):
         if isinstance(v, str):
             return to_list(v, check_str=True)

polyaxon/_flow/component/component.py

@@ -375,12 +375,13 @@ class V1Component(
     """
 
     _IDENTIFIER = "component"
+    _CUSTOM_DUMP_FIELDS = {"run"}
 
     kind: Literal[_IDENTIFIER] = _IDENTIFIER
-    inputs: Optional[List[V1IO]]
-    outputs: Optional[List[V1IO]]
+    inputs: Optional[List[V1IO]] = None
+    outputs: Optional[List[V1IO]] = None
     run: Union[V1Runtime]
-    template: Optional[V1Template]
+    template: Optional[V1Template] = None
 
     def get_run_kind(self):
         return self.run.kind if self.run else None

polyaxon/_flow/early_stopping/__init__.py

@@ -13,5 +13,5 @@ from polyaxon._flow.early_stopping.policies import (
 
 V1EarlyStopping = Annotated[
     Union[V1MetricEarlyStopping, V1FailureEarlyStopping],
-    Field(discriminator="kind", alias="earlyStopping"),
+    Field(discriminator="kind"),
 ]

polyaxon/_flow/early_stopping/policies.py

@@ -13,9 +13,9 @@ class V1MedianStoppingPolicy(BaseSchemaModel):
     _USE_DISCRIMINATOR = True
 
     kind: Literal[_IDENTIFIER] = _IDENTIFIER
-    evaluation_interval: IntOrRef = Field(alias="evaluationInterval")
-    min_interval: Optional[IntOrRef] = Field(alias="minInterval")
-    min_samples: Optional[IntOrRef] = Field(alias="minSamples")
+    evaluation_interval: IntOrRef = Field(alias="evaluationInterval", default=None)
+    min_interval: Optional[IntOrRef] = Field(alias="minInterval", default=None)
+    min_samples: Optional[IntOrRef] = Field(alias="minSamples", default=None)
 
 
 class V1TruncationStoppingPolicy(BaseSchemaModel):
@@ -24,9 +24,11 @@ class V1TruncationStoppingPolicy(BaseSchemaModel):
     kind: Literal[_IDENTIFIER] = _IDENTIFIER
     percent: FloatOrRef
     evaluation_interval: IntOrRef = Field(alias="evaluationInterval")
-    min_interval: Optional[IntOrRef] = Field(alias="minInterval")
-    min_samples: Optional[IntOrRef] = Field(alias="minSamples")
-    include_succeeded: Optional[BoolOrRef] = Field(alias="includeSucceeded")
+    min_interval: Optional[IntOrRef] = Field(alias="minInterval", default=None)
+    min_samples: Optional[IntOrRef] = Field(alias="minSamples", default=None)
+    include_succeeded: Optional[BoolOrRef] = Field(
+        alias="includeSucceeded", default=None
+    )
 
 
 class V1DiffStoppingPolicy(BaseSchemaModel):
@@ -35,13 +37,13 @@ class V1DiffStoppingPolicy(BaseSchemaModel):
     kind: Literal[_IDENTIFIER] = _IDENTIFIER
     percent: FloatOrRef
     evaluation_interval: IntOrRef = Field(alias="evaluationInterval")
-    min_interval: Optional[IntOrRef] = Field(alias="minInterval")
-    min_samples: Optional[IntOrRef] = Field(alias="minSamples")
+    min_interval: Optional[IntOrRef] = Field(alias="minInterval", default=None)
+    min_samples: Optional[IntOrRef] = Field(alias="minSamples", default=None)
 
 
 V1EarlyStoppingPolicy = Annotated[
     Union[V1MedianStoppingPolicy, V1TruncationStoppingPolicy, V1DiffStoppingPolicy],
-    Field(discriminator="kind", alias="earlyStopping"),
+    Field(discriminator="kind"),
 ]
 
 
@@ -150,7 +152,7 @@ class V1MetricEarlyStopping(BaseSchemaModel):
     metric: StrictStr
     value: FloatOrRef
     optimization: Union[StrictFloat, V1Optimization]
-    policy: Optional[V1EarlyStoppingPolicy]
+    policy: Optional[V1EarlyStoppingPolicy] = None
 
 
 class V1FailureEarlyStopping(BaseSchemaModel):

polyaxon/_flow/environment/__init__.py

@@ -1,7 +1,13 @@
 from typing import Dict, List, Optional, Union
 from typing_extensions import Literal
 
-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
@@ -389,52 +395,64 @@ class V1Environment(BaseSchemaModel):
         "dnsConfig",
     ]
 
-    labels: Optional[Dict[StrictStr, StrictStr]]
-    annotations: Optional[Dict[StrictStr, StrictStr]]
-    node_selector: Optional[Dict[StrictStr, StrictStr]] = Field(alias="nodeSelector")
-    affinity: Optional[Union[k8s_schemas.V1Affinity, Dict]]
-    tolerations: Optional[List[Union[k8s_schemas.V1Toleration, Dict]]]
-    node_name: Optional[StrictStr] = Field(alias="nodeName")
-    service_account_name: Optional[StrictStr] = Field(alias="serviceAccountName")
-    host_aliases: Optional[List[k8s_schemas.V1HostAlias]] = Field(alias="hostAliases")
+    labels: Optional[Dict[StrictStr, StrictStr]] = None
+    annotations: Optional[Dict[StrictStr, StrictStr]] = None
+    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
+    node_name: Optional[StrictStr] = Field(alias="nodeName", default=None)
+    service_account_name: Optional[StrictStr] = Field(
+        alias="serviceAccountName", default=None
+    )
+    host_aliases: Optional[List[k8s_schemas.V1HostAlias]] = Field(
+        alias="hostAliases", default=None
+    )
     security_context: Optional[Union[k8s_schemas.V1SecurityContext, Dict]] = Field(
-        alias="securityContext"
+        alias="securityContext", default=None
+    )
+    image_pull_secrets: Optional[List[StrictStr]] = Field(
+        alias="imagePullSecrets", default=None
+    )
+    host_network: Optional[bool] = Field(alias="hostNetwork", default=None)
+    host_pid: Optional[bool] = Field(alias="hostPID", default=None)
+    dns_policy: Optional[StrictStr] = Field(alias="dnsPolicy", default=None)
+    dns_config: Optional[k8s_schemas.V1PodDNSConfig] = Field(
+        alias="dnsConfig", default=None
     )
-    image_pull_secrets: Optional[List[StrictStr]] = Field(alias="imagePullSecrets")
-    host_network: Optional[bool] = Field(alias="hostNetwork")
-    host_pid: Optional[bool] = Field(alias="hostPID")
-    dns_policy: Optional[StrictStr] = Field(alias="dnsPolicy")
-    dns_config: Optional[k8s_schemas.V1PodDNSConfig] = Field(alias="dnsConfig")
-    scheduler_name: Optional[StrictStr] = Field(alias="schedulerName")
-    priority_class_name: Optional[StrictStr] = Field(alias="priorityClassName")
-    priority: Optional[int]
-    restart_policy: Optional[Literal["Always", "OnFailure", "Never"]] = Field(
-        alias="restartPolicy"
+    scheduler_name: Optional[StrictStr] = Field(alias="schedulerName", default=None)
+    priority_class_name: Optional[StrictStr] = Field(
+        alias="priorityClassName", default=None
     )
+    priority: Optional[int] = None
+    restart_policy: Optional[
+        Literal["Always", "OnFailure", "Never", "ExitCode"]
+    ] = Field(alias="restartPolicy", default=None)
 
-    @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
         return [k8s_validation.validate_k8s_toleration(vi) for vi in v]
 
-    @validator("host_aliases", always=True, pre=True)
+    @field_validator("host_aliases", **validation_always, **validation_before)
     def validate_host_aliases(cls, v):
         if not v:
             return v
         return [k8s_validation.validate_k8s_host_alias(vi) for vi in v]
 
-    @validator("security_context", always=True, pre=True)
+    @field_validator("security_context", **validation_always, **validation_before)
     def validate_security_context(cls, v):
         if not v:
             return v
         return k8s_validation.validate_k8s_security_context(v)
 
-    @validator("dns_config", always=True, pre=True)
+    @field_validator("dns_config", **validation_always, **validation_before)
     def validate_dns_config(cls, v):
         if not v:
             return v

polyaxon/_flow/events/__init__.py

@@ -71,7 +71,7 @@ class V1EventTrigger(BaseSchemaModel, ctx_refs.RefMixin):
     ## YAML usage
 
     ```yaml
-    >>> events:
+    >>> event:
     >>>   ref: {{ ops.upstream-operation }}
     >>>   kinds: [run_status_running]
     ```

polyaxon/_flow/hooks/__init__.py

@@ -1,6 +1,6 @@
 from typing import Dict, List, Optional, Union
 
-from clipped.compact.pydantic import Field, StrictStr, validator
+from clipped.compact.pydantic import Field, StrictStr, field_validator
 from clipped.types.ref_or_obj import BoolOrRef, RefField
 
 from polyaxon._flow.params import V1Param
@@ -208,16 +208,16 @@ class V1Hook(BaseSchemaModel):
     _IDENTIFIER = "hook"
 
     hub_ref: StrictStr = Field(alias="hubRef")
-    connection: Optional[StrictStr]
-    trigger: Optional[V1Statuses]
-    conditions: Optional[StrictStr]
-    presets: Optional[List[StrictStr]]
-    queue: Optional[StrictStr]
-    namespace: Optional[StrictStr]
-    params: Optional[Union[Dict[str, V1Param], RefField]]
-    disable_defaults: Optional[BoolOrRef] = Field(alias="disableDefaults")
-
-    @validator("trigger")
+    connection: Optional[StrictStr] = None
+    trigger: Optional[V1Statuses] = None
+    conditions: Optional[StrictStr] = None
+    presets: Optional[List[StrictStr]] = None
+    queue: Optional[StrictStr] = None
+    namespace: Optional[StrictStr] = None
+    params: Optional[Union[Dict[str, V1Param], RefField]] = None
+    disable_defaults: Optional[BoolOrRef] = Field(alias="disableDefaults", default=None)
+
+    @field_validator("trigger")
     def validate_trigger(cls, v):
         if v and v not in V1Statuses.get_allowable_hook_values():
             raise ValueError(

polyaxon/_flow/init/__init__.py

@@ -1,6 +1,14 @@
 from typing import List, Optional, Union
 
-from clipped.compact.pydantic import Field, StrictStr, root_validator, validator
+from clipped.compact.pydantic import (
+    Field,
+    StrictStr,
+    field_validator,
+    model_validator,
+    validation_after,
+    validation_always,
+    validation_before,
+)
 from clipped.config.schema import skip_partial
 from clipped.types.ref_or_obj import RefField
 
@@ -202,32 +210,40 @@ class V1Init(BaseSchemaModel):
     _IDENTIFIER = "init"
     _SWAGGER_FIELDS = ["container"]
 
-    artifacts: Optional[Union[V1ArtifactsType, RefField]]
-    paths: Optional[Union[List[Union[List[StrictStr], StrictStr]], StrictStr, RefField]]
-    git: Optional[Union[V1GitType, RefField]]
-    dockerfile: Optional[Union[V1DockerfileType, RefField]]
-    file: Optional[Union[V1FileType, RefField]]
-    tensorboard: Optional[Union[V1TensorboardType, RefField]]
-    lineage_ref: Optional[Union[StrictStr, RefField]] = Field(alias="lineageRef")
-    model_ref: Optional[Union[StrictStr, RefField]] = Field(alias="modelRef")
-    artifact_ref: Optional[Union[StrictStr, RefField]] = Field(alias="artifactRef")
-    connection: Optional[StrictStr]
-    path: Optional[StrictStr]
-    container: Optional[Union[k8s_schemas.V1Container, RefField]]
+    artifacts: Optional[Union[V1ArtifactsType, RefField]] = None
+    paths: Optional[
+        Union[List[Union[List[StrictStr], StrictStr]], StrictStr, RefField]
+    ] = None
+    git: Optional[Union[V1GitType, RefField]] = None
+    dockerfile: Optional[Union[V1DockerfileType, RefField]] = None
+    file: Optional[Union[V1FileType, RefField]] = None
+    tensorboard: Optional[Union[V1TensorboardType, RefField]] = None
+    lineage_ref: Optional[Union[StrictStr, RefField]] = Field(
+        alias="lineageRef", default=None
+    )
+    model_ref: Optional[Union[StrictStr, RefField]] = Field(
+        alias="modelRef", default=None
+    )
+    artifact_ref: Optional[Union[StrictStr, RefField]] = Field(
+        alias="artifactRef", default=None
+    )
+    connection: Optional[StrictStr] = None
+    path: Optional[StrictStr] = None
+    container: Optional[Union[k8s_schemas.V1Container, RefField]] = None
 
-    @root_validator
+    @model_validator(**validation_after)
     @skip_partial
     def validate_init(cls, values):
-        artifacts = values.get("artifacts")
-        paths = values.get("paths")
-        git = values.get("git")
-        dockerfile = values.get("dockerfile")
-        file = values.get("file")
-        tensorboard = values.get("tensorboard")
-        lineage_ref = values.get("lineage_ref")
-        model_ref = values.get("model_ref")
-        artifact_ref = values.get("artifact_ref")
-        connection = values.get("connection")
+        artifacts = cls.get_value_for_key("artifacts", values)
+        paths = cls.get_value_for_key("paths", values)
+        git = cls.get_value_for_key("git", values)
+        dockerfile = cls.get_value_for_key("dockerfile", values)
+        file = cls.get_value_for_key("file", values)
+        tensorboard = cls.get_value_for_key("tensorboard", values)
+        lineage_ref = cls.get_value_for_key("lineage_ref", values)
+        model_ref = cls.get_value_for_key("model_ref", values)
+        artifact_ref = cls.get_value_for_key("artifact_ref", values)
+        connection = cls.get_value_for_key("connection", values)
         schemas = 0
         if artifacts:
             schemas += 1
@@ -258,7 +274,7 @@ class V1Init(BaseSchemaModel):
             )
         return values
 
-    @validator("container", always=True, pre=True)
+    @field_validator("container", **validation_always, **validation_before)
     def validate_container(cls, v):
         return k8s_validation.validate_k8s_container(v)
 

polyaxon/_flow/io/io.py

@@ -2,7 +2,15 @@ import re
 
 from typing import Any, Dict, List, Optional, Union
 
-from clipped.compact.pydantic import Field, StrictStr, root_validator, validator
+from clipped.compact.pydantic import (
+    Field,
+    StrictStr,
+    field_validator,
+    model_validator,
+    validation_after,
+    validation_always,
+    validation_before,
+)
 from clipped.config.schema import skip_partial
 from clipped.types.numbers import StrictIntOrFloat
 from clipped.types.ref_or_obj import BoolOrRef, IntOrRef, RefField
@@ -86,7 +94,7 @@ def validate_io(
         )
 
     if is_flag and type != "bool":
-        raise TypeError(
+        raise ValueError(
             "IO type `{}` cannot be a flag, it must be of type `{}`".format(
                 type, "bool"
             )
@@ -241,29 +249,31 @@ class V1Validation(BaseSchemaModel):
     * maxItems - maximum number of items
     """
 
-    delay: Optional[BoolOrRef]
-    gt: Optional[Union[StrictIntOrFloat, RefField]]
-    ge: Optional[Union[StrictIntOrFloat, RefField]]
-    lt: Optional[Union[StrictIntOrFloat, RefField]]
-    le: Optional[Union[StrictIntOrFloat, RefField]]
-    multiple_of: Optional[Union[StrictIntOrFloat, RefField]] = Field(alias="multipleOf")
-    min_digits: Optional[IntOrRef] = Field(alias="minDigits")
-    max_digits: Optional[IntOrRef] = Field(alias="maxDigits")
-    decimal_places: Optional[IntOrRef] = Field(alias="decimalPlaces")
-    regex: Optional[StrictStr]
-    min_length: Optional[IntOrRef] = Field(alias="minLength")
-    max_length: Optional[IntOrRef] = Field(alias="maxLength")
-    contains: Optional[Any]
-    excludes: Optional[Any]
-    options: Optional[Any]
-    min_items: Optional[IntOrRef] = Field(alias="minItems")
-    max_items: Optional[IntOrRef] = Field(alias="maxItems")
-    keys: Optional[Union[List[StrictStr], RefField]]
+    delay: Optional[BoolOrRef] = None
+    gt: Optional[Union[StrictIntOrFloat, RefField]] = None
+    ge: Optional[Union[StrictIntOrFloat, RefField]] = None
+    lt: Optional[Union[StrictIntOrFloat, RefField]] = None
+    le: Optional[Union[StrictIntOrFloat, RefField]] = None
+    multiple_of: Optional[Union[StrictIntOrFloat, RefField]] = Field(
+        alias="multipleOf", default=None
+    )
+    min_digits: Optional[IntOrRef] = Field(alias="minDigits", default=None)
+    max_digits: Optional[IntOrRef] = Field(alias="maxDigits", default=None)
+    decimal_places: Optional[IntOrRef] = Field(alias="decimalPlaces", default=None)
+    regex: Optional[StrictStr] = None
+    min_length: Optional[IntOrRef] = Field(alias="minLength", default=None)
+    max_length: Optional[IntOrRef] = Field(alias="maxLength", default=None)
+    contains: Optional[Any] = None
+    excludes: Optional[Any] = None
+    options: Optional[Any] = None
+    min_items: Optional[IntOrRef] = Field(alias="minItems", default=None)
+    max_items: Optional[IntOrRef] = Field(alias="maxItems", default=None)
+    keys: Optional[Union[List[StrictStr], RefField]] = None
     contains_keys: Optional[Union[List[StrictStr], RefField]] = Field(
-        alias="containsKeys"
+        alias="containsKeys", default=None
     )
     excludes_keys: Optional[Union[List[StrictStr], RefField]] = Field(
-        alias="excludesKeys"
+        alias="excludesKeys", default=None
     )
 
     def _validate_gt(self, value):
@@ -891,27 +901,27 @@ class V1IO(BaseSchemaModel):
     _IDENTIFIER = "io"
 
     name: StrictStr
-    description: Optional[StrictStr]
-    type: Optional[StrictStr]
-    is_optional: Optional[bool] = Field(alias="isOptional")
-    is_list: Optional[bool] = Field(alias="isList")
-    is_flag: Optional[bool] = Field(alias="isFlag")
-    arg_format: Optional[StrictStr] = Field(alias="argFormat")
-    connection: Optional[StrictStr]
-    to_init: Optional[bool] = Field(alias="toInit")
-    to_env: Optional[StrictStr] = Field(alias="toEnv")
-    value: Optional[Any]
-    validation: Optional[V1Validation]
-    delay_validation: Optional[bool] = Field(alias="delayValidation")
-    options: Optional[Any]
-
-    @validator("name", always=True)
+    description: Optional[StrictStr] = None
+    type: Optional[StrictStr] = None
+    is_optional: Optional[bool] = Field(alias="isOptional", default=None)
+    is_list: Optional[bool] = Field(alias="isList", default=None)
+    is_flag: Optional[bool] = Field(alias="isFlag", default=None)
+    arg_format: Optional[StrictStr] = Field(alias="argFormat", default=None)
+    connection: Optional[StrictStr] = None
+    to_init: Optional[bool] = Field(alias="toInit", default=None)
+    to_env: Optional[StrictStr] = Field(alias="toEnv", default=None)
+    value: Optional[Any] = None
+    validation: Optional[V1Validation] = None
+    delay_validation: Optional[bool] = Field(alias="delayValidation", default=None)
+    options: Optional[Any] = None
+
+    @field_validator("name", **validation_always)
     def validate_name(cls, v):
         if v in IO_NAME_BLACK_LIST:
             raise ValueError(IO_NAME_ERROR)
         return v
 
-    @root_validator(pre=True)
+    @model_validator(**validation_before)
     def handle_validation(cls, values):
         validation = values.get("validation")
         if not validation and (
@@ -926,20 +936,20 @@ class V1IO(BaseSchemaModel):
         if values.get("delay_validation") is not None:
             validation.delay = values.pop("delay_validation")
         if validation:
-            values["validation"] = validation
+            values["validation"] = validation.to_dict()
         return values
 
-    @root_validator
+    @model_validator(**validation_after)
     @skip_partial
     def validate_io(cls, values):
         validate_io(
-            name=values.get("name"),
-            type=values.get("type"),
-            value=values.get("value"),
-            is_list=values.get("is_list"),
-            is_optional=values.get("is_optional"),
-            is_flag=values.get("is_flag"),
-            validation=values.get("validation"),
+            name=cls.get_value_for_key("name", values),
+            type=cls.get_value_for_key("type", values),
+            value=cls.get_value_for_key("value", values),
+            is_list=cls.get_value_for_key("is_list", values),
+            is_optional=cls.get_value_for_key("is_optional", values),
+            is_flag=cls.get_value_for_key("is_flag", values),
+            validation=cls.get_value_for_key("validation", values),
         )
         return values
 

polyaxon/_flow/joins/__init__.py

@@ -205,9 +205,9 @@ class V1Join(BaseSchemaModel):
 
     _IDENTIFIER = "join"
 
-    ref: Optional[StrictStr]
+    ref: Optional[StrictStr] = None
     query: StrictStr
-    sort: Optional[StrictStr]
-    limit: Optional[IntOrRef]
-    offset: Optional[IntOrRef]
-    params: Optional[Union[Dict[str, V1JoinParam], RefField]]
+    sort: Optional[StrictStr] = None
+    limit: Optional[IntOrRef] = None
+    offset: Optional[IntOrRef] = None
+    params: Optional[Union[Dict[str, V1JoinParam], RefField]] = None