diff --git a/.chronus/changes/auto-iscai-msft-python-fixDictSetting-2025-11-16-14-5-28.md b/.chronus/changes/auto-iscai-msft-python-fixDictSetting-2025-11-16-14-5-28.md new file mode 100644 index 00000000000..133ef3a7b04 --- /dev/null +++ b/.chronus/changes/auto-iscai-msft-python-fixDictSetting-2025-11-16-14-5-28.md @@ -0,0 +1,8 @@ +--- +changeKind: fix +packages: + - "@autorest/python" + - "@azure-tools/typespec-python" +--- + +Persist mutations to mutable properties when accessed via attribute syntax \ No newline at end of file diff --git a/packages/typespec-python/test/azure/generated/authentication-api-key/authentication/apikey/_utils/model_base.py b/packages/typespec-python/test/azure/generated/authentication-api-key/authentication/apikey/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/authentication-api-key/authentication/apikey/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/authentication-api-key/authentication/apikey/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/authentication-http-custom/authentication/http/custom/_utils/model_base.py b/packages/typespec-python/test/azure/generated/authentication-http-custom/authentication/http/custom/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/authentication-http-custom/authentication/http/custom/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/authentication-http-custom/authentication/http/custom/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/authentication-oauth2/authentication/oauth2/_utils/model_base.py b/packages/typespec-python/test/azure/generated/authentication-oauth2/authentication/oauth2/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/authentication-oauth2/authentication/oauth2/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/authentication-oauth2/authentication/oauth2/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/authentication-union/authentication/union/_utils/model_base.py b/packages/typespec-python/test/azure/generated/authentication-union/authentication/union/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/authentication-union/authentication/union/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/authentication-union/authentication/union/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/azure-client-generator-core-access/specs/azure/clientgenerator/core/access/_utils/model_base.py b/packages/typespec-python/test/azure/generated/azure-client-generator-core-access/specs/azure/clientgenerator/core/access/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/azure-client-generator-core-access/specs/azure/clientgenerator/core/access/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/azure-client-generator-core-access/specs/azure/clientgenerator/core/access/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/azure-client-generator-core-alternate-type/specs/azure/clientgenerator/core/alternatetype/_utils/model_base.py b/packages/typespec-python/test/azure/generated/azure-client-generator-core-alternate-type/specs/azure/clientgenerator/core/alternatetype/_utils/model_base.py index c0384642a72..528ba8fe390 100644 --- a/packages/typespec-python/test/azure/generated/azure-client-generator-core-alternate-type/specs/azure/clientgenerator/core/alternatetype/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/azure-client-generator-core-alternate-type/specs/azure/clientgenerator/core/alternatetype/_utils/model_base.py @@ -378,6 +378,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1062,9 +1071,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/azure-client-generator-core-api-version-header/client/alternateapiversion/service/header/_utils/model_base.py b/packages/typespec-python/test/azure/generated/azure-client-generator-core-api-version-header/client/alternateapiversion/service/header/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/azure-client-generator-core-api-version-header/client/alternateapiversion/service/header/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/azure-client-generator-core-api-version-header/client/alternateapiversion/service/header/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/azure-client-generator-core-api-version-path/client/alternateapiversion/service/path/_utils/model_base.py b/packages/typespec-python/test/azure/generated/azure-client-generator-core-api-version-path/client/alternateapiversion/service/path/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/azure-client-generator-core-api-version-path/client/alternateapiversion/service/path/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/azure-client-generator-core-api-version-path/client/alternateapiversion/service/path/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/azure-client-generator-core-api-version-query/client/alternateapiversion/service/query/_utils/model_base.py b/packages/typespec-python/test/azure/generated/azure-client-generator-core-api-version-query/client/alternateapiversion/service/query/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/azure-client-generator-core-api-version-query/client/alternateapiversion/service/query/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/azure-client-generator-core-api-version-query/client/alternateapiversion/service/query/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/azure-client-generator-core-client-initialization/specs/azure/clientgenerator/core/clientinitialization/_utils/model_base.py b/packages/typespec-python/test/azure/generated/azure-client-generator-core-client-initialization/specs/azure/clientgenerator/core/clientinitialization/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/azure-client-generator-core-client-initialization/specs/azure/clientgenerator/core/clientinitialization/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/azure-client-generator-core-client-initialization/specs/azure/clientgenerator/core/clientinitialization/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/azure-client-generator-core-client-location/specs/azure/clientgenerator/core/clientlocation/_utils/model_base.py b/packages/typespec-python/test/azure/generated/azure-client-generator-core-client-location/specs/azure/clientgenerator/core/clientlocation/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/azure-client-generator-core-client-location/specs/azure/clientgenerator/core/clientlocation/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/azure-client-generator-core-client-location/specs/azure/clientgenerator/core/clientlocation/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/azure-client-generator-core-deserialize-empty-string-as-null/specs/azure/clientgenerator/core/emptystring/_utils/model_base.py b/packages/typespec-python/test/azure/generated/azure-client-generator-core-deserialize-empty-string-as-null/specs/azure/clientgenerator/core/emptystring/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/azure-client-generator-core-deserialize-empty-string-as-null/specs/azure/clientgenerator/core/emptystring/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/azure-client-generator-core-deserialize-empty-string-as-null/specs/azure/clientgenerator/core/emptystring/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/azure-client-generator-core-flatten-property/specs/azure/clientgenerator/core/flattenproperty/_utils/model_base.py b/packages/typespec-python/test/azure/generated/azure-client-generator-core-flatten-property/specs/azure/clientgenerator/core/flattenproperty/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/azure-client-generator-core-flatten-property/specs/azure/clientgenerator/core/flattenproperty/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/azure-client-generator-core-flatten-property/specs/azure/clientgenerator/core/flattenproperty/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/azure-client-generator-core-hierarchy-building/specs/azure/clientgenerator/core/hierarchybuilding/_utils/model_base.py b/packages/typespec-python/test/azure/generated/azure-client-generator-core-hierarchy-building/specs/azure/clientgenerator/core/hierarchybuilding/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/azure-client-generator-core-hierarchy-building/specs/azure/clientgenerator/core/hierarchybuilding/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/azure-client-generator-core-hierarchy-building/specs/azure/clientgenerator/core/hierarchybuilding/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/azure-client-generator-core-next-link-verb/specs/azure/clientgenerator/core/nextlinkverb/_utils/model_base.py b/packages/typespec-python/test/azure/generated/azure-client-generator-core-next-link-verb/specs/azure/clientgenerator/core/nextlinkverb/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/azure-client-generator-core-next-link-verb/specs/azure/clientgenerator/core/nextlinkverb/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/azure-client-generator-core-next-link-verb/specs/azure/clientgenerator/core/nextlinkverb/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/azure-client-generator-core-override/specs/azure/clientgenerator/core/override/_utils/model_base.py b/packages/typespec-python/test/azure/generated/azure-client-generator-core-override/specs/azure/clientgenerator/core/override/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/azure-client-generator-core-override/specs/azure/clientgenerator/core/override/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/azure-client-generator-core-override/specs/azure/clientgenerator/core/override/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/azure-client-generator-core-usage/specs/azure/clientgenerator/core/usage/_utils/model_base.py b/packages/typespec-python/test/azure/generated/azure-client-generator-core-usage/specs/azure/clientgenerator/core/usage/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/azure-client-generator-core-usage/specs/azure/clientgenerator/core/usage/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/azure-client-generator-core-usage/specs/azure/clientgenerator/core/usage/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/azure-core-basic/specs/azure/core/basic/_utils/model_base.py b/packages/typespec-python/test/azure/generated/azure-core-basic/specs/azure/core/basic/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/azure-core-basic/specs/azure/core/basic/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/azure-core-basic/specs/azure/core/basic/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/azure-core-lro-rpc/specs/azure/core/lro/rpc/_utils/model_base.py b/packages/typespec-python/test/azure/generated/azure-core-lro-rpc/specs/azure/core/lro/rpc/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/azure-core-lro-rpc/specs/azure/core/lro/rpc/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/azure-core-lro-rpc/specs/azure/core/lro/rpc/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/azure-core-lro-standard/specs/azure/core/lro/standard/_utils/model_base.py b/packages/typespec-python/test/azure/generated/azure-core-lro-standard/specs/azure/core/lro/standard/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/azure-core-lro-standard/specs/azure/core/lro/standard/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/azure-core-lro-standard/specs/azure/core/lro/standard/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/azure-core-model/specs/azure/core/model/_utils/model_base.py b/packages/typespec-python/test/azure/generated/azure-core-model/specs/azure/core/model/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/azure-core-model/specs/azure/core/model/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/azure-core-model/specs/azure/core/model/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/azure-core-page/specs/azure/core/page/_utils/model_base.py b/packages/typespec-python/test/azure/generated/azure-core-page/specs/azure/core/page/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/azure-core-page/specs/azure/core/page/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/azure-core-page/specs/azure/core/page/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/azure-core-scalar/specs/azure/core/scalar/_utils/model_base.py b/packages/typespec-python/test/azure/generated/azure-core-scalar/specs/azure/core/scalar/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/azure-core-scalar/specs/azure/core/scalar/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/azure-core-scalar/specs/azure/core/scalar/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/azure-core-traits/specs/azure/core/traits/_utils/model_base.py b/packages/typespec-python/test/azure/generated/azure-core-traits/specs/azure/core/traits/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/azure-core-traits/specs/azure/core/traits/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/azure-core-traits/specs/azure/core/traits/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/azure-encode-duration/specs/azure/encode/duration/_utils/model_base.py b/packages/typespec-python/test/azure/generated/azure-encode-duration/specs/azure/encode/duration/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/azure-encode-duration/specs/azure/encode/duration/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/azure-encode-duration/specs/azure/encode/duration/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/azure-example-basic/specs/azure/example/basic/_utils/model_base.py b/packages/typespec-python/test/azure/generated/azure-example-basic/specs/azure/example/basic/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/azure-example-basic/specs/azure/example/basic/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/azure-example-basic/specs/azure/example/basic/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/azure-payload-pageable/specs/azure/payload/pageable/_utils/model_base.py b/packages/typespec-python/test/azure/generated/azure-payload-pageable/specs/azure/payload/pageable/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/azure-payload-pageable/specs/azure/payload/pageable/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/azure-payload-pageable/specs/azure/payload/pageable/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/azure-resource-manager-common-properties/azure/resourcemanager/commonproperties/_utils/model_base.py b/packages/typespec-python/test/azure/generated/azure-resource-manager-common-properties/azure/resourcemanager/commonproperties/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/azure-resource-manager-common-properties/azure/resourcemanager/commonproperties/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/azure-resource-manager-common-properties/azure/resourcemanager/commonproperties/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/azure-resource-manager-large-header/azure/resourcemanager/largeheader/_utils/model_base.py b/packages/typespec-python/test/azure/generated/azure-resource-manager-large-header/azure/resourcemanager/largeheader/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/azure-resource-manager-large-header/azure/resourcemanager/largeheader/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/azure-resource-manager-large-header/azure/resourcemanager/largeheader/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/azure-resource-manager-method-subscription-id/azure/resourcemanager/methodsubscriptionid/_utils/model_base.py b/packages/typespec-python/test/azure/generated/azure-resource-manager-method-subscription-id/azure/resourcemanager/methodsubscriptionid/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/azure-resource-manager-method-subscription-id/azure/resourcemanager/methodsubscriptionid/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/azure-resource-manager-method-subscription-id/azure/resourcemanager/methodsubscriptionid/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/azure-resource-manager-non-resource/azure/resourcemanager/nonresource/_utils/model_base.py b/packages/typespec-python/test/azure/generated/azure-resource-manager-non-resource/azure/resourcemanager/nonresource/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/azure-resource-manager-non-resource/azure/resourcemanager/nonresource/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/azure-resource-manager-non-resource/azure/resourcemanager/nonresource/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/azure-resource-manager-operation-templates/azure/resourcemanager/operationtemplates/_utils/model_base.py b/packages/typespec-python/test/azure/generated/azure-resource-manager-operation-templates/azure/resourcemanager/operationtemplates/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/azure-resource-manager-operation-templates/azure/resourcemanager/operationtemplates/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/azure-resource-manager-operation-templates/azure/resourcemanager/operationtemplates/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/azure-resource-manager-resources/azure/resourcemanager/resources/_utils/model_base.py b/packages/typespec-python/test/azure/generated/azure-resource-manager-resources/azure/resourcemanager/resources/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/azure-resource-manager-resources/azure/resourcemanager/resources/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/azure-resource-manager-resources/azure/resourcemanager/resources/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/azure-special-headers-client-request-id/azure/specialheaders/xmsclientrequestid/_utils/model_base.py b/packages/typespec-python/test/azure/generated/azure-special-headers-client-request-id/azure/specialheaders/xmsclientrequestid/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/azure-special-headers-client-request-id/azure/specialheaders/xmsclientrequestid/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/azure-special-headers-client-request-id/azure/specialheaders/xmsclientrequestid/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/azure-versioning-previewversion/specs/azure/versioning/previewversion/_utils/model_base.py b/packages/typespec-python/test/azure/generated/azure-versioning-previewversion/specs/azure/versioning/previewversion/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/azure-versioning-previewversion/specs/azure/versioning/previewversion/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/azure-versioning-previewversion/specs/azure/versioning/previewversion/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/client-namespace/client/clientnamespace/_utils/model_base.py b/packages/typespec-python/test/azure/generated/client-namespace/client/clientnamespace/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/client-namespace/client/clientnamespace/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/client-namespace/client/clientnamespace/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/client-namespace/client/clientnamespace/second/_utils/model_base.py b/packages/typespec-python/test/azure/generated/client-namespace/client/clientnamespace/second/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/client-namespace/client/clientnamespace/second/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/client-namespace/client/clientnamespace/second/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/client-naming-enum-conflict/client/naming/enumconflict/_utils/model_base.py b/packages/typespec-python/test/azure/generated/client-naming-enum-conflict/client/naming/enumconflict/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/client-naming-enum-conflict/client/naming/enumconflict/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/client-naming-enum-conflict/client/naming/enumconflict/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/client-naming/client/naming/main/_utils/model_base.py b/packages/typespec-python/test/azure/generated/client-naming/client/naming/main/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/client-naming/client/naming/main/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/client-naming/client/naming/main/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/client-overload/client/overload/_utils/model_base.py b/packages/typespec-python/test/azure/generated/client-overload/client/overload/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/client-overload/client/overload/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/client-overload/client/overload/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/client-structure-clientoperationgroup/client/structure/clientoperationgroup/_utils/model_base.py b/packages/typespec-python/test/azure/generated/client-structure-clientoperationgroup/client/structure/clientoperationgroup/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/client-structure-clientoperationgroup/client/structure/clientoperationgroup/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/client-structure-clientoperationgroup/client/structure/clientoperationgroup/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/client-structure-default/client/structure/service/_utils/model_base.py b/packages/typespec-python/test/azure/generated/client-structure-default/client/structure/service/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/client-structure-default/client/structure/service/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/client-structure-default/client/structure/service/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/client-structure-multiclient/client/structure/multiclient/_utils/model_base.py b/packages/typespec-python/test/azure/generated/client-structure-multiclient/client/structure/multiclient/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/client-structure-multiclient/client/structure/multiclient/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/client-structure-multiclient/client/structure/multiclient/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/client-structure-renamedoperation/client/structure/renamedoperation/_utils/model_base.py b/packages/typespec-python/test/azure/generated/client-structure-renamedoperation/client/structure/renamedoperation/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/client-structure-renamedoperation/client/structure/renamedoperation/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/client-structure-renamedoperation/client/structure/renamedoperation/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/client-structure-twooperationgroup/client/structure/twooperationgroup/_utils/model_base.py b/packages/typespec-python/test/azure/generated/client-structure-twooperationgroup/client/structure/twooperationgroup/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/client-structure-twooperationgroup/client/structure/twooperationgroup/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/client-structure-twooperationgroup/client/structure/twooperationgroup/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/encode-array/encode/array/_utils/model_base.py b/packages/typespec-python/test/azure/generated/encode-array/encode/array/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/encode-array/encode/array/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/encode-array/encode/array/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/encode-bytes/encode/bytes/_utils/model_base.py b/packages/typespec-python/test/azure/generated/encode-bytes/encode/bytes/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/encode-bytes/encode/bytes/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/encode-bytes/encode/bytes/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/encode-datetime/encode/datetime/_utils/model_base.py b/packages/typespec-python/test/azure/generated/encode-datetime/encode/datetime/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/encode-datetime/encode/datetime/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/encode-datetime/encode/datetime/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/encode-duration/encode/duration/_utils/model_base.py b/packages/typespec-python/test/azure/generated/encode-duration/encode/duration/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/encode-duration/encode/duration/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/encode-duration/encode/duration/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/encode-numeric/encode/numeric/_utils/model_base.py b/packages/typespec-python/test/azure/generated/encode-numeric/encode/numeric/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/encode-numeric/encode/numeric/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/encode-numeric/encode/numeric/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/generation-subdir/generation/subdir/_generated/_utils/model_base.py b/packages/typespec-python/test/azure/generated/generation-subdir/generation/subdir/_generated/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/generation-subdir/generation/subdir/_generated/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/generation-subdir/generation/subdir/_generated/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/headasbooleanfalse/headasbooleanfalse/_utils/model_base.py b/packages/typespec-python/test/azure/generated/headasbooleanfalse/headasbooleanfalse/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/headasbooleanfalse/headasbooleanfalse/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/headasbooleanfalse/headasbooleanfalse/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/headasbooleantrue/headasbooleantrue/_utils/model_base.py b/packages/typespec-python/test/azure/generated/headasbooleantrue/headasbooleantrue/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/headasbooleantrue/headasbooleantrue/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/headasbooleantrue/headasbooleantrue/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/parameters-basic/parameters/basic/_utils/model_base.py b/packages/typespec-python/test/azure/generated/parameters-basic/parameters/basic/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/parameters-basic/parameters/basic/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/parameters-basic/parameters/basic/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/parameters-body-optionality/parameters/bodyoptionality/_utils/model_base.py b/packages/typespec-python/test/azure/generated/parameters-body-optionality/parameters/bodyoptionality/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/parameters-body-optionality/parameters/bodyoptionality/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/parameters-body-optionality/parameters/bodyoptionality/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/parameters-collection-format/parameters/collectionformat/_utils/model_base.py b/packages/typespec-python/test/azure/generated/parameters-collection-format/parameters/collectionformat/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/parameters-collection-format/parameters/collectionformat/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/parameters-collection-format/parameters/collectionformat/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/parameters-path/parameters/path/_utils/model_base.py b/packages/typespec-python/test/azure/generated/parameters-path/parameters/path/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/parameters-path/parameters/path/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/parameters-path/parameters/path/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/parameters-spread/parameters/spread/_utils/model_base.py b/packages/typespec-python/test/azure/generated/parameters-spread/parameters/spread/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/parameters-spread/parameters/spread/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/parameters-spread/parameters/spread/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/payload-content-negotiation/payload/contentnegotiation/_utils/model_base.py b/packages/typespec-python/test/azure/generated/payload-content-negotiation/payload/contentnegotiation/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/payload-content-negotiation/payload/contentnegotiation/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/payload-content-negotiation/payload/contentnegotiation/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/payload-json-merge-patch/payload/jsonmergepatch/_utils/model_base.py b/packages/typespec-python/test/azure/generated/payload-json-merge-patch/payload/jsonmergepatch/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/payload-json-merge-patch/payload/jsonmergepatch/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/payload-json-merge-patch/payload/jsonmergepatch/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/payload-media-type/payload/mediatype/_utils/model_base.py b/packages/typespec-python/test/azure/generated/payload-media-type/payload/mediatype/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/payload-media-type/payload/mediatype/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/payload-media-type/payload/mediatype/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/payload-multipart/payload/multipart/_utils/model_base.py b/packages/typespec-python/test/azure/generated/payload-multipart/payload/multipart/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/payload-multipart/payload/multipart/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/payload-multipart/payload/multipart/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/payload-pageable/payload/pageable/_utils/model_base.py b/packages/typespec-python/test/azure/generated/payload-pageable/payload/pageable/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/payload-pageable/payload/pageable/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/payload-pageable/payload/pageable/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/payload-xml/payload/xml/_utils/model_base.py b/packages/typespec-python/test/azure/generated/payload-xml/payload/xml/_utils/model_base.py index 469d16c7122..c2065c870d8 100644 --- a/packages/typespec-python/test/azure/generated/payload-xml/payload/xml/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/payload-xml/payload/xml/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1065,9 +1074,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/resiliency-srv-driven1/resiliency/srv/driven1/_utils/model_base.py b/packages/typespec-python/test/azure/generated/resiliency-srv-driven1/resiliency/srv/driven1/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/resiliency-srv-driven1/resiliency/srv/driven1/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/resiliency-srv-driven1/resiliency/srv/driven1/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/resiliency-srv-driven2/resiliency/srv/driven2/_utils/model_base.py b/packages/typespec-python/test/azure/generated/resiliency-srv-driven2/resiliency/srv/driven2/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/resiliency-srv-driven2/resiliency/srv/driven2/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/resiliency-srv-driven2/resiliency/srv/driven2/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/response-status-code-range/response/statuscoderange/_utils/model_base.py b/packages/typespec-python/test/azure/generated/response-status-code-range/response/statuscoderange/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/response-status-code-range/response/statuscoderange/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/response-status-code-range/response/statuscoderange/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/routes/routes/_utils/model_base.py b/packages/typespec-python/test/azure/generated/routes/routes/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/routes/routes/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/routes/routes/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/serialization-encoded-name-json/serialization/encodedname/json/_utils/model_base.py b/packages/typespec-python/test/azure/generated/serialization-encoded-name-json/serialization/encodedname/json/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/serialization-encoded-name-json/serialization/encodedname/json/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/serialization-encoded-name-json/serialization/encodedname/json/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/server-endpoint-not-defined/server/endpoint/notdefined/_utils/model_base.py b/packages/typespec-python/test/azure/generated/server-endpoint-not-defined/server/endpoint/notdefined/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/server-endpoint-not-defined/server/endpoint/notdefined/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/server-endpoint-not-defined/server/endpoint/notdefined/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/server-path-multiple/server/path/multiple/_utils/model_base.py b/packages/typespec-python/test/azure/generated/server-path-multiple/server/path/multiple/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/server-path-multiple/server/path/multiple/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/server-path-multiple/server/path/multiple/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/server-path-single/server/path/single/_utils/model_base.py b/packages/typespec-python/test/azure/generated/server-path-single/server/path/single/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/server-path-single/server/path/single/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/server-path-single/server/path/single/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/server-versions-not-versioned/server/versions/notversioned/_utils/model_base.py b/packages/typespec-python/test/azure/generated/server-versions-not-versioned/server/versions/notversioned/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/server-versions-not-versioned/server/versions/notversioned/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/server-versions-not-versioned/server/versions/notversioned/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/server-versions-versioned/server/versions/versioned/_utils/model_base.py b/packages/typespec-python/test/azure/generated/server-versions-versioned/server/versions/versioned/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/server-versions-versioned/server/versions/versioned/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/server-versions-versioned/server/versions/versioned/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/setuppy-authentication-union/setuppy/authentication/union/_utils/model_base.py b/packages/typespec-python/test/azure/generated/setuppy-authentication-union/setuppy/authentication/union/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/setuppy-authentication-union/setuppy/authentication/union/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/setuppy-authentication-union/setuppy/authentication/union/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/special-headers-conditional-request/specialheaders/conditionalrequest/_utils/model_base.py b/packages/typespec-python/test/azure/generated/special-headers-conditional-request/specialheaders/conditionalrequest/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/special-headers-conditional-request/specialheaders/conditionalrequest/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/special-headers-conditional-request/specialheaders/conditionalrequest/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/special-headers-repeatability/specialheaders/repeatability/_utils/model_base.py b/packages/typespec-python/test/azure/generated/special-headers-repeatability/specialheaders/repeatability/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/special-headers-repeatability/specialheaders/repeatability/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/special-headers-repeatability/specialheaders/repeatability/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/special-words/specialwords/_utils/model_base.py b/packages/typespec-python/test/azure/generated/special-words/specialwords/_utils/model_base.py index 469d16c7122..c2065c870d8 100644 --- a/packages/typespec-python/test/azure/generated/special-words/specialwords/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/special-words/specialwords/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1065,9 +1074,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/specs-documentation/specs/documentation/_utils/model_base.py b/packages/typespec-python/test/azure/generated/specs-documentation/specs/documentation/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/specs-documentation/specs/documentation/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/specs-documentation/specs/documentation/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/streaming-jsonl/streaming/jsonl/_utils/model_base.py b/packages/typespec-python/test/azure/generated/streaming-jsonl/streaming/jsonl/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/streaming-jsonl/streaming/jsonl/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/streaming-jsonl/streaming/jsonl/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/typetest-array/typetest/array/_utils/model_base.py b/packages/typespec-python/test/azure/generated/typetest-array/typetest/array/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/typetest-array/typetest/array/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/typetest-array/typetest/array/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/typetest-dictionary/typetest/dictionary/_utils/model_base.py b/packages/typespec-python/test/azure/generated/typetest-dictionary/typetest/dictionary/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/typetest-dictionary/typetest/dictionary/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/typetest-dictionary/typetest/dictionary/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/typetest-enum-extensible/typetest/enum/extensible/_utils/model_base.py b/packages/typespec-python/test/azure/generated/typetest-enum-extensible/typetest/enum/extensible/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/typetest-enum-extensible/typetest/enum/extensible/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/typetest-enum-extensible/typetest/enum/extensible/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/typetest-enum-fixed/typetest/enum/fixed/_utils/model_base.py b/packages/typespec-python/test/azure/generated/typetest-enum-fixed/typetest/enum/fixed/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/typetest-enum-fixed/typetest/enum/fixed/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/typetest-enum-fixed/typetest/enum/fixed/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/typetest-model-empty/typetest/model/empty/_utils/model_base.py b/packages/typespec-python/test/azure/generated/typetest-model-empty/typetest/model/empty/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/typetest-model-empty/typetest/model/empty/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/typetest-model-empty/typetest/model/empty/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/typetest-model-enumdiscriminator/typetest/model/enumdiscriminator/_utils/model_base.py b/packages/typespec-python/test/azure/generated/typetest-model-enumdiscriminator/typetest/model/enumdiscriminator/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/typetest-model-enumdiscriminator/typetest/model/enumdiscriminator/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/typetest-model-enumdiscriminator/typetest/model/enumdiscriminator/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/typetest-model-nesteddiscriminator/typetest/model/nesteddiscriminator/_utils/model_base.py b/packages/typespec-python/test/azure/generated/typetest-model-nesteddiscriminator/typetest/model/nesteddiscriminator/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/typetest-model-nesteddiscriminator/typetest/model/nesteddiscriminator/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/typetest-model-nesteddiscriminator/typetest/model/nesteddiscriminator/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/typetest-model-notdiscriminated/typetest/model/notdiscriminated/_utils/model_base.py b/packages/typespec-python/test/azure/generated/typetest-model-notdiscriminated/typetest/model/notdiscriminated/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/typetest-model-notdiscriminated/typetest/model/notdiscriminated/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/typetest-model-notdiscriminated/typetest/model/notdiscriminated/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/typetest-model-recursive/typetest/model/recursive/_utils/model_base.py b/packages/typespec-python/test/azure/generated/typetest-model-recursive/typetest/model/recursive/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/typetest-model-recursive/typetest/model/recursive/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/typetest-model-recursive/typetest/model/recursive/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/typetest-model-singlediscriminator/typetest/model/singlediscriminator/_utils/model_base.py b/packages/typespec-python/test/azure/generated/typetest-model-singlediscriminator/typetest/model/singlediscriminator/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/typetest-model-singlediscriminator/typetest/model/singlediscriminator/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/typetest-model-singlediscriminator/typetest/model/singlediscriminator/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/typetest-model-usage/typetest/model/usage/_utils/model_base.py b/packages/typespec-python/test/azure/generated/typetest-model-usage/typetest/model/usage/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/typetest-model-usage/typetest/model/usage/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/typetest-model-usage/typetest/model/usage/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/typetest-model-visibility/typetest/model/visibility/_utils/model_base.py b/packages/typespec-python/test/azure/generated/typetest-model-visibility/typetest/model/visibility/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/typetest-model-visibility/typetest/model/visibility/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/typetest-model-visibility/typetest/model/visibility/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/typetest-property-additionalproperties/typetest/property/additionalproperties/_utils/model_base.py b/packages/typespec-python/test/azure/generated/typetest-property-additionalproperties/typetest/property/additionalproperties/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/typetest-property-additionalproperties/typetest/property/additionalproperties/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/typetest-property-additionalproperties/typetest/property/additionalproperties/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/typetest-property-nullable/typetest/property/nullable/_utils/model_base.py b/packages/typespec-python/test/azure/generated/typetest-property-nullable/typetest/property/nullable/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/typetest-property-nullable/typetest/property/nullable/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/typetest-property-nullable/typetest/property/nullable/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/typetest-property-optional/typetest/property/optional/_utils/model_base.py b/packages/typespec-python/test/azure/generated/typetest-property-optional/typetest/property/optional/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/typetest-property-optional/typetest/property/optional/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/typetest-property-optional/typetest/property/optional/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/typetest-property-valuetypes/typetest/property/valuetypes/_utils/model_base.py b/packages/typespec-python/test/azure/generated/typetest-property-valuetypes/typetest/property/valuetypes/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/typetest-property-valuetypes/typetest/property/valuetypes/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/typetest-property-valuetypes/typetest/property/valuetypes/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/typetest-scalar/typetest/scalar/_utils/model_base.py b/packages/typespec-python/test/azure/generated/typetest-scalar/typetest/scalar/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/typetest-scalar/typetest/scalar/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/typetest-scalar/typetest/scalar/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/typetest-union/typetest/union/_utils/model_base.py b/packages/typespec-python/test/azure/generated/typetest-union/typetest/union/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/typetest-union/typetest/union/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/typetest-union/typetest/union/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/versioning-added/versioning/added/_utils/model_base.py b/packages/typespec-python/test/azure/generated/versioning-added/versioning/added/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/versioning-added/versioning/added/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/versioning-added/versioning/added/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/versioning-madeoptional/versioning/madeoptional/_utils/model_base.py b/packages/typespec-python/test/azure/generated/versioning-madeoptional/versioning/madeoptional/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/versioning-madeoptional/versioning/madeoptional/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/versioning-madeoptional/versioning/madeoptional/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/versioning-removed/versioning/removed/_utils/model_base.py b/packages/typespec-python/test/azure/generated/versioning-removed/versioning/removed/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/versioning-removed/versioning/removed/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/versioning-removed/versioning/removed/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/versioning-renamedfrom/versioning/renamedfrom/_utils/model_base.py b/packages/typespec-python/test/azure/generated/versioning-renamedfrom/versioning/renamedfrom/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/versioning-renamedfrom/versioning/renamedfrom/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/versioning-renamedfrom/versioning/renamedfrom/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/versioning-returntypechangedfrom/versioning/returntypechangedfrom/_utils/model_base.py b/packages/typespec-python/test/azure/generated/versioning-returntypechangedfrom/versioning/returntypechangedfrom/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/versioning-returntypechangedfrom/versioning/returntypechangedfrom/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/versioning-returntypechangedfrom/versioning/returntypechangedfrom/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/azure/generated/versioning-typechangedfrom/versioning/typechangedfrom/_utils/model_base.py b/packages/typespec-python/test/azure/generated/versioning-typechangedfrom/versioning/typechangedfrom/_utils/model_base.py index 83322a4e6eb..0ea9be40558 100644 --- a/packages/typespec-python/test/azure/generated/versioning-typechangedfrom/versioning/typechangedfrom/_utils/model_base.py +++ b/packages/typespec-python/test/azure/generated/versioning-typechangedfrom/versioning/typechangedfrom/_utils/model_base.py @@ -370,6 +370,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1048,9 +1057,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/generic_mock_api_tests/unittests/test_model_base_serialization.py b/packages/typespec-python/test/generic_mock_api_tests/unittests/test_model_base_serialization.py index 7522a9c23fe..bc3776fc95d 100644 --- a/packages/typespec-python/test/generic_mock_api_tests/unittests/test_model_base_serialization.py +++ b/packages/typespec-python/test/generic_mock_api_tests/unittests/test_model_base_serialization.py @@ -932,9 +932,7 @@ def __init__(self, *args, **kwargs): model_with_callback = MyModel2(prop=[1.3, 2.4, 3.5]) assert model_with_callback.prop == ["1.3", "2.4", "3.5"] - # since the deserialize function is not roundtrippable, once we deserialize - # the serialized version is the same - assert model_with_callback["prop"] == [1.3, 2.4, 3.5] + assert model_with_callback["prop"] == ["1.3", "2.4", "3.5"] def test_deserialization_callback_override_parent(): @@ -970,7 +968,7 @@ def __init__(self, *args, **kwargs): child_model = ChildWithCallback(prop=[1, 1, 2, 3]) assert child_model.prop == set(["1", "1", "2", "3"]) - assert child_model["prop"] == [1, 1, 2, 3] + assert child_model["prop"] == set(["1", "1", "2", "3"]) def test_inheritance_basic(): @@ -3271,7 +3269,7 @@ def test_complex_array_wrapper(model: ArrayWrapper): model["array"] = [1, 2, 3, 4, 5] assert model.array == ["1", "2", "3", "4", "5"] - assert model["array"] == [1, 2, 3, 4, 5] + assert model["array"] == ["1", "2", "3", "4", "5"] @pytest.mark.parametrize("model", [ArrayWrapper(array=[]), ArrayWrapper({"array": []})]) diff --git a/packages/typespec-python/test/unbranded/generated/authentication-api-key/authentication/apikey/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/authentication-api-key/authentication/apikey/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/authentication-api-key/authentication/apikey/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/authentication-api-key/authentication/apikey/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/authentication-http-custom/authentication/http/custom/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/authentication-http-custom/authentication/http/custom/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/authentication-http-custom/authentication/http/custom/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/authentication-http-custom/authentication/http/custom/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/authentication-oauth2/authentication/oauth2/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/authentication-oauth2/authentication/oauth2/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/authentication-oauth2/authentication/oauth2/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/authentication-oauth2/authentication/oauth2/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/authentication-union/authentication/union/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/authentication-union/authentication/union/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/authentication-union/authentication/union/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/authentication-union/authentication/union/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/encode-array/encode/array/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/encode-array/encode/array/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/encode-array/encode/array/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/encode-array/encode/array/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/encode-bytes/encode/bytes/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/encode-bytes/encode/bytes/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/encode-bytes/encode/bytes/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/encode-bytes/encode/bytes/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/encode-datetime/encode/datetime/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/encode-datetime/encode/datetime/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/encode-datetime/encode/datetime/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/encode-datetime/encode/datetime/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/encode-duration/encode/duration/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/encode-duration/encode/duration/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/encode-duration/encode/duration/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/encode-duration/encode/duration/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/encode-numeric/encode/numeric/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/encode-numeric/encode/numeric/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/encode-numeric/encode/numeric/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/encode-numeric/encode/numeric/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/generation-subdir/generation/subdir/_generated/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/generation-subdir/generation/subdir/_generated/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/generation-subdir/generation/subdir/_generated/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/generation-subdir/generation/subdir/_generated/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/headasbooleanfalse/headasbooleanfalse/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/headasbooleanfalse/headasbooleanfalse/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/headasbooleanfalse/headasbooleanfalse/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/headasbooleanfalse/headasbooleanfalse/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/headasbooleantrue/headasbooleantrue/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/headasbooleantrue/headasbooleantrue/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/headasbooleantrue/headasbooleantrue/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/headasbooleantrue/headasbooleantrue/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/parameters-basic/parameters/basic/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/parameters-basic/parameters/basic/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/parameters-basic/parameters/basic/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/parameters-basic/parameters/basic/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/parameters-body-optionality/parameters/bodyoptionality/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/parameters-body-optionality/parameters/bodyoptionality/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/parameters-body-optionality/parameters/bodyoptionality/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/parameters-body-optionality/parameters/bodyoptionality/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/parameters-collection-format/parameters/collectionformat/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/parameters-collection-format/parameters/collectionformat/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/parameters-collection-format/parameters/collectionformat/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/parameters-collection-format/parameters/collectionformat/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/parameters-path/parameters/path/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/parameters-path/parameters/path/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/parameters-path/parameters/path/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/parameters-path/parameters/path/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/parameters-spread/parameters/spread/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/parameters-spread/parameters/spread/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/parameters-spread/parameters/spread/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/parameters-spread/parameters/spread/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/payload-content-negotiation/payload/contentnegotiation/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/payload-content-negotiation/payload/contentnegotiation/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/payload-content-negotiation/payload/contentnegotiation/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/payload-content-negotiation/payload/contentnegotiation/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/payload-json-merge-patch/payload/jsonmergepatch/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/payload-json-merge-patch/payload/jsonmergepatch/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/payload-json-merge-patch/payload/jsonmergepatch/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/payload-json-merge-patch/payload/jsonmergepatch/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/payload-media-type/payload/mediatype/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/payload-media-type/payload/mediatype/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/payload-media-type/payload/mediatype/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/payload-media-type/payload/mediatype/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/payload-multipart/payload/multipart/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/payload-multipart/payload/multipart/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/payload-multipart/payload/multipart/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/payload-multipart/payload/multipart/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/payload-pageable/payload/pageable/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/payload-pageable/payload/pageable/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/payload-pageable/payload/pageable/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/payload-pageable/payload/pageable/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/payload-xml/payload/xml/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/payload-xml/payload/xml/_utils/model_base.py index aadef95da44..2a0c6555720 100644 --- a/packages/typespec-python/test/unbranded/generated/payload-xml/payload/xml/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/payload-xml/payload/xml/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1059,9 +1068,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/response-status-code-range/response/statuscoderange/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/response-status-code-range/response/statuscoderange/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/response-status-code-range/response/statuscoderange/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/response-status-code-range/response/statuscoderange/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/routes/routes/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/routes/routes/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/routes/routes/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/routes/routes/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/serialization-encoded-name-json/serialization/encodedname/json/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/serialization-encoded-name-json/serialization/encodedname/json/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/serialization-encoded-name-json/serialization/encodedname/json/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/serialization-encoded-name-json/serialization/encodedname/json/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/server-endpoint-not-defined/server/endpoint/notdefined/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/server-endpoint-not-defined/server/endpoint/notdefined/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/server-endpoint-not-defined/server/endpoint/notdefined/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/server-endpoint-not-defined/server/endpoint/notdefined/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/server-path-multiple/server/path/multiple/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/server-path-multiple/server/path/multiple/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/server-path-multiple/server/path/multiple/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/server-path-multiple/server/path/multiple/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/server-path-single/server/path/single/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/server-path-single/server/path/single/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/server-path-single/server/path/single/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/server-path-single/server/path/single/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/server-versions-not-versioned/server/versions/notversioned/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/server-versions-not-versioned/server/versions/notversioned/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/server-versions-not-versioned/server/versions/notversioned/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/server-versions-not-versioned/server/versions/notversioned/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/server-versions-versioned/server/versions/versioned/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/server-versions-versioned/server/versions/versioned/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/server-versions-versioned/server/versions/versioned/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/server-versions-versioned/server/versions/versioned/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/setuppy-authentication-union/setuppy/authentication/union/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/setuppy-authentication-union/setuppy/authentication/union/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/setuppy-authentication-union/setuppy/authentication/union/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/setuppy-authentication-union/setuppy/authentication/union/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/special-headers-conditional-request/specialheaders/conditionalrequest/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/special-headers-conditional-request/specialheaders/conditionalrequest/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/special-headers-conditional-request/specialheaders/conditionalrequest/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/special-headers-conditional-request/specialheaders/conditionalrequest/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/special-headers-repeatability/specialheaders/repeatability/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/special-headers-repeatability/specialheaders/repeatability/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/special-headers-repeatability/specialheaders/repeatability/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/special-headers-repeatability/specialheaders/repeatability/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/special-words/specialwords/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/special-words/specialwords/_utils/model_base.py index aadef95da44..2a0c6555720 100644 --- a/packages/typespec-python/test/unbranded/generated/special-words/specialwords/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/special-words/specialwords/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1059,9 +1068,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/specs-documentation/specs/documentation/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/specs-documentation/specs/documentation/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/specs-documentation/specs/documentation/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/specs-documentation/specs/documentation/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/streaming-jsonl/streaming/jsonl/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/streaming-jsonl/streaming/jsonl/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/streaming-jsonl/streaming/jsonl/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/streaming-jsonl/streaming/jsonl/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/typetest-array/typetest/array/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/typetest-array/typetest/array/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/typetest-array/typetest/array/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/typetest-array/typetest/array/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/typetest-dictionary/typetest/dictionary/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/typetest-dictionary/typetest/dictionary/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/typetest-dictionary/typetest/dictionary/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/typetest-dictionary/typetest/dictionary/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/typetest-enum-extensible/typetest/enum/extensible/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/typetest-enum-extensible/typetest/enum/extensible/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/typetest-enum-extensible/typetest/enum/extensible/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/typetest-enum-extensible/typetest/enum/extensible/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/typetest-enum-fixed/typetest/enum/fixed/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/typetest-enum-fixed/typetest/enum/fixed/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/typetest-enum-fixed/typetest/enum/fixed/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/typetest-enum-fixed/typetest/enum/fixed/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/typetest-model-empty/typetest/model/empty/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/typetest-model-empty/typetest/model/empty/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/typetest-model-empty/typetest/model/empty/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/typetest-model-empty/typetest/model/empty/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/typetest-model-enumdiscriminator/typetest/model/enumdiscriminator/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/typetest-model-enumdiscriminator/typetest/model/enumdiscriminator/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/typetest-model-enumdiscriminator/typetest/model/enumdiscriminator/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/typetest-model-enumdiscriminator/typetest/model/enumdiscriminator/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/typetest-model-nesteddiscriminator/typetest/model/nesteddiscriminator/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/typetest-model-nesteddiscriminator/typetest/model/nesteddiscriminator/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/typetest-model-nesteddiscriminator/typetest/model/nesteddiscriminator/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/typetest-model-nesteddiscriminator/typetest/model/nesteddiscriminator/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/typetest-model-notdiscriminated/typetest/model/notdiscriminated/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/typetest-model-notdiscriminated/typetest/model/notdiscriminated/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/typetest-model-notdiscriminated/typetest/model/notdiscriminated/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/typetest-model-notdiscriminated/typetest/model/notdiscriminated/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/typetest-model-recursive/typetest/model/recursive/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/typetest-model-recursive/typetest/model/recursive/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/typetest-model-recursive/typetest/model/recursive/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/typetest-model-recursive/typetest/model/recursive/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/typetest-model-singlediscriminator/typetest/model/singlediscriminator/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/typetest-model-singlediscriminator/typetest/model/singlediscriminator/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/typetest-model-singlediscriminator/typetest/model/singlediscriminator/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/typetest-model-singlediscriminator/typetest/model/singlediscriminator/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/typetest-model-usage/typetest/model/usage/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/typetest-model-usage/typetest/model/usage/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/typetest-model-usage/typetest/model/usage/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/typetest-model-usage/typetest/model/usage/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/typetest-model-visibility/typetest/model/visibility/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/typetest-model-visibility/typetest/model/visibility/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/typetest-model-visibility/typetest/model/visibility/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/typetest-model-visibility/typetest/model/visibility/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/typetest-property-additionalproperties/typetest/property/additionalproperties/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/typetest-property-additionalproperties/typetest/property/additionalproperties/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/typetest-property-additionalproperties/typetest/property/additionalproperties/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/typetest-property-additionalproperties/typetest/property/additionalproperties/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/typetest-property-nullable/typetest/property/nullable/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/typetest-property-nullable/typetest/property/nullable/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/typetest-property-nullable/typetest/property/nullable/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/typetest-property-nullable/typetest/property/nullable/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/typetest-property-optional/typetest/property/optional/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/typetest-property-optional/typetest/property/optional/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/typetest-property-optional/typetest/property/optional/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/typetest-property-optional/typetest/property/optional/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/typetest-property-valuetypes/typetest/property/valuetypes/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/typetest-property-valuetypes/typetest/property/valuetypes/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/typetest-property-valuetypes/typetest/property/valuetypes/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/typetest-property-valuetypes/typetest/property/valuetypes/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/typetest-scalar/typetest/scalar/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/typetest-scalar/typetest/scalar/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/typetest-scalar/typetest/scalar/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/typetest-scalar/typetest/scalar/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/typetest-union/typetest/union/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/typetest-union/typetest/union/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/typetest-union/typetest/union/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/typetest-union/typetest/union/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/versioning-added/versioning/added/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/versioning-added/versioning/added/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/versioning-added/versioning/added/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/versioning-added/versioning/added/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/versioning-madeoptional/versioning/madeoptional/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/versioning-madeoptional/versioning/madeoptional/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/versioning-madeoptional/versioning/madeoptional/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/versioning-madeoptional/versioning/madeoptional/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/versioning-removed/versioning/removed/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/versioning-removed/versioning/removed/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/versioning-removed/versioning/removed/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/versioning-removed/versioning/removed/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/versioning-renamedfrom/versioning/renamedfrom/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/versioning-renamedfrom/versioning/renamedfrom/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/versioning-renamedfrom/versioning/renamedfrom/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/versioning-renamedfrom/versioning/renamedfrom/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/versioning-returntypechangedfrom/versioning/returntypechangedfrom/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/versioning-returntypechangedfrom/versioning/returntypechangedfrom/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/versioning-returntypechangedfrom/versioning/returntypechangedfrom/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/versioning-returntypechangedfrom/versioning/returntypechangedfrom/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: diff --git a/packages/typespec-python/test/unbranded/generated/versioning-typechangedfrom/versioning/typechangedfrom/_utils/model_base.py b/packages/typespec-python/test/unbranded/generated/versioning-typechangedfrom/versioning/typechangedfrom/_utils/model_base.py index 0d8f380c661..204fe396ff2 100644 --- a/packages/typespec-python/test/unbranded/generated/versioning-typechangedfrom/versioning/typechangedfrom/_utils/model_base.py +++ b/packages/typespec-python/test/unbranded/generated/versioning-typechangedfrom/versioning/typechangedfrom/_utils/model_base.py @@ -364,6 +364,15 @@ def __contains__(self, key: typing.Any) -> bool: return key in self._data def __getitem__(self, key: str) -> typing.Any: + # Sync any cached deserialized value back to storage before returning + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + cached_value = object.__getattribute__(self, cache_attr) + rf = _get_rest_field(self._attr_to_rest_field, key) + if rf: + # Serialize the cached value back to storage + self._data[key] = _serialize(cached_value, rf._format) return self._data.__getitem__(key) def __setitem__(self, key: str, value: typing.Any) -> None: @@ -1042,9 +1051,29 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin return item if self._is_model: return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) + # For mutable types (dict, list, set), cache the deserialized object to allow mutations to persist + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + return object.__getattribute__(obj, cache_attr) + + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # Cache mutable types so mutations persist + try: + if isinstance(deserialized, (dict, list, set)): + object.__setattr__(obj, cache_attr, deserialized) + except AttributeError: + pass + + return deserialized def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + try: + object.__delattr__(obj, cache_attr) + except AttributeError: + pass if value is None: # we want to wipe out entries if users set attr to None try: