@autorest/python 6.2.11 → 6.2.15

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

@@ -38,7 +38,22 @@ import logging
 import re
 import sys
 import codecs
-from typing import Optional, Union, AnyStr, IO, Mapping
+from typing import (
+    Dict,
+    Any,
+    cast,
+    Optional,
+    Union,
+    AnyStr,
+    IO,
+    Mapping,
+    Callable,
+    TypeVar,
+    MutableMapping,
+    Type,
+    List,
+    Mapping,
+)
 
 try:
     from urllib import quote  # type: ignore
@@ -48,12 +63,13 @@ import xml.etree.ElementTree as ET
 
 import isodate  # type: ignore
 
-from typing import Dict, Any, cast
-
 from azure.core.exceptions import DeserializationError, SerializationError, raise_with_traceback
 
 _BOM = codecs.BOM_UTF8.decode(encoding="utf-8")
 
+ModelType = TypeVar("ModelType", bound="Model")
+JSON = MutableMapping[str, Any]
+
 
 class RawDeserializer:
 
@@ -277,8 +293,8 @@ class Model(object):
     _attribute_map: Dict[str, Dict[str, Any]] = {}
     _validation: Dict[str, Dict[str, Any]] = {}
 
-    def __init__(self, **kwargs):
-        self.additional_properties = {}
+    def __init__(self, **kwargs: Any) -> None:
+        self.additional_properties: Dict[str, Any] = {}
         for k in kwargs:
             if k not in self._attribute_map:
                 _LOGGER.warning("%s is not a known attribute of class %s and will be ignored", k, self.__class__)
@@ -287,25 +303,25 @@ class Model(object):
             else:
                 setattr(self, k, kwargs[k])
 
-    def __eq__(self, other):
+    def __eq__(self, other: Any) -> bool:
         """Compare objects by comparing all attributes."""
         if isinstance(other, self.__class__):
             return self.__dict__ == other.__dict__
         return False
 
-    def __ne__(self, other):
+    def __ne__(self, other: Any) -> bool:
         """Compare objects by comparing all attributes."""
         return not self.__eq__(other)
 
-    def __str__(self):
+    def __str__(self) -> str:
         return str(self.__dict__)
 
     @classmethod
-    def enable_additional_properties_sending(cls):
+    def enable_additional_properties_sending(cls) -> None:
         cls._attribute_map["additional_properties"] = {"key": "", "type": "{object}"}
 
     @classmethod
-    def is_xml_model(cls):
+    def is_xml_model(cls) -> bool:
         try:
             cls._xml_map  # type: ignore
         except AttributeError:
@@ -322,7 +338,7 @@ class Model(object):
 
         return _create_xml_node(xml_map.get("name", cls.__name__), xml_map.get("prefix", None), xml_map.get("ns", None))
 
-    def serialize(self, keep_readonly=False, **kwargs):
+    def serialize(self, keep_readonly: bool = False, **kwargs: Any) -> JSON:
         """Return the JSON that would be sent to azure from this model.
 
         This is an alias to `as_dict(full_restapi_key_transformer, keep_readonly=False)`.
@@ -336,8 +352,15 @@ class Model(object):
         serializer = Serializer(self._infer_class_models())
         return serializer._serialize(self, keep_readonly=keep_readonly, **kwargs)
 
-    def as_dict(self, keep_readonly=True, key_transformer=attribute_transformer, **kwargs):
-        """Return a dict that can be JSONify using json.dump.
+    def as_dict(
+        self,
+        keep_readonly: bool = True,
+        key_transformer: Callable[
+            [str, Dict[str, Any], Any], Any
+        ] = attribute_transformer,
+        **kwargs: Any
+    ) -> JSON:
+        """Return a dict that can be serialized using json.dump.
 
         Advanced usage might optionally use a callback as parameter:
 
@@ -384,7 +407,7 @@ class Model(object):
         return client_models
 
     @classmethod
-    def deserialize(cls, data, content_type=None):
+    def deserialize(cls: Type[ModelType], data: Any, content_type: Optional[str] = None) -> ModelType:
         """Parse a str using the RestAPI syntax and return a model.
 
         :param str data: A str using RestAPI structure. JSON by default.
@@ -396,7 +419,12 @@ class Model(object):
         return deserializer(cls.__name__, data, content_type=content_type)
 
     @classmethod
-    def from_dict(cls, data, key_extractors=None, content_type=None):
+    def from_dict(
+        cls: Type[ModelType],
+        data: Any,
+        key_extractors: Optional[Callable[[str, Dict[str, Any], Any], Any]] = None,
+        content_type: Optional[str] = None,
+    ) -> ModelType:
         """Parse a dict using given key extractor return a model.
 
         By default consider key
@@ -409,8 +437,8 @@ class Model(object):
         :raises: DeserializationError if something went wrong
         """
         deserializer = Deserializer(cls._infer_class_models())
-        deserializer.key_extractors = (
-            [
+        deserializer.key_extractors = (  # type: ignore
+            [  # type: ignore
                 attribute_key_case_insensitive_extractor,
                 rest_key_case_insensitive_extractor,
                 last_rest_key_case_insensitive_extractor,
@@ -518,7 +546,7 @@ class Serializer(object):
         "multiple": lambda x, y: x % y != 0,
     }
 
-    def __init__(self, classes=None):
+    def __init__(self, classes: Optional[Mapping[str, Type[ModelType]]]=None):
         self.serialize_type = {
             "iso-8601": Serializer.serialize_iso,
             "rfc-1123": Serializer.serialize_rfc,
@@ -534,7 +562,7 @@ class Serializer(object):
             "[]": self.serialize_iter,
             "{}": self.serialize_dict,
         }
-        self.dependencies = dict(classes) if classes else {}
+        self.dependencies: Dict[str, Type[ModelType]] = dict(classes) if classes else {}
         self.key_transformer = full_restapi_key_transformer
         self.client_side_validation = True
 
@@ -626,8 +654,7 @@ class Serializer(object):
                             serialized.append(local_node)  # type: ignore
                     else:  # JSON
                         for k in reversed(keys):  # type: ignore
-                            unflattened = {k: new_attr}
-                            new_attr = unflattened
+                            new_attr = {k: new_attr}
 
                         _new_attr = new_attr
                         _serialized = serialized
@@ -656,8 +683,8 @@ class Serializer(object):
         """
 
         # Just in case this is a dict
-        internal_data_type = data_type.strip("[]{}")
-        internal_data_type = self.dependencies.get(internal_data_type, None)
+        internal_data_type_str = data_type.strip("[]{}")
+        internal_data_type = self.dependencies.get(internal_data_type_str, None)
         try:
             is_xml_model_serialization = kwargs["is_xml"]
         except KeyError:
@@ -1161,7 +1188,8 @@ def rest_key_extractor(attr, attr_desc, data):
     working_data = data
 
     while "." in key:
-        dict_keys = _FLATTEN.split(key)
+        # Need the cast, as for some reasons "split" is typed as list[str | Any]
+        dict_keys = cast(List[str], _FLATTEN.split(key))
         if len(dict_keys) == 1:
             key = _decode_attribute_map_key(dict_keys[0])
             break
@@ -1332,7 +1360,7 @@ class Deserializer(object):
 
     valid_date = re.compile(r"\d{4}[-]\d{2}[-]\d{2}T\d{2}:\d{2}:\d{2}" r"\.?\d*Z?[-+]?[\d{2}]?:?[\d{2}]?")
 
-    def __init__(self, classes=None):
+    def __init__(self, classes: Optional[Mapping[str, Type[ModelType]]]=None):
         self.deserialize_type = {
             "iso-8601": Deserializer.deserialize_iso,
             "rfc-1123": Deserializer.deserialize_rfc,
@@ -1352,7 +1380,7 @@ class Deserializer(object):
             "duration": (isodate.Duration, datetime.timedelta),
             "iso-8601": (datetime.datetime),
         }
-        self.dependencies = dict(classes) if classes else {}
+        self.dependencies: Dict[str, Type[ModelType]] = dict(classes) if classes else {}
         self.key_extractors = [rest_key_extractor, xml_key_extractor]
         # Additional properties only works if the "rest_key_extractor" is used to
         # extract the keys. Making it to work whatever the key extractor is too much
@@ -1471,7 +1499,7 @@ class Deserializer(object):
         Once classification has been determined, initialize object.
 
         :param str target: The target object type to deserialize to.
-        :param str/dict data: The response data to deseralize.
+        :param str/dict data: The response data to deserialize.
         """
         if target is None:
             return None, None
@@ -1486,7 +1514,7 @@ class Deserializer(object):
             target = target._classify(data, self.dependencies)
         except AttributeError:
             pass  # Target is not a Model, no classify
-        return target, target.__class__.__name__
+        return target, target.__class__.__name__  # type: ignore
 
     def failsafe_deserialize(self, target_obj, data, content_type=None):
         """Ignores any errors encountered in deserialization,
@@ -1496,7 +1524,7 @@ class Deserializer(object):
         a deserialization error.
 
         :param str target_obj: The target object type to deserialize to.
-        :param str/dict data: The response data to deseralize.
+        :param str/dict data: The response data to deserialize.
         :param str content_type: Swagger "produces" if available.
         """
         try:

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

@@ -19,14 +19,15 @@ def _format_url_section(template, **kwargs):
         try:
             return template.format(**kwargs)
         except KeyError as key:
-            formatted_components = template.split("/")
+            # Need the cast, as for some reasons "split" is typed as list[str | Any]
+            formatted_components = cast(List[str], template.split("/"))
             components = [
                 c for c in formatted_components if "{{{}}}".format(key.args[0]) not in c
             ]
             template = "/".join(components)
 {% endif %}
 {% if code_model.need_mixin_abc %}
-    {% for client in code_model.clients | selectattr("has_mixin") %}
+    {% for client in clients | selectattr("has_mixin") %}
 
 class {{ client.name }}MixinABC(ABC):
     """DO NOT use this class. It is for internal typing use only."""

package/autorest/jsonrpc/localapi.py

@@ -26,17 +26,17 @@ class LocalAutorestAPI(AutorestAPI):
             reachable_files = []
         self._reachable_files = reachable_files
         self._output_folder = Path(output_folder)
-        self.values: Dict[str, Optional[str]] = dict()
+        self.values: Dict[str, Optional[str]] = {}
 
     def write_file(self, filename: Union[str, Path], file_content: str) -> None:
         _LOGGER.debug("Writing file: %s", filename)
-        with (self._output_folder / Path(filename)).open("w") as fd:
+        with (self._output_folder / Path(filename)).open("w", encoding="utf-8") as fd:
             fd.write(file_content)
         _LOGGER.debug("Written file: %s", filename)
 
     def read_file(self, filename: Union[str, Path]) -> str:
         _LOGGER.debug("Reading file: %s", filename)
-        with (self._output_folder / Path(filename)).open("r") as fd:
+        with (self._output_folder / Path(filename)).open("r", encoding="utf-8") as fd:
             return fd.read()
 
     def list_inputs(self) -> List[str]:

package/autorest/jsonrpc/server.py

@@ -84,15 +84,15 @@ def main() -> None:
     ):
         try:
             import ptvsd  # pylint: disable=import-outside-toplevel
-        except ImportError:
+        except ImportError as exc:
             raise SystemExit(
                 "Please pip install ptvsd in order to use VSCode debugging"
-            )
+            ) from exc
 
         # 5678 is the default attach port in the VS Code debug configurations
         ptvsd.enable_attach(address=("localhost", 5678), redirect_output=True)
         ptvsd.wait_for_attach()
-        breakpoint()  # pylint: disable=undefined-variable
+        breakpoint()  # pylint: disable=undefined-variable,forgotten-debug-statement
 
     _LOGGER.debug("Starting JSON RPC server")
 

package/autorest/m2r/__init__.py

@@ -22,7 +22,7 @@ class AutorestRender(m2r2.RestRenderer):
     in the description/summary.
     """
 
-    def inline_html(self, html: str) -> str:  # pylint: disable=no-self-use
+    def inline_html(self, html: str) -> str:
         """Do not render inline HTML with a role definition."""
         return f":code:`{html}`"
 

package/autorest/m4reformatter/__init__.py

@@ -143,6 +143,7 @@ def create_model(yaml_data: Dict[str, Any]) -> Dict[str, Any]:
     base["name"] = yaml_data["language"]["default"]["name"]
     base["description"] = yaml_data["language"]["default"]["description"]
     base["isXml"] = "xml" in yaml_data.get("serializationFormats", [])
+    base["base"] = "msrest"
     return base
 
 
@@ -422,6 +423,12 @@ class M4Reformatter(
     def legacy(self) -> bool:
         return not (self.version_tolerant or self.low_level_client)
 
+    @property
+    def only_path_and_body_parameters_positional(self) -> bool:
+        return self.version_tolerant or bool(
+            self._autorestapi.get_boolean_value("only-path-and-body-params-positional")
+        )
+
     @property
     def default_optional_constants_to_none(self) -> bool:
         return bool(
@@ -951,7 +958,11 @@ class M4Reformatter(
             if name == "$host":
                 # I am the non-parameterized endpoint. Modify name based off of flag
 
-                client_name = "base_url" if self.legacy else "endpoint"
+                client_name = (
+                    "endpoint"
+                    if self.only_path_and_body_parameters_positional
+                    else "base_url"
+                )
                 global_parameter["language"]["default"]["description"] = "Service URL."
             elif (
                 global_parameter.get("origin") == "modelerfour:synthesized/api-version"
@@ -1082,7 +1093,7 @@ class M4Reformatter(
             "skipUrlEncoding": True,
             "inOverload": False,
         }
-        if self.version_tolerant or self.low_level_client:
+        if self.only_path_and_body_parameters_positional:
             parameters.append(credential)
         else:
             parameters.insert(0, credential)

package/autorest/multiapi/models/__init__.py

@@ -5,10 +5,12 @@
 # --------------------------------------------------------------------------
 from .code_model import CodeModel
 from .imports import ImportType, FileImport, TypingSection
+from .global_parameter import GlobalParameter
 
 __all__ = [
     "CodeModel",
     "FileImport",
     "ImportType",
     "TypingSection",
+    "GlobalParameter",
 ]

package/autorest/multiapi/models/code_model.py

@@ -71,6 +71,19 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes
         operation_groups.sort(key=lambda x: x.name)
         return operation_groups
 
+    @property
+    def host_variable_name(self) -> str:
+        if self.client.parameterized_host_template_to_api_version:
+            return "base_url"
+        params = (
+            self.global_parameters.parameters
+            + self.global_parameters.service_client_specific_global_parameters
+        )
+        try:
+            return next(p for p in params if p.name in ["endpoint", "base_url"]).name
+        except StopIteration:
+            return "_endpoint"
+
     @property
     def last_rt_list(self) -> Dict[str, str]:
         """Build the a mapping RT => API version if RT doesn't exist in latest detected API version.

package/autorest/multiapi/models/global_parameter.py

@@ -17,6 +17,7 @@ class GlobalParameter:
         self.global_parameter_metadata_sync = global_parameter_metadata_sync
         self.global_parameter_metadata_async = global_parameter_metadata_async
         self.required = global_parameter_metadata_sync["required"]
+        self.method_location = global_parameter_metadata_sync["method_location"]
 
     def _global_parameter_metadata(self, async_mode: bool) -> Dict[str, Any]:
         if async_mode:

package/autorest/multiapi/models/imports.py

@@ -85,7 +85,7 @@ class FileImport:
                 ],
             ],
         ] = (
-            imports or dict()
+            imports or {}
         )
 
     def _add_import(
@@ -123,8 +123,8 @@ class FileImport:
             ]
         ] = None
         name_input = convert_list_to_tuple(name_import)
-        self._imports.setdefault(typing_section, dict()).setdefault(
-            import_type, dict()
+        self._imports.setdefault(typing_section, {}).setdefault(
+            import_type, {}
         ).setdefault(from_section, set()).add(name_input)
 
     def add_submodule_import(

package/autorest/multiapi/serializers/__init__.py

@@ -4,13 +4,13 @@
 # license information.
 # --------------------------------------------------------------------------
 from pathlib import Path
-from typing import Any, Optional, Union
+from typing import Any, Optional, Union, List
 from jinja2 import PackageLoader, Environment
 
 from .import_serializer import FileImportSerializer
 
 from ...jsonrpc import AutorestAPI
-from ..models import CodeModel
+from ..models import CodeModel, GlobalParameter
 from ... import ReaderAndWriter, ReaderAndWriterAutorest
 
 __all__ = [
@@ -26,6 +26,15 @@ _FILE_TO_TEMPLATE = {
 }
 
 
+def _method_signature_helper(
+    parameters: List[GlobalParameter], async_mode: bool
+) -> List[str]:
+    return [
+        p.signature(async_mode)
+        for p in sorted(parameters, key=lambda p: p.required, reverse=True)
+    ]
+
+
 def _get_file_path(filename: str, async_mode: bool) -> Path:
     filename += ".py"
     if async_mode:
@@ -48,8 +57,26 @@ class MultiAPISerializer(ReaderAndWriter):  # pylint: disable=abstract-method
     def _serialize_helper(self, code_model: CodeModel, async_mode: bool) -> None:
         def _render_template(file: str, **kwargs: Any) -> str:
             template = self.env.get_template(_FILE_TO_TEMPLATE[file])
+            all_params = (
+                code_model.global_parameters.parameters
+                + code_model.global_parameters.service_client_specific_global_parameters
+            )
+            positional_params = [
+                p for p in all_params if p.method_location == "positional"
+            ]
+            keyword_only_params = [
+                p for p in all_params if p.method_location == "keywordOnly"
+            ]
             return template.render(
-                code_model=code_model, async_mode=async_mode, **kwargs
+                code_model=code_model,
+                async_mode=async_mode,
+                positional_params=_method_signature_helper(
+                    positional_params, async_mode
+                ),
+                keyword_only_params=_method_signature_helper(
+                    keyword_only_params, async_mode
+                ),
+                **kwargs
             )
 
         # serialize init file

package/autorest/multiapi/templates/multiapi_service_client.py.jinja2

@@ -1,18 +1,14 @@
 {% macro method_signature() %}
 def __init__(
     self,
-    {% for parameter in code_model.global_parameters.parameters %}
-        {% if parameter.required %}
-    {{ parameter.signature(async_mode) }}
-        {% endif %}
-    {% endfor %}
-    {% for parameter in code_model.global_parameters.parameters %}
-        {% if not parameter.required %}
-    {{ parameter.signature(async_mode) }}
-        {% endif %}
+    {% for pos in positional_params %}
+    {{ pos }}
     {% endfor %}
-    {% for parameter in code_model.global_parameters.service_client_specific_global_parameters %}
-    {{ parameter.signature(async_mode) }}
+    {% if keyword_only_params %}
+    *,
+    {% endif %}
+    {% for ko in keyword_only_params %}
+    {{ ko }}
     {% endfor %}
     **kwargs: Any
 ){{" -> None" if async_mode else "" }}:{% endmacro %}
@@ -92,7 +88,7 @@ class {{ code_model.client.name }}({% if code_model.operation_mixin_group.mixin_
             raise ValueError("API version {} is not available".format(api_version))
         {% endif %}
         self._config = {{ code_model.client.name }}Configuration({{ code_model.global_parameters.call }}{{ ", " if code_model.global_parameters.call }}**kwargs)
-        self._client = {{ async_prefix }}{{ code_model.client.pipeline_client }}(base_url=base_url, config=self._config, **kwargs)
+        self._client = {{ async_prefix }}{{ code_model.client.pipeline_client }}(base_url={{ code_model.host_variable_name }}, config=self._config, **kwargs)
         super({{ code_model.client.name }}, self).__init__(
             api_version=api_version,
             profile=profile

package/autorest/postprocess/get_all.py

@@ -15,5 +15,7 @@ def main(namespace):
 if __name__ == "__main__":
     patched = ",".join(main(sys.argv[1]))
     output_folder = sys.argv[2]
-    with open(f"{output_folder}/.temp_folder/patched.txt", "w") as f:
+    with open(
+        f"{output_folder}/.temp_folder/patched.txt", "w", encoding="utf-8-sig"
+    ) as f:
         f.write(patched)

package/autorest/postprocess/venvtools.py

@@ -48,7 +48,7 @@ def create(
 
 
 def python_run(  # pylint: disable=inconsistent-return-statements
-    venv_context, module, command, directory=_ROOT_DIR, *, error_ok=False
+    venv_context, module, command, directory=_ROOT_DIR
 ) -> Optional[str]:
     try:
         cmd_line = [
@@ -64,10 +64,11 @@ def python_run(  # pylint: disable=inconsistent-return-statements
             stdout=False,
         )
         if module == "get_all":
-            with open(f"{command[1]}/.temp_folder/patched.txt", "r") as f:
+            with open(
+                f"{command[1]}/.temp_folder/patched.txt", "r", encoding="utf-8-sig"
+            ) as f:
                 return f.read()
     except subprocess.CalledProcessError as err:
         print(err)
-        if not error_ok:
-            sys.exit(1)
+        sys.exit(1)
     return None

package/autorest/preprocess/__init__.py

@@ -23,7 +23,6 @@ from .._utils import parse_args, get_body_type_for_description, JSON_REGEXP, KNO
 def add_body_param_type(
     code_model: Dict[str, Any],
     body_parameter: Dict[str, Any],
-    models_mode: Optional[str],
 ):
     if (
         body_parameter
@@ -35,11 +34,12 @@ def add_body_param_type(
         and not any(t for t in ["flattened", "groupedBy"] if body_parameter.get(t))
     ):
         origin_type = body_parameter["type"]["type"]
+        is_dpg_model = body_parameter["type"].get("base") == "dpg"
         body_parameter["type"] = {
             "type": "combined",
             "types": [body_parameter["type"], KNOWN_TYPES["binary"]],
         }
-        if origin_type == "model" and models_mode == "dpg":
+        if origin_type == "model" and is_dpg_model:
             body_parameter["type"]["types"].insert(1, KNOWN_TYPES["any-object"])
         code_model["types"].append(body_parameter["type"])
 
@@ -60,13 +60,21 @@ def update_overload_section(
                     overload_h["type"] = original_h["type"]
 
 
-def add_overload(yaml_data: Dict[str, Any], body_type: Dict[str, Any]):
+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
 
     overload["overloads"] = []
 
+    if for_flatten_params:
+        overload["bodyParameter"]["flattened"] = True
+    else:
+        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"]
@@ -107,6 +115,10 @@ def add_overloads_for_body_param(yaml_data: Dict[str, Any]) -> None:
         ):
             continue
         yaml_data["overloads"].append(add_overload(yaml_data, body_type))
+        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)
+            )
     content_type_param = next(
         p for p in yaml_data["parameters"] if p["restApiName"].lower() == "content-type"
     )
@@ -162,9 +174,9 @@ def update_parameter(yaml_data: Dict[str, Any]) -> None:
     if yaml_data.get("propertyToParameterName"):
         # need to create a new one with padded keys and values
         yaml_data["propertyToParameterName"] = {
-            pad_reserved_words(prop, PadType.PROPERTY)
-            .lower(): pad_reserved_words(param_name, PadType.PARAMETER)
-            .lower()
+            pad_reserved_words(prop, PadType.PROPERTY): pad_reserved_words(
+                param_name, PadType.PARAMETER
+            )
             for prop, param_name in yaml_data["propertyToParameterName"].items()
         }
 
@@ -257,7 +269,7 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
             response["discriminator"] = "operation"
         if body_parameter and not is_overload:
             # if we have a JSON body, we add a binary overload
-            add_body_param_type(code_model, body_parameter, self.models_mode)
+            add_body_param_type(code_model, body_parameter)
             add_overloads_for_body_param(yaml_data)
 
     def _update_lro_operation_helper(self, yaml_data: Dict[str, Any]) -> None:

package/autorest/preprocess/python_mappings.py

@@ -173,6 +173,7 @@ REDEFINED_BUILTINS = [  # we don't pad, but we need to do lint ignores
     "min",
     "max",
     "filter",
+    "property",
 ]
 
 BUILTIN_PACKAGES = [

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@autorest/python",
-  "version": "6.2.11",
+  "version": "6.2.15",
   "description": "The Python extension for generators in AutoRest.",
+  "main": "index.js",
   "repository": {
     "type": "git",
     "url": "https://github.com/Azure/autorest.python/tree/autorestv3"

package/requirements.txt

@@ -1,13 +1,13 @@
-black==22.6.0
+black==22.12.0
 click==8.1.3
-docutils==0.18
+docutils==0.19
 Jinja2==3.1.2
-json-rpc==1.13.0
-m2r2==0.3.2
+json-rpc==1.14.0
+m2r2==0.3.3
 MarkupSafe==2.1.1
 mistune==0.8.4
 mypy-extensions==0.4.3
-pathspec==0.9.0
-platformdirs==2.5.2
+pathspec==0.10.3
+platformdirs==2.6.2
 PyYAML==6.0
 tomli==2.0.1

package/setup.py

@@ -52,6 +52,5 @@ setup(
         "pyyaml",
         "m2r2",
         "black",
-        "docutils<0.19", # m2r2 fails with docutils 0.19
     ],
 )