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

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
+    )
+    scheduler_name: Optional[StrictStr] = Field(alias="schedulerName", default=None)
+    priority_class_name: Optional[StrictStr] = Field(
+        alias="priorityClassName", 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]
+    priority: Optional[int] = None
     restart_policy: Optional[
         Literal["Always", "OnFailure", "Never", "ExitCode"]
-    ] = Field(alias="restartPolicy")
+    ] = 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/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
@@ -38,6 +46,8 @@ def validate_io_value(
             default=default,
         )
         if validation:
+            if isinstance(validation, dict):
+                validation = V1Validation(**validation)
             validation.run_validation(
                 value=parsed_value, type=type, is_optional=is_optional
             )
@@ -86,7 +96,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 +251,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 +903,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 +938,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

polyaxon/_flow/matrix/bayes.py

@@ -5,8 +5,10 @@ from clipped.compact.pydantic import (
     Field,
     PositiveInt,
     StrictInt,
-    root_validator,
-    validator,
+    field_validator,
+    model_validator,
+    validation_after,
+    validation_always,
 )
 from clipped.config.schema import skip_partial
 from clipped.types.ref_or_obj import RefField
@@ -60,19 +62,21 @@ class UtilityFunctionConfig(BaseSchemaModel):  # TODO: Rename to V1UtilityFuncti
     acquisition_function: Optional[AcquisitionFunctions] = Field(
         default=AcquisitionFunctions.UCB, alias="acquisitionFunction"
     )
-    gaussian_process: Optional[GaussianProcessConfig] = Field(alias="gaussianProcess")
-    kappa: Optional[float]
-    eps: Optional[float]
-    num_warmup: Optional[int] = Field(alias="numWarmup")
-    num_iterations: Optional[int] = Field(alias="numIterations")
+    gaussian_process: Optional[GaussianProcessConfig] = Field(
+        alias="gaussianProcess", default=None
+    )
+    kappa: Optional[float] = None
+    eps: Optional[float] = None
+    num_warmup: Optional[int] = Field(alias="numWarmup", default=None)
+    num_iterations: Optional[int] = Field(alias="numIterations", default=None)
 
-    @root_validator
+    @model_validator(**validation_after)
     @skip_partial
     def validate_utility_function(cls, values):
         validate_utility_function(
-            acquisition_function=values.get("acquisition_function"),
-            kappa=values.get("kappa"),
-            eps=values.get("eps"),
+            acquisition_function=cls.get_value_for_key("acquisition_function", values),
+            kappa=cls.get_value_for_key("kappa", values),
+            eps=cls.get_value_for_key("eps", values),
         )
         return values
 
@@ -393,16 +397,18 @@ class V1Bayes(BaseSearchConfig):
     _IDENTIFIER = V1MatrixKind.BAYES
 
     kind: Literal[_IDENTIFIER] = _IDENTIFIER
-    utility_function: Optional[UtilityFunctionConfig] = Field(alias="utilityFunction")
+    utility_function: Optional[UtilityFunctionConfig] = Field(
+        alias="utilityFunction", default=None
+    )
     num_initial_runs: Union[PositiveInt, RefField] = Field(alias="numInitialRuns")
     max_iterations: Union[PositiveInt, RefField] = Field(alias="maxIterations")
     metric: V1OptimizationMetric
     params: Union[Dict[str, V1HpParam], RefField]
-    seed: Optional[Union[StrictInt, RefField]]
-    concurrency: Optional[Union[PositiveInt, RefField]]
-    tuner: Optional[Union[V1Tuner, RefField]]
+    seed: Optional[Union[StrictInt, RefField]] = None
+    concurrency: Optional[Union[PositiveInt, RefField]] = None
+    tuner: Optional[Union[V1Tuner, RefField]] = None
     early_stopping: Optional[Union[List[V1EarlyStopping], RefField]] = Field(
-        alias="earlyStopping"
+        alias="earlyStopping", default=None
     )
 
     def create_iteration(self, iteration: Optional[int] = None) -> int:
@@ -414,7 +420,7 @@ class V1Bayes(BaseSearchConfig):
         """Return a boolean to indicate if we need to reschedule another iteration."""
         return iteration < self.max_iterations
 
-    @validator("params", always=True)
+    @field_validator("params", **validation_always)
     @skip_partial
     def validate_matrix(cls, params):
         return validate_matrix(params)

polyaxon/_flow/matrix/grid_search.py

@@ -1,7 +1,13 @@
 from typing import Dict, List, Optional, Union
 from typing_extensions import Literal
 
-from clipped.compact.pydantic import Field, PositiveInt, validator
+from clipped.compact.pydantic import (
+    Field,
+    PositiveInt,
+    field_validator,
+    validation_always,
+    validation_before,
+)
 from clipped.config.schema import skip_partial
 from clipped.types.ref_or_obj import RefField
 
@@ -196,19 +202,22 @@ class V1GridSearch(BaseSearchConfig):
 
     kind: Literal[_IDENTIFIER] = _IDENTIFIER
     params: Union[Dict[str, V1HpParam], RefField]
-    num_runs: Optional[Union[PositiveInt, RefField]] = Field(alias="numRuns")
-    concurrency: Optional[Union[PositiveInt, RefField]]
+    num_runs: Optional[Union[PositiveInt, RefField]] = Field(
+        alias="numRuns", default=None
+    )
+    concurrency: Optional[Union[PositiveInt, RefField]] = None
     early_stopping: Optional[Union[List[V1EarlyStopping], RefField]] = Field(
-        alias="earlyStopping"
+        alias="earlyStopping", default=None
     )
 
-    @validator("num_runs", "concurrency", pre=True)
+    @field_validator("num_runs", "concurrency", **validation_before)
     def check_values(cls, v, field):
+        key = cls.get_field_name(field)
         if v and v < 1:
-            raise ValueError(f"{field} must be greater than 1, received `{v}` instead.")
+            raise ValueError(f"{key} must be greater than 1, received `{v}` instead.")
         return v
 
-    @validator("params", always=True)
+    @field_validator("params", **validation_always)
     @skip_partial
     def validate_matrix(cls, params):
         return validate_matrix(params)

polyaxon/_flow/matrix/hyperband.py

@@ -313,17 +313,17 @@ class V1Hyperband(BaseSearchConfig):
     _IDENTIFIER = V1MatrixKind.HYPERBAND
 
     kind: Literal[_IDENTIFIER] = _IDENTIFIER
-    params: Optional[Union[Dict[str, V1HpParam], RefField]]
-    max_iterations: Optional[PositiveInt] = Field(alias="maxIterations")
-    eta: Optional[Union[NonNegativeFloat, RefField]]
-    resource: Optional[V1OptimizationResource]
-    metric: Optional[V1OptimizationMetric]
-    resume: Optional[BoolOrRef]
-    seed: Optional[IntOrRef]
-    concurrency: Optional[Union[PositiveInt, RefField]]
-    tuner: Optional[V1Tuner]
+    params: Optional[Union[Dict[str, V1HpParam], RefField]] = None
+    max_iterations: Optional[PositiveInt] = Field(alias="maxIterations", default=None)
+    eta: Optional[Union[NonNegativeFloat, RefField]] = None
+    resource: Optional[V1OptimizationResource] = None
+    metric: Optional[V1OptimizationMetric] = None
+    resume: Optional[BoolOrRef] = None
+    seed: Optional[IntOrRef] = None
+    concurrency: Optional[Union[PositiveInt, RefField]] = None
+    tuner: Optional[V1Tuner] = None
     early_stopping: Optional[Union[List[V1EarlyStopping], RefField]] = Field(
-        alias="earlyStopping"
+        alias="earlyStopping", default=None
     )
 
     _s_max: Optional[int] = PrivateAttr()

polyaxon/_flow/matrix/hyperopt.py

@@ -1,7 +1,12 @@
 from typing import Dict, List, Optional, Union
 from typing_extensions import Literal
 
-from clipped.compact.pydantic import Field, PositiveInt, validator
+from clipped.compact.pydantic import (
+    Field,
+    PositiveInt,
+    field_validator,
+    validation_before,
+)
 from clipped.types.ref_or_obj import IntOrRef, RefField
 from clipped.utils.enums import PEnum
 
@@ -212,19 +217,19 @@ class V1Hyperopt(BaseSearchConfig):
     _IDENTIFIER = V1MatrixKind.HYPEROPT
 
     kind: Literal[_IDENTIFIER] = _IDENTIFIER
-    max_iterations: Optional[IntOrRef] = Field(alias="maxIterations")
+    max_iterations: Optional[IntOrRef] = Field(alias="maxIterations", default=None)
     metric: V1OptimizationMetric
-    algorithm: Optional[V1HyperoptAlgorithms]
+    algorithm: Optional[V1HyperoptAlgorithms] = None
     params: Union[Dict[str, V1HpParam], RefField]
-    num_runs: Union[PositiveInt, RefField] = Field(alias="numRuns")
-    seed: Optional[IntOrRef]
-    concurrency: Optional[Union[PositiveInt, RefField]]
-    tuner: Optional[V1Tuner]
+    num_runs: Union[PositiveInt, RefField] = Field(alias="numRuns", default=None)
+    seed: Optional[IntOrRef] = None
+    concurrency: Optional[Union[PositiveInt, RefField]] = None
+    tuner: Optional[V1Tuner] = None
     early_stopping: Optional[Union[List[V1EarlyStopping], RefField]] = Field(
-        alias="earlyStopping"
+        alias="earlyStopping", default=None
     )
 
-    @validator("num_runs", "concurrency", pre=True)
+    @field_validator("num_runs", "concurrency", **validation_before)
     def check_values(cls, v, field):
         if v and v < 1:
             raise ValueError(f"{field} must be greater than 1, received `{v}` instead.")