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

polyaxon/_deploy/schemas/security_context.py

@@ -1,27 +1,37 @@
 from typing import Optional
 
-from clipped.compact.pydantic import Field, StrictInt, StrictStr, root_validator
+from clipped.compact.pydantic import (
+    Field,
+    StrictInt,
+    StrictStr,
+    model_validator,
+    validation_after,
+)
 from clipped.config.schema import skip_partial
 
 from polyaxon._schemas.base import BaseSchemaModel
 
 
-def validate_security_context(user, group):
-    if any([user, group]) and not all([user, group]):
-        raise ValueError("Security context requires both `user` and `group` or none.")
-
-
 class SecurityContextConfig(BaseSchemaModel):
-    enabled: Optional[bool]
-    run_as_user: Optional[StrictInt] = Field(alias="runAsUser")
-    run_as_group: Optional[StrictInt] = Field(alias="runAsGroup")
-    fs_group: Optional[StrictInt] = Field(alias="fsGroup")
-    fs_group_change_policy: Optional[StrictStr] = Field(alias="fsGroupChangePolicy")
-    allow_privilege_escalation: Optional[bool] = Field(alias="allowPrivilegeEscalation")
-    run_as_non_root: Optional[bool] = Field(alias="runAsNonRoot")
+    enabled: Optional[bool] = None
+    run_as_user: Optional[StrictInt] = Field(alias="runAsUser", default=None)
+    run_as_group: Optional[StrictInt] = Field(alias="runAsGroup", default=None)
+    fs_group: Optional[StrictInt] = Field(alias="fsGroup", default=None)
+    fs_group_change_policy: Optional[StrictStr] = Field(
+        alias="fsGroupChangePolicy", default=None
+    )
+    allow_privilege_escalation: Optional[bool] = Field(
+        alias="allowPrivilegeEscalation", default=None
+    )
+    run_as_non_root: Optional[bool] = Field(alias="runAsNonRoot", default=None)
 
-    @root_validator
+    @model_validator(**validation_after)
     @skip_partial
     def validate_security_context(cls, values):
-        validate_security_context(values.get("run_as_user"), values.get("run_as_group"))
+        user = cls.get_value_for_key("run_as_user", values)
+        group = cls.get_value_for_key("run_as_group", values)
+        if any([user, group]) and not all([user, group]):
+            raise ValueError(
+                "Security context requires both `user` and `group` or none."
+            )
         return values

polyaxon/_deploy/schemas/service.py

@@ -1,6 +1,6 @@
 from typing import Dict, List, Optional
 
-from clipped.compact.pydantic import Extra, Field, StrictInt, StrictStr
+from clipped.compact.pydantic import Field, StrictInt, StrictStr
 
 from polyaxon._deploy.schemas.celery import CeleryConfig
 from polyaxon._deploy.schemas.service_types import ServiceTypes
@@ -9,119 +9,123 @@ from polyaxon._schemas.services import BaseServiceConfig
 
 
 class DeploymentService(BaseServiceConfig):
-    enabled: Optional[bool]
-    replicas: Optional[StrictInt]
-    concurrency: Optional[StrictInt]
-    per_core: Optional[bool] = Field(alias="perCore")
-    scheme: Optional[StrictStr]
+    enabled: Optional[bool] = None
+    replicas: Optional[StrictInt] = None
+    concurrency: Optional[StrictInt] = None
+    per_core: Optional[bool] = Field(alias="perCore", default=None)
+    scheme: Optional[StrictStr] = None
 
 
 class WorkerServiceConfig(DeploymentService):
-    celery: Optional[CeleryConfig]
+    celery: Optional[CeleryConfig] = None
 
 
 class AgentServiceConfig(DeploymentService):
-    instance: Optional[StrictStr]
-    token: Optional[StrictStr]
-    watch_cluster: Optional[bool] = Field(alias="watchCluster")
-    additional_namespaces: Optional[List[str]] = Field(alias="additionalNamespaces")
+    instance: Optional[StrictStr] = None
+    token: Optional[StrictStr] = None
+    watch_cluster: Optional[bool] = Field(alias="watchCluster", default=None)
+    additional_namespaces: Optional[List[str]] = Field(
+        alias="additionalNamespaces", default=None
+    )
     service_account_annotations: Optional[Dict] = Field(
-        alias="serviceAccountAnnotations"
+        alias="serviceAccountAnnotations", default=None
     )
-    is_replica: Optional[bool] = Field(alias="isReplica")
+    is_replica: Optional[bool] = Field(alias="isReplica", default=None)
 
 
 class OperatorServiceConfig(DeploymentService):
-    skip_crd: Optional[bool] = Field(alias="skipCRD")
+    skip_crd: Optional[bool] = Field(alias="skipCRD", default=None)
 
 
 class BaseService(BaseSchemaModel):
-    name: Optional[StrictStr]
-    type: Optional[ServiceTypes]
-    port: Optional[StrictInt]
-    target_port: Optional[StrictInt] = Field(alias="targetPort")
-    node_port: Optional[StrictInt] = Field(alias="nodePort")
-    annotations: Optional[Dict]
+    name: Optional[StrictStr] = None
+    type: Optional[ServiceTypes] = None
+    port: Optional[StrictInt] = None
+    target_port: Optional[StrictInt] = Field(alias="targetPort", default=None)
+    node_port: Optional[StrictInt] = Field(alias="nodePort", default=None)
+    annotations: Optional[Dict] = None
 
     class Config:
-        extra = Extra.allow
+        extra = "allow"
 
 
 class ApiServiceConfig(DeploymentService):
-    service: Optional[BaseService]
+    service: Optional[BaseService] = None
 
 
 class HooksConfig(DeploymentService):
-    load_fixtures: Optional[bool] = Field(alias="loadFixtures")
-    tables: Optional[bool] = Field(alias="tables")
-    sync_db: Optional[bool] = Field(alias="syncdb")
-    admin_user: Optional[bool] = Field(alias="adminUser")
-    default_org: Optional[bool] = Field(alias="defaultOrg")
+    load_fixtures: Optional[bool] = Field(alias="loadFixtures", default=None)
+    tables: Optional[bool] = Field(alias="tables", default=None)
+    sync_db: Optional[bool] = Field(alias="syncdb", default=None)
+    admin_user: Optional[bool] = Field(alias="adminUser", default=None)
+    default_org: Optional[bool] = Field(alias="defaultOrg", default=None)
 
 
 class ThirdPartyService(DeploymentService):
-    persistence: Optional[Dict]
+    persistence: Optional[Dict] = None
 
     class Config:
-        extra = Extra.allow
+        extra = "allow"
 
 
 class PostgresqlConfig(ThirdPartyService):
-    auth: Optional[Dict]
-    conn_max_age: Optional[StrictInt] = Field(alias="connMaxAge")
+    auth: Optional[Dict] = None
+    conn_max_age: Optional[StrictInt] = Field(alias="connMaxAge", default=None)
 
 
 class RedisConfig(ThirdPartyService):
-    image: Optional[Dict]  # type: ignore[assignment]
-    non_broker: Optional[bool] = Field(alias="nonBroker")
-    use_password: Optional[bool] = Field(alias="usePassword")
-    auth: Optional[Dict]
+    image: Optional[Dict] = None  # type: ignore[assignment]
+    non_broker: Optional[bool] = Field(alias="nonBroker", default=None)
+    use_password: Optional[bool] = Field(alias="usePassword", default=None)
+    auth: Optional[Dict] = None
 
 
 class RabbitmqConfig(ThirdPartyService):
-    auth: Optional[Dict]
+    auth: Optional[Dict] = None
 
 
 class ExternalService(BaseSchemaModel):
-    user: Optional[StrictStr]
-    password: Optional[StrictStr]
-    host: Optional[StrictStr]
-    port: Optional[StrictInt]
-    database: Optional[StrictStr]
-    use_password: Optional[bool] = Field(alias="usePassword")
-    conn_max_age: Optional[StrictInt] = Field(alias="connMaxAge")
-    pgbouncer: Optional[Dict]
-    options: Optional[Dict]
-    use_resolver: Optional[bool] = Field(alias="useResolver")
-    corporate_proxy: Optional[StrictStr] = Field(alias="corporateProxy")
+    user: Optional[StrictStr] = None
+    password: Optional[StrictStr] = None
+    host: Optional[StrictStr] = None
+    port: Optional[StrictInt] = None
+    database: Optional[StrictStr] = None
+    use_password: Optional[bool] = Field(alias="usePassword", default=None)
+    conn_max_age: Optional[StrictInt] = Field(alias="connMaxAge", default=None)
+    pgbouncer: Optional[Dict] = None
+    options: Optional[Dict] = None
+    use_resolver: Optional[bool] = Field(alias="useResolver", default=None)
+    corporate_proxy: Optional[StrictStr] = Field(alias="corporateProxy", default=None)
 
 
 class ExternalBackend(BaseSchemaModel):
-    enabled: Optional[bool]
-    backend: Optional[StrictStr]
-    url: Optional[StrictStr]
-    options: Optional[Dict]
+    enabled: Optional[bool] = None
+    backend: Optional[StrictStr] = None
+    url: Optional[StrictStr] = None
+    options: Optional[Dict] = None
 
 
 class AuthServicesConfig(BaseSchemaModel):
-    github: Optional[ExternalBackend]
-    gitlab: Optional[ExternalBackend]
-    bitbucket: Optional[ExternalBackend]
-    google: Optional[ExternalBackend]
-    okta: Optional[ExternalBackend]
-    onelogin: Optional[ExternalBackend]
-    azuread: Optional[ExternalBackend]
+    github: Optional[ExternalBackend] = None
+    gitlab: Optional[ExternalBackend] = None
+    bitbucket: Optional[ExternalBackend] = None
+    google: Optional[ExternalBackend] = None
+    okta: Optional[ExternalBackend] = None
+    onelogin: Optional[ExternalBackend] = None
+    azuread: Optional[ExternalBackend] = None
 
 
 class ExternalServicesConfig(BaseSchemaModel):
-    redis: Optional[ExternalService]
-    rabbitmq: Optional[ExternalService]
-    postgresql: Optional[ExternalService]
-    gateway: Optional[ExternalService]
-    api: Optional[ExternalService]
-    transactions: Optional[ExternalBackend]
-    analytics: Optional[ExternalBackend]
-    metrics: Optional[ExternalBackend]
-    errors: Optional[ExternalBackend]
-    auth: Optional[AuthServicesConfig]
-    allowed_versions: Optional[List[StrictStr]] = Field(alias="allowedVersions")
+    redis: Optional[ExternalService] = None
+    rabbitmq: Optional[ExternalService] = None
+    postgresql: Optional[ExternalService] = None
+    gateway: Optional[ExternalService] = None
+    api: Optional[ExternalService] = None
+    transactions: Optional[ExternalBackend] = None
+    analytics: Optional[ExternalBackend] = None
+    metrics: Optional[ExternalBackend] = None
+    errors: Optional[ExternalBackend] = None
+    auth: Optional[AuthServicesConfig] = None
+    allowed_versions: Optional[List[StrictStr]] = Field(
+        alias="allowedVersions", default=None
+    )

polyaxon/_deploy/schemas/ssl.py

@@ -6,6 +6,6 @@ from polyaxon._schemas.base import BaseSchemaModel
 
 
 class SSLConfig(BaseSchemaModel):
-    enabled: Optional[bool]
-    secret_name: Optional[StrictStr] = Field(alias="secretName")
-    path: Optional[StrictStr]
+    enabled: Optional[bool] = None
+    secret_name: Optional[StrictStr] = Field(alias="secretName", default=None)
+    path: Optional[StrictStr] = None

polyaxon/_deploy/schemas/ui.py

@@ -6,11 +6,13 @@ from polyaxon._schemas.base import BaseSchemaModel
 
 
 class UIConfig(BaseSchemaModel):
-    enabled: Optional[bool]
-    offline: Optional[bool]
-    static_url: Optional[StrictStr] = Field(alias="staticUrl")
-    base_url: Optional[StrictStr] = Field(alias="baseUrl")
-    assets_version: Optional[StrictStr] = Field(alias="assetsVersion")
-    admin_enabled: Optional[bool] = Field(alias="adminEnabled")
-    single_url: Optional[bool] = Field(alias="singleUrl")
-    default_streams_url: Optional[StrictStr] = Field(alias="defaultStreamsUrl")
+    enabled: Optional[bool] = None
+    offline: Optional[bool] = None
+    static_url: Optional[StrictStr] = Field(alias="staticUrl", default=None)
+    base_url: Optional[StrictStr] = Field(alias="baseUrl", default=None)
+    assets_version: Optional[StrictStr] = Field(alias="assetsVersion", default=None)
+    admin_enabled: Optional[bool] = Field(alias="adminEnabled", default=None)
+    single_url: Optional[bool] = Field(alias="singleUrl", default=None)
+    default_streams_url: Optional[StrictStr] = Field(
+        alias="defaultStreamsUrl", default=None
+    )

polyaxon/_docker/builder/builder.py

@@ -120,8 +120,11 @@ class DockerBuilder(DockerMixin):
         if not self.registries:
             return
         for registry in self.registries:
+            username = (
+                registry.username if hasattr(registry, "username") else registry.user
+            )
             self.docker.login(
-                username=registry.user,
+                username=username,
                 password=registry.password,
                 registry=registry.host_port,
                 reauth=True,

polyaxon/_docker/converter/base/containers.py

@@ -49,11 +49,8 @@ class ContainerMixin(BaseConverter):
         env: List[docker_types.V1EnvVar],
     ) -> List[docker_types.V1EnvVar]:
         def sanitize_env_dict(d: Dict):
-            return docker_types.V1EnvVar(
-                __root__={
-                    d_k: sanitize_value(d_v, handle_dict=False)
-                    for d_k, d_v in d.items()
-                }
+            return docker_types.V1EnvVar.make(
+                {d_k: sanitize_value(d_v, handle_dict=False) for d_k, d_v in d.items()}
             )
 
         results = []
@@ -63,8 +60,8 @@ class ContainerMixin(BaseConverter):
                 results.append(e)
             elif isinstance(e, tuple):
                 if e[1] is not None:
-                    e = docker_types.V1EnvVar(
-                        __root__=(e[0], sanitize_value(e[1], handle_dict=False))
+                    e = docker_types.V1EnvVar.make(
+                        (e[0], sanitize_value(e[1], handle_dict=False))
                     )
                 results.append(e)
             elif isinstance(e, docker_types.V1EnvVar):

polyaxon/_docker/converter/base/env_vars.py

@@ -42,7 +42,7 @@ class EnvMixin(BaseConverter):
             except (ValueError, TypeError) as e:
                 raise PolyaxonConverterError(e)
 
-        return docker_types.V1EnvVar(__root__=(name, value))
+        return docker_types.V1EnvVar.make((name, value))
 
     @staticmethod
     def _get_from_json_resource(
@@ -59,7 +59,7 @@ class EnvMixin(BaseConverter):
         except Exception as e:
             raise PolyaxonConverterError from e
 
-        return [docker_types.V1EnvVar(__root__=k) for k in (secret_value.items())]
+        return [docker_types.V1EnvVar.make(k) for k in (secret_value.items())]
 
     @classmethod
     def _get_env_from_json_resources(
@@ -82,10 +82,10 @@ class EnvMixin(BaseConverter):
         try:
             secret_value = orjson_loads(secret)
         except orjson.JSONDecodeError:
-            return docker_types.V1EnvVar(__root__=(key, secret))
+            return docker_types.V1EnvVar.make((key, secret))
 
         value = secret_value.get(key)
-        return docker_types.V1EnvVar(__root__=(key, value))
+        return docker_types.V1EnvVar.make((key, value))
 
     @classmethod
     def _get_items_from_json_resource(
@@ -104,7 +104,7 @@ class EnvMixin(BaseConverter):
         for item in resource.items:
             value = secret_value.get(item)
             if value:
-                items_from.append(docker_types.V1EnvVar(__root__=(item, value)))
+                items_from.append(docker_types.V1EnvVar.make((item, value)))
         return items_from
 
     @classmethod

polyaxon/_docker/converter/base/mounts.py

@@ -14,7 +14,7 @@ class MountsMixin(BaseConverter):
         volume = f"{host_path}:{mount_path}"
         if read_only:
             volume += ":ro"
-        return docker_types.V1VolumeMount(__root__=("-v", volume))
+        return docker_types.V1VolumeMount.make(("-v", volume))
 
     @staticmethod
     def _get_docker_mount(
@@ -23,7 +23,7 @@ class MountsMixin(BaseConverter):
         mount = f"type=tmpfs,destination={mount_path}"
         if read_only:
             mount += ",ro"
-        return docker_types.V1VolumeMount(__root__=("--mount", mount))
+        return docker_types.V1VolumeMount.make(("--mount", mount))
 
     @classmethod
     def _get_config_volume(cls) -> docker_types.V1VolumeMount:

polyaxon/_docker/docker_types.py

@@ -1,47 +1,72 @@
 from typing import Dict, List, Optional, Tuple, Union
 
-from clipped.compact.pydantic import Field
+from clipped.compact.pydantic import (
+    PYDANTIC_VERSION,
+    Field,
+    field_validator,
+    validation_always,
+)
 from clipped.utils.units import to_cpu_value, to_memory_bytes, to_unit_memory
 
-from polyaxon._schemas.base import BaseSchemaModel
+from polyaxon._schemas.base import BaseSchemaModel, RootModel
 
 
-class V1EnvVar(BaseSchemaModel):
-    __root__: Union[Tuple[str, str], Dict[str, str]]
+class V1EnvVar(RootModel):
+    if PYDANTIC_VERSION.startswith("2."):
+        root: Union[Tuple[str, str], Dict[str, str]]
+    else:
+        __root__: Union[Tuple[str, str], Dict[str, str]]
 
     def to_cmd(self):
-        if isinstance(self.__root__, tuple):
-            value = self.__root__
-        else:
-            value = self.__root__.items()
+        value = self.get_root()
         return [f"{value[0]}={value[1]}"]
 
 
-class V1VolumeMount(BaseSchemaModel):
-    __root__: Tuple[str, str]
+class V1VolumeMount(RootModel):
+    if PYDANTIC_VERSION.startswith("2."):
+        root: Tuple[str, str]
+    else:
+        __root__: Tuple[str, str]
 
     def to_cmd(self):
-        return list(self.__root__)
+        return list(self.get_root())
+
 
+ROOT_TYPE = Union[
+    int,
+    str,
+    List[Union[int, str]],
+    Tuple[Union[int, str], Union[int, str]],
+    Dict[Union[int, str], Union[Union[int, str], Union[int, str]]],
+]
 
-class V1ContainerPort(BaseSchemaModel):
-    __root__: Union[str, Tuple[str, str], Dict[str, str]]
+
+class V1ContainerPort(RootModel):
+    if PYDANTIC_VERSION.startswith("2."):
+        root: ROOT_TYPE
+    else:
+        __root__: ROOT_TYPE
 
     def to_cmd(self):
-        if isinstance(self.__root__, str):
-            return [self.__root__]
+        root = self.get_root()
+        if isinstance(root, (str, int)):
+            return [root]
 
-        if isinstance(self.__root__, tuple):
-            value = self.__root__
+        if isinstance(root, (list, tuple)):
+            value = root
         else:
-            value = self.__root__.items()
+            value = root.items()
         return list(value[0])
 
 
 class V1ResourceRequirements(BaseSchemaModel):
-    cpus: Optional[str]
-    memory: Optional[str]
-    gpus: Optional[str]
+    cpus: Optional[Union[str, float, int]] = None
+    memory: Optional[Union[str, float, int]] = None
+    gpus: Optional[str] = None
+
+    @field_validator("cpus", "memory", **validation_always)
+    def value_to_str(cls, v):
+        return str(v)
 
     @staticmethod
     def from_k8s_cpu(cpu: str) -> Union[str, float]:
@@ -68,15 +93,17 @@ class V1ResourceRequirements(BaseSchemaModel):
 
 
 class V1Container(BaseSchemaModel):
-    image: Optional[str]
-    name: Optional[str]
-    command: Optional[List[str]]
-    args: Optional[List[str]]
-    env: Optional[List[V1EnvVar]]
-    volume_mounts: Optional[List[V1VolumeMount]] = Field(alias="volumeMounts")
-    resources: Optional[V1ResourceRequirements]
-    ports: Optional[List[V1ContainerPort]]
-    working_dir: Optional[str] = Field(alias="workingDir")
+    image: Optional[str] = None
+    name: Optional[str] = None
+    command: Optional[List[str]] = None
+    args: Optional[List[str]] = None
+    env: Optional[List[V1EnvVar]] = None
+    volume_mounts: Optional[List[V1VolumeMount]] = Field(
+        alias="volumeMounts", default=None
+    )
+    resources: Optional[V1ResourceRequirements] = None
+    ports: Optional[List[V1ContainerPort]] = None
+    working_dir: Optional[str] = Field(alias="workingDir", default=None)
 
     def get_cmd_args(self):
         cmd_args = ["run", "--rm"]

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"),
 ]