[core] set value of dict property not working (#44435)

Author: iscai-msft

sdk/core/azure-core/tests/specs/modeltypes/main.tsp

@@ -17,8 +17,8 @@ model Scratch {
 model FlattenModel {
   name: string;
 
-  #suppress "deprecated" "@flattenProperty decorator is not recommended to use."
-  @flattenProperty
+  #suppress "@azure-tools/typespec-azure-core/no-legacy-usage" "Testing backcompat"
+  @Azure.ClientGenerator.Core.Legacy.flattenProperty
   properties: PropertiesModel;
 }
 
@@ -86,3 +86,21 @@ model RecursiveElement extends Element {
 model Element {
   recursiveElement?: RecursiveElement[];
 }
+
+model BackcompatModel {
+  keys: Record<string>;
+}
+
+@alternateType(
+  {
+    identity: "geojson.Feature",
+    package: "geojson",
+    minVersion: "3.2.0",
+  },
+  "python"
+)
+model Feature {
+  type: "Feature";
+  properties: Record<unknown>;
+  id?: string | numeric;
+}

sdk/core/azure-core/tests/specs_sdk/modeltypes/apiview-properties.json

@@ -1,6 +1,7 @@
 {
     "CrossLanguagePackageId": "",
     "CrossLanguageDefinitionId": {
+        "modeltypes.models.BackcompatModel": "ModelTypes.BackcompatModel",
         "modeltypes.models.ClientNameAndJsonEncodedNameModel": "ModelTypes.ClientNameAndJsonEncodedNameModel",
         "modeltypes.models.Element": "ModelTypes.Element",
         "modeltypes.models.Fish": "ModelTypes.Fish",

sdk/core/azure-core/tests/specs_sdk/modeltypes/modeltypes/_utils/model_base.py

@@ -21,7 +21,6 @@
 import sys
 import codecs
 from typing import (
-    Dict,
     Any,
     cast,
     Optional,
@@ -31,7 +30,6 @@
     Mapping,
     Callable,
     MutableMapping,
-    List,
 )
 
 try:
@@ -229,12 +227,12 @@ class Model:
     serialization and deserialization.
     """
 
-    _subtype_map: Dict[str, Dict[str, Any]] = {}
-    _attribute_map: Dict[str, Dict[str, Any]] = {}
-    _validation: Dict[str, Dict[str, Any]] = {}
+    _subtype_map: dict[str, dict[str, Any]] = {}
+    _attribute_map: dict[str, dict[str, Any]] = {}
+    _validation: dict[str, dict[str, Any]] = {}
 
     def __init__(self, **kwargs: Any) -> None:
-        self.additional_properties: Optional[Dict[str, Any]] = {}
+        self.additional_properties: Optional[dict[str, Any]] = {}
         for k in kwargs:  # pylint: disable=consider-using-dict-items
             if k not in self._attribute_map:
                 _LOGGER.warning("%s is not a known attribute of class %s and will be ignored", k, self.__class__)
@@ -311,7 +309,7 @@ def serialize(self, keep_readonly: bool = False, **kwargs: Any) -> JSON:
     def as_dict(
         self,
         keep_readonly: bool = True,
-        key_transformer: Callable[[str, Dict[str, Any], Any], Any] = attribute_transformer,
+        key_transformer: Callable[[str, dict[str, Any], Any], Any] = attribute_transformer,
         **kwargs: Any
     ) -> JSON:
         """Return a dict that can be serialized using json.dump.
@@ -380,7 +378,7 @@ def deserialize(cls, data: Any, content_type: Optional[str] = None) -> Self:
     def from_dict(
         cls,
         data: Any,
-        key_extractors: Optional[Callable[[str, Dict[str, Any], Any], Any]] = None,
+        key_extractors: Optional[Callable[[str, dict[str, Any], Any], Any]] = None,
         content_type: Optional[str] = None,
     ) -> Self:
         """Parse a dict using given key extractor return a model.
@@ -414,7 +412,7 @@ def _flatten_subtype(cls, key, objects):
             return {}
         result = dict(cls._subtype_map[key])
         for valuetype in cls._subtype_map[key].values():
-            result.update(objects[valuetype]._flatten_subtype(key, objects))  # pylint: disable=protected-access
+            result |= objects[valuetype]._flatten_subtype(key, objects)  # pylint: disable=protected-access
         return result
 
     @classmethod
@@ -528,7 +526,7 @@ def __init__(self, classes: Optional[Mapping[str, type]] = None) -> None:
             "[]": self.serialize_iter,
             "{}": self.serialize_dict,
         }
-        self.dependencies: Dict[str, type] = dict(classes) if classes else {}
+        self.dependencies: dict[str, type] = dict(classes) if classes else {}
         self.key_transformer = full_restapi_key_transformer
         self.client_side_validation = True
 
@@ -579,7 +577,7 @@ def _serialize(  # pylint: disable=too-many-nested-blocks, too-many-branches, to
 
                 if attr_name == "additional_properties" and attr_desc["key"] == "":
                     if target_obj.additional_properties is not None:
-                        serialized.update(target_obj.additional_properties)
+                        serialized |= target_obj.additional_properties
                     continue
                 try:
 
@@ -789,7 +787,7 @@ def serialize_data(self, data, data_type, **kwargs):
 
             # If dependencies is empty, try with current data class
             # It has to be a subclass of Enum anyway
-            enum_type = self.dependencies.get(data_type, data.__class__)
+            enum_type = self.dependencies.get(data_type, cast(type, data.__class__))
             if issubclass(enum_type, Enum):
                 return Serializer.serialize_enum(data, enum_obj=enum_type)
 
@@ -823,13 +821,20 @@ def serialize_basic(cls, data, data_type, **kwargs):
         :param str data_type: Type of object in the iterable.
         :rtype: str, int, float, bool
         :return: serialized object
+        :raises TypeError: raise if data_type is not one of str, int, float, bool.
         """
         custom_serializer = cls._get_custom_serializers(data_type, **kwargs)
         if custom_serializer:
             return custom_serializer(data)
         if data_type == "str":
             return cls.serialize_unicode(data)
-        return eval(data_type)(data)  # nosec # pylint: disable=eval-used
+        if data_type == "int":
+            return int(data)
+        if data_type == "float":
+            return float(data)
+        if data_type == "bool":
+            return bool(data)
+        raise TypeError("Unknown basic data type: {}".format(data_type))
 
     @classmethod
     def serialize_unicode(cls, data):
@@ -1184,7 +1189,7 @@ def rest_key_extractor(attr, attr_desc, data):  # pylint: disable=unused-argumen
 
     while "." in key:
         # Need the cast, as for some reasons "split" is typed as list[str | Any]
-        dict_keys = cast(List[str], _FLATTEN.split(key))
+        dict_keys = cast(list[str], _FLATTEN.split(key))
         if len(dict_keys) == 1:
             key = _decode_attribute_map_key(dict_keys[0])
             break
@@ -1386,7 +1391,7 @@ def __init__(self, classes: Optional[Mapping[str, type]] = None) -> None:
             "duration": (isodate.Duration, datetime.timedelta),
             "iso-8601": (datetime.datetime),
         }
-        self.dependencies: Dict[str, type] = dict(classes) if classes else {}
+        self.dependencies: dict[str, type] = dict(classes) if classes else {}
         self.key_extractors = [rest_key_extractor, xml_key_extractor]
         # Additional properties only works if the "rest_key_extractor" is used to
         # extract the keys. Making it to work whatever the key extractor is too much
@@ -1759,7 +1764,7 @@ def deserialize_basic(self, attr, data_type):  # pylint: disable=too-many-return
         :param str data_type: deserialization data type.
         :return: Deserialized basic type.
         :rtype: str, int, float or bool
-        :raises TypeError: if string format is not valid.
+        :raises TypeError: if string format is not valid or data_type is not one of str, int, float, bool.
         """
         # If we're here, data is supposed to be a basic type.
         # If it's still an XML node, take the text
@@ -1785,7 +1790,11 @@ def deserialize_basic(self, attr, data_type):  # pylint: disable=too-many-return
 
         if data_type == "str":
             return self.deserialize_unicode(attr)
-        return eval(data_type)(attr)  # nosec # pylint: disable=eval-used
+        if data_type == "int":
+            return int(attr)
+        if data_type == "float":
+            return float(attr)
+        raise TypeError("Unknown basic data type: {}".format(data_type))
 
     @staticmethod
     def deserialize_unicode(data):

sdk/core/azure-core/tests/specs_sdk/modeltypes/modeltypes/_utils/serialization.py

@@ -14,6 +14,7 @@
 
 
 from ._models import (  # type: ignore
+    BackcompatModel,
     ClientNameAndJsonEncodedNameModel,
     Element,
     Fish,
@@ -32,6 +33,7 @@
 from ._patch import patch_sdk as _patch_sdk
 
 __all__ = [
+    "BackcompatModel",
     "ClientNameAndJsonEncodedNameModel",
     "Element",
     "Fish",

sdk/core/azure-core/tests/specs_sdk/modeltypes/modeltypes/models/__init__.py

@@ -8,14 +8,44 @@
 # --------------------------------------------------------------------------
 # pylint: disable=useless-super-delegation
 
-from typing import Any, Dict, List, Literal, Mapping, Optional, TYPE_CHECKING, overload
+from typing import Any, Literal, Mapping, Optional, TYPE_CHECKING, overload
 
 from .._utils.model_base import Model as _Model, rest_discriminator, rest_field
 
 if TYPE_CHECKING:
     from .. import models as _models
 
 
+class BackcompatModel(_Model):
+    """BackcompatModel.
+
+    :ivar keys_property: Required.
+    :vartype keys_property: dict[str, str]
+    """
+
+    keys_property: dict[str, str] = rest_field(
+        name="keys", visibility=["read", "create", "update", "delete", "query"], original_tsp_name="keys"
+    )
+    """Required."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        keys_property: dict[str, str],
+    ) -> None: ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]) -> None:
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+
+
 class ClientNameAndJsonEncodedNameModel(_Model):
     """Model with a property that has a client name.
 
@@ -51,15 +81,15 @@ class Element(_Model):
     :vartype recursive_element: list[~modeltypes.models.RecursiveElement]
     """
 
-    recursive_element: Optional[List["_models.RecursiveElement"]] = rest_field(
+    recursive_element: Optional[list["_models.RecursiveElement"]] = rest_field(
         name="recursiveElement", visibility=["read", "create", "update", "delete", "query"]
     )
 
     @overload
     def __init__(
         self,
         *,
-        recursive_element: Optional[List["_models.RecursiveElement"]] = None,
+        recursive_element: Optional[list["_models.RecursiveElement"]] = None,
     ) -> None: ...
 
     @overload
@@ -85,7 +115,7 @@ class Fish(_Model):
     :vartype age: int
     """
 
-    __mapping__: Dict[str, _Model] = {}
+    __mapping__: dict[str, _Model] = {}
     kind: str = rest_discriminator(name="kind")
     """Discriminator property for Fish. Required. Default value is None."""
     age: int = rest_field(visibility=["read", "create", "update", "delete", "query"])
@@ -178,7 +208,7 @@ class Shark(Fish, discriminator="shark"):
     :vartype shark_type: str
     """
 
-    __mapping__: Dict[str, _Model] = {}
+    __mapping__: dict[str, _Model] = {}
     kind: Literal["shark"] = rest_discriminator(name="kind", visibility=["read", "create", "update", "delete", "query"])  # type: ignore
     """Required. Default value is \"shark\"."""
     shark_type: str = rest_discriminator(name="sharkType", visibility=["read", "create", "update", "delete", "query"])
@@ -200,7 +230,8 @@ def __init__(self, mapping: Mapping[str, Any]) -> None:
         """
 
     def __init__(self, *args: Any, **kwargs: Any) -> None:
-        super().__init__(*args, kind="shark", **kwargs)
+        super().__init__(*args, **kwargs)
+        self.kind = "shark"  # type: ignore
 
 
 class GoblinShark(Shark, discriminator="goblin"):
@@ -214,7 +245,7 @@ class GoblinShark(Shark, discriminator="goblin"):
     :vartype shark_type: str
     """
 
-    __mapping__: Dict[str, _Model] = {}
+    __mapping__: dict[str, _Model] = {}
     shark_type: Literal["goblin"] = rest_discriminator(name="sharkType", visibility=["read", "create", "update", "delete", "query"])  # type: ignore
     """Required. Default value is \"goblin\"."""
 
@@ -233,7 +264,8 @@ def __init__(self, mapping: Mapping[str, Any]) -> None:
         """
 
     def __init__(self, *args: Any, **kwargs: Any) -> None:
-        super().__init__(*args, shark_type="goblin", **kwargs)
+        super().__init__(*args, **kwargs)
+        self.shark_type = "goblin"  # type: ignore
 
 
 class PropertiesModel(_Model):
@@ -326,8 +358,8 @@ class Salmon(Fish, discriminator="salmon"):
 
     kind: Literal["salmon"] = rest_discriminator(name="kind", visibility=["read", "create", "update", "delete", "query"])  # type: ignore
     """Required. Default value is \"salmon\"."""
-    friends: Optional[List["_models.Fish"]] = rest_field(visibility=["read", "create", "update", "delete", "query"])
-    hate: Optional[Dict[str, "_models.Fish"]] = rest_field(visibility=["read", "create", "update", "delete", "query"])
+    friends: Optional[list["_models.Fish"]] = rest_field(visibility=["read", "create", "update", "delete", "query"])
+    hate: Optional[dict[str, "_models.Fish"]] = rest_field(visibility=["read", "create", "update", "delete", "query"])
     life_partner: Optional["_models.Fish"] = rest_field(
         name="lifePartner", visibility=["read", "create", "update", "delete", "query"]
     )
@@ -337,8 +369,8 @@ def __init__(
         self,
         *,
         age: int,
-        friends: Optional[List["_models.Fish"]] = None,
-        hate: Optional[Dict[str, "_models.Fish"]] = None,
+        friends: Optional[list["_models.Fish"]] = None,
+        hate: Optional[dict[str, "_models.Fish"]] = None,
         life_partner: Optional["_models.Fish"] = None,
     ) -> None: ...
 
@@ -350,7 +382,8 @@ def __init__(self, mapping: Mapping[str, Any]) -> None:
         """
 
     def __init__(self, *args: Any, **kwargs: Any) -> None:
-        super().__init__(*args, kind="salmon", **kwargs)
+        super().__init__(*args, **kwargs)
+        self.kind = "salmon"  # type: ignore
 
 
 class SawShark(Shark, discriminator="saw"):
@@ -364,7 +397,7 @@ class SawShark(Shark, discriminator="saw"):
     :vartype shark_type: str
     """
 
-    __mapping__: Dict[str, _Model] = {}
+    __mapping__: dict[str, _Model] = {}
     shark_type: Literal["saw"] = rest_discriminator(name="sharkType", visibility=["read", "create", "update", "delete", "query"])  # type: ignore
     """Required. Default value is \"saw\"."""
 
@@ -383,7 +416,8 @@ def __init__(self, mapping: Mapping[str, Any]) -> None:
         """
 
     def __init__(self, *args: Any, **kwargs: Any) -> None:
-        super().__init__(*args, shark_type="saw", **kwargs)
+        super().__init__(*args, **kwargs)
+        self.shark_type = "saw"  # type: ignore
 
 
 class Scratch(_Model):