[core] add as_attribute_dict to azure.core.serialization (#41517)

Author: iscai-msft

eng/pipelines/tsp-spec-sync.yml

@@ -29,9 +29,9 @@ extends:
                 displayName: 'Configure Git'
 
               - script: |
-                  tsp-client update --local-spec-repo ../../specs/scratch/
+                  tsp-client update --local-spec-repo ../../specs/modeltypes
                 displayName: 'Run TSP Client Update'
-                workingDirectory: '$(Build.SourcesDirectory)/sdk/core/azure-core/tests/specs_sdk/scratch'
+                workingDirectory: '$(Build.SourcesDirectory)/sdk/core/azure-core/tests/specs_sdk/modeltypes'
 
               - script: |
                   changes=$(git status --porcelain)

sdk/core/azure-core/CHANGELOG.md

@@ -6,6 +6,7 @@
 
 - Added a `start_time` keyword argument to the `start_span` and `start_as_current_span` methods in the `OpenTelemetryTracer` class. This allows users to specify a custom start time for created spans. #41106
 - Added a `context` keyword argument to the `start_span` and `start_as_current_span` methods in the `OpenTelemetryTracer` class. This allows users to specify a custom parent context for created spans. #41511
+- Added method `as_attribute_dict` to `azure.core.serialization` for backcompat migration purposes. Will return a generated model as a dictionary where the keys are in attribute syntax.
 - Added `is_generated_model` method to `azure.core.serialization`. Returns whether a given input is a model from one of our generated sdks. #41445
 
 ### Breaking Changes

sdk/core/azure-core/azure/core/serialization.py

@@ -6,7 +6,7 @@
 # --------------------------------------------------------------------------
 import base64
 from json import JSONEncoder
-from typing import Union, cast, Any
+from typing import Dict, Optional, Union, cast, Any
 from datetime import datetime, date, time, timedelta
 from datetime import timezone
 
@@ -140,3 +140,111 @@ def is_generated_model(obj: Any) -> bool:
     :rtype: bool
     """
     return bool(getattr(obj, "_is_model", False) or hasattr(obj, "_attribute_map"))
+
+
+def _is_readonly(p: Any) -> bool:
+    """Check if an attribute is readonly.
+
+    :param any p: The property to check.
+    :return: True if the property is readonly, False otherwise.
+    :rtype: bool
+    """
+    try:
+        return p._visibility == ["read"]  # pylint: disable=protected-access
+    except AttributeError:
+        return False
+
+
+def _as_attribute_dict_value(v: Any, *, exclude_readonly: bool = False) -> Any:
+    if v is None or isinstance(v, _Null):
+        return None
+    if isinstance(v, (list, tuple, set)):
+        return type(v)(_as_attribute_dict_value(x, exclude_readonly=exclude_readonly) for x in v)
+    if isinstance(v, dict):
+        return {dk: _as_attribute_dict_value(dv, exclude_readonly=exclude_readonly) for dk, dv in v.items()}
+    return as_attribute_dict(v, exclude_readonly=exclude_readonly) if is_generated_model(v) else v
+
+
+def _get_flattened_attribute(obj: Any) -> Optional[str]:
+    flattened_items = None
+    try:
+        flattened_items = getattr(obj, next(a for a in dir(obj) if "__flattened_items" in a), None)
+    except StopIteration:
+        return None
+
+    if flattened_items is None:
+        return None
+
+    for k, v in obj._attr_to_rest_field.items():  # pylint: disable=protected-access
+        try:
+            if set(v._class_type._attr_to_rest_field.keys()).intersection(  # pylint: disable=protected-access
+                set(flattened_items)
+            ):
+                return k
+        except AttributeError:
+            # if the attribute does not have _class_type, it is not a typespec generated model
+            continue
+    return None
+
+
+def as_attribute_dict(obj: Any, *, exclude_readonly: bool = False) -> Dict[str, Any]:
+    """Convert an object to a dictionary of its attributes.
+
+    Made solely for backcompatibility with the legacy `.as_dict()` on msrest models.
+
+    .. deprecated::1.35.0
+        This function is added for backcompat purposes only.
+
+    :param any obj: The object to convert to a dictionary
+    :keyword bool exclude_readonly: Whether to exclude readonly properties
+    :return: A dictionary containing the object's attributes
+    :rtype: dict[str, any]
+    :raises TypeError: If the object is not a generated model instance
+    """
+    if not is_generated_model(obj):
+        raise TypeError("Object must be a generated model instance.")
+    if hasattr(obj, "_attribute_map"):
+        # msrest generated model
+        return obj.as_dict(keep_readonly=not exclude_readonly)
+    try:
+        # now we're a typespec generated model
+        result = {}
+        readonly_props = set()
+
+        # create a reverse mapping from rest field name to attribute name
+        rest_to_attr = {}
+        flattened_attribute = _get_flattened_attribute(obj)
+        for attr_name, rest_field in obj._attr_to_rest_field.items():  # pylint: disable=protected-access
+
+            if exclude_readonly and _is_readonly(rest_field):
+                # if we're excluding readonly properties, we need to track them
+                readonly_props.add(rest_field._rest_name)  # pylint: disable=protected-access
+            if flattened_attribute == attr_name:
+                for fk, fv in rest_field._class_type._attr_to_rest_field.items():  # pylint: disable=protected-access
+                    rest_to_attr[fv._rest_name] = fk  # pylint: disable=protected-access
+            else:
+                rest_to_attr[rest_field._rest_name] = attr_name  # pylint: disable=protected-access
+        for k, v in obj.items():
+            if exclude_readonly and k in readonly_props:  # pyright: ignore
+                continue
+            if k == flattened_attribute:
+                for fk, fv in v.items():
+                    result[rest_to_attr.get(fk, fk)] = _as_attribute_dict_value(fv, exclude_readonly=exclude_readonly)
+            else:
+                is_multipart_file_input = False
+                try:
+                    is_multipart_file_input = next(  # pylint: disable=protected-access
+                        rf
+                        for rf in obj._attr_to_rest_field.values()  # pylint: disable=protected-access
+                        if rf._rest_name == k  # pylint: disable=protected-access
+                    )._is_multipart_file_input
+                except StopIteration:
+                    pass
+
+                result[rest_to_attr.get(k, k)] = (
+                    v if is_multipart_file_input else _as_attribute_dict_value(v, exclude_readonly=exclude_readonly)
+                )
+        return result
+    except AttributeError as exc:
+        # not a typespec generated model
+        raise TypeError("Object must be a generated model instance.") from exc

sdk/core/azure-core/dev_requirements.txt

@@ -5,7 +5,7 @@ aiohttp<3.8.6 ; platform_python_implementation == "PyPy"
 aiohttp ; platform_python_implementation != "PyPy"
 -e ../../../tools/azure-sdk-tools
 -e tests/testserver_tests/coretestserver
--e tests/specs_sdk/scratch
+-e tests/specs_sdk/modeltypes
 pytest-trio
 azure-storage-blob
 azure-data-tables

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

@@ -0,0 +1,88 @@
+import "@azure-tools/typespec-client-generator-core";
+
+using Azure.ClientGenerator.Core;
+
+@usage(Usage.input)
+namespace ModelTypes;
+/** A scratch model for testing purposes */
+
+model Scratch {
+    /** A string property */
+    prop: string;
+}
+
+/**
+ * Model with one level of flattening
+ */
+model FlattenModel {
+  name: string;
+
+  #suppress "deprecated" "@flattenProperty decorator is not recommended to use."
+  @flattenProperty
+  properties: PropertiesModel;
+}
+
+/**
+ * Properties model
+ */
+model PropertiesModel {
+  @encodedName("application/json", "modelDescription")
+  description: string;
+  age: int32;
+}
+
+/**
+ * Model with a property that has a client name
+ */
+model ClientNameAndJsonEncodedNameModel {
+    @doc("Pass in true")
+    @encodedName("application/json", "wireName")
+    clientName: string;
+  }
+
+/**
+ * Model with a readonly property
+ */
+model ReadonlyModel {
+  @visibility(Lifecycle.Read)
+  id: int32;
+}
+
+@doc("This is base model for polymorphic multiple levels inheritance with a discriminator.")
+@discriminator("kind")
+model Fish {
+  age: int32;
+}
+
+@doc("The second level model in polymorphic multiple levels inheritance and it defines a new discriminator.")
+@discriminator("sharkType")
+model Shark extends Fish {
+  kind: "shark";
+  sharkType: string;
+}
+
+@doc("The second level model in polymorphic multiple levels inheritance which contains references to other polymorphic instances.")
+model Salmon extends Fish {
+  kind: "salmon";
+  friends?: Fish[];
+  hate?: Record<Fish>;
+  lifePartner?: Fish;
+}
+
+@doc("The third level model SawShark in polymorphic multiple levels inheritance.")
+model SawShark extends Shark {
+  sharkType: "saw";
+}
+
+@doc("The third level model GoblinShark in polymorphic multiple levels inheritance.")
+model GoblinShark extends Shark {
+  sharkType: "goblin";
+}
+
+model RecursiveElement extends Element {
+  level: int8;
+}
+
+model Element {
+  recursiveElement?: RecursiveElement[];
+}

sdk/core/azure-core/tests/specs/scratch/tspconfig.yaml renamed to sdk/core/azure-core/tests/specs/modeltypes/tspconfig.yaml

@@ -1,5 +1,5 @@
 include *.md
 include LICENSE
-include modeltest/py.typed
+include modeltypes/py.typed
 recursive-include tests *.py
 recursive-include samples *.py *.md