@autorest/python 6.29.1 → 6.31.0

package/autorest/m4reformatter/__init__.py

@@ -551,7 +551,7 @@ class M4Reformatter(YamlUpdatePluginAutorest):  # pylint: disable=too-many-publi
     def add_paging_information(self, group_name: str, operation: Dict[str, Any], yaml_data: Dict[str, Any]) -> None:
         operation["discriminator"] = "paging"
         operation["itemName"] = yaml_data["extensions"]["x-ms-pageable"].get("itemName", "value")
-        operation["continuationTokenName"] = yaml_data["extensions"]["x-ms-pageable"].get("nextLinkName")
+        operation["nextLinkName"] = yaml_data["extensions"]["x-ms-pageable"].get("nextLinkName")
         returned_response_object = (
             operation["nextOperation"]["responses"][0] if operation.get("nextOperation") else operation["responses"][0]
         )

package/generator/build/lib/pygen/__init__.py

@@ -78,12 +78,12 @@ class YamlUpdatePlugin(Plugin):
     """A plugin that update the YAML as input."""
 
     def get_yaml(self) -> Dict[str, Any]:
-        # cadl file doesn't have to be relative to output folder
-        with open(self.options["cadl_file"], "r", encoding="utf-8-sig") as fd:
+        # tsp file doesn't have to be relative to output folder
+        with open(self.options["tsp_file"], "r", encoding="utf-8-sig") as fd:
             return yaml.safe_load(fd.read())
 
     def write_yaml(self, yaml_string: str) -> None:
-        with open(self.options["cadl_file"], "w", encoding="utf-8-sig") as fd:
+        with open(self.options["tsp_file"], "w", encoding="utf-8-sig") as fd:
             fd.write(yaml_string)
 
     def process(self) -> bool:

package/generator/build/lib/pygen/black.py

@@ -77,6 +77,6 @@ class BlackScriptPlugin(Plugin):
 
 
 if __name__ == "__main__":
-    # CADL pipeline will call this
-    args, unknown_args = parse_args(need_cadl_file=False)
+    # TSP pipeline will call this
+    args, unknown_args = parse_args(need_tsp_file=False)
     BlackScriptPlugin(output_folder=args.output_folder, **unknown_args).process()

package/generator/build/lib/pygen/codegen/__init__.py

@@ -40,7 +40,6 @@ class OptionsRetriever:
         "generate-test": False,
         "from-typespec": False,
         "emit-cross-language-definition-file": False,
-        "enable-typespec-namespace": False,
     }
 
     @property
@@ -79,7 +78,7 @@ class OptionsRetriever:
     @property
     def _models_mode_default(self) -> str:
         models_mode_default = "none" if self.low_level_client or self.version_tolerant else "msrest"
-        if self.options.get("cadl_file") is not None:
+        if self.options.get("tsp_file") is not None:
             models_mode_default = "dpg"
         return models_mode_default
 
@@ -317,13 +316,12 @@ class CodeGenerator(Plugin):
             "flavor",
             "company_name",
             "emit_cross_language_definition_file",
-            "enable_typespec_namespace",
         ]
         return {f: getattr(self.options_retriever, f) for f in flags}
 
     def get_yaml(self) -> Dict[str, Any]:
-        # cadl file doesn't have to be relative to output folder
-        with open(self.options["cadl_file"], "r", encoding="utf-8-sig") as fd:
+        # tsp file doesn't have to be relative to output folder
+        with open(self.options["tsp_file"], "r", encoding="utf-8-sig") as fd:
             return yaml.safe_load(fd.read())
 
     def get_serializer(self, code_model: CodeModel):
@@ -350,10 +348,10 @@ class CodeGenerator(Plugin):
 
 
 if __name__ == "__main__":
-    # CADL pipeline will call this
+    # TSP pipeline will call this
     parsed_args, unknown_args = parse_args()
     CodeGenerator(
         output_folder=parsed_args.output_folder,
-        cadl_file=parsed_args.cadl_file,
+        tsp_file=parsed_args.tsp_file,
         **unknown_args,
     ).process()

package/generator/build/lib/pygen/codegen/models/code_model.py

@@ -145,12 +145,8 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
             return result
         return f"{result}{module_name}" if result.endswith(".") else f"{result}.{module_name}"
 
-    @property
-    def need_unique_model_alias(self) -> bool:
-        return self.has_subnamespace and self.options["enable_typespec_namespace"]
-
     def get_unique_models_alias(self, serialize_namespace: str, imported_namespace: str) -> str:
-        if not self.need_unique_model_alias:
+        if not self.has_subnamespace:
             return "_models"
         relative_path = self.get_relative_import_path(
             serialize_namespace, self.get_imported_namespace_for_model(imported_namespace)
@@ -406,3 +402,7 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
     @staticmethod
     def has_non_json_models(models: List[ModelType]) -> bool:
         return any(m for m in models if m.base != "json")
+
+    @property
+    def is_tsp(self) -> bool:
+        return self.options.get("tsp_file") is not None

package/generator/build/lib/pygen/codegen/models/paging_operation.py

@@ -58,6 +58,15 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
         self.override_success_response_to_200 = override_success_response_to_200
         self.pager_sync: str = yaml_data.get("pagerSync") or f"{self.code_model.core_library}.paging.ItemPaged"
         self.pager_async: str = yaml_data.get("pagerAsync") or f"{self.code_model.core_library}.paging.AsyncItemPaged"
+        self.continuation_token: Dict[str, Any] = yaml_data.get("continuationToken", {})
+
+    @property
+    def has_continuation_token(self) -> bool:
+        return bool(self.continuation_token.get("input") and self.continuation_token.get("output"))
+
+    @property
+    def next_variable_name(self) -> str:
+        return "_continuation_token" if self.has_continuation_token else "next_link"
 
     def _get_attr_name(self, wire_name: str) -> str:
         response_type = self.responses[0].type
@@ -74,8 +83,8 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
         return self.responses[0].get_pager(async_mode)
 
     @property
-    def continuation_token_name(self) -> Optional[str]:
-        wire_name = self.yaml_data.get("continuationTokenName")
+    def next_link_name(self) -> Optional[str]:
+        wire_name = self.yaml_data.get("nextLinkName")
         if not wire_name:
             # That's an ok scenario, it just means no next page possible
             return None

package/generator/build/lib/pygen/codegen/models/parameter.py

@@ -85,6 +85,7 @@ class _ParameterBase(BaseModel, abc.ABC):  # pylint: disable=too-many-instance-a
         self.in_overload: bool = self.yaml_data.get("inOverload", False)
         self.default_to_unset_sentinel: bool = self.yaml_data.get("defaultToUnsetSentinel", False)
         self.hide_in_method: bool = self.yaml_data.get("hideInMethod", False)
+        self.is_continuation_token: bool = bool(self.yaml_data.get("isContinuationToken"))
 
     def get_declaration(self, value: Any = None) -> Any:
         return self.type.get_declaration(value)
@@ -314,7 +315,7 @@ class Parameter(_ParameterBase):
     def hide_in_operation_signature(self) -> bool:
         if self.code_model.options["version_tolerant"] and self.client_name == "maxpagesize":
             return True
-        return False
+        return self.is_continuation_token
 
     @property
     def in_method_signature(self) -> bool:

package/generator/build/lib/pygen/codegen/models/request_builder_parameter.py

@@ -112,4 +112,6 @@ class RequestBuilderParameter(Parameter):
             return f"_{self.client_name}"
         if self.implementation == "Client":
             return f"self._config.{self.client_name}"
+        if self.is_continuation_token:
+            return "_continuation_token"
         return self.client_name

package/generator/build/lib/pygen/codegen/models/response.py

@@ -63,7 +63,7 @@ class Response(BaseModel):
     def result_property(self) -> str:
         field = self.yaml_data.get("resultProperty")
         if field:
-            return f'.get("{field}")'
+            return "".join([f'.get("{field}", {{}})' for field in field.split(".")])
         return ""
 
     def get_polymorphic_subtypes(self, polymorphic_subtypes: List["ModelType"]) -> None:

package/generator/build/lib/pygen/codegen/serializers/__init__.py

@@ -197,6 +197,8 @@ class JinjaSerializer(ReaderAndWriter):
             env = Environment(
                 loader=PackageLoader("pygen.codegen", "templates/packaging_templates"),
                 undefined=StrictUndefined,
+                trim_blocks=True,
+                lstrip_blocks=True,
             )
 
             package_files = _PACKAGE_FILES
@@ -460,21 +462,11 @@ class JinjaSerializer(ReaderAndWriter):
         metadata_serializer = MetadataSerializer(self.code_model, env, client_namespace=namespace)
         self.write_file(self.exec_path(namespace) / Path("_metadata.json"), metadata_serializer.serialize())
 
-    @property
-    def _namespace_from_package_name(self) -> str:
-        return get_namespace_from_package_name(self.code_model.options["package_name"])
-
-    def _name_space(self) -> str:
-        if self.code_model.namespace.count(".") >= self._namespace_from_package_name.count("."):
-            return self.code_model.namespace
-
-        return self._namespace_from_package_name
-
     @property
     def exec_path_compensation(self) -> Path:
         """Assume the process is running in the root folder of the package. If not, we need the path compensation."""
         return (
-            Path("../" * (self._name_space().count(".") + 1))
+            Path("../" * (self.code_model.namespace.count(".") + 1))
             if self.code_model.options["no_namespace_folders"]
             else Path(".")
         )
@@ -482,16 +474,28 @@ class JinjaSerializer(ReaderAndWriter):
     def exec_path_for_test_sample(self, namespace: str) -> Path:
         return self.exec_path_compensation / Path(*namespace.split("."))
 
+    # pylint: disable=line-too-long
     def exec_path(self, namespace: str) -> Path:
         if self.code_model.options["no_namespace_folders"] and not self.code_model.options["multiapi"]:
+            # when output folder contains parts different from the namespace, we fall back to current folder directly.
+            # (e.g. https://github.com/Azure/azure-sdk-for-python/blob/main/sdk/communication/azure-communication-callautomation/swagger/SWAGGER.md)
             return Path(".")
         return self.exec_path_compensation / Path(*namespace.split("."))
 
+    # pylint: disable=line-too-long
     @property
-    def _additional_folder(self) -> Path:
+    def sample_additional_folder(self) -> Path:
+        # For special package, we need to additional folder when generate samples.
+        # For example, azure-mgmt-resource is combined by multiple modules, and each module is multiapi package.
+        # one of namespace is "azure.mgmt.resource.resources.v2020_01_01", then additional folder is "resources"
+        # so that we could avoid conflict when generate samples.
+        # python config: https://github.com/Azure/azure-rest-api-specs/blob/main/specification/resources/resource-manager/readme.python.md
+        # generated SDK: https://github.com/Azure/azure-sdk-for-python/tree/main/sdk/resources/azure-mgmt-resource/generated_samples
         namespace_config = get_namespace_config(self.code_model.namespace, self.code_model.options["multiapi"])
         num_of_namespace = namespace_config.count(".") + 1
-        num_of_package_namespace = self._namespace_from_package_name.count(".") + 1
+        num_of_package_namespace = (
+            get_namespace_from_package_name(self.code_model.options["package_name"]).count(".") + 1
+        )
         if num_of_namespace > num_of_package_namespace:
             return Path("/".join(namespace_config.split(".")[num_of_package_namespace:]))
         return Path("")
@@ -514,7 +518,7 @@ class JinjaSerializer(ReaderAndWriter):
                         file_name = to_snake_case(extract_sample_name(file)) + ".py"
                         try:
                             self.write_file(
-                                out_path / self._additional_folder / _sample_output_path(file) / file_name,
+                                out_path / self.sample_additional_folder / _sample_output_path(file) / file_name,
                                 SampleSerializer(
                                     code_model=self.code_model,
                                     env=env,

package/generator/build/lib/pygen/codegen/serializers/builder_serializer.py

@@ -630,7 +630,7 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
             operation_name=f"('{builder.name}')" if builder.group_name == "" else "",
         )
         for p in builder.parameters.parameters:
-            if p.hide_in_operation_signature:
+            if p.hide_in_operation_signature and not p.is_continuation_token:
                 kwargs.append(f'{p.client_name} = kwargs.pop("{p.client_name}", None)')
         cls_annotation = builder.cls_type_annotation(
             async_mode=self.async_mode, serialize_namespace=self.serialize_namespace
@@ -1001,9 +1001,7 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
                 retval.extend(deserialize_code)
         return retval
 
-    def handle_error_response(  # pylint: disable=too-many-statements, too-many-branches
-        self, builder: OperationType
-    ) -> List[str]:
+    def handle_error_response(self, builder: OperationType) -> List[str]:
         async_await = "await " if self.async_mode else ""
         retval = [f"if response.status_code not in {str(builder.success_status_codes)}:"]
         response_read = [
@@ -1290,16 +1288,20 @@ class _PagingOperationSerializer(_OperationSerializer[PagingOperationType]):
 
     def _prepare_request_callback(self, builder: PagingOperationType) -> List[str]:
         retval = self._initialize_overloads(builder)
-        retval.append("def prepare_request(next_link=None):")
-        retval.append("    if not next_link:")
-        retval.extend([f"        {line}" for line in self.call_request_builder(builder, is_paging=True)])
-        retval.append("")
-        retval.append("    else:")
-        retval.extend([f"        {line}" for line in self.call_next_link_request_builder(builder)])
-        if not builder.next_request_builder and self.code_model.is_legacy:
-            retval.append('        _request.method = "GET"')
+        if builder.has_continuation_token:
+            retval.append(f"def prepare_request({builder.next_variable_name}=None):")
+            retval.extend([f"    {line}" for line in self.call_request_builder(builder, is_paging=True)])
         else:
+            retval.append("def prepare_request(next_link=None):")
+            retval.append("    if not next_link:")
+            retval.extend([f"        {line}" for line in self.call_request_builder(builder, is_paging=True)])
             retval.append("")
+            retval.append("    else:")
+            retval.extend([f"        {line}" for line in self.call_next_link_request_builder(builder)])
+            if not builder.next_request_builder and self.code_model.is_legacy:
+                retval.append('        _request.method = "GET"')
+            else:
+                retval.append("")
         retval.append("    return _request")
         return retval
 
@@ -1307,7 +1309,7 @@ class _PagingOperationSerializer(_OperationSerializer[PagingOperationType]):
     def _function_def(self) -> str:
         return "def"
 
-    def _extract_data_callback(self, builder: PagingOperationType) -> List[str]:
+    def _extract_data_callback(self, builder: PagingOperationType) -> List[str]:  # pylint: disable=too-many-statements
         retval = [f"{'async ' if self.async_mode else ''}def extract_data(pipeline_response):"]
         response = builder.responses[0]
         deserialized = "pipeline_response.http_response.json()"
@@ -1328,7 +1330,13 @@ class _PagingOperationSerializer(_OperationSerializer[PagingOperationType]):
         else:
             retval.append(f"    deserialized = {deserialized}")
         item_name = builder.item_name
-        access = f".{item_name}" if self.code_model.options["models_mode"] == "msrest" else f'["{item_name}"]'
+        if self.code_model.options["models_mode"] == "msrest":
+            access = f".{item_name}"
+        else:
+            item_name_array = item_name.split(".")
+            access = (
+                "".join([f'.get("{i}", {{}})' for i in item_name_array[:-1]]) + f'.get("{item_name_array[-1]}", [])'
+            )
         list_of_elem_deserialized = ""
         if self.code_model.options["models_mode"] == "dpg":
             item_type = builder.item_type.type_annotation(
@@ -1341,20 +1349,34 @@ class _PagingOperationSerializer(_OperationSerializer[PagingOperationType]):
         retval.append("    if cls:")
         retval.append("        list_of_elem = cls(list_of_elem) # type: ignore")
 
-        continuation_token_name = builder.continuation_token_name
-        if not continuation_token_name:
-            cont_token_property = "None"
-        elif self.code_model.options["models_mode"] == "msrest":
-            cont_token_property = f"deserialized.{continuation_token_name} or None"
+        if builder.has_continuation_token:
+            location = builder.continuation_token.get("output", {}).get("location")
+            wire_name = builder.continuation_token.get("output", {}).get("wireName") or ""
+            if location == "header":
+                cont_token_property = f'pipeline_response.http_response.headers.get("{wire_name}") or None'
+            else:
+                wire_name_array = wire_name.split(".")
+                wire_name_call = (
+                    "".join([f'.get("{i}", {{}})' for i in wire_name_array[:-1]]) + f'.get("{wire_name_array[-1]}")'
+                )
+                cont_token_property = f"deserialized{wire_name_call} or None"
         else:
-            cont_token_property = f'deserialized.get("{continuation_token_name}") or None'
+            next_link_name = builder.next_link_name
+            if not next_link_name:
+                cont_token_property = "None"
+            elif self.code_model.options["models_mode"] == "msrest":
+                cont_token_property = f"deserialized.{next_link_name} or None"
+            else:
+                cont_token_property = f'deserialized.get("{next_link_name}") or None'
         list_type = "AsyncList" if self.async_mode else "iter"
         retval.append(f"    return {cont_token_property}, {list_type}(list_of_elem)")
         return retval
 
     def _get_next_callback(self, builder: PagingOperationType) -> List[str]:
-        retval = [f"{'async ' if self.async_mode else ''}def get_next(next_link=None):"]
-        retval.append("    _request = prepare_request(next_link)")
+        retval = [
+            f"{'async ' if self.async_mode else ''}def get_next({builder.next_variable_name}=None):"  # pylint: disable=line-too-long
+        ]
+        retval.append(f"    _request = prepare_request({builder.next_variable_name})")
         retval.append("")
         retval.extend([f"    {l}" for l in self.make_pipeline_call(builder)])
         retval.append("    response = pipeline_response.http_response")
@@ -1506,10 +1528,10 @@ class LROPagingOperationSerializer(
 
     def get_long_running_output(self, builder: LROPagingOperation) -> List[str]:
         retval = ["def get_long_running_output(pipeline_response):"]
-        retval.append(f"    {self._function_def} internal_get_next(next_link=None):")
-        retval.append("        if next_link is None:")
+        retval.append(f"    {self._function_def} internal_get_next({builder.next_variable_name}=None):")
+        retval.append(f"        if {builder.next_variable_name} is None:")
         retval.append("            return pipeline_response")
-        retval.append(f"        return {self._call_method}get_next(next_link)")
+        retval.append(f"        return {self._call_method}get_next({builder.next_variable_name})")
         retval.append("")
         retval.append(f"    return {builder.get_pager(self.async_mode)}(")
         retval.append("        internal_get_next, extract_data")

package/generator/build/lib/pygen/codegen/serializers/general_serializer.py

@@ -28,7 +28,11 @@ class GeneralSerializer(BaseSerializer):
 
     def serialize_package_file(self, template_name: str, **kwargs: Any) -> str:
         template = self.env.get_template(template_name)
-        package_parts = (self.code_model.options["package_name"] or "").split("-")[:-1]
+        package_parts = (
+            self.code_model.namespace.split(".")[:-1]
+            if self.code_model.is_tsp
+            else (self.code_model.options["package_name"] or "").split("-")[:-1]
+        )
         token_credential = any(
             c for c in self.code_model.clients if isinstance(getattr(c.credential, "type", None), TokenCredentialType)
         )
@@ -44,7 +48,6 @@ class GeneralSerializer(BaseSerializer):
             "pkgutil_names": [".".join(package_parts[: i + 1]) for i in range(len(package_parts))],
             "init_names": ["/".join(package_parts[: i + 1]) + "/__init__.py" for i in range(len(package_parts))],
             "client_name": self.code_model.clients[0].name,
-            "namespace": self.code_model.namespace,
         }
         params.update(self.code_model.options)
         params.update(kwargs)

package/generator/build/lib/pygen/codegen/serializers/test_serializer.py

@@ -19,7 +19,7 @@ from ..models import (
     CombinedType,
     FileImport,
 )
-from .utils import get_namespace_from_package_name, json_dumps_template
+from .utils import json_dumps_template
 
 
 def is_lro(operation_type: str) -> bool:

package/generator/build/lib/pygen/codegen/templates/packaging_templates/MANIFEST.in.jinja2

@@ -1,8 +1,12 @@
 include *.md
 include LICENSE
+{% if code_model.is_tsp %}
+include {{ code_model.namespace.replace('.', '/') }}/py.typed
+{% else %}
 include {{ package_name.replace('-', '/') }}/py.typed
+{% endif %}
 recursive-include tests *.py
 recursive-include samples *.py *.md
-{%- for init_name in init_names %}
+{% for init_name in init_names %}
 include {{ init_name }}
-{%- endfor %}
+{% endfor %}

package/generator/build/lib/pygen/codegen/templates/packaging_templates/README.md.jinja2

@@ -1,5 +1,5 @@
 {% if code_model.is_azure_flavor %}
-{% if package_mode == "mgmtplane" -%}
+{% if package_mode == "mgmtplane" %}
 # Microsoft Azure SDK for Python
 
 This is the Microsoft {{package_pprint_name}} Client Library.
@@ -40,7 +40,7 @@ python -m pip install {{ package_name }}
 - You need an [Azure subscription][azure_sub] to use this package.
 - An existing {{ package_pprint_name }} instance.
 
-{%- if token_credential %}
+{% if token_credential %}
 #### Create with an Azure Active Directory Credential
 To use an [Azure Active Directory (AAD) token credential][authenticate_with_token],
 provide an instance of the desired credential type obtained from the
@@ -57,7 +57,7 @@ Set the values of the client ID, tenant ID, and client secret of the AAD applica
 Use the returned token credential to authenticate the client:
 
 ```python
->>> from {{ namespace }} import {{ client_name }}
+>>> from {{ code_model.namespace }} import {{ client_name }}
 >>> from azure.identity import DefaultAzureCredential
 >>> client = {{ client_name }}(endpoint='<endpoint>', credential=DefaultAzureCredential())
 ```
@@ -65,7 +65,7 @@ Use the returned token credential to authenticate the client:
 ## Examples
 
 ```python
->>> from {{ namespace }} import {{ client_name }}
+>>> from {{ code_model.namespace }} import {{ client_name }}
 >>> from azure.identity import DefaultAzureCredential
 >>> from {{ code_model.core_library }}.exceptions import HttpResponseError
 
@@ -76,7 +76,7 @@ Use the returned token credential to authenticate the client:
         print('service responds error: {}'.format(e.response.json()))
 
 ```
-{%- endif %}
+{% endif %}
 
 ## Contributing
 

package/generator/build/lib/pygen/codegen/templates/packaging_templates/dev_requirements.txt.jinja2

@@ -1,9 +1,9 @@
 -e ../../../tools/azure-sdk-tools
 ../../core/azure-core
-{% if token_credential -%}
+{% if token_credential %}
 ../../identity/azure-identity
 {% endif -%}
-{% if azure_arm -%}
+{% if azure_arm %}
 ../../core/azure-mgmt-core
-{% endif -%}
+{% endif %}
 aiohttp

package/generator/build/lib/pygen/codegen/templates/packaging_templates/setup.py.jinja2

@@ -2,19 +2,27 @@
 {{ license_header }}
 # coding: utf-8
 {% if package_mode %}
+
 import os
 import re
-{% endif -%}
+{% endif %}
 from setuptools import setup, find_packages
 
 {% set package_name = package_name or code_model.clients[0].name %}
 
 PACKAGE_NAME = "{{ package_name|lower }}"
-{% if package_mode -%}
+{% if package_mode %}
 PACKAGE_PPRINT_NAME = "{{ package_pprint_name }}"
+{% if code_model.is_tsp %}
+PACKAGE_NAMESPACE = "{{ code_model.namespace|lower }}"
+
+# a.b.c => a/b/c
+package_folder_path = PACKAGE_NAMESPACE.replace(".", "/")
+{% else %}
 
 # a-b-c => a/b/c
 package_folder_path = PACKAGE_NAME.replace("-", "/")
+{% endif %}
 
 # Version extraction inspired from 'requests'
 with open(os.path.join(package_folder_path, "_version.py"), "r") as fd:
@@ -33,7 +41,8 @@ version = "{{ package_version }}"
 {% set long_description = code_model.description %}
 {% set author_email = "" %}
 {% set url = "" %}
-{% endif -%}
+{% endif %}
+
 
 setup(
     name=PACKAGE_NAME,
@@ -70,9 +79,9 @@ setup(
             {% if pkgutil_names %}
             # Exclude packages that will be covered by PEP420 or nspkg
             {% endif %}
-            {%- for pkgutil_name in pkgutil_names %}
+            {% for pkgutil_name in pkgutil_names %}
             "{{ pkgutil_name }}",
-            {%- endfor %}
+            {% endfor %}
         ]
     ),
     include_package_data=True,

package/generator/build/lib/pygen/preprocess/__init__.py

@@ -14,7 +14,7 @@ from .helpers import (
     pad_builtin_namespaces,
     pad_special_chars,
 )
-from .python_mappings import CADL_RESERVED_WORDS, RESERVED_WORDS, PadType
+from .python_mappings import TSP_RESERVED_WORDS, RESERVED_WORDS, PadType
 
 from .. import YamlUpdatePlugin
 from ..utils import (
@@ -182,11 +182,11 @@ class PreProcessPlugin(YamlUpdatePlugin):
 
     @property
     def models_mode(self) -> Optional[str]:
-        return self.options.get("models-mode", "dpg" if self.is_cadl else None)
+        return self.options.get("models-mode", "dpg" if self.is_tsp else None)
 
     @property
-    def is_cadl(self) -> bool:
-        return self.options.get("cadl_file", False)
+    def is_tsp(self) -> bool:
+        return self.options.get("tsp_file", False)
 
     def add_body_param_type(
         self,
@@ -197,9 +197,7 @@ 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_cadl 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))
         ):
@@ -210,7 +208,7 @@ class PreProcessPlugin(YamlUpdatePlugin):
                 "types": [body_parameter["type"]],
             }
             # don't add binary overload for multipart content type
-            if not (self.is_cadl and has_multi_part_content_type(body_parameter)):
+            if not (self.is_tsp and has_multi_part_content_type(body_parameter)):
                 body_parameter["type"]["types"].append(KNOWN_TYPES["binary"])
 
             if origin_type == "model" and is_dpg_model and self.models_mode == "dpg":
@@ -223,8 +221,8 @@ class PreProcessPlugin(YamlUpdatePlugin):
             # we'll pass in empty operation groups sometime etc.
             return name
 
-        if self.is_cadl:
-            reserved_words = {k: (v + CADL_RESERVED_WORDS.get(k, [])) for k, v in RESERVED_WORDS.items()}
+        if self.is_tsp:
+            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)
@@ -506,6 +504,6 @@ class PreProcessPlugin(YamlUpdatePlugin):
 
 
 if __name__ == "__main__":
-    # CADL pipeline will call this
+    # TSP pipeline will call this
     args, unknown_args = parse_args()
-    PreProcessPlugin(output_folder=args.output_folder, cadl_file=args.cadl_file, **unknown_args).process()
+    PreProcessPlugin(output_folder=args.output_folder, tsp_file=args.tsp_file, **unknown_args).process()

package/generator/build/lib/pygen/preprocess/python_mappings.py

@@ -185,7 +185,7 @@ RESERVED_WORDS = {
     PadType.OPERATION_GROUP: [*_always_reserved],
 }
 
-CADL_RESERVED_WORDS = {
+TSP_RESERVED_WORDS = {
     PadType.PARAMETER: ["stream"],
     PadType.PROPERTY: RESERVED_MODEL_PROPERTIES,
 }

package/generator/build/lib/pygen/utils.py

@@ -44,7 +44,7 @@ def to_snake_case(name: str) -> str:
 
 
 def parse_args(
-    need_cadl_file: bool = True,
+    need_tsp_file: bool = True,
 ) -> Tuple[argparse.Namespace, Dict[str, Any]]:
     parser = argparse.ArgumentParser(
         description="Run mypy against target folder. Add a local custom plugin to the path prior to execution. "
@@ -56,10 +56,10 @@ def parse_args(
         required=True,
     )
     parser.add_argument(
-        "--cadl-file",
-        dest="cadl_file",
-        help="Serialized cadl file",
-        required=need_cadl_file,
+        "--tsp-file",
+        dest="tsp_file",
+        help="Serialized tsp file",
+        required=need_tsp_file,
     )
     parser.add_argument(
         "--debug",