@autorest/python 5.14.0 → 5.15.0

package/autorest/codegen/models/primitive_schemas.py

@@ -39,8 +39,7 @@ class PrimitiveSchema(BaseSchema):
     def docstring_type(self) -> str:
         return self._to_python_type()
 
-    @property
-    def type_annotation(self) -> str:
+    def type_annotation(self, *, is_operation_file: bool = False) -> str:  # pylint: disable=unused-argument
         return self.docstring_type
 
     @property
@@ -102,8 +101,7 @@ class IOSchema(PrimitiveSchema):
     def docstring_type(self) -> str:
         return self.type
 
-    @property
-    def type_annotation(self) -> str:
+    def type_annotation(self, *, is_operation_file: bool = False) -> str:  # pylint: disable=unused-argument
         return self.docstring_type
 
     @property
@@ -128,8 +126,7 @@ class AnySchema(PrimitiveSchema):
     def docstring_type(self) -> str:
         return "any"
 
-    @property
-    def type_annotation(self) -> str:
+    def type_annotation(self, *, is_operation_file: bool = False) -> str:  # pylint: disable=unused-argument
         return "Any"
 
     @property
@@ -147,8 +144,7 @@ class JSONSchema(AnySchema):
     def docstring_type(self) -> str:
         return "JSONType"
 
-    @property
-    def type_annotation(self) -> str:
+    def type_annotation(self, *, is_operation_file: bool = False) -> str:  # pylint: disable=unused-argument
         return "JSONType"
 
 
@@ -206,8 +202,7 @@ class NumberSchema(PrimitiveSchema):
             return "int"
         return "float"
 
-    @property
-    def type_annotation(self) -> str:
+    def type_annotation(self, *, is_operation_file: bool = False) -> str:  # pylint: disable=unused-argument
         python_type = self.docstring_type
         if python_type == "long":
             return "int"
@@ -269,10 +264,9 @@ class DatetimeSchema(PrimitiveSchema):
 
     @property
     def docstring_type(self) -> str:
-        return "~" + self.type_annotation
+        return "~" + self.type_annotation()
 
-    @property
-    def type_annotation(self) -> str:
+    def type_annotation(self, *, is_operation_file: bool = False) -> str:  # pylint: disable=unused-argument
         return "datetime.datetime"
 
     @property
@@ -301,10 +295,9 @@ class TimeSchema(PrimitiveSchema):
 
     @property
     def docstring_type(self) -> str:
-        return "~" + self.type_annotation
+        return "~" + self.type_annotation()
 
-    @property
-    def type_annotation(self) -> str:
+    def type_annotation(self, *, is_operation_file: bool = False) -> str:  # pylint: disable=unused-argument
         return "datetime.time"
 
     @property
@@ -334,10 +327,9 @@ class UnixTimeSchema(PrimitiveSchema):
 
     @property
     def docstring_type(self) -> str:
-        return "~" + self.type_annotation
+        return "~" + self.type_annotation()
 
-    @property
-    def type_annotation(self) -> str:
+    def type_annotation(self, *, is_operation_file: bool = False) -> str:  # pylint: disable=unused-argument
         return "datetime.datetime"
 
     @property
@@ -367,10 +359,9 @@ class DateSchema(PrimitiveSchema):
 
     @property
     def docstring_type(self) -> str:
-        return "~" + self.type_annotation
+        return "~" + self.type_annotation()
 
-    @property
-    def type_annotation(self) -> str:
+    def type_annotation(self, *, is_operation_file: bool = False) -> str:  # pylint: disable=unused-argument
         return "datetime.date"
 
     @property
@@ -400,10 +391,9 @@ class DurationSchema(PrimitiveSchema):
 
     @property
     def docstring_type(self) -> str:
-        return "~" + self.type_annotation
+        return "~" + self.type_annotation()
 
-    @property
-    def type_annotation(self) -> str:
+    def type_annotation(self, *, is_operation_file: bool = False) -> str:  # pylint: disable=unused-argument
         return "datetime.timedelta"
 
     @property

package/autorest/codegen/models/property.py

@@ -60,7 +60,7 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
             values = [self.schema.enum_type.get_declaration(v.value) for v in self.schema.values]
             if description and description[-1] != " ":
                 description += " "
-            description += "Possible values include: {}.".format(", ".join(values))
+            description += "Known values are: {}.".format(", ".join(values))
             if self.schema.default_value:
                 description += f' Default value: "{self.schema.default_value}".'
         return description
@@ -149,11 +149,10 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
             return self.schema.get_declaration(self.client_default_value)
         return self.schema.default_value_declaration
 
-    @property
-    def type_annotation(self) -> str:
+    def type_annotation(self, *, is_operation_file: bool = False) -> str:
         if self.required:
-            return self.schema.type_annotation
-        return f"Optional[{self.schema.type_annotation}]"
+            return self.schema.type_annotation(is_operation_file=is_operation_file)
+        return f"Optional[{self.schema.type_annotation(is_operation_file=is_operation_file)}]"
 
     def get_json_template_representation(self, **kwargs: Any) -> Any:
         kwargs["optional"] = not self.required
@@ -171,4 +170,5 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
         file_import = self.schema.model_file_imports()
         if not self.required:
             file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        file_import.merge(self.schema.model_file_imports())
         return file_import

package/autorest/codegen/models/request_builder.py

@@ -82,9 +82,7 @@ class RequestBuilder(BaseBuilder):
                 f"{relative_path}_vendor", "_format_url_section", ImportType.LOCAL
             )
         if self.parameters.headers or self.parameters.query:
-            file_import.add_submodule_import(
-                "typing", "Dict", ImportType.STDLIB, typing_section=TypingSection.CONDITIONAL
-            )
+            file_import.add_submodule_import("azure.core.utils", "case_insensitive_dict", ImportType.AZURECORE)
         file_import.add_submodule_import(
             "typing", "Any", ImportType.STDLIB, typing_section=TypingSection.CONDITIONAL
         )
@@ -130,7 +128,9 @@ class RequestBuilder(BaseBuilder):
             schema_requests=schema_requests,
             parameters=parameter_list,
             description=yaml_data["language"]["python"]["description"],
-            responses=[SchemaResponse.from_yaml(yaml) for yaml in yaml_data.get("responses", [])],
+            responses=[
+                SchemaResponse.from_yaml(yaml, code_model=code_model) for yaml in yaml_data.get("responses", [])
+            ],
             summary=yaml_data["language"]["python"].get("summary"),
         )
         code_model.request_builder_ids[id(yaml_data)] = request_builder_class

package/autorest/codegen/models/request_builder_parameter.py

@@ -4,7 +4,8 @@
 # license information.
 # --------------------------------------------------------------------------
 from typing import Any, Dict, List, Optional
-from .parameter import ParameterOnlyPathAndBodyPositional, ParameterLocation, ParameterStyle
+from .parameter import ParameterOnlyPathAndBodyPositional, ParameterLocation, ParameterStyle, get_target_property_name
+from .utils import get_schema
 
 def _make_public(name):
     if name[0] == "_":
@@ -16,8 +17,8 @@ class RequestBuilderParameter(ParameterOnlyPathAndBodyPositional):
     @property
     def in_method_signature(self) -> bool:
         return not(
-            # don't put accept in method signature
-            self.rest_api_name == "Accept"
+            # if not inputtable, don't put in signature
+            not self.inputtable_by_user
             # If i'm not in the method code, no point in being in signature
             or not self.in_method_code
             # If I'm a flattened property of a body, don't want me, want the body param
@@ -78,10 +79,16 @@ class RequestBuilderParameter(ParameterOnlyPathAndBodyPositional):
         http_protocol = yaml_data["protocol"].get("http", {"in": ParameterLocation.Other})
         name = yaml_data["language"]["python"]["name"]
         location = ParameterLocation(http_protocol["in"])
+        serialized_name = yaml_data["language"]["python"]["name"]
+        schema = get_schema(
+            code_model, yaml_data.get("schema"), serialized_name
+        )
+        target_property = yaml_data.get("targetProperty")
+        target_property_name = get_target_property_name(code_model, id(target_property)) if target_property else None
         return cls(
             code_model=code_model,
             yaml_data=yaml_data,
-            schema=yaml_data.get("schema", None),  # FIXME replace by operation model
+            schema=schema,
             # See also https://github.com/Azure/autorest.modelerfour/issues/80
             rest_api_name=yaml_data["language"]["default"].get(
                 "serializedName", yaml_data["language"]["default"]["name"]
@@ -93,7 +100,7 @@ class RequestBuilderParameter(ParameterOnlyPathAndBodyPositional):
             location=location,
             skip_url_encoding=yaml_data.get("extensions", {}).get("x-ms-skip-url-encoding", False),
             constraints=[],  # FIXME constraints
-            target_property_name=id(yaml_data["targetProperty"]) if yaml_data.get("targetProperty") else None,
+            target_property_name=target_property_name,
             style=ParameterStyle(http_protocol["style"]) if "style" in http_protocol else None,
             explode=http_protocol.get("explode", False),
             grouped_by=yaml_data.get("groupedBy", None),

package/autorest/codegen/models/schema_response.py

@@ -3,12 +3,17 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Dict, Optional, List, Union, Any, cast
+from typing import Dict, Optional, List, Union, Any, cast, TYPE_CHECKING
 
 from .base_model import BaseModel
 from .base_schema import BaseSchema
 from .object_schema import ObjectSchema
 from .imports import FileImport, ImportType
+from .utils import get_schema
+from .primitive_schemas import IOSchema
+
+if TYPE_CHECKING:
+    from .code_model import CodeModel
 
 
 class HeaderResponse:
@@ -24,6 +29,7 @@ class HeaderResponse:
 class SchemaResponse(BaseModel):
     def __init__(
         self,
+        code_model: "CodeModel",
         yaml_data: Dict[str, Any],
         schema: Optional[BaseSchema],
         content_types: List[str],
@@ -32,6 +38,7 @@ class SchemaResponse(BaseModel):
         binary: bool,
     ) -> None:
         super().__init__(yaml_data)
+        self.code_model = code_model
         self.schema = schema
         self.content_types = content_types
         self.status_codes = status_codes
@@ -57,13 +64,12 @@ class SchemaResponse(BaseModel):
             return self.schema.serialization_type
         return "None"
 
-    @property
-    def operation_type_annotation(self) -> str:
+    def type_annotation(self, *, is_operation_file: bool = False) -> str:
         if not self.schema:
             return "None"
         if self.nullable:
-            return f"Optional[{self.schema.operation_type_annotation}]"
-        return self.schema.operation_type_annotation
+            return f"Optional[{self.schema.type_annotation(is_operation_file=is_operation_file)}]"
+        return self.schema.type_annotation(is_operation_file=is_operation_file)
 
     @property
     def docstring_text(self) -> str:
@@ -103,20 +109,27 @@ class SchemaResponse(BaseModel):
         return file_import
 
     @classmethod
-    def from_yaml(cls, yaml_data: Dict[str, Any]) -> "SchemaResponse":
-
+    def from_yaml(cls, yaml_data: Dict[str, Any], *, code_model: "CodeModel") -> "SchemaResponse":
+        binary = yaml_data.get("binary", False)
+        if binary:
+            schema: BaseSchema = IOSchema(namespace=None, yaml_data={})
+        else:
+            schema = get_schema(code_model, yaml_data.get("schema"))
         return cls(
+            code_model=code_model,
             yaml_data=yaml_data,
-            schema=yaml_data.get("schema", None),  # FIXME replace by operation model
+            schema=schema,
             content_types=yaml_data["protocol"]["http"].get("mediaTypes", []),
             status_codes=[
                 int(code) if code != "default" else "default" for code in yaml_data["protocol"]["http"]["statusCodes"]
             ],
             headers=[
-                HeaderResponse(header_prop["header"], header_prop["schema"])
+                HeaderResponse(
+                    header_prop["header"], get_schema(code_model, header_prop["schema"], header_prop["header"])
+                )
                 for header_prop in yaml_data["protocol"]["http"].get("headers", [])
             ],
-            binary=yaml_data.get("binary", False),
+            binary=binary,
         )
 
     def __repr__(self) -> str:

package/autorest/codegen/models/utils.py

@@ -4,5 +4,25 @@
 # license information.
 # --------------------------------------------------------------------------
 import re
+from typing import Any, TYPE_CHECKING
+import logging
+from .base_schema import BaseSchema
+
+if TYPE_CHECKING:
+    from .code_model import CodeModel
+
+
+_LOGGER = logging.getLogger(__name__)
 
 JSON_REGEXP = re.compile(r'^(application|text)/(.+\+)?json$')
+
+def get_schema(code_model: "CodeModel", schema: Any, serialized_name: str = "unknown") -> BaseSchema:
+    if not isinstance(schema, dict):
+        return schema
+    schema_id = id(schema)
+    _LOGGER.debug("Looking for id %s for member %s", schema_id, serialized_name)
+    try:
+        return code_model.lookup_schema(schema_id)
+    except KeyError:
+        _LOGGER.critical("Unable to ref the object")
+        raise

package/autorest/codegen/serializers/__init__.py

@@ -49,6 +49,10 @@ class JinjaSerializer:
         self._autorestapi = autorestapi
         self.code_model = code_model
 
+    @property
+    def has_aio_folder(self) -> bool:
+        return not self.code_model.options["no_async"] and bool(self.code_model.rest.request_builders)
+
     def serialize(self) -> None:
         env = Environment(
             loader=PackageLoader("autorest.codegen", "templates"),
@@ -64,17 +68,28 @@ class JinjaSerializer:
             if self.code_model.options["no_namespace_folders"]
             else Path(*(self.code_model.namespace.split(".")))
         )
-
         # if there was a patch file before, we keep it
         self._keep_patch_file(namespace_path / Path("_patch.py"), env)
-        self._keep_patch_file(namespace_path / Path("aio") / Path("_patch.py"), env)
+        if self.has_aio_folder:
+            self._keep_patch_file(namespace_path / Path("aio") / Path("_patch.py"), env)
+
+        if self.code_model.options["models_mode"] and (self.code_model.schemas or self.code_model.enums):
+            self._keep_patch_file(namespace_path / Path("models") / Path("_patch.py"), env)
+        if self.code_model.options["show_operations"] and self.code_model.operation_groups:
+            self._keep_patch_file(
+                namespace_path / Path(self.code_model.operations_folder_name) / Path("_patch.py"), env
+            )
+            if self.has_aio_folder:
+                self._keep_patch_file(
+                    namespace_path / Path("aio") / Path(self.code_model.operations_folder_name) / Path("_patch.py"), env
+                )
 
         self._serialize_and_write_top_level_folder(env=env, namespace_path=namespace_path)
 
         if self.code_model.rest.request_builders:
             if self.code_model.options["builders_visibility"] != "embedded":
                 self._serialize_and_write_rest_layer(env=env, namespace_path=namespace_path)
-            if not self.code_model.options["no_async"]:
+            if self.has_aio_folder:
                 self._serialize_and_write_aio_top_level_folder(
                     env=env, namespace_path=namespace_path,
                 )
@@ -88,6 +103,12 @@ class JinjaSerializer:
 
         if self.code_model.options["models_mode"] and (self.code_model.schemas or self.code_model.enums):
             self._serialize_and_write_models_folder(env=env, namespace_path=namespace_path)
+        if not self.code_model.options["models_mode"]:
+            # keep models file if users ended up just writing a models file
+            if self._autorestapi.read_file(namespace_path / Path("models.py")):
+                self._autorestapi.write_file(
+                    namespace_path / Path("models.py"), self._autorestapi.read_file(namespace_path / Path("models.py"))
+                )
 
         if self.code_model.options["package_mode"]:
             self._serialize_and_write_package_files(out_path=namespace_path)
@@ -106,7 +127,10 @@ class JinjaSerializer:
         def _prepare_params() -> Dict[Any, Any]:
             package_parts = self.code_model.options["package_name"].split("-")[:-1]
             try:
-                token_cred = isinstance(self.code_model.credential_schema_policy.credential, TokenCredentialSchema)
+                token_cred = isinstance(
+                    self.code_model.credential_model.credential_schema_policy.credential,
+                    TokenCredentialSchema
+                )
             except ValueError:
                 token_cred = False
             version = self.code_model.options["package_version"]
@@ -149,8 +173,7 @@ class JinjaSerializer:
         if self._autorestapi.read_file(path_file):
             self._autorestapi.write_file(path_file, self._autorestapi.read_file(path_file))
         else:
-            self._autorestapi.write_file(path_file, PatchSerializer(env=env).serialize())
-
+            self._autorestapi.write_file(path_file, PatchSerializer(env=env, code_model=self.code_model).serialize())
 
     def _serialize_and_write_models_folder(self, env: Environment, namespace_path: Path) -> None:
         # Write the models folder
@@ -158,16 +181,16 @@ class JinjaSerializer:
         if self.code_model.schemas:
             if not self.code_model.options['python3_only']:
                 self._autorestapi.write_file(
-                    models_path / Path("_models.py"),
+                    models_path / Path(f"{self.code_model.get_models_filename(is_python3_file=False)}.py"),
                     ModelGenericSerializer(code_model=self.code_model, env=env).serialize()
                 )
             self._autorestapi.write_file(
-                models_path / Path("_models_py3.py"),
+                models_path / Path(f"{self.code_model.get_models_filename(is_python3_file=True)}.py"),
                 ModelPython3Serializer(code_model=self.code_model, env=env).serialize()
             )
         if self.code_model.enums:
             self._autorestapi.write_file(
-                models_path / Path(f"_{self.code_model.module_name}_enums.py"),
+                models_path / Path(f"{self.code_model.enums_filename}.py"),
                 EnumSerializer(code_model=self.code_model, env=env).serialize(),
             )
         self._autorestapi.write_file(
@@ -257,7 +280,7 @@ class JinjaSerializer:
                 operation_group_serializer.serialize(),
             )
 
-        if not self.code_model.options["no_async"]:
+        if self.has_aio_folder:
             # write async operation group and operation files
             operation_group_async_serializer = OperationGroupsSerializer(
                 code_model=self.code_model,
@@ -287,7 +310,7 @@ class JinjaSerializer:
         )
 
         # write async operations init file
-        if not self.code_model.options["no_async"]:
+        if self.has_aio_folder:
             operations_async_init_serializer = OperationsInitSerializer(
                 code_model=self.code_model, env=env, async_mode=True
             )
@@ -336,14 +359,9 @@ class JinjaSerializer:
     ) -> None:
         general_serializer = GeneralSerializer(code_model=self.code_model, env=env, async_mode=False)
 
-        if self.code_model.rest.request_builders:
-            self._autorestapi.write_file(
-                namespace_path / Path("__init__.py"), general_serializer.serialize_init_file()
-            )
-        else:
-            self._autorestapi.write_file(
-                namespace_path / Path("__init__.py"), general_serializer.serialize_pkgutil_init_file()
-            )
+        self._autorestapi.write_file(
+            namespace_path / Path("__init__.py"), general_serializer.serialize_init_file()
+        )
         p = namespace_path.parent
         while p != Path("."):
             # write pkgutil init file
@@ -355,11 +373,11 @@ class JinjaSerializer:
         # Write the service client
         if self.code_model.rest.request_builders:
             self._autorestapi.write_file(
-                namespace_path / Path(f"_{self.code_model.module_name}.py"),
+                namespace_path / Path(f"{self.code_model.service_client.filename}.py"),
                 general_serializer.serialize_service_client_file()
             )
 
-        if self.code_model.need_vendored_code:
+        if self.code_model.need_vendored_code(async_mode=False):
             self._autorestapi.write_file(
                 namespace_path / Path("_vendor.py"),
                 general_serializer.serialize_vendor_file()
@@ -391,15 +409,21 @@ class JinjaSerializer:
         self._autorestapi.write_file(aio_path / Path("__init__.py"), aio_general_serializer.serialize_init_file())
 
         # Write the service client
-        self._autorestapi.write_file(
-            aio_path / Path(f"_{self.code_model.module_name}.py"),
-            aio_general_serializer.serialize_service_client_file(),
-        )
+        if self.code_model.rest.request_builders:
+            self._autorestapi.write_file(
+                aio_path / Path(f"{self.code_model.service_client.filename}.py"),
+                aio_general_serializer.serialize_service_client_file(),
+            )
 
         # Write the config file
         self._autorestapi.write_file(
             aio_path / Path("_configuration.py"), aio_general_serializer.serialize_config_file()
         )
+        if self.code_model.need_vendored_code(async_mode=True):
+            self._autorestapi.write_file(
+                aio_path / Path("_vendor.py"),
+                aio_general_serializer.serialize_vendor_file()
+            )
 
 
     def _serialize_and_write_metadata(self, env: Environment, namespace_path: Path) -> None: