@autorest/python 6.1.2 → 6.1.5

package/ChangeLog.md

@@ -1,5 +1,61 @@
 # Release History
 
+### 2022-09-06 - 6.1.5
+
+| Library                                                                 | Min Version |
+| ----------------------------------------------------------------------- | ----------- |
+| `@autorest/core`                                                        | `3.8.4`     |
+| `@autorest/modelerfour`                                                 | `4.23.5`    |
+| `azure-core` dep of generated code                                      | `1.24.0`    |
+| `isodate` dep of generated code                                         | `0.6.1`     |
+| `msrest` dep of generated code (If generating legacy code)              | `0.7.1`     |
+| `azure-mgmt-core` dep of generated code (If generating mgmt plane code) | `1.3.2`     |
+
+**Bug Fixes**
+
+- Fix `api_version` error when there are multi different `api-version`(not multiapi)   #1429
+- Fix generator raising `KeyError` in corner case when generating an LRO-paging operation  #1425
+
+**Other Changes**
+
+- Default `304` errors to throw `azure.core.exception.ResourceNotFoundError`s  #1415
+
+### 2022-08-31 - 6.1.4
+
+| Library                                                                 | Min Version |
+| ----------------------------------------------------------------------- | ----------- |
+| `@autorest/core`                                                        | `3.8.4`     |
+| `@autorest/modelerfour`                                                 | `4.23.5`    |
+| `azure-core` dep of generated code                                      | `1.24.0`    |
+| `isodate` dep of generated code                                         | `0.6.1`     |
+| `msrest` dep of generated code (If generating legacy code)              | `0.7.1`     |
+| `azure-mgmt-core` dep of generated code (If generating mgmt plane code) | `1.3.2`     |
+
+**Bug Fixes**
+
+- Fix generation failure for `format: password`  #1404
+- Fix `content_type` error when paging with body  #1407
+- Fix excessive warning level logging in vendored `failsafe_deserialize`  #1419
+
+**Other Changes**
+
+- Upgrade min dependency for `azure-mgmt-core` to `1.3.2`  #1404
+
+### 2022-08-22 - 6.1.3
+
+| Library                                                                 | Min Version |
+| ----------------------------------------------------------------------- | ----------- |
+| `@autorest/core`                                                        | `3.8.4`     |
+| `@autorest/modelerfour`                                                 | `4.23.5`    |
+| `azure-core` dep of generated code                                      | `1.24.0`    |
+| `isodate` dep of generated code                                         | `0.6.1`     |
+| `msrest` dep of generated code (If generating legacy code)              | `0.7.1`     |
+| `azure-mgmt-core` dep of generated code (If generating mgmt plane code) | `1.3.2`     |
+
+**Bug Fixes**
+
+- Fix circular recursion for lropaging  #1400
+
 ### 2022-08-16 - 6.1.2
 
 | Library                                                                 | Min Version |

package/autorest/_utils.py

@@ -53,7 +53,13 @@ def parse_args(need_cadl_file: bool = True):
         help="Serialized cadl file",
         required=need_cadl_file,
     )
-
+    parser.add_argument(
+        "--debug",
+        dest="debug",
+        help="Debug mode",
+        required=False,
+        action="store_true",
+    )
     return parser.parse_args()
 
 

package/autorest/codegen/__init__.py

@@ -122,7 +122,7 @@ class CodeGenerator(Plugin):
     @staticmethod
     def _build_package_dependency() -> Dict[str, str]:
         return {
-            "dependency_azure_mgmt_core": "azure-mgmt-core<2.0.0,>=1.3.0",
+            "dependency_azure_mgmt_core": "azure-mgmt-core<2.0.0,>=1.3.2",
             "dependency_azure_core": "azure-core<2.0.0,>=1.24.0",
             "dependency_msrest": "msrest>=0.7.1",
         }

package/autorest/codegen/models/__init__.py

@@ -140,6 +140,7 @@ TYPE_TO_OBJECT = {
     "AzureKeyCredentialPolicy": AzureKeyCredentialPolicyType,
     "any-object": AnyObjectType,
     "unixtime": UnixTimeType,
+    "credential": StringType,
 }
 _LOGGER = logging.getLogger(__name__)
 

package/autorest/codegen/models/credential_types.py

@@ -159,18 +159,18 @@ class TokenCredentialType(
     """Type of a token credential. Used by BearerAuth and ARMChallenge policies"""
 
     def type_annotation(self, **kwargs: Any) -> str:  # pylint: disable=no-self-use
-        if kwargs.pop("async_mode"):
+        if kwargs.get("async_mode"):
             return '"AsyncTokenCredential"'
         return '"TokenCredential"'
 
     def docstring_type(self, **kwargs: Any) -> str:  # pylint: disable=no-self-use
-        if kwargs.pop("async_mode"):
+        if kwargs.get("async_mode"):
             return "~azure.core.credentials_async.AsyncTokenCredential"
         return "~azure.core.credentials.TokenCredential"
 
     def imports(self, **kwargs: Any) -> FileImport:  # pylint: disable=no-self-use
         file_import = FileImport()
-        if kwargs.pop("async_mode"):
+        if kwargs.get("async_mode"):
             file_import.add_submodule_import(
                 "azure.core.credentials_async",
                 "AsyncTokenCredential",

package/autorest/codegen/models/model_type.py

@@ -72,16 +72,20 @@ class ModelType(BaseType):  # pylint: disable=too-many-instance-attributes
     @property
     def serialization_type(self) -> str:
         if self.code_model.options["models_mode"]:
-            return self.name
+            return (
+                self.name
+                if self.is_public
+                else f"{self.code_model.models_filename}.{self.name}"
+            )
         return "object"
 
     def type_annotation(self, **kwargs: Any) -> str:
         if self.code_model.options["models_mode"]:
             is_operation_file = kwargs.pop("is_operation_file", False)
-            if self.is_public:
-                retval = f"_models.{self.name}"
-                return retval if is_operation_file else f'"{retval}"'
-            return self.name if is_operation_file else f'"{self.name}"'
+            retval = f"_models.{self.name}"
+            if not self.is_public:
+                retval = f"{self.code_model.models_filename}.{retval}"
+            return retval if is_operation_file else f'"{retval}"'
         return "ET.Element" if self.is_xml else "JSON"
 
     def docstring_type(self, **kwargs: Any) -> str:
@@ -250,16 +254,9 @@ class ModelType(BaseType):  # pylint: disable=too-many-instance-attributes
         relative_path = kwargs.pop("relative_path", None)
         if self.code_model.options["models_mode"] and relative_path:
             # add import for models in operations file
-            if self.is_public:
-                file_import.add_submodule_import(
-                    relative_path, "models", ImportType.LOCAL, alias="_models"
-                )
-            else:
-                file_import.add_submodule_import(
-                    f"{relative_path}models.{self.code_model.models_filename}",
-                    self.name,
-                    ImportType.LOCAL,
-                )
+            file_import.add_submodule_import(
+                relative_path, "models", ImportType.LOCAL, alias="_models"
+            )
         if self.code_model.options["models_mode"]:
             return file_import
         file_import.add_submodule_import(

package/autorest/codegen/models/operation.py

@@ -291,27 +291,22 @@ class OperationBase(  # pylint: disable=too-many-public-methods
             file_import.merge(self.parameters.body_parameter.type.imports(**kwargs))
 
         # Exceptions
-        file_import.add_submodule_import(
-            "azure.core.exceptions", "map_error", ImportType.AZURECORE
-        )
+        errors = [
+            "map_error",
+            "HttpResponseError",
+            "ClientAuthenticationError",
+            "ResourceNotFoundError",
+            "ResourceExistsError",
+            "ResourceNotModifiedError",
+        ]
+        for error in errors:
+            file_import.add_submodule_import(
+                "azure.core.exceptions", error, ImportType.AZURECORE
+            )
         if self.code_model.options["azure_arm"]:
             file_import.add_submodule_import(
                 "azure.mgmt.core.exceptions", "ARMErrorFormat", ImportType.AZURECORE
             )
-        file_import.add_submodule_import(
-            "azure.core.exceptions", "HttpResponseError", ImportType.AZURECORE
-        )
-        file_import.add_submodule_import(
-            "azure.core.exceptions",
-            "ClientAuthenticationError",
-            ImportType.AZURECORE,
-        )
-        file_import.add_submodule_import(
-            "azure.core.exceptions", "ResourceNotFoundError", ImportType.AZURECORE
-        )
-        file_import.add_submodule_import(
-            "azure.core.exceptions", "ResourceExistsError", ImportType.AZURECORE
-        )
 
         if self.has_kwargs_to_pop_with_default(
             self.parameters.kwargs_to_pop, ParameterLocation.HEADER

package/autorest/codegen/models/primitive_types.py

@@ -122,13 +122,13 @@ class BinaryIteratorType(PrimitiveType):
         return "IO"
 
     def docstring_type(self, **kwargs: Any) -> str:
-        return "AsyncIterator[bytes]" if kwargs.pop("async_mode") else "Iterator[bytes]"
+        return "AsyncIterator[bytes]" if kwargs.get("async_mode") else "Iterator[bytes]"
 
     def type_annotation(self, **kwargs: Any) -> str:
         return self.docstring_type(**kwargs)
 
     def docstring_text(self, **kwargs: Any) -> str:
-        iterator = "Async iterator" if kwargs.pop("async_mode") else "Iterator"
+        iterator = "Async iterator" if kwargs.get("async_mode") else "Iterator"
         return f"{iterator} of the response bytes"
 
     @property
@@ -137,7 +137,7 @@ class BinaryIteratorType(PrimitiveType):
 
     def imports(self, **kwargs: Any) -> FileImport:
         file_import = FileImport()
-        iterator = "AsyncIterator" if kwargs.pop("async_mode") else "Iterator"
+        iterator = "AsyncIterator" if kwargs.get("async_mode") else "Iterator"
         file_import.add_submodule_import("typing", iterator, ImportType.STDLIB)
         return file_import
 

package/autorest/codegen/models/response.py

@@ -170,7 +170,7 @@ class PagingResponse(Response):
 
     def _imports_shared(self, **kwargs: Any) -> FileImport:
         file_import = super()._imports_shared(**kwargs)
-        async_mode = kwargs.pop("async_mode")
+        async_mode = kwargs.get("async_mode", False)
         pager_import_path = ".".join(self.get_pager_path(async_mode).split(".")[:-1])
         pager = self.get_pager(async_mode)
 
@@ -179,7 +179,7 @@ class PagingResponse(Response):
 
     def imports(self, **kwargs: Any) -> FileImport:
         file_import = self._imports_shared(**kwargs)
-        async_mode = kwargs.pop("async_mode")
+        async_mode = kwargs.get("async_mode")
         if async_mode:
             file_import.add_submodule_import(
                 "azure.core.async_paging", "AsyncList", ImportType.AZURECORE
@@ -234,16 +234,14 @@ class LROResponse(Response):
         return self.get_base_polling_method_path(async_mode).split(".")[-1]
 
     def type_annotation(self, **kwargs: Any) -> str:
-        return f"{self.get_poller(kwargs.pop('async_mode'))}[{super().type_annotation(**kwargs)}]"
+        return f"{self.get_poller(kwargs.get('async_mode', False))}[{super().type_annotation(**kwargs)}]"
 
     def docstring_type(self, **kwargs: Any) -> str:
-        return f"~{self.get_poller_path(kwargs.pop('async_mode'))}[{super().docstring_type(**kwargs)}]"
+        return f"~{self.get_poller_path(kwargs.get('async_mode', False))}[{super().docstring_type(**kwargs)}]"
 
     def docstring_text(self, **kwargs) -> str:
         super_text = super().docstring_text(**kwargs)
-        base_description = (
-            f"An instance of {self.get_poller(kwargs.pop('async_mode'))} that returns "
-        )
+        base_description = f"An instance of {self.get_poller(kwargs.get('async_mode', False))} that returns "
         if not self.code_model.options["version_tolerant"]:
             base_description += "either "
         return base_description + super_text
@@ -297,11 +295,11 @@ class LROResponse(Response):
 class LROPagingResponse(LROResponse, PagingResponse):
     def type_annotation(self, **kwargs: Any) -> str:
         paging_type_annotation = PagingResponse.type_annotation(self, **kwargs)
-        return f"{self.get_poller(kwargs.pop('async_mode'))}[{paging_type_annotation}]"
+        return f"{self.get_poller(kwargs.get('async_mode', False))}[{paging_type_annotation}]"
 
     def docstring_type(self, **kwargs: Any) -> str:
         paging_docstring_type = PagingResponse.docstring_type(self, **kwargs)
-        return f"~{self.get_poller_path(kwargs.pop('async_mode'))}[{paging_docstring_type}]"
+        return f"~{self.get_poller_path(kwargs.get('async_mode', False))}[{paging_docstring_type}]"
 
     def docstring_text(self, **kwargs) -> str:
         base_description = (

package/autorest/codegen/serializers/builder_serializer.py

@@ -708,8 +708,13 @@ class _OperationSerializer(
             retval.extend(self._serialize_body_parameter(builder))
         return retval
 
-    def _initialize_overloads(self, builder: OperationType) -> List[str]:
+    def _initialize_overloads(
+        self, builder: OperationType, is_paging: bool = False
+    ) -> List[str]:
         retval: List[str] = []
+        # For paging, we put body parameter in local place outside `prepare_request`
+        if is_paging:
+            return retval
         same_content_type = (
             len(
                 set(
@@ -883,6 +888,7 @@ class _OperationSerializer(
         request_builder: RequestBuilderType,
         template_url: Optional[str] = None,
         is_next_request: bool = False,
+        is_paging: bool = False,
     ) -> List[str]:
         retval = []
         if builder.parameters.grouped:
@@ -893,7 +899,7 @@ class _OperationSerializer(
             retval.extend(_serialize_flattened_body(builder.parameters.body_parameter))
         if builder.overloads:
             # we are only dealing with two overloads. If there are three, we generate an abstract operation
-            retval.extend(self._initialize_overloads(builder))
+            retval.extend(self._initialize_overloads(builder, is_paging=is_paging))
         elif builder.parameters.has_body:
             # non-overloaded body
             retval.extend(self._create_body_parameter(builder))
@@ -906,8 +912,12 @@ class _OperationSerializer(
         retval.extend(self._postprocess_http_request(builder, template_url))
         return retval
 
-    def call_request_builder(self, builder: OperationType) -> List[str]:
-        return self._call_request_builder_helper(builder, builder.request_builder)
+    def call_request_builder(
+        self, builder: OperationType, is_paging: bool = False
+    ) -> List[str]:
+        return self._call_request_builder_helper(
+            builder, builder.request_builder, is_paging=is_paging
+        )
 
     def response_headers_and_deserialization(
         self,
@@ -1033,6 +1043,8 @@ class _OperationSerializer(
                 retval.append("    404: ResourceNotFoundError,")
             if not 409 in builder.non_default_error_status_codes:
                 retval.append("    409: ResourceExistsError,")
+            if not 304 in builder.non_default_error_status_codes:
+                retval.append("    304: ResourceNotModifiedError,")
             for excep in builder.non_default_errors:
                 error_model_str = ""
                 if (
@@ -1061,6 +1073,11 @@ class _OperationSerializer(
                             "    409: lambda response: ResourceExistsError(response=response"
                             f"{error_model_str}{error_format_str}),"
                         )
+                    elif status_code == 304:
+                        retval.append(
+                            "    304: lambda response: ResourceNotModifiedError(response=response"
+                            f"{error_model_str}{error_format_str}),"
+                        )
                     elif not error_model_str and not error_format_str:
                         retval.append(f"    {status_code}: HttpResponseError,")
                     else:
@@ -1070,7 +1087,8 @@ class _OperationSerializer(
                         )
         else:
             retval.append(
-                "    401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError"
+                "    401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, "
+                "304: ResourceNotModifiedError"
             )
         retval.append("}")
         retval.append("error_map.update(kwargs.pop('error_map', {}) or {})")
@@ -1116,6 +1134,8 @@ class _PagingOperationSerializer(
     def decorators(self, builder: PagingOperationType) -> List[str]:
         """Decorators for the method"""
         retval: List[str] = []
+        if builder.is_overload:
+            return ["@overload"]
         if self.code_model.options["tracing"] and builder.want_tracing:
             retval.append("@distributed_trace")
         return retval
@@ -1168,10 +1188,14 @@ class _PagingOperationSerializer(
         return retval
 
     def _prepare_request_callback(self, builder: PagingOperationType) -> List[str]:
-        retval = ["def prepare_request(next_link=None):"]
+        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)]
+            [
+                f"        {line}"
+                for line in self.call_request_builder(builder, is_paging=True)
+            ]
         )
         retval.append("")
         retval.append("    else:")

package/autorest/codegen/templates/paging_operation.py.jinja2

@@ -1,5 +1,8 @@
 {% import 'operation_tools.jinja2' as op_tools with context %}
 {# actual template starts here #}
+{% if operation.overloads and operation.public %}
+{{ op_tools.generate_overloads(operation_serializer, operation) }}
+{% endif %}
 {{ operation_serializer.method_signature_and_response_type_annotation(operation) }}
 {% if operation.public %}
     {{ op_tools.description(operation, operation_serializer) | indent }}{% endif %}
@@ -18,4 +21,4 @@
     {% endif %}
 {% if not code_model.options["version_tolerant"] %}
 {{ operation_serializer.get_metadata_url(operation) -}}
-{% endif %}
+{% endif %}

package/autorest/codegen/templates/serialization.py.jinja2

@@ -1524,7 +1524,7 @@ class Deserializer(object):
         try:
             return self(target_obj, data, content_type=content_type)
         except:
-            _LOGGER.warning(
+            _LOGGER.debug(
                 "Ran into a deserialization error. Ignoring since this is failsafe deserialization",
 				exc_info=True
             )
@@ -2003,4 +2003,4 @@ class Deserializer(object):
             msg = "Cannot deserialize to unix datetime object."
             raise_with_traceback(DeserializationError, msg, err)
         else:
-            return date_obj
+            return date_obj

package/autorest/m4reformatter/__init__.py

@@ -426,6 +426,10 @@ class M4Reformatter(
 ):  # pylint: disable=too-many-public-methods
     """Add Python naming information."""
 
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.check_client_input: bool = False
+
     @property
     def azure_arm(self) -> bool:
         return bool(self._autorestapi.get_boolean_value("azure-arm"))
@@ -802,7 +806,7 @@ class M4Reformatter(
                 param["inDocstring"] = False
                 if self.legacy:
                     param["implementation"] = "Method"
-                    param["checkClientInput"] = True
+                    param["checkClientInput"] = self.check_client_input
             if has_flattened_body and param.get("targetProperty"):
                 retval.append(self.update_flattened_parameter(param, body_parameter))
                 continue
@@ -935,6 +939,8 @@ class M4Reformatter(
 
                 client_name = "base_url" if self.legacy else "endpoint"
                 global_parameter["language"]["default"]["description"] = "Service URL."
+            elif name == "api_version":
+                self.check_client_input = True
             global_params.append(
                 self.update_parameter(
                     global_parameter, override_client_name=client_name

package/autorest/preprocess/__init__.py

@@ -263,28 +263,37 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
                 )
 
     def update_lro_paging_operation(
-        self, code_model: Dict[str, Any], yaml_data: Dict[str, Any]
+        self,
+        code_model: Dict[str, Any],
+        yaml_data: Dict[str, Any],
+        is_overload: bool = False,
     ) -> None:
-        self.update_lro_operation(code_model, yaml_data)
-        self.update_paging_operation(code_model, yaml_data)
+        self.update_lro_operation(code_model, yaml_data, is_overload=is_overload)
+        self.update_paging_operation(code_model, yaml_data, is_overload=is_overload)
         yaml_data["discriminator"] = "lropaging"
         for response in yaml_data.get("responses", []):
             response["discriminator"] = "lropaging"
         for overload in yaml_data.get("overloads", []):
-            self.update_lro_paging_operation(code_model, overload)
+            self.update_lro_paging_operation(code_model, overload, is_overload=True)
 
     def update_lro_operation(
-        self, code_model: Dict[str, Any], yaml_data: Dict[str, Any]
+        self,
+        code_model: Dict[str, Any],
+        yaml_data: Dict[str, Any],
+        is_overload: bool = False,
     ) -> None:
-        self.update_operation(code_model, yaml_data)
+        self.update_operation(code_model, yaml_data, is_overload=is_overload)
         self._update_lro_operation_helper(yaml_data)
         for overload in yaml_data.get("overloads", []):
             self._update_lro_operation_helper(overload)
 
     def update_paging_operation(
-        self, code_model: Dict[str, Any], yaml_data: Dict[str, Any]
+        self,
+        code_model: Dict[str, Any],
+        yaml_data: Dict[str, Any],
+        is_overload: bool = False,
     ) -> None:
-        self.update_operation(code_model, yaml_data)
+        self.update_operation(code_model, yaml_data, is_overload=is_overload)
         if not yaml_data.get("pagerSync"):
             yaml_data["pagerSync"] = "azure.core.paging.ItemPaged"
         if not yaml_data.get("pagerAsync"):
@@ -319,7 +328,7 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
             update_paging_response(response)
             response["itemType"] = item_type
         for overload in yaml_data.get("overloads", []):
-            self.update_paging_operation(code_model, overload)
+            self.update_paging_operation(code_model, overload, is_overload=True)
 
     def update_operation_groups(self, yaml_data: Dict[str, Any]) -> None:
         operation_groups_yaml_data = yaml_data["operationGroups"]

package/package.json

@@ -1,44 +1,45 @@
 {
-    "name": "@autorest/python",
-    "version": "6.1.2",
-    "description": "The Python extension for generators in AutoRest.",
-    "scripts": {
-        "prepare": "node run-python3.js prepare.py",
-        "start": "node run-python3.js start.py",
-        "install": "node run-python3.js install.py",
-        "debug": "node run-python3.js start.py --debug"
-    },
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/Azure/autorest.python/tree/autorestv3"
-    },
-    "readme": "https://github.com/Azure/autorest.python/blob/autorestv3/README.md",
-    "keywords": [
-        "autorest",
-        "python"
-    ],
-    "author": "Microsoft Corporation",
-    "license": "MIT",
-    "bugs": {
-        "url": "https://github.com/Azure/autorest.python/issues"
-    },
-    "homepage": "https://github.com/Azure/autorest.python/blob/autorestv3/README.md",
-    "dependencies": {
-        "@autorest/system-requirements": "~1.0.0"
-    },
-    "devDependencies": {
-        "@microsoft.azure/autorest.testserver": "^3.3.31"
-    },
-    "files": [
-        "autorest/**/*.py",
-        "autorest/**/*.jinja2",
-        "setup.py",
-        "install.py",
-        "prepare.py",
-        "start.py",
-        "venvtools.py",
-        "run-python3.js",
-        "requirements.txt",
-        "run_cadl.py"
-    ]
+  "name": "@autorest/python",
+  "version": "6.1.5",
+  "description": "The Python extension for generators in AutoRest.",
+  "scripts": {
+    "prepare": "node run-python3.js prepare.py",
+    "start": "node run-python3.js start.py",
+    "install": "node run-python3.js install.py",
+    "debug": "node run-python3.js start.py --debug"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Azure/autorest.python/tree/autorestv3"
+  },
+  "readme": "https://github.com/Azure/autorest.python/blob/autorestv3/README.md",
+  "keywords": [
+    "autorest",
+    "python"
+  ],
+  "author": "Microsoft Corporation",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/Azure/autorest.python/issues"
+  },
+  "homepage": "https://github.com/Azure/autorest.python/blob/autorestv3/README.md",
+  "dependencies": {
+    "@autorest/system-requirements": "~1.0.0"
+  },
+  "devDependencies": {
+    "@microsoft.azure/autorest.testserver": "^3.3.38",
+    "typescript": "^4.7.4"
+  },
+  "files": [
+    "autorest/**/*.py",
+    "autorest/**/*.jinja2",
+    "setup.py",
+    "install.py",
+    "prepare.py",
+    "start.py",
+    "venvtools.py",
+    "run-python3.js",
+    "requirements.txt",
+    "run_cadl.py"
+  ]
 }

package/run_cadl.py

@@ -5,11 +5,14 @@
 # --------------------------------------------------------------------------
 import sys
 import venv
+import logging
 from pathlib import Path
 from venvtools import python_run
 
 _ROOT_DIR = Path(__file__).parent
 
+_LOGGER = logging.getLogger(__name__)
+
 if __name__ == "__main__":
     venv_path = _ROOT_DIR / "venv"
     venv_prexists = venv_path.exists()
@@ -19,6 +22,19 @@ if __name__ == "__main__":
     env_builder = venv.EnvBuilder(with_pip=True)
     venv_context = env_builder.ensure_directories(venv_path)
 
+    if "--debug" in sys.argv:
+        try:
+            import debugpy  # pylint: disable=import-outside-toplevel
+        except ImportError:
+            raise SystemExit(
+                "Please pip install ptvsd in order to use VSCode debugging"
+            )
+
+        # 5678 is the default attach port in the VS Code debug configurations
+        debugpy.listen(("localhost", 5678))
+        debugpy.wait_for_client()
+        breakpoint()  # pylint: disable=undefined-variable
+
     # run m2r
     python_run(venv_context, "autorest.m2r.__init__", command=sys.argv[1:])
     python_run(venv_context, "autorest.preprocess.__init__", command=sys.argv[1:])