Rename CRD to CR

Signed-off-by: Andrey Velichkevich <[email protected]>

Author: andreyvelich

kubeflow/optimizer/backends/kubernetes/backend.py

@@ -189,7 +189,7 @@ def list_jobs(self) -> list[OptimizationJob]:
                 return result
 
             for optimization_job in optimization_job_list.items:
-                result.append(self.__get_optimization_job_from_crd(optimization_job))
+                result.append(self.__get_optimization_job_from_custom_resource(optimization_job))
 
         except multiprocessing.TimeoutError as e:
             raise TimeoutError(
@@ -224,7 +224,7 @@ def get_job(self, name: str) -> OptimizationJob:
         except Exception as e:
             raise RuntimeError(f"Failed to get OptimizationJob: {self.namespace}/{name}") from e
 
-        return self.__get_optimization_job_from_crd(optimization_job)  # type: ignore
+        return self.__get_optimization_job_from_custom_resource(optimization_job)  # type: ignore
 
     def delete_job(self, name: str):
         """Delete the OptimizationJob"""
@@ -244,44 +244,44 @@ def delete_job(self, name: str):
 
         logger.debug(f"OptimizationJob {self.namespace}/{name} has been deleted")
 
-    def __get_optimization_job_from_crd(
+    def __get_optimization_job_from_custom_resource(
         self,
-        optimization_job_crd: models.V1beta1Experiment,
+        optimization_job_cr: models.V1beta1Experiment,
     ) -> OptimizationJob:
         if not (
-            optimization_job_crd.metadata
-            and optimization_job_crd.metadata.name
-            and optimization_job_crd.metadata.namespace
-            and optimization_job_crd.spec
-            and optimization_job_crd.spec.parameters
-            and optimization_job_crd.spec.objective
-            and optimization_job_crd.spec.algorithm
-            and optimization_job_crd.spec.max_trial_count
-            and optimization_job_crd.spec.parallel_trial_count
-            and optimization_job_crd.metadata.creation_timestamp
+            optimization_job_cr.metadata
+            and optimization_job_cr.metadata.name
+            and optimization_job_cr.metadata.namespace
+            and optimization_job_cr.spec
+            and optimization_job_cr.spec.parameters
+            and optimization_job_cr.spec.objective
+            and optimization_job_cr.spec.algorithm
+            and optimization_job_cr.spec.max_trial_count
+            and optimization_job_cr.spec.parallel_trial_count
+            and optimization_job_cr.metadata.creation_timestamp
         ):
-            raise Exception(f"OptimizationJob CRD is invalid: {optimization_job_crd}")
+            raise Exception(f"OptimizationJob CR is invalid: {optimization_job_cr}")
 
         optimization_job = OptimizationJob(
-            name=optimization_job_crd.metadata.name,
+            name=optimization_job_cr.metadata.name,
             search_space=utils.get_search_space_from_katib_spec(
-                optimization_job_crd.spec.parameters
+                optimization_job_cr.spec.parameters
             ),
-            objectives=utils.get_objectives_from_katib_spec(optimization_job_crd.spec.objective),
-            algorithm=utils.get_algorithm_from_katib_spec(optimization_job_crd.spec.algorithm),
+            objectives=utils.get_objectives_from_katib_spec(optimization_job_cr.spec.objective),
+            algorithm=utils.get_algorithm_from_katib_spec(optimization_job_cr.spec.algorithm),
             trial_config=TrialConfig(
-                num_trials=optimization_job_crd.spec.max_trial_count,
-                parallel_trials=optimization_job_crd.spec.parallel_trial_count,
-                max_failed_trials=optimization_job_crd.spec.max_failed_trial_count,
+                num_trials=optimization_job_cr.spec.max_trial_count,
+                parallel_trials=optimization_job_cr.spec.parallel_trial_count,
+                max_failed_trials=optimization_job_cr.spec.max_failed_trial_count,
             ),
-            trials=self.__get_trials_from_crd(optimization_job_crd.metadata.name),
-            creation_timestamp=optimization_job_crd.metadata.creation_timestamp,
+            trials=self.__get_trials_from_job(optimization_job_cr.metadata.name),
+            creation_timestamp=optimization_job_cr.metadata.creation_timestamp,
             status=constants.OPTIMIZATION_JOB_CREATED,  # The default OptimizationJob status.
         )
 
         # Update the OptimizationJob status from Experiment conditions.
-        if optimization_job_crd.status and optimization_job_crd.status.conditions:
-            for c in optimization_job_crd.status.conditions:
+        if optimization_job_cr.status and optimization_job_cr.status.conditions:
+            for c in optimization_job_cr.status.conditions:
                 if c.type == constants.EXPERIMENT_SUCCEEDED and c.status == "True":
                     optimization_job.status = constants.OPTIMIZATION_JOB_COMPLETE
                 elif c.type == constants.OPTIMIZATION_JOB_FAILED and c.status == "True":
@@ -293,7 +293,7 @@ def __get_optimization_job_from_crd(
 
         return optimization_job
 
-    def __get_trials_from_crd(self, optimization_job_name: str) -> list[Trial]:
+    def __get_trials_from_job(self, optimization_job_name: str) -> list[Trial]:
         result = []
         try:
             thread = self.custom_api.list_namespaced_custom_object(
@@ -314,7 +314,7 @@ def __get_trials_from_crd(self, optimization_job_name: str) -> list[Trial]:
 
             for t in trial_list.items:
                 if not (t.metadata and t.metadata.name and t.spec and t.spec.parameter_assignments):
-                    raise ValueError(f"Trial CRD is invalid: {t}")
+                    raise ValueError(f"Trial CR is invalid: {t}")
 
                 # Trial name is equal to the TrainJob name.
                 trial = Trial(

kubeflow/trainer/backends/kubernetes/backend.py

@@ -87,7 +87,7 @@ def list_runtimes(self) -> list[types.Runtime]:
                         f"{constants.RUNTIME_FRAMEWORK_LABEL} label."
                     )
                     continue
-                result.append(self.__get_runtime_from_crd(runtime))
+                result.append(self.__get_runtime_from_cr(runtime))
 
         except multiprocessing.TimeoutError as e:
             raise TimeoutError(
@@ -129,7 +129,7 @@ def get_runtime(self, name: str) -> types.Runtime:
                 f"{self.namespace}/{name}"
             ) from e
 
-        return self.__get_runtime_from_crd(runtime)  # type: ignore
+        return self.__get_runtime_from_cr(runtime)  # type: ignore
 
     def get_runtime_packages(self, runtime: types.Runtime):
         if runtime.trainer.trainer_type == types.TrainerType.BUILTIN_TRAINER:
@@ -249,7 +249,7 @@ def list_jobs(self, runtime: Optional[types.Runtime] = None) -> list[types.Train
                 ):
                     continue
 
-                result.append(self.__get_trainjob_from_crd(trainjob))
+                result.append(self.__get_trainjob_from_cr(trainjob))
 
         except multiprocessing.TimeoutError as e:
             raise TimeoutError(
@@ -288,7 +288,7 @@ def get_job(self, name: str) -> types.TrainJob:
                 f"Failed to get {constants.TRAINJOB_KIND}: {self.namespace}/{name}"
             ) from e
 
-        return self.__get_trainjob_from_crd(trainjob)  # type: ignore
+        return self.__get_trainjob_from_cr(trainjob)  # type: ignore
 
     def get_job_logs(
         self,
@@ -395,66 +395,66 @@ def delete_job(self, name: str):
 
         logger.debug(f"{constants.TRAINJOB_KIND} {self.namespace}/{name} has been deleted")
 
-    def __get_runtime_from_crd(
+    def __get_runtime_from_cr(
         self,
-        runtime_crd: models.TrainerV1alpha1ClusterTrainingRuntime,
+        runtime_cr: models.TrainerV1alpha1ClusterTrainingRuntime,
     ) -> types.Runtime:
         if not (
-            runtime_crd.metadata
-            and runtime_crd.metadata.name
-            and runtime_crd.spec
-            and runtime_crd.spec.ml_policy
-            and runtime_crd.spec.template.spec
-            and runtime_crd.spec.template.spec.replicated_jobs
+            runtime_cr.metadata
+            and runtime_cr.metadata.name
+            and runtime_cr.spec
+            and runtime_cr.spec.ml_policy
+            and runtime_cr.spec.template.spec
+            and runtime_cr.spec.template.spec.replicated_jobs
         ):
-            raise Exception(f"ClusterTrainingRuntime CRD is invalid: {runtime_crd}")
+            raise Exception(f"ClusterTrainingRuntime CR is invalid: {runtime_cr}")
 
         if not (
-            runtime_crd.metadata.labels
-            and constants.RUNTIME_FRAMEWORK_LABEL in runtime_crd.metadata.labels
+            runtime_cr.metadata.labels
+            and constants.RUNTIME_FRAMEWORK_LABEL in runtime_cr.metadata.labels
         ):
             raise Exception(
-                f"Runtime {runtime_crd.metadata.name} must have "
+                f"Runtime {runtime_cr.metadata.name} must have "
                 f"{constants.RUNTIME_FRAMEWORK_LABEL} label"
             )
 
         return types.Runtime(
-            name=runtime_crd.metadata.name,
+            name=runtime_cr.metadata.name,
             trainer=utils.get_runtime_trainer(
-                runtime_crd.metadata.labels[constants.RUNTIME_FRAMEWORK_LABEL],
-                runtime_crd.spec.template.spec.replicated_jobs,
-                runtime_crd.spec.ml_policy,
+                runtime_cr.metadata.labels[constants.RUNTIME_FRAMEWORK_LABEL],
+                runtime_cr.spec.template.spec.replicated_jobs,
+                runtime_cr.spec.ml_policy,
             ),
         )
 
-    def __get_trainjob_from_crd(
+    def __get_trainjob_from_cr(
         self,
-        trainjob_crd: models.TrainerV1alpha1TrainJob,
+        trainjob_cr: models.TrainerV1alpha1TrainJob,
     ) -> types.TrainJob:
         if not (
-            trainjob_crd.metadata
-            and trainjob_crd.metadata.name
-            and trainjob_crd.metadata.namespace
-            and trainjob_crd.spec
-            and trainjob_crd.metadata.creation_timestamp
+            trainjob_cr.metadata
+            and trainjob_cr.metadata.name
+            and trainjob_cr.metadata.namespace
+            and trainjob_cr.spec
+            and trainjob_cr.metadata.creation_timestamp
         ):
-            raise Exception(f"TrainJob CRD is invalid: {trainjob_crd}")
+            raise Exception(f"TrainJob CR is invalid: {trainjob_cr}")
 
-        name = trainjob_crd.metadata.name
-        namespace = trainjob_crd.metadata.namespace
+        name = trainjob_cr.metadata.name
+        namespace = trainjob_cr.metadata.namespace
 
-        runtime = self.get_runtime(trainjob_crd.spec.runtime_ref.name)
+        runtime = self.get_runtime(trainjob_cr.spec.runtime_ref.name)
 
-        # Construct the TrainJob from the CRD.
+        # Construct the TrainJob from the CR.
         trainjob = types.TrainJob(
             name=name,
-            creation_timestamp=trainjob_crd.metadata.creation_timestamp,
+            creation_timestamp=trainjob_cr.metadata.creation_timestamp,
             runtime=runtime,
             steps=[],
             # Number of nodes is taken from TrainJob or TrainingRuntime
             num_nodes=(
-                trainjob_crd.spec.trainer.num_nodes
-                if trainjob_crd.spec.trainer and trainjob_crd.spec.trainer.num_nodes
+                trainjob_cr.spec.trainer.num_nodes
+                if trainjob_cr.spec.trainer and trainjob_cr.spec.trainer.num_nodes
                 else runtime.trainer.num_nodes
             ),
             status=constants.TRAINJOB_CREATED,  # The default TrainJob status.
@@ -516,8 +516,8 @@ def __get_trainjob_from_crd(
             ) from e
 
         # Update the TrainJob status from its conditions.
-        if trainjob_crd.status and trainjob_crd.status.conditions:
-            for c in trainjob_crd.status.conditions:
+        if trainjob_cr.status and trainjob_cr.status.conditions:
+            for c in trainjob_cr.status.conditions:
                 if (
                     c.type == constants.TRAINJOB_COMPLETE
                     and c.status == "True"
@@ -554,20 +554,20 @@ def _get_trainjob_spec(
             runtime = self.get_runtime(constants.TORCH_RUNTIME)
 
         # Build the Trainer.
-        trainer_crd = models.TrainerV1alpha1Trainer()
+        trainer_cr = models.TrainerV1alpha1Trainer()
 
         if trainer:
             # If users choose to use a custom training function.
             if isinstance(trainer, types.CustomTrainer):
                 if runtime.trainer.trainer_type != types.TrainerType.CUSTOM_TRAINER:
                     raise ValueError(f"CustomTrainer can't be used with {runtime} runtime")
-                trainer_crd = utils.get_trainer_crd_from_custom_trainer(runtime, trainer)
+                trainer_cr = utils.get_trainer_cr_from_custom_trainer(runtime, trainer)
 
             # If users choose to use a builtin trainer for post-training.
             elif isinstance(trainer, types.BuiltinTrainer):
                 if runtime.trainer.trainer_type != types.TrainerType.BUILTIN_TRAINER:
                     raise ValueError(f"BuiltinTrainer can't be used with {runtime} runtime")
-                trainer_crd = utils.get_trainer_crd_from_builtin_trainer(
+                trainer_cr = utils.get_trainer_cr_from_builtin_trainer(
                     runtime, trainer, initializer
                 )
 
@@ -579,7 +579,7 @@ def _get_trainjob_spec(
 
         return models.TrainerV1alpha1TrainJobSpec(
             runtimeRef=models.TrainerV1alpha1RuntimeRef(name=runtime.name),
-            trainer=(trainer_crd if trainer_crd != models.TrainerV1alpha1Trainer() else None),
+            trainer=(trainer_cr if trainer_cr != models.TrainerV1alpha1Trainer() else None),
             initializer=(
                 models.TrainerV1alpha1Initializer(
                     dataset=utils.get_dataset_initializer(initializer.dataset),

kubeflow/trainer/backends/kubernetes/utils.py

@@ -343,26 +343,26 @@ def get_command_using_train_func(
     return command
 
 
-def get_trainer_crd_from_custom_trainer(
+def get_trainer_cr_from_custom_trainer(
     runtime: types.Runtime,
     trainer: types.CustomTrainer,
 ) -> models.TrainerV1alpha1Trainer:
     """
-    Get the Trainer CRD from the custom trainer.
+    Get the Trainer CR from the custom trainer.
     """
-    trainer_crd = models.TrainerV1alpha1Trainer()
+    trainer_cr = models.TrainerV1alpha1Trainer()
 
     # Add number of nodes to the Trainer.
     if trainer.num_nodes:
-        trainer_crd.num_nodes = trainer.num_nodes
+        trainer_cr.num_nodes = trainer.num_nodes
 
     # Add resources per node to the Trainer.
     if trainer.resources_per_node:
-        trainer_crd.resources_per_node = get_resources_per_node(trainer.resources_per_node)
+        trainer_cr.resources_per_node = get_resources_per_node(trainer.resources_per_node)
 
     # Add command to the Trainer.
     # TODO: Support train function parameters.
-    trainer_crd.command = get_command_using_train_func(
+    trainer_cr.command = get_command_using_train_func(
         runtime,
         trainer.func,
         trainer.func_args,
@@ -372,41 +372,41 @@ def get_trainer_crd_from_custom_trainer(
 
     # Add environment variables to the Trainer.
     if trainer.env:
-        trainer_crd.env = [
+        trainer_cr.env = [
             models.IoK8sApiCoreV1EnvVar(name=key, value=value) for key, value in trainer.env.items()
         ]
 
-    return trainer_crd
+    return trainer_cr
 
 
-def get_trainer_crd_from_builtin_trainer(
+def get_trainer_cr_from_builtin_trainer(
     runtime: types.Runtime,
     trainer: types.BuiltinTrainer,
     initializer: Optional[types.Initializer] = None,
 ) -> models.TrainerV1alpha1Trainer:
     """
-    Get the Trainer CRD from the builtin trainer.
+    Get the Trainer CR from the builtin trainer.
     """
     if not isinstance(trainer.config, types.TorchTuneConfig):
         raise ValueError(f"The BuiltinTrainer config is invalid: {trainer.config}")
 
-    trainer_crd = models.TrainerV1alpha1Trainer()
+    trainer_cr = models.TrainerV1alpha1Trainer()
 
     # Add number of nodes to the Trainer.
     if trainer.config.num_nodes:
-        trainer_crd.num_nodes = trainer.config.num_nodes
+        trainer_cr.num_nodes = trainer.config.num_nodes
 
     # Add resources per node to the Trainer.
     if trainer.config.resources_per_node:
-        trainer_crd.resources_per_node = get_resources_per_node(trainer.config.resources_per_node)
+        trainer_cr.resources_per_node = get_resources_per_node(trainer.config.resources_per_node)
 
-    trainer_crd.command = list(runtime.trainer.command)
+    trainer_cr.command = list(runtime.trainer.command)
     # Parse args in the TorchTuneConfig to the Trainer, preparing for the mutation of
     # the torchtune config in the runtime plugin.
     # Ref:https://github.com/kubeflow/trainer/tree/master/docs/proposals/2401-llm-trainer-v2
-    trainer_crd.args = get_args_using_torchtune_config(trainer.config, initializer)
+    trainer_cr.args = get_args_using_torchtune_config(trainer.config, initializer)
 
-    return trainer_crd
+    return trainer_cr
 
 
 def get_args_using_torchtune_config(