Add recipe validation

Tested by running hyp recipe-init and hyp recipe-validate on files in recipe collection

Author: zhaoqizqwang

.gitignore

@@ -18,6 +18,7 @@ __pycache__/
 /doc/_apidoc/
 doc/_build/
 /build
+/hyperpod-pytorch-job-template/build
 
 /sagemaker-hyperpod/build
 /sagemaker-hyperpod/.coverage

hyperpod-pytorch-job-template/hyperpod_pytorch_job_template/v1_0/model.py

@@ -9,75 +9,60 @@
     Template,
     Metadata,
     Volumes,
-    HostPath, 
-    PersistentVolumeClaim
+    HostPath,
+    PersistentVolumeClaim,
 )
 
 
 class VolumeConfig(BaseModel):
-    name: str = Field(
-        ..., 
-        description="Volume name",
-        min_length=1
-    )
-    type: Literal['hostPath', 'pvc'] = Field(..., description="Volume type")
-    mount_path: str = Field(
-        ..., 
-        description="Mount path in container",
-        min_length=1
-    )
+    name: str = Field(..., description="Volume name", min_length=1)
+    type: Literal["hostPath", "pvc"] = Field(..., description="Volume type")
+    mount_path: str = Field(..., description="Mount path in container", min_length=1)
     path: Optional[str] = Field(
-        None, 
-        description="Host path (required for hostPath volumes)",
-        min_length=1
+        None, description="Host path (required for hostPath volumes)", min_length=1
     )
     claim_name: Optional[str] = Field(
-        None, 
-        description="PVC claim name (required for pvc volumes)",
-        min_length=1
+        None, description="PVC claim name (required for pvc volumes)", min_length=1
+    )
+    read_only: Optional[Literal["true", "false"]] = Field(
+        None, description="Read-only flag for pvc volumes"
     )
-    read_only: Optional[Literal['true', 'false']] = Field(None, description="Read-only flag for pvc volumes")
-    
-    @field_validator('mount_path', 'path')
+
+    @field_validator("mount_path", "path")
     @classmethod
     def paths_must_be_absolute(cls, v):
         """Validate that paths are absolute (start with /)."""
-        if v and not v.startswith('/'):
-            raise ValueError('Path must be absolute (start with /)')
+        if v and not v.startswith("/"):
+            raise ValueError("Path must be absolute (start with /)")
         return v
-    
-    @model_validator(mode='after')
+
+    @model_validator(mode="after")
     def validate_type_specific_fields(self):
         """Validate that required fields are present based on volume type."""
-        
-        if self.type == 'hostPath':
+
+        if self.type == "hostPath":
             if not self.path:
-                raise ValueError('hostPath volumes require path field')
-        elif self.type == 'pvc':
+                raise ValueError("hostPath volumes require path field")
+        elif self.type == "pvc":
             if not self.claim_name:
-                raise ValueError('PVC volumes require claim_name field')
-        
+                raise ValueError("PVC volumes require claim_name field")
+
         return self
 
 
 class PyTorchJobConfig(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
     job_name: str = Field(
-        alias="job_name", 
+        alias="job_name",
         description="Job name",
         min_length=1,
         max_length=63,
-        pattern=r'^[a-z0-9]([-a-z0-9]*[a-z0-9])?$'
-    )
-    image: str = Field(
-        description="Docker image for training",
-        min_length=1
+        pattern=r"^[a-z0-9]([-a-z0-9]*[a-z0-9])?$",
     )
+    image: str = Field(description="Docker image for training", min_length=1)
     namespace: Optional[str] = Field(
-        default=None, 
-        description="Kubernetes namespace",
-        min_length=1
+        default=None, description="Kubernetes namespace", min_length=1
     )
     command: Optional[List[str]] = Field(
         default=None, description="Command to run in the container"
@@ -89,28 +74,22 @@ class PyTorchJobConfig(BaseModel):
         default=None, description="Environment variables as key_value pairs"
     )
     pull_policy: Optional[str] = Field(
-        default=None, 
-        alias="pull_policy", 
-        description="Image pull policy",
-        min_length=1
+        default=None, alias="pull_policy", description="Image pull policy", min_length=1
     )
     instance_type: Optional[str] = Field(
-        default=None, 
-        alias="instance_type", 
+        default=None,
+        alias="instance_type",
         description="Instance type for training",
-        min_length=1
+        min_length=1,
     )
     node_count: Optional[int] = Field(
-        default=None, 
-        alias="node_count", 
-        description="Number of nodes",
-        ge=1
+        default=None, alias="node_count", description="Number of nodes", ge=1
     )
     tasks_per_node: Optional[int] = Field(
-        default=None, 
-        alias="tasks_per_node", 
+        default=None,
+        alias="tasks_per_node",
         description="Number of tasks per node",
-        ge=1
+        ge=1,
     )
     label_selector: Optional[Dict[str, str]] = Field(
         default=None,
@@ -123,114 +102,122 @@ class PyTorchJobConfig(BaseModel):
         description="Schedule pods only on nodes that passed deep health check",
     )
     scheduler_type: Optional[str] = Field(
-        default=None, 
-        alias="scheduler_type", 
-        description="Scheduler type",
-        min_length=1
+        default=None, alias="scheduler_type", description="Scheduler type", min_length=1
     )
     queue_name: Optional[str] = Field(
-        default=None, 
-        alias="queue_name", 
+        default=None,
+        alias="queue_name",
         description="Queue name for job scheduling",
         min_length=1,
         max_length=63,
-        pattern=r'^[a-z0-9]([-a-z0-9]*[a-z0-9])?$'
+        pattern=r"^[a-z0-9]([-a-z0-9]*[a-z0-9])?$",
     )
     priority: Optional[str] = Field(
-        default=None, 
-        description="Priority class for job scheduling",
-        min_length=1
+        default=None, description="Priority class for job scheduling", min_length=1
     )
     max_retry: Optional[int] = Field(
-        default=None, 
-        alias="max_retry", 
+        default=None,
+        alias="max_retry",
         description="Maximum number of job retries",
-        ge=0
+        ge=0,
     )
     volume: Optional[List[VolumeConfig]] = Field(
-        default=None, description="List of volume configurations. \
+        default=None,
+        description="List of volume configurations. \
         Command structure: --volume name=<volume_name>,type=<volume_type>,mount_path=<mount_path>,<type-specific options> \
         For hostPath: --volume name=model-data,type=hostPath,mount_path=/data,path=/data  \
         For persistentVolumeClaim: --volume name=training-output,type=pvc,mount_path=/mnt/output,claim_name=training-output-pvc,read_only=false \
         If multiple --volume flag if multiple volumes are needed \
-        "
+        ",
     )
     service_account_name: Optional[str] = Field(
-        default=None, 
-        alias="service_account_name", 
+        default=None,
+        alias="service_account_name",
         description="Service account name",
-        min_length=1
+        min_length=1,
     )
 
-    @field_validator('volume')
+    @field_validator("volume")
     def validate_no_duplicates(cls, v):
         """Validate no duplicate volume names or mount paths."""
         if not v:
             return v
-        
+
         # Check for duplicate volume names
         names = [vol.name for vol in v]
         if len(names) != len(set(names)):
             raise ValueError("Duplicate volume names found")
-        
+
         # Check for duplicate mount paths
         mount_paths = [vol.mount_path for vol in v]
         if len(mount_paths) != len(set(mount_paths)):
             raise ValueError("Duplicate mount paths found")
-        
+
         return v
 
-    @field_validator('command', 'args')
+    @field_validator("command", "args")
     def validate_string_lists(cls, v):
         """Validate that command and args contain non-empty strings."""
         if not v:
             return v
-        
+
         for i, item in enumerate(v):
             if not isinstance(item, str) or not item.strip():
-                field_name = cls.model_fields.get('command', {}).get('alias', 'command') if 'command' in str(v) else 'args'
+                field_name = (
+                    cls.model_fields.get("command", {}).get("alias", "command")
+                    if "command" in str(v)
+                    else "args"
+                )
                 raise ValueError(f"{field_name}[{i}] must be a non-empty string")
-        
+
         return v
 
-    @field_validator('environment')
+    @field_validator("environment")
     def validate_environment_variable_names(cls, v):
         """Validate environment variable names follow C_IDENTIFIER pattern."""
         if not v:
             return v
-        
+
         import re
-        c_identifier_pattern = re.compile(r'^[a-zA-Z_][a-zA-Z0-9_]*$')
-        
+
+        c_identifier_pattern = re.compile(r"^[a-zA-Z_][a-zA-Z0-9_]*$")
+
         for key in v.keys():
             if not c_identifier_pattern.match(key):
-                raise ValueError(f"Environment variable name '{key}' must be a valid C_IDENTIFIER")
-        
+                raise ValueError(
+                    f"Environment variable name '{key}' must be a valid C_IDENTIFIER"
+                )
+
         return v
 
-    @field_validator('label_selector')
+    @field_validator("label_selector")
     def validate_label_selector_keys(cls, v):
         """Validate label selector keys follow Kubernetes label naming conventions."""
         if not v:
             return v
-        
+
         import re
+
         # Kubernetes label key pattern - allows namespaced labels like kubernetes.io/arch
         # Pattern: [prefix/]name where prefix and name follow DNS subdomain rules
         # Also reject double dots
-        label_key_pattern = re.compile(r'^([a-zA-Z0-9]([a-zA-Z0-9\-_.]*[a-zA-Z0-9])?/)?[a-zA-Z0-9]([a-zA-Z0-9\-_.]*[a-zA-Z0-9])?$')
-        
+        label_key_pattern = re.compile(
+            r"^([a-zA-Z0-9]([a-zA-Z0-9\-_.]*[a-zA-Z0-9])?/)?[a-zA-Z0-9]([a-zA-Z0-9\-_.]*[a-zA-Z0-9])?$"
+        )
+
         for key in v.keys():
-            if not key or not label_key_pattern.match(key) or '..' in key:
-                raise ValueError(f"Label selector key '{key}' must follow Kubernetes label naming conventions")
-        
+            if not key or not label_key_pattern.match(key) or ".." in key:
+                raise ValueError(
+                    f"Label selector key '{key}' must follow Kubernetes label naming conventions"
+                )
+
         return v
 
     def to_domain(self) -> Dict:
         """
         Convert flat config to domain model (HyperPodPytorchJobSpec)
         """
-        
+
         # Create container with required fields
         container_kwargs = {
             "name": "container-name",
@@ -258,9 +245,8 @@ def to_domain(self) -> Dict:
             for i, vol in enumerate(self.volume):
                 volume_mount = {"name": vol.name, "mount_path": vol.mount_path}
                 volume_mounts.append(volume_mount)
-            
-            container_kwargs["volume_mounts"] = volume_mounts
 
+            container_kwargs["volume_mounts"] = volume_mounts
 
         # Create container object
         try:
@@ -280,14 +266,16 @@ def to_domain(self) -> Dict:
                     volume_obj = Volumes(name=vol.name, host_path=host_path)
                 elif vol.type == "pvc":
                     pvc_config = PersistentVolumeClaim(
-                         claim_name=vol.claim_name,
-                         read_only=vol.read_only == "true" if vol.read_only else False
+                        claim_name=vol.claim_name,
+                        read_only=vol.read_only == "true" if vol.read_only else False,
+                    )
+                    volume_obj = Volumes(
+                        name=vol.name, persistent_volume_claim=pvc_config
                     )
-                    volume_obj = Volumes(name=vol.name, persistent_volume_claim=pvc_config)
                 volumes.append(volume_obj)
-            
+
             spec_kwargs["volumes"] = volumes
-        
+
         # Add node selector if any selector fields are present
         node_selector = {}
         if self.instance_type is not None: