@typespec/http-client-python 0.32.0 → 0.34.0

package/generator/pygen/codegen/templates/packaging_templates/pyproject.toml.jinja2

@@ -11,15 +11,32 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "{{ options.get('package-name')|lower }}"
 {% if options.get('package-mode') %}
+{% if KEEP_FIELDS and KEEP_FIELDS.get('project.authors') %}
+authors = [
+  {% for author in KEEP_FIELDS.get('project.authors') %}
+  { {% for key, val in author.items() %}{{ key }} = {{ val|tojson }}{% if not loop.last %}, {% endif %}{% endfor %} },
+  {% endfor %}
+]
+{% else %}
 authors = [
   { name = "{{ code_model.company_name }}"{% if code_model.is_azure_flavor %}, email = "azpysdkhelp@microsoft.com"{% endif %} },
 ]
-{% if options.get("azure-arm") %}
+{% endif %}
+{% if KEEP_FIELDS and KEEP_FIELDS.get('project.description') %}
+description = {{ KEEP_FIELDS.get('project.description')|tojson }}
+{% elif options.get("azure-arm") %}
 description = "Microsoft Azure {{ options.get('package-pprint-name') }} Client Library for Python"
 {% else %}
 description = "{{ code_model.company_name }} {% if code_model.is_azure_flavor and not options.get('package-pprint-name').startswith('Azure ') %}Azure {% endif %}{{ options.get('package-pprint-name') }} Client Library for Python"
 {% endif %}
 license = "MIT"
+{% if KEEP_FIELDS and KEEP_FIELDS.get('project.classifiers') %}
+classifiers = [
+    {% for classifier in KEEP_FIELDS.get('project.classifiers') %}
+    {{ classifier|tojson }},
+    {% endfor %}
+]
+{% else %}
 classifiers = [
     "Development Status :: {{ dev_status }}",
     "Programming Language :: Python",
@@ -29,10 +46,15 @@ classifiers = [
     "Programming Language :: Python :: 3.{{ version }}",
     {% endfor %}
 ]
+{% endif %}
 requires-python = ">={{ MIN_PYTHON_VERSION }}"
 {% else %}
+{% if KEEP_FIELDS and KEEP_FIELDS.get('project.description') %}
+description = {{ KEEP_FIELDS.get('project.description')|tojson }}
+{% else %}
 description = "{{ options.get('package-name') }}"
 {% endif %}
+{% endif %}
 {% if code_model.is_azure_flavor %}
 keywords = ["azure", "azure sdk"]
 {% endif %}
@@ -77,7 +99,13 @@ version = "{{ options.get("package-version", "unknown") }}"
 ]
 {% endfor %}
 {% endif %}
-{% if code_model.is_azure_flavor %}
+{% if KEEP_FIELDS and KEEP_FIELDS.get('project.urls') %}
+
+[project.urls]
+{% for key, val in KEEP_FIELDS.get('project.urls').items() %}
+{{ key }} = {{ val|tojson }}
+{% endfor %}
+{% elif code_model.is_azure_flavor %}
 
 [project.urls]
 repository = "https://github.com/Azure/azure-sdk-for-python"

package/generator/pygen/codegen/templates/types.py.jinja2

@@ -4,6 +4,55 @@
 {% endif %}
 
 {{ imports }}
-{% for nu in code_model.named_unions %}
-{{nu.name}} = {{nu.type_definition()}}
+{% import 'operation_tools.jinja2' as op_tools %}
+{% import "macros.jinja2" as macros %}
+{% for enum in literal_enums %}
+
+{{ serializer.declare_literal_enum(enum) }}
+{% if enum.yaml_data.get("description") %}
+"""{{ op_tools.wrap_string(enum.yaml_data["description"], "\n") }}"""
+{% endif %}
+{% endfor %}
+{% for model in models %}
+{% if serializer.has_keyword_wire_names(model) %}
+
+
+{{ serializer.declare_functional_model(model) }}
+{{ model.name }}.__doc__ = """{{ op_tools.wrap_string(model.description(is_operation_file=False), "\n") }}
+
+{% if model.properties != None %}
+    {% for p in model.properties %}
+        {% for line in serializer.variable_documentation_string(p) %}
+{{ macros.wrap_model_string(line, '\n') -}}
+        {% endfor %}
+    {% endfor %}
+{% endif %}
+"""
+{% else %}
+
+
+{{ serializer.declare_model(model) }}
+    """{{ op_tools.wrap_string(model.description(is_operation_file=False), "\n    ") }}
+
+    {% if model.properties != None %}
+        {% for p in model.properties %}
+            {% for line in serializer.variable_documentation_string(p) %}
+    {{ macros.wrap_model_string(line, '\n    ') -}}
+            {% endfor %}
+        {% endfor %}
+    {% endif %}
+    """
+
+    {% set shadowed = serializer.get_shadowed_builtins(model) %}
+    {% for p in serializer.get_properties_to_declare(model)%}
+    {{ serializer.declare_property(p, shadowed) }}
+        {% set prop_description = p.description(is_operation_file=False).replace('"', '\\"') %}
+        {% if prop_description %}
+    """{{ macros.wrap_model_string(prop_description, '\n    ', '\"\"\"') -}}
+        {% endif %}
+    {% endfor %}
+{% endif %}
+{% endfor %}
+{% for model in discriminated_bases %}
+{{ serializer.discriminated_subtypes_union(model) }}
 {% endfor %}

package/generator/pygen/codegen/templates/unions.py.jinja2

@@ -0,0 +1,9 @@
+# coding=utf-8
+{% if code_model.license_header %}
+{{ code_model.license_header }}
+{% endif %}
+
+{{ imports }}
+{% for nu in code_model.named_unions %}
+{{nu.name}} = {{nu.type_definition()}}
+{% endfor %}

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,
 )
 
 
@@ -93,6 +94,8 @@ def add_overloads_for_body_param(yaml_data: dict[str, Any]) -> None:
             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))
+            # Skip single-body JSON overload; the TypedDict overload replaces it
+            continue
         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["inOverload"] = False
@@ -108,7 +111,9 @@ def update_description(description: Optional[str], default_description: 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
 
@@ -301,6 +306,44 @@ class PreProcessPlugin(YamlUpdatePlugin):
     def is_tsp(self) -> bool:
         return self.options.get("tsp_file", False)
 
+    @staticmethod
+    def _find_existing_typeddict(code_model: dict[str, Any], cross_lang_id: Optional[str]) -> Optional[dict[str, Any]]:
+        """Find an existing typeddict copy with the given crossLanguageDefinitionId."""
+        if not cross_lang_id:
+            return None
+        return next(
+            (
+                t
+                for t in code_model["types"]
+                if t.get("type") == "model"
+                and t.get("base") == "typeddict"
+                and t.get("crossLanguageDefinitionId") == cross_lang_id
+            ),
+            None,
+        )
+
+    @staticmethod
+    def _insert_typeddict_overload(
+        code_model: dict[str, Any],
+        body_parameter: dict[str, Any],
+        source: dict[str, Any],
+        origin_type: str,
+        existing_td: Optional[dict[str, Any]],
+    ) -> None:
+        """Insert a typeddict type into the body parameter's combined types."""
+        if origin_type == "model":
+            td_type = existing_td or {**source, "base": "typeddict"}
+            body_parameter["type"]["types"].insert(1, td_type)
+            if not existing_td:
+                code_model["types"].append(td_type)
+        else:
+            td_list_or_dict = copy.deepcopy(body_parameter["type"]["types"][0])
+            td_elem = existing_td or {**source, "base": "typeddict"}
+            td_list_or_dict["elementType"] = td_elem
+            body_parameter["type"]["types"].insert(1, td_list_or_dict)
+            if not existing_td:
+                code_model["types"].append(td_elem)
+
     def add_body_param_type(
         self,
         code_model: dict[str, Any],
@@ -319,25 +362,65 @@ class PreProcessPlugin(YamlUpdatePlugin):
                 body_parameter["type"] if origin_type == "model" else body_parameter["type"].get("elementType", {})
             )
             is_dpg_model = model_type.get("base") == "dpg"
+            is_json_model = model_type.get("base") == "json"
+            is_typeddict_only = self.options["models-mode"] == "typeddict"
+
             body_parameter["type"] = {
                 "type": "combined",
                 "types": [body_parameter["type"]],
             }
-            # don't add binary overload for multipart content type
-            if not (self.is_tsp and has_multi_part_content_type(body_parameter)):
+            # don't add binary overload for multipart content type or typeddict-only mode
+            if not (self.is_tsp and has_multi_part_content_type(body_parameter)) and not is_typeddict_only:
                 body_parameter["type"]["types"].append(KNOWN_TYPES["binary"])
 
+            # Add typeddict overload for non-spread dpg models
             if self.options["models-mode"] == "dpg" and is_dpg_model:
-                if origin_type == "model":
-                    body_parameter["type"]["types"].insert(1, KNOWN_TYPES["any-object"])
+                cross_lang_id = model_type.get("crossLanguageDefinitionId")
+                existing_td = self._find_existing_typeddict(code_model, cross_lang_id)
+                self._insert_typeddict_overload(code_model, body_parameter, model_type, origin_type, existing_td)
+
+            # For spread bodies (json base), add a typeddict overload that references
+            # the original model. This replaces the JSON single-body overload.
+            if is_json_model:
+                cross_lang_id = model_type.get("crossLanguageDefinitionId")
+                original = None
+                if cross_lang_id:
+                    original = next(
+                        (
+                            t
+                            for t in code_model["types"]
+                            if t.get("type") == "model"
+                            and t.get("crossLanguageDefinitionId") == cross_lang_id
+                            and t is not model_type
+                        ),
+                        None,
+                    )
+
+                if is_typeddict_only and original:
+                    # In typeddict-only mode, the original dpg model already renders
+                    # as a TypedDict — reference it directly, no copy needed.
+                    if origin_type == "model":
+                        body_parameter["type"]["types"].insert(1, original)
+                    else:
+                        td_list_or_dict = copy.deepcopy(body_parameter["type"]["types"][0])
+                        td_list_or_dict["elementType"] = original
+                        body_parameter["type"]["types"].insert(1, td_list_or_dict)
                 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["elementType"] = KNOWN_TYPES["any-object"]
-                    body_parameter["type"]["types"].insert(1, any_obj_list_or_dict)
+                    source = original or model_type
+                    existing_td = self._find_existing_typeddict(code_model, cross_lang_id)
+                    self._insert_typeddict_overload(code_model, body_parameter, source, origin_type, existing_td)
+
+            if len(body_parameter["type"]["types"]) == 1:
+                # Only one body variant remains (e.g. typeddict-only mode where the
+                # binary and JSON overloads are omitted). Collapse the combined
+                # wrapper back to the single type so we don't emit a lone
+                # ``@overload`` (mypy rejects a single overload definition).
+                body_parameter["type"] = body_parameter["type"]["types"][0]
+                return
+
             code_model["types"].append(body_parameter["type"])
 
+
     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:
@@ -485,7 +568,11 @@ class PreProcessPlugin(YamlUpdatePlugin):
             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:
@@ -576,7 +663,9 @@ 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"])
             for response in yaml_data["nextOperation"].get("responses", []):
@@ -598,7 +687,9 @@ class PreProcessPlugin(YamlUpdatePlugin):
             )
             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["className"] = update_operation_group_class_name(

package/generator/pygen/utils.py

@@ -11,6 +11,22 @@ 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]:
     return {

package/generator/pygen.egg-info/SOURCES.txt

@@ -56,6 +56,7 @@ pygen/codegen/serializers/request_builders_serializer.py
 pygen/codegen/serializers/sample_serializer.py
 pygen/codegen/serializers/test_serializer.py
 pygen/codegen/serializers/types_serializer.py
+pygen/codegen/serializers/unions_serializer.py
 pygen/codegen/serializers/utils.py
 pygen/codegen/templates/client.py.jinja2
 pygen/codegen/templates/client_container.py.jinja2
@@ -90,6 +91,7 @@ pygen/codegen/templates/serialization.py.jinja2
 pygen/codegen/templates/test.py.jinja2
 pygen/codegen/templates/testpreparer.py.jinja2
 pygen/codegen/templates/types.py.jinja2
+pygen/codegen/templates/unions.py.jinja2
 pygen/codegen/templates/utils.py.jinja2
 pygen/codegen/templates/validation.py.jinja2
 pygen/codegen/templates/version.py.jinja2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typespec/http-client-python",
-  "version": "0.32.0",
+  "version": "0.34.0",
   "author": "Microsoft Corporation",
   "description": "TypeSpec emitter for Python SDKs",
   "homepage": "https://typespec.io",
@@ -68,7 +68,7 @@
     "@azure-tools/typespec-azure-core": ">=0.69.0 <1.0.0",
     "@azure-tools/typespec-azure-resource-manager": ">=0.69.1 <1.0.0",
     "@azure-tools/typespec-azure-rulesets": ">=0.69.1 <1.0.0",
-    "@azure-tools/typespec-client-generator-core": ">=0.69.0 <1.0.0",
+    "@azure-tools/typespec-client-generator-core": ">=0.69.1 <1.0.0",
     "@typespec/compiler": "^1.13.0",
     "@typespec/http": "^1.13.0",
     "@typespec/openapi": "^1.13.0",
@@ -95,7 +95,7 @@
     ]
   },
   "dependencies": {
-    "js-yaml": "~4.1.0",
+    "js-yaml": "^4.2.0",
     "marked": "^15.0.6",
     "pyodide": "0.26.2",
     "semver": "~7.6.2",
@@ -106,7 +106,7 @@
     "@azure-tools/typespec-azure-core": "~0.69.0",
     "@azure-tools/typespec-azure-resource-manager": "~0.69.1",
     "@azure-tools/typespec-azure-rulesets": "~0.69.1",
-    "@azure-tools/typespec-client-generator-core": "~0.69.0",
+    "@azure-tools/typespec-client-generator-core": "~0.69.1",
     "@azure-tools/azure-http-specs": "0.1.0-alpha.42",
     "@typespec/compiler": "^1.13.0",
     "@typespec/http": "^1.13.0",
@@ -119,7 +119,7 @@
     "@typespec/sse": "~0.83.0",
     "@typespec/streams": "~0.83.0",
     "@typespec/xml": "~0.83.0",
-    "@typespec/http-specs": "0.1.0-alpha.39-dev.1",
+    "@typespec/http-specs": "0.1.0-alpha.39-dev.2",
     "@types/js-yaml": "~4.0.5",
     "@types/node": "~25.0.2",
     "@types/semver": "7.5.8",