Use auto aliasing for cases for the runopt (#1143)

Summary:

Introduces enum for auto aliasing based on casing for the runopt nam

```
    class AutoAlias(IntEnum):
        snake_case = 0x1
        SNAKE_CASE = 0x2
        camelCase = 0x4
```
So user can extend name to be used as 
```
        opts.add(
            ["job_priority", runopt.AutoAlias.camelCase],
            type_=str,
            help="run as user",
        )
        opts.add(
            [
                "model_type_name",
                runopt.AutoAlias.camelCase | runopt.AutoAlias.SNAKE_CASE,
            ],
            type_=str,
            help="run as user",
        )
```
This should automatically produce additional aliases of `jobPriority` to `job_priority` and produce `modelTypeName` and `MODEL_TYPE_NAME` for `model_type_name`

Differential Revision: D84192560

Author: AbishekS

torchx/specs/api.py

@@ -18,7 +18,7 @@
 import warnings
 from dataclasses import asdict, dataclass, field
 from datetime import datetime
-from enum import Enum
+from enum import Enum, IntEnum
 from json import JSONDecodeError
 from string import Template
 from typing import (
@@ -893,6 +893,30 @@ class runopt:
     Represents the metadata about the specific run option
     """
 
+    class AutoAlias(IntEnum):
+        snake_case = 0x1
+        SNAKE_CASE = 0x2
+        camelCase = 0x4
+
+        @staticmethod
+        def convert_to_camel_case(alias: str) -> str:
+            words = re.split(r"[_\-\s]+|(?<=[a-z])(?=[A-Z])", alias)
+            words = [w for w in words if w]  # Remove empty strings
+            if not words:
+                return ""
+            return words[0].lower() + "".join(w.capitalize() for w in words[1:])
+
+        @staticmethod
+        def convert_to_snake_case(alias: str) -> str:
+            alias = re.sub(r"[-\s]+", "_", alias)
+            alias = re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", alias)
+            alias = re.sub(r"([A-Z]+)([A-Z][a-z])", r"\1_\2", alias)
+            return alias.lower()
+
+        @staticmethod
+        def convert_to_const_case(alias: str) -> str:
+            return runopt.AutoAlias.convert_to_snake_case(alias).upper()
+
     class alias(str):
         pass
 
@@ -903,8 +927,8 @@ class deprecated(str):
     opt_type: Type[CfgVal]
     is_required: bool
     help: str
-    aliases: list[alias] | None = None
-    deprecated_aliases: list[deprecated] | None = None
+    aliases: set[alias] | None = None
+    deprecated_aliases: set[deprecated] | None = None
 
     @property
     def is_type_list_of_str(self) -> bool:
@@ -1190,26 +1214,42 @@ def cfg_from_json_repr(self, json_repr: str) -> Dict[str, CfgVal]:
                     cfg[key] = val
         return cfg
 
+    def _generate_aliases(
+        self, auto_alias: int, aliases: set[str]
+    ) -> set[runopt.alias]:
+        generated_aliases = set()
+        for alias in aliases:
+            if auto_alias & runopt.AutoAlias.camelCase:
+                generated_aliases.add(runopt.AutoAlias.convert_to_camel_case(alias))
+            if auto_alias & runopt.AutoAlias.snake_case:
+                generated_aliases.add(runopt.AutoAlias.convert_to_snake_case(alias))
+            if auto_alias & runopt.AutoAlias.SNAKE_CASE:
+                generated_aliases.add(runopt.AutoAlias.convert_to_const_case(alias))
+        return generated_aliases
+
     def _get_primary_key_and_aliases(
         self,
-        cfg_key: list[str] | str,
-    ) -> tuple[str, list[runopt.alias], list[runopt.deprecated]]:
+        cfg_key: list[str | int] | str,
+    ) -> tuple[str, set[runopt.alias], set[runopt.deprecated]]:
         """
         Returns the primary key and aliases for the given cfg_key.
         """
         if isinstance(cfg_key, str):
-            return cfg_key, [], []
+            return cfg_key, set(), set()
 
         if len(cfg_key) == 0:
             raise ValueError("cfg_key must be a non-empty list")
         primary_key = None
-        aliases = list[runopt.alias]()
-        deprecated_aliases = list[runopt.deprecated]()
+        auto_alias = 0x0
+        aliases = set[runopt.alias]()
+        deprecated_aliases = set[runopt.deprecated]()
         for name in cfg_key:
             if isinstance(name, runopt.alias):
-                aliases.append(name)
+                aliases.add(name)
             elif isinstance(name, runopt.deprecated):
-                deprecated_aliases.append(name)
+                deprecated_aliases.add(name)
+            elif isinstance(name, int):
+                auto_alias = auto_alias | name
             else:
                 if primary_key is not None:
                     raise ValueError(
@@ -1220,11 +1260,17 @@ def _get_primary_key_and_aliases(
             raise ValueError(
                 "Missing cfg_key. Please provide one other than the aliases."
             )
+        if auto_alias != 0x0:
+            aliases_to_generate_for = aliases | {primary_key}
+            additional_aliases = self._generate_aliases(
+                auto_alias, aliases_to_generate_for
+            )
+            aliases.update(additional_aliases)
         return primary_key, aliases, deprecated_aliases
 
     def add(
         self,
-        cfg_key: str | list[str],
+        cfg_key: str | list[str | int],
         type_: Type[CfgVal],
         help: str,
         default: CfgVal = None,

torchx/specs/test/api_test.py

@@ -640,6 +640,28 @@ def test_runopts_add_with_deprecated_aliases(self) -> None:
                 "Run option: jobPriority, is deprecated. Please use job_priority instead",
             )
 
+    def test_runopt_auto_aliases(self) -> None:
+        opts = runopts()
+        opts.add(
+            ["job_priority", runopt.AutoAlias.camelCase],
+            type_=str,
+            help="run as user",
+        )
+        opts.add(
+            [
+                "model_type_name",
+                runopt.AutoAlias.camelCase | runopt.AutoAlias.SNAKE_CASE,
+            ],
+            type_=str,
+            help="run as user",
+        )
+        self.assertEqual(2, len(opts._opts))
+        self.assertIsNotNone(opts.get("job_priority"))
+        self.assertIsNotNone(opts.get("jobPriority"))
+        self.assertIsNotNone(opts.get("model_type_name"))
+        self.assertIsNotNone(opts.get("modelTypeName"))
+        self.assertIsNotNone(opts.get("MODEL_TYPE_NAME"))
+
     def get_runopts(self) -> runopts:
         opts = runopts()
         opts.add("run_as", type_=str, help="run as user", required=True)