Support AnyType

Author: kairu-ms

src/azure-cli-core/azure/cli/core/aaz/__init__.py

@@ -12,7 +12,8 @@
 from ._arg import AAZArgumentsSchema, AAZArgEnum, AAZStrArg, AAZIntArg, AAZObjectArg, AAZDictArg, \
     AAZFreeFormDictArg, AAZFloatArg, AAZBaseArg, AAZBoolArg, AAZListArg, AAZResourceGroupNameArg, \
     AAZResourceLocationArg, AAZResourceIdArg, AAZSubscriptionIdArg, AAZUuidArg, AAZDateArg, AAZTimeArg, \
-    AAZDateTimeArg, AAZDurationArg, AAZFileArg, AAZPasswordArg, AAZPaginationTokenArg, AAZPaginationLimitArg
+    AAZDateTimeArg, AAZDurationArg, AAZFileArg, AAZPasswordArg, AAZPaginationTokenArg, AAZPaginationLimitArg, \
+    AAZAnyTypeArg
 from ._arg_fmt import AAZStrArgFormat, AAZIntArgFormat, AAZFloatArgFormat, AAZBoolArgFormat, AAZObjectArgFormat, \
     AAZDictArgFormat, AAZFreeFormDictArgFormat, AAZListArgFormat, AAZResourceLocationArgFormat, \
     AAZResourceIdArgFormat, AAZSubscriptionIdArgFormat, AAZUuidFormat, AAZDateFormat, AAZTimeFormat, \
@@ -22,7 +23,7 @@
 from ._command import AAZCommand, AAZWaitCommand, AAZCommandGroup, \
     register_callback, register_command, register_command_group, load_aaz_command_table, link_helper
 from ._field_type import AAZIntType, AAZFloatType, AAZStrType, AAZBoolType, AAZDictType, AAZFreeFormDictType, \
-    AAZListType, AAZObjectType, AAZIdentityObjectType
+    AAZListType, AAZObjectType, AAZIdentityObjectType, AAZAnyType
 from ._operation import AAZHttpOperation, AAZJsonInstanceUpdateOperation, AAZGenericInstanceUpdateOperation, \
     AAZJsonInstanceDeleteOperation, AAZJsonInstanceCreateOperation
 from ._prompt import AAZPromptInput, AAZPromptPasswordInput

src/azure-cli-core/azure/cli/core/aaz/_arg.py

@@ -13,11 +13,11 @@
 from knack.util import status_tag_messages
 from knack.log import get_logger
 
-from ._arg_action import AAZSimpleTypeArgAction, AAZObjectArgAction, AAZDictArgAction, AAZFreeFormDictArgAction, \
-    AAZListArgAction, AAZGenericUpdateAction, AAZGenericUpdateForceStringAction
+from ._arg_action import AAZSimpleTypeArgAction, AAZObjectArgAction, AAZDictArgAction, \
+    AAZListArgAction, AAZGenericUpdateAction, AAZGenericUpdateForceStringAction, AAZAnyTypeArgAction
 from ._base import AAZBaseType, AAZUndefined
 from ._field_type import AAZObjectType, AAZStrType, AAZIntType, AAZBoolType, AAZFloatType, AAZListType, AAZDictType, \
-    AAZSimpleType, AAZFreeFormDictType
+    AAZSimpleType, AAZFreeFormDictType, AAZAnyType
 from ._field_value import AAZObject
 from ._arg_fmt import AAZObjectArgFormat, AAZListArgFormat, AAZDictArgFormat, AAZFreeFormDictArgFormat, \
     AAZSubscriptionIdArgFormat, AAZResourceLocationArgFormat, AAZResourceIdArgFormat, AAZUuidFormat, AAZDateFormat, \
@@ -356,6 +356,28 @@ def _type_in_help(self):
         return "Float"
 
 
+class AAZAnyTypeArg(AAZBaseArg, AAZAnyType):
+
+    def _build_cmd_action(self):
+        class Action(AAZAnyTypeArgAction):
+            _schema = self  # bind action class with current schema
+        return Action
+
+    def to_cmd_arg(self, name, **kwargs):
+        from ._help import shorthand_help_messages
+        arg = super().to_cmd_arg(name, **kwargs)
+        short_summary = arg.type.settings.get('help', None) or ''
+        if short_summary:
+            short_summary += '  '
+        short_summary += shorthand_help_messages['short-summary-anytype']
+        arg.help = short_summary
+        return arg
+    
+    @property
+    def _type_in_help(self):
+        return "Any"
+
+
 class AAZCompoundTypeArg(AAZBaseArg):
 
     @abc.abstractmethod
@@ -427,30 +449,15 @@ def _type_in_help(self):
         return f"Dict<String,{self.Element._type_in_help}>"
 
 
-class AAZFreeFormDictArg(AAZBaseArg, AAZFreeFormDictType):
+# Warning: This type should not be used any more, the new aaz-dev-tools only use AAZDictType with AAZAnyType
+class AAZFreeFormDictArg(AAZDictArg, AAZFreeFormDictType):
 
     def __init__(self, fmt=None, **kwargs):
         fmt = fmt or AAZFreeFormDictArgFormat()
         super().__init__(fmt=fmt, **kwargs)
-
-    def to_cmd_arg(self, name, **kwargs):
-        arg = super().to_cmd_arg(name, **kwargs)
-        short_summary = arg.type.settings.get('help', None) or ''
-        if short_summary:
-            short_summary += '  '
-        short_summary += "Support json-file and yaml-file."
-        arg.help = short_summary
-        return arg
-
-    def _build_cmd_action(self):
-        class Action(AAZFreeFormDictArgAction):
-            _schema = self  # bind action class with current schema
-
-        return Action
-
-    @property
-    def _type_in_help(self):
-        return "Dict<String, Any>"
+        # for backward compatible, support nullable value here for AAZFreeFormDictArg,
+        # from the new code gen tools, it will avoid using AAZFreeFormDictArg
+        self._element = AAZAnyTypeArg(nullable=True)
 
 
 class AAZListArg(AAZCompoundTypeArg, AAZListType):

src/azure-cli-core/azure/cli/core/aaz/_arg_action.py

@@ -150,6 +150,14 @@ def format_data(cls, data):
                 return AAZPromptInputOperation(prompt=cls._schema._blank, action_cls=cls)
             data = copy.deepcopy(cls._schema._blank)
 
+        if data is None:
+            if cls._schema._nullable:
+                return data
+            raise AAZInvalidValueError("field is not nullable")
+
+        if cls._schema.DataType == str and isinstance(data, (int, bool, float)):
+            data = str(data).lower()  # convert to json raw values
+
         if isinstance(data, str):
             # transfer string into correct data
             if cls._schema.enum:
@@ -159,12 +167,80 @@ def format_data(cls, data):
         if isinstance(data, cls._schema.DataType):
             return data
 
+        raise AAZInvalidValueError(f"{cls._schema.DataType} type value expected, got '{data}'({type(data)})")
+
+
+class AAZAnyTypeArgAction(AAZArgAction):
+
+    @classmethod
+    def setup_operations(cls, dest_ops, values, prefix_keys=None):
+        if prefix_keys is None:
+            prefix_keys = []
+        if values is None:
+            data = AAZBlankArgValue  # use blank data when values string is None
+        else:
+            if isinstance(values, list):
+                assert prefix_keys  # the values will be input as an list when parse singular option of a list argument
+                if len(values) != 1:
+                    raise AAZInvalidValueError(f"only support 1 value, got {len(values)}: {values}")
+                values = values[0]
+
+            if isinstance(values, str) and len(values) > 0:
+                try:
+                    data = cls.decode_str(values)
+                except AAZShowHelp as aaz_help:
+                    aaz_help.schema = cls._schema
+                    raise aaz_help
+            else:
+                data = values
+        data = cls.format_data(data)
+        dest_ops.add(data, *prefix_keys)
+
+    @classmethod
+    def decode_str(cls, value):
+        from azure.cli.core.util import get_file_json, shell_safe_json_parse, get_file_yaml
+
+        # check if the value is a partial value
+        key, _, v = cls._str_parser.split_partial_value(value)
+        if key is not None:
+            raise AAZInvalidValueError(f"AnyType args only support full value shorthand syntax, please don't use partial value shorthand syntax. If it's a simple string, please wrap it with single quotes.")
+        
+        # read from file
+        path = os.path.expanduser(value)
+        if os.path.exists(path):
+            if path.endswith('.yml') or path.endswith('.yaml'):
+                # read from yaml file
+                v = get_file_yaml(path)
+            else:
+                # read from json file
+                v = get_file_json(path, preserve_order=True)
+        else:
+            try:
+                v = cls._str_parser(value)
+            except AAZInvalidShorthandSyntaxError as shorthand_ex:
+                try:
+                    v = shell_safe_json_parse(value, True)
+                except Exception as ex:
+                    logger.debug(ex)  # log parse json failed expression
+                    raise shorthand_ex  # raise shorthand syntax exception
+        return v
+
+    @classmethod
+    def format_data(cls, data):
+        if data == AAZBlankArgValue:
+            if cls._schema._blank == AAZUndefined:
+                raise AAZInvalidValueError("argument value cannot be blank")
+            if isinstance(cls._schema._blank, AAZPromptInput):
+                # Postpone the prompt input when apply the operation.
+                # In order not to break the logic of displaying help or validating other parameters.
+                return AAZPromptInputOperation(prompt=cls._schema._blank, action_cls=cls)
+            data = copy.deepcopy(cls._schema._blank)
+
         if data is None:
             if cls._schema._nullable:
                 return data
             raise AAZInvalidValueError("field is not nullable")
-
-        raise AAZInvalidValueError(f"{cls._schema.DataType} type value expected, got '{data}'({type(data)})")
+        return data
 
 
 class AAZCompoundTypeArgAction(AAZArgAction):  # pylint: disable=abstract-method
@@ -245,7 +321,7 @@ def _decode_value(cls, schema, value):  # pylint: disable=unused-argument
             # simple type
             v = cls._str_parser(value, is_simple=True)
         else:
-            # compound type
+            # compound type or any type
             # read from file
             path = os.path.expanduser(value)
             if os.path.exists(path):
@@ -264,7 +340,6 @@ def _decode_value(cls, schema, value):  # pylint: disable=unused-argument
                     except Exception as ex:
                         logger.debug(ex)  # log parse json failed expression
                         raise shorthand_ex  # raise shorthand syntax exception
-
         return v
 
 
@@ -324,52 +399,6 @@ def format_data(cls, data):
         raise AAZInvalidValueError(f"dict type value expected, got '{data}'({type(data)})")
 
 
-class AAZFreeFormDictArgAction(AAZSimpleTypeArgAction):
-
-    @classmethod
-    def decode_str(cls, value):
-        from azure.cli.core.util import get_file_json, shell_safe_json_parse, get_file_yaml
-
-        if len(value) == 0:
-            # the express "a=" will return the blank value of schema 'a'
-            return AAZBlankArgValue
-
-        path = os.path.expanduser(value)
-        if os.path.exists(path):
-            if path.endswith('.yml') or path.endswith('.yaml'):
-                # read from yaml file
-                v = get_file_yaml(path)
-            else:
-                # read from json file
-                v = get_file_json(path, preserve_order=True)
-        else:
-            try:
-                v = shell_safe_json_parse(value, True)
-            except Exception as ex:
-                logger.debug(ex)  # log parse json failed expression
-                raise
-        return v
-
-    @classmethod
-    def format_data(cls, data):
-        if data == AAZBlankArgValue:
-            if cls._schema._blank == AAZUndefined:
-                raise AAZInvalidValueError("argument value cannot be blank")
-            assert not isinstance(cls._schema._blank, AAZPromptInput), "Prompt input is not supported in " \
-                                                                       "FreeFormDict args."
-            data = copy.deepcopy(cls._schema._blank)
-
-        if isinstance(data, dict):
-            return data
-
-        if data is None:
-            if cls._schema._nullable:
-                return data
-            raise AAZInvalidValueError("field is not nullable")
-
-        raise AAZInvalidValueError(f"dict type value expected, got '{data}'({type(data)})")
-
-
 class AAZListArgAction(AAZCompoundTypeArgAction):
 
     def __call__(self, parser, namespace, values, option_string=None):

src/azure-cli-core/azure/cli/core/aaz/_arg_fmt.py

@@ -466,32 +466,9 @@ def __call__(self, ctx, value):
         return value
 
 
-class AAZFreeFormDictArgFormat(AAZBaseArgFormat):
-
-    def __init__(self, max_properties=None, min_properties=None):
-        self._max_properties = max_properties
-        self._min_properties = min_properties
-
-    def __call__(self, ctx, value):
-        assert isinstance(value, AAZFreeFormDict)
-        data = value._data
-        if data == AAZUndefined or data is None:
-            return value
-
-        assert isinstance(data, dict)
-
-        if value._is_patch:
-            return value
-
-        if self._min_properties and len(value) < self._min_properties:
-            raise AAZInvalidArgValueError(
-                f"Invalid format: dict length is less than {self._min_properties}")
-
-        if self._max_properties and len(value) > self._max_properties:
-            raise AAZInvalidArgValueError(
-                f"Invalid format: dict length is greater than {self._max_properties}")
-
-        return value
+# Warning: This type should not be used any more, the new aaz-dev-tools only use AAZDictArgFormat
+class AAZFreeFormDictArgFormat(AAZDictArgFormat):
+    pass
 
 
 class AAZListArgFormat(AAZBaseArgFormat):

src/azure-cli-core/azure/cli/core/aaz/_field_type.py

@@ -9,7 +9,7 @@
 from azure.cli.core.util import shell_safe_json_parse
 from ._base import AAZBaseType, AAZValuePatch, AAZUndefined
 from ._field_value import AAZObject, AAZDict, AAZFreeFormDict, AAZList, AAZSimpleValue, \
-    AAZIdentityObject
+    AAZIdentityObject, AAZAnyValue
 from ._utils import to_snack_case
 from .exceptions import AAZUnknownFieldError, AAZConflictFieldDefinitionError, AAZValuePrecisionLossError, \
     AAZInvalidFieldError, AAZInvalidValueError
@@ -111,6 +111,41 @@ def process_data(self, data, **kwargs):
         return data
 
 
+class AAZAnyType(AAZSimpleType):
+    """Any type"""
+
+    _ValueCls = AAZAnyValue
+
+    def process_data(self, data, **kwargs):
+        if isinstance(data, (AAZObject, AAZDict, AAZList)):
+            # convert them to simple dict, list, None or AAZUndefined values
+            value = data.to_serialized_data()
+            # TODO: may need to add warnings or raise error when treat the patch assign into the full assign.
+            # for the code gen commands it will not happen as the any type args only support full assign.
+            # but for the customization code, this will happen when convert AAZCompoundTypeArg to AAZAnyTypeArg
+            # if data._is_patch and isinstance(value, (dict, list)) and len(value):
+            #     pass
+            data = value
+
+        if data == None:  # noqa: E711, pylint: disable=singleton-comparison
+            # data can be None or AAZSimpleValue == None
+            if self._nullable:
+                return None
+            return AAZValuePatch.build(self)
+
+        if data == AAZUndefined:
+            return AAZValuePatch.build(self)
+
+        if isinstance(data, AAZSimpleValue):
+            if data._is_patch:
+                # return value patch
+                return AAZValuePatch.build(self)
+
+            return data._data
+
+        return data
+
+
 # compound types
 class AAZObjectType(AAZBaseType):
     """Object value type"""
@@ -355,14 +390,17 @@ def Element(self, value):
     def __getitem__(self, key):
         return self.Element
 
-
-class AAZFreeFormDictType(AAZBaseDictType):
+# Warning: This type should not be used any more, the new aaz-dev-tools only use AAZDictType with AAZAnyType
+class AAZFreeFormDictType(AAZDictType):
     """Free form dict value type"""
 
     _ValueCls = AAZFreeFormDict
 
-    def __getitem__(self, key):
-        return None
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        # for backward compatible, so support nullable for any type.
+        # from the new code gen tools, it will avoid using AAZFreeFormDictType
+        self._element = AAZAnyType(nullable=True)
 
 
 class AAZListType(AAZBaseType):