polyaxon 2.4.0rc1__py3-none-any.whl → 2.6.0__py3-none-any.whl

polyaxon/_runner/agent/sync_agent.py

@@ -45,7 +45,7 @@ class BaseSyncAgent(BaseAgent):
             self.client.log_agent_failed(message="{} {}".format(message, reason))
             raise PolyaxonAgentError(message="{} {}".format(message, reason))
         except Exception as e:
-            raise PolyaxonAgentError from e
+            raise PolyaxonAgentError(f"Unexpected error: {str(e)}") from e
 
     def _exit(self):
         if not self.client._is_managed:
@@ -79,14 +79,17 @@ class BaseSyncAgent(BaseAgent):
 
     def reconcile(self):
         if (
-            now() - self._last_reconciled_at
+            now() - self._last_data_collected_at
         ).total_seconds() > self.SLEEP_AGENT_DATA_COLLECT_TIME:
+            self.collect_agent_data()
+        if (
+            now() - self._last_reconciled_at
+        ).total_seconds() < self.SLEEP_AGENT_DATA_RECONCILE_TIME:
             return
 
-        # Collect data
-        self.collect_agent_data()
-
         # Update reconcile
+        logger.info("Checking cluster state.")
+        self._last_reconciled_at = now()
         namespaces = [settings.AGENT_CONFIG.namespace]
         namespaces += settings.AGENT_CONFIG.additional_namespaces or []
         ops = []

polyaxon/_runner/converter/converter.py

@@ -820,7 +820,7 @@ class BaseConverter:
                             connection=V1Connection(
                                 name=git_name,
                                 kind=V1ConnectionKind.GIT,
-                                schema_=init_connection.git,
+                                schema_=init_connection.git.to_connection(),
                                 secret=None,
                             ),
                             container=self._ensure_container(
@@ -930,15 +930,23 @@ class BaseConverter:
 
         # Add outputs
         if plugins and plugins.collect_artifacts:
+            _artifacts_init_env = []
+            if log_level:
+                _artifacts_init_env.append(
+                    self._get_env_var(name=ENV_KEYS_LOG_LEVEL, value=log_level)
+                )
+            proxy_env = self._get_proxy_env_vars(
+                settings.AGENT_CONFIG.use_proxy_env_vars_use_in_ops
+            )
+            if proxy_env:
+                _artifacts_init_env += proxy_env
             containers += to_list(
                 self._get_artifacts_path_init_container(
                     polyaxon_init=polyaxon_init,
                     artifacts_store=artifacts_store,
                     run_path=self.run_path,
                     auto_resume=plugins.auto_resume,
-                    env=self._get_proxy_env_vars(
-                        settings.AGENT_CONFIG.use_proxy_env_vars_use_in_ops
-                    ),
+                    env=_artifacts_init_env,
                 ),
                 check_none=True,
             )

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

@@ -1,15 +1,19 @@
 from typing import List, Optional
 
-from clipped.compact.pydantic import StrictStr
+from clipped.compact.pydantic import Field, StrictStr
 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]
-    auth: Optional[List[StrictStr]]
+    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
+    )

polyaxon/_schemas/lifecycle.py

@@ -185,7 +185,7 @@ class LifeCycle:
 
     @classmethod
     def is_pending(cls, status: str) -> bool:
-        """Checks if a run with this status is in a pending status."""
+        """Checks if a run with this status is in one of the pending(not compiled or queued yet) statuses."""
         return status in cls.PENDING_VALUES
 
     @classmethod
@@ -220,7 +220,7 @@ class LifeCycle:
 
     @classmethod
     def is_safe_stoppable(cls, status: str) -> bool:
-        """Checks if a run with this status is an be stopped without operator."""
+        """Checks if a run with this status is can be stopped without calling the operator."""
         return status in cls.SAFE_STOP_VALUES
 
     @classmethod
@@ -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):