@autorest/python 6.2.4 → 6.2.7

package/autorest/black/__init__.py

@@ -8,13 +8,14 @@ from pathlib import Path
 import os
 from typing import Any, Dict
 import black
+from black.report import NothingChanged
 
 from .. import Plugin, PluginAutorest
 from .._utils import parse_args
 
 logging.getLogger("blib2to3").setLevel(logging.ERROR)
 
-_BLACK_MODE = black.Mode()
+_BLACK_MODE = black.Mode()  # pyright: ignore [reportPrivateImportUsage]
 _BLACK_MODE.line_length = 120
 
 
@@ -42,7 +43,7 @@ class BlackScriptPlugin(Plugin):  # pylint: disable=abstract-method
             file_content = black.format_file_contents(
                 file_content, fast=True, mode=_BLACK_MODE
             )
-        except black.NothingChanged:
+        except NothingChanged:
             pass
         self.write_file(file, file_content)
 

package/autorest/codegen/__init__.py

@@ -293,7 +293,7 @@ class CodeGeneratorAutorest(CodeGenerator, PluginAutorest):
         # Parse the received YAML
         return yaml.safe_load(file_content)
 
-    def get_serializer(self, code_model: CodeModel):  # type: ignore
+    def get_serializer(self, code_model: CodeModel):
         return JinjaSerializerAutorest(
             self._autorestapi,
             code_model,

package/autorest/codegen/models/base.py

@@ -32,7 +32,7 @@ class BaseModel:
         return f"<{self.__class__.__name__}>"
 
 
-class BaseType(BaseModel, ABC):
+class BaseType(BaseModel, ABC):  # pylint: disable=too-many-public-methods
     """This is the base class for all types.
 
     :param yaml_data: the yaml data for this schema
@@ -60,6 +60,14 @@ class BaseType(BaseModel, ABC):
     def imports_for_multiapi(self, **kwargs: Any) -> FileImport:
         return self.imports(**kwargs)
 
+    @staticmethod
+    def imports_for_sample() -> FileImport:
+        return FileImport()
+
+    @staticmethod
+    def serialize_sample_value(value: Any) -> str:
+        return repr(value)
+
     @property
     def xml_metadata(self) -> Dict[str, Any]:
         """XML metadata for the type, if the type has it."""
@@ -87,7 +95,6 @@ class BaseType(BaseModel, ABC):
         return ", ".join(attrs_list)
 
     @property
-    @abstractmethod
     def serialization_type(self) -> str:
         """The tag recognized by 'msrest' as a serialization/deserialization.
 
@@ -100,6 +107,11 @@ class BaseType(BaseModel, ABC):
         If dict: '{str}'
         """
         ...
+        raise NotImplementedError()
+
+    @property
+    def msrest_deserialization_key(self) -> str:
+        return self.serialization_type
 
     @property
     def client_default_value(self) -> Any:

package/autorest/codegen/models/client.py

@@ -74,7 +74,9 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
             ]
             self.format_lro_operations()
 
-    def _build_request_builders(self):
+    def _build_request_builders(
+        self,
+    ) -> List[Union[RequestBuilder, OverloadedRequestBuilder]]:
         request_builders: List[Union[RequestBuilder, OverloadedRequestBuilder]] = []
         for og_group in self.yaml_data["operationGroups"]:
             for operation_yaml in og_group["operations"]:
@@ -84,7 +86,7 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
                     client=self,
                 )
                 if request_builder.overloads:
-                    request_builders.extend(request_builder.overloads)  # type: ignore
+                    request_builders.extend(request_builder.overloads)
                 request_builders.append(request_builder)
                 if operation_yaml.get("nextOperation"):
                     # i am a paging operation and i have a next operation.
@@ -174,7 +176,9 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
         for gp in self.parameters:
             if gp.method_location == ParameterMethodLocation.KWARG:
                 continue
-            file_import.merge(gp.imports(async_mode))
+            file_import.merge(
+                gp.imports(async_mode, relative_path=".." if async_mode else ".")
+            )
         file_import.add_submodule_import(
             "._configuration",
             f"{self.name}Configuration",
@@ -285,23 +289,9 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
             and self.code_model.options["models_mode"] == "msrest"
         ):
             path_to_models = ".." if async_mode else "."
-            if len(self.code_model.model_types) != len(
-                self.code_model.public_model_types
-            ):
-                # this means we have hidden models. In that case, we import directly from the models
-                # file, not the module, bc we don't expose the hidden models in the models module
-
-                # Also in this case, we're in version tolerant, so python3 only is true
-                file_import.add_submodule_import(
-                    f"{path_to_models}models",
-                    self.code_model.models_filename,
-                    ImportType.LOCAL,
-                    alias="models",
-                )
-            else:
-                file_import.add_submodule_import(
-                    path_to_models, "models", ImportType.LOCAL
-                )
+            file_import.add_submodule_import(
+                path_to_models, "models", ImportType.LOCAL, alias="_models"
+            )
         elif self.code_model.options["models_mode"] == "msrest":
             # in this case, we have client_models = {} in the service client, which needs a type annotation
             # this import will always be commented, so will always add it to the typing section
@@ -411,7 +401,11 @@ class Config(_ClientConfigBase[ConfigGlobalParameterList]):
                 and gp not in self.parameters.kwargs_to_pop
             ):
                 continue
-            file_import.merge(gp.imports(async_mode=async_mode))
+            file_import.merge(
+                gp.imports(
+                    async_mode=async_mode, relative_path=".." if async_mode else "."
+                )
+            )
         return file_import
 
     def imports_for_multiapi(self, async_mode: bool) -> FileImport:
@@ -423,7 +417,11 @@ class Config(_ClientConfigBase[ConfigGlobalParameterList]):
                 and gp.client_name == "api_version"
             ):
                 continue
-            file_import.merge(gp.imports_for_multiapi(async_mode=async_mode))
+            file_import.merge(
+                gp.imports_for_multiapi(
+                    async_mode=async_mode, relative_path=".." if async_mode else "."
+                )
+            )
         return file_import
 
     @classmethod

package/autorest/codegen/models/combined_type.py

@@ -41,7 +41,7 @@ class CombinedType(BaseType):
         If list: '[str]'
         If dict: '{str}'
         """
-        ...
+        raise ValueError("Shouldn't get serialization type of a combinedtype")
 
     @property
     def client_default_value(self) -> Any:

package/autorest/codegen/models/imports.py

@@ -69,7 +69,7 @@ class ImportModel:
         except AttributeError:
             return False
 
-    def __hash__(self):
+    def __hash__(self) -> int:
         retval: int = 0
         for attr in dir(self):
             if attr[0] != "_":
@@ -88,7 +88,7 @@ class TypeDefinition:
 
 
 class FileImport:
-    def __init__(self, imports: List[ImportModel] = None) -> None:
+    def __init__(self, imports: Optional[List[ImportModel]] = None) -> None:
         self.imports = imports or []
         # has sync and async type definitions
         self.type_definitions: Dict[str, TypeDefinition] = {}

package/autorest/codegen/models/model_type.py

@@ -81,6 +81,10 @@ class ModelType(
             return f"{'' if self.is_public else '_models.'}_models.{self.name}"
         return "object"
 
+    @property
+    def msrest_deserialization_key(self) -> str:
+        return self.name
+
     @property
     def is_polymorphic(self) -> bool:
         return any(p.is_polymorphic for p in self.properties)

package/autorest/codegen/models/operation.py

@@ -160,10 +160,10 @@ class OperationBase(  # pylint: disable=too-many-public-methods
             isinstance(r.type, ModelType) for r in self.responses
         ):
             r = next(r for r in self.responses if isinstance(r.type, ModelType))
-            type_name = getattr(r, "item_type", getattr(r, "type")).docstring_text(
-                **kwargs
-            )
-            retval += f". The {type_name} is compatible with MutableMapping"
+            item_type = getattr(r, "item_type", getattr(r, "type"))
+            if item_type:
+                type_name = item_type.docstring_text(**kwargs)
+                retval += f". The {type_name} is compatible with MutableMapping"
         return retval
 
     def response_docstring_type(self, **kwargs) -> str:
@@ -344,9 +344,9 @@ class OperationBase(  # pylint: disable=too-many-public-methods
             )
 
         if self.has_kwargs_to_pop_with_default(
-            self.parameters.kwargs_to_pop, ParameterLocation.HEADER
+            self.parameters.kwargs_to_pop, ParameterLocation.HEADER  # type: ignore
         ) or self.has_kwargs_to_pop_with_default(
-            self.parameters.kwargs_to_pop, ParameterLocation.QUERY
+            self.parameters.kwargs_to_pop, ParameterLocation.QUERY  # type: ignore
         ):
             file_import.add_submodule_import(
                 "azure.core.utils", "case_insensitive_dict", ImportType.AZURECORE

package/autorest/codegen/models/operation_group.py

@@ -48,11 +48,16 @@ class OperationGroup(BaseModel):
 
     def imports_for_multiapi(self, async_mode: bool) -> FileImport:
         file_import = FileImport()
+        relative_path = ".." if async_mode else "."
         for operation in self.operations:
             file_import.merge(
-                operation.imports_for_multiapi(
-                    async_mode, relative_path=".." if async_mode else "."
-                )
+                operation.imports_for_multiapi(async_mode, relative_path=relative_path)
+            )
+        if (
+            self.code_model.model_types or self.code_model.enums
+        ) and self.code_model.options["models_mode"] == "msrest":
+            file_import.add_submodule_import(
+                relative_path, "models", ImportType.LOCAL, alias="_models"
             )
         return file_import
 
@@ -63,12 +68,6 @@ class OperationGroup(BaseModel):
             retval = add_to_pylint_disable(retval, "abstract-class-instantiated")
         return retval
 
-    @property
-    def mypy_ignore(self) -> str:
-        if self.has_abstract_operations:
-            return "  # type: ignore"
-        return ""
-
     @property
     def need_validation(self) -> bool:
         """Whether any of its operations need validation"""
@@ -84,8 +83,10 @@ class OperationGroup(BaseModel):
             )
         # for multiapi
         if (
-            self.code_model.model_types or self.code_model.enums
-        ) and self.code_model.options["models_mode"] == "msrest":
+            (self.code_model.public_model_types)
+            and self.code_model.options["models_mode"] == "msrest"
+            and not self.is_mixin
+        ):
             file_import.add_submodule_import(
                 relative_path, "models", ImportType.LOCAL, alias="_models"
             )

package/autorest/codegen/models/primitive_types.py

@@ -384,6 +384,16 @@ class DatetimeType(PrimitiveType):
     def instance_check_template(self) -> str:
         return "isinstance({}, datetime.datetime)"
 
+    @staticmethod
+    def imports_for_sample() -> FileImport:
+        file_import = super(DatetimeType, DatetimeType).imports_for_sample()
+        file_import.add_import("isodate", ImportType.STDLIB)
+        return file_import
+
+    @staticmethod
+    def serialize_sample_value(value: Any) -> str:
+        return f"isodate.parse_datetime({repr(value)})"
+
 
 class TimeType(PrimitiveType):
     @property
@@ -418,6 +428,16 @@ class TimeType(PrimitiveType):
     def instance_check_template(self) -> str:
         return "isinstance({}, datetime.time)"
 
+    @staticmethod
+    def imports_for_sample() -> FileImport:
+        file_import = super(TimeType, TimeType).imports_for_sample()
+        file_import.add_import("isodate", ImportType.STDLIB)
+        return file_import
+
+    @staticmethod
+    def serialize_sample_value(value: Any) -> str:
+        return f"isodate.parse_time({repr(value)})"
+
 
 class UnixTimeType(PrimitiveType):
     @property
@@ -452,6 +472,16 @@ class UnixTimeType(PrimitiveType):
     def instance_check_template(self) -> str:
         return "isinstance({}, datetime.time)"
 
+    @staticmethod
+    def imports_for_sample() -> FileImport:
+        file_import = super(UnixTimeType, UnixTimeType).imports_for_sample()
+        file_import.add_import("datetime", ImportType.STDLIB)
+        return file_import
+
+    @staticmethod
+    def serialize_sample_value(value: Any) -> str:
+        return f"datetime.datetime.fromtimestamp({repr(value)}, datetime.timezone.utc)"
+
 
 class DateType(PrimitiveType):
     @property
@@ -486,6 +516,16 @@ class DateType(PrimitiveType):
     def instance_check_template(self) -> str:
         return "isinstance({}, datetime.date)"
 
+    @staticmethod
+    def imports_for_sample() -> FileImport:
+        file_import = super(DateType, DateType).imports_for_sample()
+        file_import.add_import("isodate", ImportType.STDLIB)
+        return file_import
+
+    @staticmethod
+    def serialize_sample_value(value: Any) -> str:
+        return f"isodate.parse_date({repr(value)})"
+
 
 class DurationType(PrimitiveType):
     @property
@@ -520,6 +560,16 @@ class DurationType(PrimitiveType):
     def instance_check_template(self) -> str:
         return "isinstance({}, datetime.timedelta)"
 
+    @staticmethod
+    def imports_for_sample() -> FileImport:
+        file_import = super(DurationType, DurationType).imports_for_sample()
+        file_import.add_import("isodate", ImportType.STDLIB)
+        return file_import
+
+    @staticmethod
+    def serialize_sample_value(value: Any) -> str:
+        return f"isodate.parse_duration({repr(value)})"
+
 
 class ByteArraySchema(PrimitiveType):
     def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:

package/autorest/codegen/models/property.py

@@ -83,6 +83,10 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
     def serialization_type(self) -> str:
         return self.type.serialization_type
 
+    @property
+    def msrest_deserialization_key(self) -> str:
+        return self.type.msrest_deserialization_key
+
     def type_annotation(self, *, is_operation_file: bool = False) -> str:
         if self.optional and self.client_default_value is None:
             return f"Optional[{self.type.type_annotation(is_operation_file=is_operation_file)}]"

package/autorest/codegen/models/request_builder.py

@@ -71,10 +71,18 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
 
     def imports(self) -> FileImport:
         file_import = FileImport()
+        relative_path = ".."
+        if (
+            not self.code_model.options["builders_visibility"] == "embedded"
+            and self.group_name
+        ):
+            relative_path = "..." if self.group_name else ".."
         if self.abstract:
             return file_import
         for parameter in self.parameters.method:
-            file_import.merge(parameter.imports(async_mode=False))
+            file_import.merge(
+                parameter.imports(async_mode=False, relative_path=relative_path)
+            )
 
         file_import.add_submodule_import(
             "azure.core.rest",
@@ -83,12 +91,6 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
         )
 
         if self.parameters.path:
-            relative_path = ".."
-            if (
-                not self.code_model.options["builders_visibility"] == "embedded"
-                and self.group_name
-            ):
-                relative_path = "..." if self.group_name else ".."
             file_import.add_submodule_import(
                 f"{relative_path}_vendor", "_format_url_section", ImportType.LOCAL
             )

package/autorest/codegen/serializers/__init__.py

@@ -4,7 +4,7 @@
 # license information.
 # --------------------------------------------------------------------------
 import logging
-from typing import List, Optional, Any, Union, cast
+from typing import List, Optional, Any, Union
 from pathlib import Path
 from jinja2 import PackageLoader, Environment, FileSystemLoader, StrictUndefined
 
@@ -28,6 +28,7 @@ from .request_builders_serializer import RequestBuildersSerializer
 from .patch_serializer import PatchSerializer
 from .sample_serializer import SampleSerializer
 from ..._utils import to_snake_case
+from .utils import extract_sample_name
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -190,7 +191,7 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
             if self.read_file(namespace_path / Path("models.py")):
                 self.write_file(
                     namespace_path / Path("models.py"),
-                    cast(str, self.read_file(namespace_path / Path("models.py"))),
+                    self.read_file(namespace_path / Path("models.py")),
                 )
 
     def _serialize_and_write_package_files(self, namespace_path: Path) -> None:
@@ -543,8 +544,9 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
                     samples = operation.yaml_data["samples"]
                     if not samples or operation.name.startswith("_"):
                         continue
-                    for key, value in samples.items():
-                        file_name = to_snake_case(key) + ".py"
+                    for value in samples.values():
+                        file = value.get("x-ms-original-file", "sample.json")
+                        file_name = to_snake_case(extract_sample_name(file)) + ".py"
                         try:
                             self.write_file(
                                 out_path / file_name,
@@ -555,12 +557,11 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
                                     operation=operation,
                                     sample=value,
                                     file_name=file_name,
-                                    sample_origin_name=key,
                                 ).serialize(),
                             )
                         except Exception as e:  # pylint: disable=broad-except
                             # sample generation shall not block code generation, so just log error
-                            log_error = f"error happens in sample {key}: {e}"
+                            log_error = f"error happens in sample {file}: {e}"
                             _LOGGER.error(log_error)