@typespec/http-client-python 0.32.0 → 0.33.0

package/generator/pygen/preprocess/__init__.py

@@ -22,6 +22,7 @@ from ..utils import (
     get_body_type_for_description,
     JSON_REGEXP,
     KNOWN_TYPES,
+    description_ends_with_code_block,
 )
 
 
@@ -35,14 +36,18 @@ def update_overload_section(
             if overload_s.get("type"):
                 overload_s["type"] = original_s["type"]
             if overload_s.get("headers"):
-                for overload_h, original_h in zip(overload_s["headers"], original_s["headers"]):
+                for overload_h, original_h in zip(
+                    overload_s["headers"], original_s["headers"]
+                ):
                     if overload_h.get("type"):
                         overload_h["type"] = original_h["type"]
     except KeyError as exc:
         raise ValueError(overload["name"]) from exc
 
 
-def add_overload(yaml_data: dict[str, Any], body_type: dict[str, Any], for_flatten_params=False):
+def add_overload(
+    yaml_data: dict[str, Any], body_type: dict[str, Any], for_flatten_params=False
+):
     overload = copy.deepcopy(yaml_data)
     overload["isOverload"] = True
     overload["bodyParameter"]["type"] = body_type
@@ -54,7 +59,9 @@ def add_overload(yaml_data: dict[str, Any], body_type: dict[str, Any], for_flatt
     if for_flatten_params:
         overload["bodyParameter"]["flattened"] = True
     else:
-        overload["parameters"] = [p for p in overload["parameters"] if not p.get("inFlattenedBody")]
+        overload["parameters"] = [
+            p for p in overload["parameters"] if not p.get("inFlattenedBody")
+        ]
     # for yaml sync, we need to make sure all of the responses, parameters, and exceptions' types have the same yaml id
     for overload_p, original_p in zip(overload["parameters"], yaml_data["parameters"]):
         overload_p["type"] = original_p["type"]
@@ -62,7 +69,9 @@ def add_overload(yaml_data: dict[str, Any], body_type: dict[str, Any], for_flatt
     update_overload_section(overload, yaml_data, "exceptions")
 
     # update content type to be an overloads content type
-    content_type_param = next(p for p in overload["parameters"] if p["wireName"].lower() == "content-type")
+    content_type_param = next(
+        p for p in overload["parameters"] if p["wireName"].lower() == "content-type"
+    )
     content_type_param["inOverload"] = True
     content_type_param["inDocstring"] = True
     body_type_description = get_body_type_for_description(overload["bodyParameter"])
@@ -85,16 +94,25 @@ def add_overloads_for_body_param(yaml_data: dict[str, Any]) -> None:
     body_parameter = yaml_data["bodyParameter"]
     if not (
         body_parameter["type"]["type"] == "combined"
-        and len(yaml_data["bodyParameter"]["type"]["types"]) > len(yaml_data["overloads"])
+        and len(yaml_data["bodyParameter"]["type"]["types"])
+        > len(yaml_data["overloads"])
     ):
         return
     for body_type in body_parameter["type"]["types"]:
-        if any(o for o in yaml_data["overloads"] if id(o["bodyParameter"]["type"]) == id(body_type)):
+        if any(
+            o
+            for o in yaml_data["overloads"]
+            if id(o["bodyParameter"]["type"]) == id(body_type)
+        ):
             continue
         if body_type.get("type") == "model" and body_type.get("base") == "json":
-            yaml_data["overloads"].append(add_overload(yaml_data, body_type, for_flatten_params=True))
+            yaml_data["overloads"].append(
+                add_overload(yaml_data, body_type, for_flatten_params=True)
+            )
         yaml_data["overloads"].append(add_overload(yaml_data, body_type))
-    content_type_param = next(p for p in yaml_data["parameters"] if p["wireName"].lower() == "content-type")
+    content_type_param = next(
+        p for p in yaml_data["parameters"] if p["wireName"].lower() == "content-type"
+    )
     content_type_param["inOverload"] = False
     content_type_param["inOverridden"] = True
     content_type_param["inDocstring"] = True
@@ -104,11 +122,19 @@ def add_overloads_for_body_param(yaml_data: dict[str, Any]) -> None:
     content_type_param["optional"] = True
 
 
-def update_description(description: Optional[str], default_description: str = "") -> str:
+def update_description(
+    description: Optional[str], default_description: str = ""
+) -> str:
     if not description:
         description = default_description
     description.rstrip(" ")
-    if description and description[-1] != ".":
+    # Don't append a trailing period when the description ends with a code block: the
+    # period would land inside the rendered literal block (e.g. "]." ) and break Sphinx.
+    if (
+        description
+        and description[-1] != "."
+        and not description_ends_with_code_block(description)
+    ):
         description += "."
     return description
 
@@ -171,7 +197,9 @@ def _get_etag_role(parameter: dict[str, Any]) -> Optional[str]:
     return parameter.get("etagRole")
 
 
-def _pick_etag_slot(candidates: list[dict[str, Any]], standard_wire_name: str) -> Optional[dict[str, Any]]:
+def _pick_etag_slot(
+    candidates: list[dict[str, Any]], standard_wire_name: str
+) -> Optional[dict[str, Any]]:
     """Choose which etag-typed header should be promoted to the etag/match_condition slot.
 
     When more than one etag-typed header is present in an operation, prefer the
@@ -199,16 +227,25 @@ def _resolve_etag_pair(
     Returns (property_if_match, property_if_none_match) — both None when
     there are no etag candidates.
     """
-    property_if_match = _pick_etag_slot(if_match_candidates, STANDARD_IF_MATCH_WIRE_NAME)
-    property_if_none_match = _pick_etag_slot(if_none_match_candidates, STANDARD_IF_NONE_MATCH_WIRE_NAME)
+    property_if_match = _pick_etag_slot(
+        if_match_candidates, STANDARD_IF_MATCH_WIRE_NAME
+    )
+    property_if_none_match = _pick_etag_slot(
+        if_none_match_candidates, STANDARD_IF_NONE_MATCH_WIRE_NAME
+    )
 
     # Ensure the promoted pair come from the same family.  When one slot is
     # standard and the other custom (cross-family), replace the custom slot
     # with a synthetic standard partner.  Also synthesize the missing partner
     # when only one side is present.
     if property_if_match and property_if_none_match:
-        match_is_std = get_wire_name_lower(property_if_match) == STANDARD_IF_MATCH_WIRE_NAME
-        none_match_is_std = get_wire_name_lower(property_if_none_match) == STANDARD_IF_NONE_MATCH_WIRE_NAME
+        match_is_std = (
+            get_wire_name_lower(property_if_match) == STANDARD_IF_MATCH_WIRE_NAME
+        )
+        none_match_is_std = (
+            get_wire_name_lower(property_if_none_match)
+            == STANDARD_IF_NONE_MATCH_WIRE_NAME
+        )
         if match_is_std and not none_match_is_std:
             property_if_none_match = property_if_match.copy()
             property_if_none_match["wireName"] = STANDARD_IF_NONE_MATCH_WIRE_NAME
@@ -256,11 +293,15 @@ def _process_operation_etag_headers(
             elif role == "ifNoneMatch":
                 if_none_match_candidates.append(p)
 
-    property_if_match, property_if_none_match = _resolve_etag_pair(if_match_candidates, if_none_match_candidates)
+    property_if_match, property_if_none_match = _resolve_etag_pair(
+        if_match_candidates, if_none_match_candidates
+    )
 
     if property_if_match and property_if_none_match:
         etag_params = {id(property_if_match), id(property_if_none_match)}
-        operation["parameters"] = [item for item in operation["parameters"] if id(item) not in etag_params] + [
+        operation["parameters"] = [
+            item for item in operation["parameters"] if id(item) not in etag_params
+        ] + [
             property_if_match,
             property_if_none_match,
         ]
@@ -279,7 +320,9 @@ def has_json_content_type(yaml_data: dict[str, Any]) -> bool:
 
 
 def has_multi_part_content_type(yaml_data: dict[str, Any]) -> bool:
-    return any(ct for ct in yaml_data.get("contentTypes", []) if ct == "multipart/form-data")
+    return any(
+        ct for ct in yaml_data.get("contentTypes", []) if ct == "multipart/form-data"
+    )
 
 
 class PreProcessPlugin(YamlUpdatePlugin):
@@ -310,13 +353,18 @@ class PreProcessPlugin(YamlUpdatePlugin):
         if (  # pylint: disable=too-many-boolean-expressions
             body_parameter
             and body_parameter["type"]["type"] in ("model", "dict", "list")
-            and (has_json_content_type(body_parameter) or (self.is_tsp and has_multi_part_content_type(body_parameter)))
+            and (
+                has_json_content_type(body_parameter)
+                or (self.is_tsp and has_multi_part_content_type(body_parameter))
+            )
             and not body_parameter["type"].get("xmlMetadata")
             and not any(t for t in ["flattened", "groupedBy"] if body_parameter.get(t))
         ):
             origin_type = body_parameter["type"]["type"]
             model_type = (
-                body_parameter["type"] if origin_type == "model" else body_parameter["type"].get("elementType", {})
+                body_parameter["type"]
+                if origin_type == "model"
+                else body_parameter["type"].get("elementType", {})
             )
             is_dpg_model = model_type.get("base") == "dpg"
             body_parameter["type"] = {
@@ -333,19 +381,26 @@ class PreProcessPlugin(YamlUpdatePlugin):
                 else:
                     # dict or list
                     # copy the original dict / list type
-                    any_obj_list_or_dict = copy.deepcopy(body_parameter["type"]["types"][0])
+                    any_obj_list_or_dict = copy.deepcopy(
+                        body_parameter["type"]["types"][0]
+                    )
                     any_obj_list_or_dict["elementType"] = KNOWN_TYPES["any-object"]
                     body_parameter["type"]["types"].insert(1, any_obj_list_or_dict)
             code_model["types"].append(body_parameter["type"])
 
-    def pad_reserved_words(self, name: str, pad_type: PadType, yaml_type: dict[str, Any]) -> str:
+    def pad_reserved_words(
+        self, name: str, pad_type: PadType, yaml_type: dict[str, Any]
+    ) -> str:
         # we want to pad hidden variables as well
         if not name:
             # we'll pass in empty operation groups sometime etc.
             return name
 
         if self.is_tsp:
-            reserved_words = {k: (v + TSP_RESERVED_WORDS.get(k, [])) for k, v in RESERVED_WORDS.items()}
+            reserved_words = {
+                k: (v + TSP_RESERVED_WORDS.get(k, []))
+                for k, v in RESERVED_WORDS.items()
+            }
         else:
             reserved_words = RESERVED_WORDS
         name = pad_special_chars(name)
@@ -362,18 +417,24 @@ class PreProcessPlugin(YamlUpdatePlugin):
     def update_types(self, yaml_data: list[dict[str, Any]]) -> None:
         for type in yaml_data:
             for property in type.get("properties", []):
-                property["description"] = update_description(property.get("description", ""))
+                property["description"] = update_description(
+                    property.get("description", "")
+                )
                 if not property.get("isExactName", False):
                     property["clientName"] = self.pad_reserved_words(
                         property["clientName"].lower(), PadType.PROPERTY, property
                     )
                 add_redefined_builtin_info(property["clientName"], property)
             if type.get("name"):
-                pad_type = PadType.MODEL if type["type"] == "model" else PadType.ENUM_CLASS
+                pad_type = (
+                    PadType.MODEL if type["type"] == "model" else PadType.ENUM_CLASS
+                )
                 if type["type"] != "enumvalue":
                     name = self.pad_reserved_words(type["name"], pad_type, type)
                     type["name"] = name[0].upper() + name[1:]
-                type["description"] = update_description(type.get("description", ""), type["name"])
+                type["description"] = update_description(
+                    type.get("description", ""), type["name"]
+                )
                 type["snakeCaseName"] = to_snake_case(type["name"])
             if type.get("values"):
                 # we're enums - enum values are UPPER_CASE so no padding needed for reserved words
@@ -391,16 +452,24 @@ class PreProcessPlugin(YamlUpdatePlugin):
         yaml_data.append(CLOUD_SETTING["type"])  # type: ignore
 
     def update_client(self, yaml_data: dict[str, Any]) -> None:
-        yaml_data["description"] = update_description(yaml_data["description"], default_description=yaml_data["name"])
+        yaml_data["description"] = update_description(
+            yaml_data["description"], default_description=yaml_data["name"]
+        )
         yaml_data["legacyFilename"] = to_snake_case(yaml_data["name"].replace(" ", "_"))
         parameters = yaml_data["parameters"]
         for parameter in parameters:
             self.update_parameter(parameter)
             if parameter["clientName"] == "credential":
                 policy = parameter["type"].get("policy")
-                if policy and policy["type"] == "BearerTokenCredentialPolicy" and self.azure_arm:
+                if (
+                    policy
+                    and policy["type"] == "BearerTokenCredentialPolicy"
+                    and self.azure_arm
+                ):
                     policy["type"] = "ARMChallengeAuthenticationPolicy"
-                    policy["credentialScopes"] = ["https://management.azure.com/.default"]
+                    policy["credentialScopes"] = [
+                        "https://management.azure.com/.default"
+                    ]
         if (
             (not self.version_tolerant or self.azure_arm)
             and parameters
@@ -420,7 +489,9 @@ class PreProcessPlugin(YamlUpdatePlugin):
         if self.azure_arm and yaml_data["parameters"]:
             yaml_data["parameters"].append(CLOUD_SETTING)
 
-    def get_operation_updater(self, yaml_data: dict[str, Any]) -> Callable[[dict[str, Any], dict[str, Any]], None]:
+    def get_operation_updater(
+        self, yaml_data: dict[str, Any]
+    ) -> Callable[[dict[str, Any], dict[str, Any]], None]:
         if yaml_data["discriminator"] == "lropaging":
             return self.update_lro_paging_operation
         if yaml_data["discriminator"] == "lro":
@@ -432,7 +503,8 @@ class PreProcessPlugin(YamlUpdatePlugin):
     def update_parameter(self, yaml_data: dict[str, Any]) -> None:
         yaml_data["description"] = update_description(yaml_data.get("description", ""))
         if not yaml_data.get("isExactName", False) and not (
-            yaml_data["location"] == "header" and yaml_data["clientName"] in ("content_type", "accept")
+            yaml_data["location"] == "header"
+            and yaml_data["clientName"] in ("content_type", "accept")
         ):
             yaml_data["clientName"] = self.pad_reserved_words(
                 yaml_data["clientName"].lower(), PadType.PARAMETER, yaml_data
@@ -448,13 +520,16 @@ class PreProcessPlugin(YamlUpdatePlugin):
                 prop: (
                     param_name
                     if prop in exact_name_props
-                    else self.pad_reserved_words(param_name, PadType.PARAMETER, yaml_data).lower()
+                    else self.pad_reserved_words(
+                        param_name, PadType.PARAMETER, yaml_data
+                    ).lower()
                 )
                 for prop, param_name in yaml_data["propertyToParameterName"].items()
             }
         wire_name_lower = (yaml_data.get("wireName") or "").lower()
         if yaml_data["location"] == "header" and (
-            wire_name_lower in HEADERS_HIDE_IN_METHOD or yaml_data.get("clientDefaultValue") == "multipart/form-data"
+            wire_name_lower in HEADERS_HIDE_IN_METHOD
+            or yaml_data.get("clientDefaultValue") == "multipart/form-data"
         ):
             yaml_data["hideInMethod"] = True
         if self.version_tolerant and yaml_data["location"] == "header":
@@ -463,7 +538,10 @@ class PreProcessPlugin(YamlUpdatePlugin):
                 headers_convert(yaml_data, ETAG_MATCH_DATA)
             elif role == "ifNoneMatch":
                 headers_convert(yaml_data, ETAG_NONE_MATCH_DATA)
-        if wire_name_lower in ["$host", "content-type", "accept"] and yaml_data["type"]["type"] == "constant":
+        if (
+            wire_name_lower in ["$host", "content-type", "accept"]
+            and yaml_data["type"]["type"] == "constant"
+        ):
             yaml_data["clientDefaultValue"] = yaml_data["type"]["value"]
 
     def update_operation(
@@ -473,24 +551,36 @@ class PreProcessPlugin(YamlUpdatePlugin):
         *,
         is_overload: bool = False,
     ) -> None:
-        yaml_data["groupName"] = self.pad_reserved_words(yaml_data["groupName"], PadType.OPERATION_GROUP, yaml_data)
+        yaml_data["groupName"] = self.pad_reserved_words(
+            yaml_data["groupName"], PadType.OPERATION_GROUP, yaml_data
+        )
         yaml_data["groupName"] = to_snake_case(yaml_data["groupName"])
         if yaml_data.get("isExactName", False):
             # exact() client name: keep the operation name as-is without lowercasing,
             # snake-casing, or padding reserved words.
             if yaml_data.get("isLroInitialOperation") is True:
-                yaml_data["name"] = "_" + extract_original_name(yaml_data["name"]) + "_initial"
+                yaml_data["name"] = (
+                    "_" + extract_original_name(yaml_data["name"]) + "_initial"
+                )
         else:
             yaml_data["name"] = yaml_data["name"].lower()
             if yaml_data.get("isLroInitialOperation") is True:
                 yaml_data["name"] = (
                     "_"
-                    + self.pad_reserved_words(extract_original_name(yaml_data["name"]), PadType.METHOD, yaml_data)
+                    + self.pad_reserved_words(
+                        extract_original_name(yaml_data["name"]),
+                        PadType.METHOD,
+                        yaml_data,
+                    )
                     + "_initial"
                 )
             else:
-                yaml_data["name"] = self.pad_reserved_words(yaml_data["name"], PadType.METHOD, yaml_data)
-        yaml_data["description"] = update_description(yaml_data["description"], yaml_data["name"])
+                yaml_data["name"] = self.pad_reserved_words(
+                    yaml_data["name"], PadType.METHOD, yaml_data
+                )
+        yaml_data["description"] = update_description(
+            yaml_data["description"], yaml_data["name"]
+        )
         yaml_data["summary"] = update_description(yaml_data.get("summary", ""))
         body_parameter = yaml_data.get("bodyParameter")
         for parameter in yaml_data["parameters"]:
@@ -511,8 +601,12 @@ class PreProcessPlugin(YamlUpdatePlugin):
     def _update_lro_operation_helper(self, yaml_data: dict[str, Any]) -> None:
         for response in yaml_data.get("responses", []):
             response["discriminator"] = "lro"
-            response["pollerSync"] = response.get("pollerSync") or "azure.core.polling.LROPoller"
-            response["pollerAsync"] = response.get("pollerAsync") or "azure.core.polling.AsyncLROPoller"
+            response["pollerSync"] = (
+                response.get("pollerSync") or "azure.core.polling.LROPoller"
+            )
+            response["pollerAsync"] = (
+                response.get("pollerAsync") or "azure.core.polling.AsyncLROPoller"
+            )
             if not response.get("pollingMethodSync"):
                 response["pollingMethodSync"] = (
                     "azure.mgmt.core.polling.arm_polling.ARMPolling"
@@ -534,7 +628,9 @@ class PreProcessPlugin(YamlUpdatePlugin):
         item_type: Optional[dict[str, Any]] = None,
     ) -> None:
         self.update_lro_operation(code_model, yaml_data, is_overload=is_overload)
-        self.update_paging_operation(code_model, yaml_data, is_overload=is_overload, item_type=item_type)
+        self.update_paging_operation(
+            code_model, yaml_data, is_overload=is_overload, item_type=item_type
+        )
         yaml_data["discriminator"] = "lropaging"
         for response in yaml_data.get("responses", []):
             response["discriminator"] = "lropaging"
@@ -557,12 +653,16 @@ class PreProcessPlugin(YamlUpdatePlugin):
                 response["type"] = KNOWN_TYPES["binary"]
 
         self.update_operation(code_model, yaml_data, is_overload=is_overload)
-        self.update_operation(code_model, yaml_data["initialOperation"], is_overload=is_overload)
+        self.update_operation(
+            code_model, yaml_data["initialOperation"], is_overload=is_overload
+        )
         convert_initial_operation_response_type(yaml_data["initialOperation"])
         self._update_lro_operation_helper(yaml_data)
         for overload in yaml_data.get("overloads", []):
             self._update_lro_operation_helper(overload)
-            self.update_operation(code_model, overload["initialOperation"], is_overload=True)
+            self.update_operation(
+                code_model, overload["initialOperation"], is_overload=True
+            )
             convert_initial_operation_response_type(overload["initialOperation"])
 
     def update_paging_operation(
@@ -576,9 +676,13 @@ class PreProcessPlugin(YamlUpdatePlugin):
         item_type = item_type or yaml_data["itemType"]["elementType"]
         if yaml_data.get("nextOperation"):
             yaml_data["nextOperation"]["groupName"] = self.pad_reserved_words(
-                yaml_data["nextOperation"]["groupName"], PadType.OPERATION_GROUP, yaml_data["nextOperation"]
+                yaml_data["nextOperation"]["groupName"],
+                PadType.OPERATION_GROUP,
+                yaml_data["nextOperation"],
+            )
+            yaml_data["nextOperation"]["groupName"] = to_snake_case(
+                yaml_data["nextOperation"]["groupName"]
             )
-            yaml_data["nextOperation"]["groupName"] = to_snake_case(yaml_data["nextOperation"]["groupName"])
             for response in yaml_data["nextOperation"].get("responses", []):
                 update_paging_response(response)
                 response["itemType"] = item_type
@@ -586,9 +690,13 @@ class PreProcessPlugin(YamlUpdatePlugin):
             update_paging_response(response)
             response["itemType"] = item_type
         for overload in yaml_data.get("overloads", []):
-            self.update_paging_operation(code_model, overload, is_overload=True, item_type=item_type)
+            self.update_paging_operation(
+                code_model, overload, is_overload=True, item_type=item_type
+            )
 
-    def update_operation_groups(self, code_model: dict[str, Any], client: dict[str, Any]) -> None:
+    def update_operation_groups(
+        self, code_model: dict[str, Any], client: dict[str, Any]
+    ) -> None:
         operation_groups_yaml_data = client.get("operationGroups", [])
         for operation_group in operation_groups_yaml_data:
             operation_group["identifyName"] = self.pad_reserved_words(
@@ -596,11 +704,17 @@ class PreProcessPlugin(YamlUpdatePlugin):
                 PadType.OPERATION_GROUP,
                 operation_group,
             )
-            operation_group["identifyName"] = to_snake_case(operation_group["identifyName"])
+            operation_group["identifyName"] = to_snake_case(
+                operation_group["identifyName"]
+            )
             operation_group["propertyName"] = self.pad_reserved_words(
-                operation_group["propertyName"], PadType.OPERATION_GROUP, operation_group
+                operation_group["propertyName"],
+                PadType.OPERATION_GROUP,
+                operation_group,
+            )
+            operation_group["propertyName"] = to_snake_case(
+                operation_group["propertyName"]
             )
-            operation_group["propertyName"] = to_snake_case(operation_group["propertyName"])
             operation_group["className"] = update_operation_group_class_name(
                 client["name"], operation_group["className"]
             )
@@ -624,4 +738,6 @@ class PreProcessPlugin(YamlUpdatePlugin):
 if __name__ == "__main__":
     # TSP pipeline will call this
     args, unknown_args = parse_args()
-    PreProcessPlugin(output_folder=args.output_folder, tsp_file=args.tsp_file, **unknown_args).process()
+    PreProcessPlugin(
+        output_folder=args.output_folder, tsp_file=args.tsp_file, **unknown_args
+    ).process()

package/generator/pygen/utils.py

@@ -11,8 +11,31 @@ SWAGGER_PACKAGE_MODE = ["mgmtplane", "dataplane"]  # for backward compatibility
 TYPESPEC_PACKAGE_MODE = ["azure-mgmt", "azure-dataplane", "generic"]
 VALID_PACKAGE_MODE = SWAGGER_PACKAGE_MODE + TYPESPEC_PACKAGE_MODE
 
+CODE_BLOCK_MARKER = ".. code-block::"
+
+
+def description_ends_with_code_block(description: str) -> bool:
+    """Return True when the description's trailing content is an RST ``.. code-block::``.
+
+    True when the last ``.. code-block::`` directive (starting its own line, so inline
+    mentions are ignored) is followed only by blank or indented lines, i.e. the literal
+    block runs to the end of the description.
+    """
+    lines = description.rstrip().splitlines()
+    directives = [
+        i for i, line in enumerate(lines) if line.lstrip().startswith(CODE_BLOCK_MARKER)
+    ]
+    if not directives:
+        return False
+    return all(
+        not line.strip() or line.startswith((" ", "\t"))
+        for line in lines[directives[-1] + 1 :]
+    )
+
 
-def update_enum_value(name: str, value: Any, description: str, enum_type: dict[str, Any]) -> dict[str, Any]:
+def update_enum_value(
+    name: str, value: Any, description: str, enum_type: dict[str, Any]
+) -> dict[str, Any]:
     return {
         "name": name,
         "type": "enumvalue",
@@ -39,7 +62,12 @@ def to_snake_case(name: str) -> str:
             and len(name) - next_non_upper_case_char_location > 1
             and name[next_non_upper_case_char_location].isalpha()
         ):
-            return prefix + match_str[: len(match_str) - 1] + "_" + match_str[len(match_str) - 1]
+            return (
+                prefix
+                + match_str[: len(match_str) - 1]
+                + "_"
+                + match_str[len(match_str) - 1]
+            )
 
         return prefix + match_str
 
@@ -86,7 +114,9 @@ def parse_args(
         return value
 
     unknown_args_ret = {
-        ua.strip("--").split("=", maxsplit=1)[0]: _get_value(ua.strip("--").split("=", maxsplit=1)[1])
+        ua.strip("--").split("=", maxsplit=1)[0]: _get_value(
+            ua.strip("--").split("=", maxsplit=1)[1]
+        )
         for ua in unknown_args
     }
     return args, unknown_args_ret
@@ -128,7 +158,11 @@ def build_policies(
             "self._config.user_agent_policy",
             "self._config.proxy_policy",
             "policies.ContentDecodePolicy(**kwargs)",
-            (f"{async_prefix}ARMAutoResourceProviderRegistrationPolicy()" if is_arm else None),
+            (
+                f"{async_prefix}ARMAutoResourceProviderRegistrationPolicy()"
+                if is_arm
+                else None
+            ),
             "self._config.redirect_policy",
             "self._config.retry_policy",
             "self._config.authentication_policy",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typespec/http-client-python",
-  "version": "0.32.0",
+  "version": "0.33.0",
   "author": "Microsoft Corporation",
   "description": "TypeSpec emitter for Python SDKs",
   "homepage": "https://typespec.io",