@autorest/python 6.1.5 → 6.1.6

package/ChangeLog.md

@@ -1,5 +1,20 @@
 # Release History
 
+### 2022-09-15 - 6.1.6
+
+| 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 `--clear-output-folder` when `--black=true`  #1410
+
 ### 2022-09-06 - 6.1.5
 
 | Library                                                                 | Min Version |

package/autorest/__init__.py

@@ -7,7 +7,7 @@ import logging
 from pathlib import Path
 import json
 from abc import ABC, abstractmethod
-from typing import Any, Dict, Union
+from typing import Any, Dict, Union, List
 
 import yaml
 
@@ -22,6 +22,7 @@ _LOGGER = logging.getLogger(__name__)
 class ReaderAndWriter:
     def __init__(self, *, output_folder: Union[str, Path], **kwargs: Any) -> None:
         self.output_folder = Path(output_folder)
+        self._list_file: List[str] = []
         try:
             with open(
                 Path(self.output_folder) / Path("..") / Path("python.json"), "r"
@@ -37,7 +38,7 @@ class ReaderAndWriter:
         self.options.update(python_json)
 
     def read_file(self, path: Union[str, Path]) -> str:
-        """How does one read a file in cadl?"""
+        """Directly reading from disk"""
         # make path relative to output folder
         try:
             with open(self.output_folder / Path(path), "r") as fd:
@@ -46,13 +47,16 @@ class ReaderAndWriter:
             return ""
 
     def write_file(self, filename: Union[str, Path], file_content: str) -> None:
-        """How does writing work in cadl?"""
+        """Directly writing to disk"""
         file_folder = Path(filename).parent
         if not Path.is_dir(self.output_folder / file_folder):
             Path.mkdir(self.output_folder / file_folder, parents=True)
         with open(self.output_folder / Path(filename), "w") as fd:
             fd.write(file_content)
 
+    def list_file(self) -> List[str]:
+        return [str(f) for f in self.output_folder.glob("**/*") if f.is_file()]
+
 
 class ReaderAndWriterAutorest(ReaderAndWriter):
     def __init__(
@@ -67,6 +71,9 @@ class ReaderAndWriterAutorest(ReaderAndWriter):
     def write_file(self, filename: Union[str, Path], file_content: str) -> None:
         return self._autorestapi.write_file(filename, file_content)
 
+    def list_file(self) -> List[str]:
+        return self._autorestapi.list_inputs()
+
 
 class Plugin(ReaderAndWriter, ABC):
     """A base class for autorest plugin.

package/autorest/black/__init__.py

@@ -30,16 +30,10 @@ class BlackScriptPlugin(Plugin):  # pylint: disable=abstract-method
 
     def process(self) -> bool:
         # apply format_file on every file in the output folder
-        list(
-            map(
-                self.format_file,
-                [f for f in self.output_folder.glob("**/*") if f.is_file()],
-            )
-        )
+        list(map(self.format_file, [Path(f) for f in self.list_file()]))
         return True
 
-    def format_file(self, full_path) -> None:
-        file = full_path.relative_to(self.output_folder)
+    def format_file(self, file: Path) -> None:
         file_content = self.read_file(file)
         if not file.suffix == ".py":
             self.write_file(file, file_content)

package/autorest/codegen/models/base_builder.py

@@ -31,7 +31,9 @@ if TYPE_CHECKING:
 _LOGGER = logging.getLogger(__name__)
 
 
-class BaseBuilder(Generic[ParameterListType], BaseModel):
+class BaseBuilder(
+    Generic[ParameterListType], BaseModel
+):  # pylint: disable=too-many-instance-attributes
     """Base class for Operations and Request Builders"""
 
     def __init__(
@@ -56,6 +58,7 @@ class BaseBuilder(Generic[ParameterListType], BaseModel):
         self.group_name: str = yaml_data["groupName"]
         self.is_overload: bool = yaml_data["isOverload"]
         self.api_versions: List[str] = yaml_data["apiVersions"]
+        self.added_on: Optional[str] = yaml_data.get("addedOn")
 
         if code_model.options["version_tolerant"] and yaml_data.get("abstract"):
             _LOGGER.warning(

package/autorest/codegen/models/operation.py

@@ -209,6 +209,12 @@ class OperationBase(  # pylint: disable=too-many-public-methods
             file_import.add_submodule_import(
                 "typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL
             )
+        if self.added_on:
+            file_import.add_submodule_import(
+                f"{'.' if async_mode else ''}.._validation",
+                "api_version_validation",
+                ImportType.LOCAL,
+            )
         return file_import
 
     def imports_for_multiapi(self, async_mode: bool, **kwargs: Any) -> FileImport:
@@ -244,6 +250,11 @@ class OperationBase(  # pylint: disable=too-many-public-methods
             for kwarg in kwargs_to_pop
         )
 
+    @property
+    def need_validation(self) -> bool:
+        """Whether we need parameter / operation validation. For API version."""
+        return bool(self.added_on) or any(p for p in self.parameters if p.added_on)
+
     def get_request_builder_import(
         self,
         request_builder: Union[RequestBuilder, OverloadedRequestBuilder],

package/autorest/codegen/models/operation_group.py

@@ -66,6 +66,11 @@ class OperationGroup(BaseModel):
             return "  # type: ignore"
         return ""
 
+    @property
+    def need_validation(self) -> bool:
+        """Whether any of its operations need validation"""
+        return any(o for o in self.operations if o.need_validation)
+
     def imports(self, async_mode: bool) -> FileImport:
         file_import = FileImport()
 

package/autorest/codegen/models/parameter.py

@@ -82,6 +82,7 @@ class _ParameterBase(
         self.in_flattened_body: bool = self.yaml_data.get("inFlattenedBody", False)
         self.grouper: bool = self.yaml_data.get("grouper", False)
         self.check_client_input: bool = self.yaml_data.get("checkClientInput", False)
+        self.added_on: Optional[str] = self.yaml_data.get("addedOn")
 
     @property
     def constant(self) -> bool:
@@ -152,6 +153,12 @@ class _ParameterBase(
         )
         if self.optional and self.client_default_value is None:
             file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB)
+        if self.added_on:
+            file_import.add_submodule_import(
+                f"{'.' if async_mode else ''}.._validation",
+                "api_version_validation",
+                ImportType.LOCAL,
+            )
         return file_import
 
     @property

package/autorest/codegen/serializers/__init__.py

@@ -428,6 +428,12 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
                 general_serializer.serialize_serialization_file(),
             )
 
+        if any(og for og in self.code_model.operation_groups if og.need_validation):
+            self.write_file(
+                namespace_path / Path("_validation.py"),
+                general_serializer.serialize_validation_file(),
+            )
+
         # Write the config file
         if self.code_model.request_builders:
             self.write_file(

package/autorest/codegen/serializers/builder_serializer.py

@@ -173,6 +173,22 @@ def _get_json_response_template_to_status_codes(
     return retval
 
 
+def _api_version_validation(builder: OperationType) -> str:
+    retval: List[str] = []
+    if builder.added_on:
+        retval.append(f'    method_added_on="{builder.added_on}",')
+    params_added_on = defaultdict(list)
+    for parameter in builder.parameters:
+        if parameter.added_on:
+            params_added_on[parameter.added_on].append(parameter.client_name)
+    if params_added_on:
+        retval.append(f"    params_added_on={dict(params_added_on)},")
+    if retval:
+        retval_str = "\n".join(retval)
+        return f"@api_version_validation(\n{retval_str}\n)"
+    return ""
+
+
 class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-method
     def __init__(self, code_model: CodeModel, async_mode: bool) -> None:
         self.code_model = code_model
@@ -590,8 +606,10 @@ class _OperationSerializer(
 
     def decorators(self, builder: OperationType) -> List[str]:
         """Decorators for the method"""
-        super_decorators = super().decorators(builder)
-        return super_decorators
+        retval = super().decorators(builder)
+        if _api_version_validation(builder):
+            retval.append(_api_version_validation(builder))
+        return retval
 
     def param_description(
         self, builder: OperationType
@@ -1138,6 +1156,8 @@ class _PagingOperationSerializer(
             return ["@overload"]
         if self.code_model.options["tracing"] and builder.want_tracing:
             retval.append("@distributed_trace")
+        if _api_version_validation(builder):
+            retval.append(_api_version_validation(builder))
         return retval
 
     def call_next_link_request_builder(self, builder: PagingOperationType) -> List[str]:

package/autorest/codegen/serializers/general_serializer.py

@@ -120,3 +120,7 @@ class GeneralSerializer:
     def serialize_serialization_file(self) -> str:
         template = self.env.get_template("serialization.py.jinja2")
         return template.render(code_model=self.code_model)
+
+    def serialize_validation_file(self) -> str:
+        template = self.env.get_template("validation.py.jinja2")
+        return template.render(code_model=self.code_model)

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

@@ -17,4 +17,4 @@
 {% endif %}
 {% for operation_group in operation_groups %}
     {% include "operation_group.py.jinja2" %}
-{% endfor %}
+{% endfor %}

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

@@ -0,0 +1,38 @@
+{{ code_model.options['license_header'] }}
+import functools
+
+def api_version_validation(**kwargs):
+    params_added_on = kwargs.pop("params_added_on", {})
+    method_added_on = kwargs.pop("method_added_on", "")
+
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            try:
+                # this assumes the client has an _api_version attribute
+                client = args[0]
+                client_api_version = client._config.api_version  # pylint: disable=protected-access
+            except AttributeError:
+                return func(*args, **kwargs)
+
+            if method_added_on > client_api_version:
+                raise ValueError(
+                    f"'{func.__name__}' is not available in API version "
+                    f"{client_api_version}. Pass service API version {method_added_on} or newer to your client."
+                )
+
+            unsupported = {
+                parameter: api_version
+                for api_version, parameters in params_added_on.items()
+                for parameter in parameters
+                if parameter in kwargs and api_version > client_api_version
+            }
+            if unsupported:
+                raise ValueError("".join([
+                    f"'{param}' is not available in API version {client_api_version}. "
+                    f"Use service API version {version} or newer.\n"
+                    for param, version in unsupported.items()
+                ]))
+            return func(*args, **kwargs)
+        return wrapper
+    return decorator

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autorest/python",
-  "version": "6.1.5",
+  "version": "6.1.6",
   "description": "The Python extension for generators in AutoRest.",
   "scripts": {
     "prepare": "node run-python3.js prepare.py",