@autorest/python 6.9.5 → 6.9.7

package/autorest/codegen/models/request_builder.py

@@ -78,10 +78,10 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
         )
 
     def response_docstring_type(self, **kwargs) -> str:
-        return f"~{self.init_file_import().import_core_rest}.HttpRequest"
+        return f"~{self.code_model.core_library}.rest.HttpRequest"
 
     def imports(self) -> FileImport:
-        file_import = self.init_file_import()
+        file_import = FileImport(self.code_model)
         relative_path = ".."
         if (
             not self.code_model.options["builders_visibility"] == "embedded"
@@ -98,14 +98,14 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
             )
 
         file_import.add_submodule_import(
-            file_import.import_core_rest,
+            "rest",
             "HttpRequest",
             ImportType.SDKCORE,
         )
 
         if self.parameters.headers or self.parameters.query:
             file_import.add_submodule_import(
-                file_import.import_core_utils,
+                "utils",
                 "case_insensitive_dict",
                 ImportType.SDKCORE,
             )

package/autorest/codegen/models/response.py

@@ -114,7 +114,7 @@ class Response(BaseModel):
         return self.type.docstring_type(**kwargs) if self.type else "None"
 
     def _imports_shared(self, **kwargs: Any) -> FileImport:
-        file_import = self.init_file_import()
+        file_import = FileImport(self.code_model)
         if self.type:
             file_import.merge(self.type.imports(**kwargs))
         if self.nullable:
@@ -134,6 +134,16 @@ class Response(BaseModel):
     def imports_for_multiapi(self, **kwargs: Any) -> FileImport:
         return self._imports_shared(**kwargs)
 
+    def _get_import_type(self, input_path: str) -> ImportType:
+        # helper function to return imports for responses based off
+        # of whether we're importing from the core library, or users
+        # are customizing responses
+        return (
+            ImportType.SDKCORE
+            if self.code_model.core_library.split(".")[0] in input_path
+            else ImportType.THIRDPARTY
+        )
+
     @classmethod
     def from_yaml(
         cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
@@ -166,11 +176,14 @@ class PagingResponse(Response):
         self.item_type = self.code_model.lookup_type(id(self.yaml_data["itemType"]))
         self.pager_sync: str = (
             self.yaml_data.get("pagerSync")
-            or f"{self.init_file_import().import_core_paging}.ItemPaged"
+            or f"{self.code_model.core_library}.paging.ItemPaged"
+        )
+        default_paging_submodule = (
+            f"{'' if self.code_model.options['unbranded'] else 'async_'}paging"
         )
         self.pager_async: str = (
             self.yaml_data.get("pagerAsync")
-            or f"{self.init_file_import().import_core_paging_async}.AsyncItemPaged"
+            or f"{self.code_model.core_library}.{default_paging_submodule}.AsyncItemPaged"
         )
 
     def get_polymorphic_subtypes(self, polymorphic_subtypes: List["ModelType"]) -> None:
@@ -179,6 +192,9 @@ class PagingResponse(Response):
     def get_json_template_representation(self) -> Any:
         return self.item_type.get_json_template_representation()
 
+    def get_pager_import_path(self, async_mode: bool) -> str:
+        return ".".join(self.get_pager_path(async_mode).split(".")[:-1])
+
     def get_pager_path(self, async_mode: bool) -> str:
         return self.pager_async if async_mode else self.pager_sync
 
@@ -201,10 +217,12 @@ class PagingResponse(Response):
     def _imports_shared(self, **kwargs: Any) -> FileImport:
         file_import = super()._imports_shared(**kwargs)
         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)
+        pager_path = self.get_pager_import_path(async_mode)
 
-        file_import.add_submodule_import(pager_import_path, pager, ImportType.SDKCORE)
+        file_import.add_submodule_import(
+            pager_path, pager, self._get_import_type(pager_path)
+        )
         return file_import
 
     def imports(self, **kwargs: Any) -> FileImport:
@@ -212,7 +230,7 @@ class PagingResponse(Response):
         async_mode = kwargs.get("async_mode")
         if async_mode:
             file_import.add_submodule_import(
-                file_import.import_core_paging_async,
+                f"{'' if self.code_model.options['unbranded'] else 'async_'}paging",
                 "AsyncList",
                 ImportType.SDKCORE,
             )
@@ -283,7 +301,9 @@ class LROResponse(Response):
         async_mode = kwargs["async_mode"]
         poller_import_path = ".".join(self.get_poller_path(async_mode).split(".")[:-1])
         poller = self.get_poller(async_mode)
-        file_import.add_submodule_import(poller_import_path, poller, ImportType.SDKCORE)
+        file_import.add_submodule_import(
+            poller_import_path, poller, self._get_import_type(poller_import_path)
+        )
         return file_import
 
     def imports(self, **kwargs: Any) -> FileImport:
@@ -297,7 +317,7 @@ class LROResponse(Response):
         file_import.add_submodule_import(
             default_polling_method_import_path,
             default_polling_method,
-            ImportType.SDKCORE,
+            self._get_import_type(default_polling_method_import_path),
         )
         default_no_polling_method_import_path = ".".join(
             self.get_no_polling_method_path(async_mode).split(".")[:-1]
@@ -306,7 +326,7 @@ class LROResponse(Response):
         file_import.add_submodule_import(
             default_no_polling_method_import_path,
             default_no_polling_method,
-            ImportType.SDKCORE,
+            self._get_import_type(default_no_polling_method_import_path),
         )
 
         base_polling_method_import_path = ".".join(
@@ -314,7 +334,9 @@ class LROResponse(Response):
         )
         base_polling_method = self.get_base_polling_method(async_mode)
         file_import.add_submodule_import(
-            base_polling_method_import_path, base_polling_method, ImportType.SDKCORE
+            base_polling_method_import_path,
+            base_polling_method,
+            self._get_import_type(base_polling_method_import_path),
         )
         return file_import
 

package/autorest/codegen/serializers/builder_serializer.py

@@ -428,9 +428,7 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
 
     @property
     def pipeline_name(self) -> str:
-        if not self.code_model.options["unbranded"]:
-            return "_pipeline"
-        return "pipeline"
+        return f"{'' if self.code_model.options['unbranded'] else '_'}pipeline"
 
 
 ############################## REQUEST BUILDERS ##############################
@@ -489,13 +487,13 @@ class RequestBuilderSerializer(
         return False
 
     def response_docstring(self, builder: RequestBuilderType) -> List[str]:
-        import_core_rest = builder.init_file_import().import_core_rest
+        request_full_path = f"{self.code_model.core_library}.rest.HttpRequest"
         response_str = (
-            f":return: Returns an :class:`~{import_core_rest}.HttpRequest` that you will pass to the client's "
+            f":return: Returns an :class:`~{request_full_path}` that you will pass to the client's "
             + "`send_request` method. See https://aka.ms/azsdk/dpcodegen/python/send_request for how to "
             + "incorporate this response into your code flow."
         )
-        rtype_str = f":rtype: ~{import_core_rest}.HttpRequest"
+        rtype_str = f":rtype: ~{request_full_path}"
         return [response_str, rtype_str]
 
     def pop_kwargs_from_signature(self, builder: RequestBuilderType) -> List[str]:
@@ -645,7 +643,7 @@ class _OperationSerializer(
         type_ignore = self.async_mode and builder.group_name == ""  # is in a mixin
         stream_value = (
             f'kwargs.pop("stream", {builder.has_stream_response})'
-            if builder.expose_stream_keyword
+            if builder.expose_stream_keyword and builder.has_response_body
             else builder.has_stream_response
         )
         return [
@@ -730,7 +728,7 @@ class _OperationSerializer(
         return [
             response_str,
             rtype_str,
-            f":raises ~{builder.init_file_import().import_core_exceptions}.HttpResponseError:",
+            f":raises ~{self.code_model.core_library}.exceptions.HttpResponseError:",
         ]
 
     def _serialize_body_parameter(self, builder: OperationType) -> List[str]:
@@ -763,13 +761,13 @@ class _OperationSerializer(
             if hasattr(body_param.type, "encode") and body_param.type.encode:  # type: ignore
                 create_body_call = (
                     f"_{body_kwarg_name} = json.dumps({body_param.client_name}, "
-                    "cls=AzureJSONEncoder, exclude_readonly=True, "
+                    "cls=SdkJSONEncoder, exclude_readonly=True, "
                     f"format='{body_param.type.encode}')  # type: ignore"  # type: ignore
                 )
             else:
                 create_body_call = (
                     f"_{body_kwarg_name} = json.dumps({body_param.client_name}, "
-                    "cls=AzureJSONEncoder, exclude_readonly=True)  # type: ignore"
+                    "cls=SdkJSONEncoder, exclude_readonly=True)  # type: ignore"
                 )
         else:
             create_body_call = f"_{body_kwarg_name} = {body_param.client_name}"
@@ -1082,12 +1080,18 @@ class _OperationSerializer(
                 if builder.has_stream_response:
                     deserialize_code.append("deserialized = response.content")
                 else:
+                    format_filed = (
+                        f', format="{response.type.encode}"'
+                        if isinstance(response.type, ByteArraySchema)
+                        and response.default_content_type == "application/json"
+                        else ""
+                    )
                     deserialize_code.append("deserialized = _deserialize(")
                     deserialize_code.append(
                         f"    {response.type.type_annotation(is_operation_file=True)},{pylint_disable}"
                     )
                     deserialize_code.append(
-                        f"    response.json(){response.result_property}"
+                        f"    response.json(){response.result_property}{format_filed}"
                     )
                     deserialize_code.append(")")
 

package/autorest/codegen/serializers/client_serializer.py

@@ -192,7 +192,7 @@ class ClientSerializer:
 
     def _send_request_signature(self) -> str:
         send_request_signature = [
-            "request: HttpRequest,"
+            "request: HttpRequest, *, stream: bool = False,"
         ] + self.client.parameters.method_signature_kwargs
         return self.parameter_serializer.serialize_method(
             function_def="def",
@@ -253,7 +253,7 @@ class ClientSerializer:
 
     def _rest_request_example(self, async_mode: bool) -> List[str]:
         retval = [
-            f">>> from {self.client.init_file_import().import_core_rest} import HttpRequest"
+            f">>> from {self.client.code_model.core_library}.rest import HttpRequest"
         ]
         retval.append('>>> request = HttpRequest("GET", "https://www.example.org/")')
         retval.append("<HttpRequest [GET], url: 'https://www.example.org/'>")
@@ -261,6 +261,7 @@ class ClientSerializer:
         return retval
 
     def send_request_description(self, async_mode: bool) -> List[str]:
+        rest_library = f"{self.client.code_model.core_library}.rest"
         retval = ['"""Runs the network request through the client\'s chained policies.']
         retval.append("")
         if self.client.code_model.options["builders_visibility"] != "embedded":
@@ -273,9 +274,7 @@ class ClientSerializer:
         )
         retval.append("")
         retval.append(":param request: The network request you want to make. Required.")
-        retval.append(
-            f":type request: ~{self.client.init_file_import().import_core_rest}.HttpRequest"
-        )
+        retval.append(f":type request: ~{rest_library}.HttpRequest")
         retval.append(
             ":keyword bool stream: Whether the response payload will be streamed. Defaults to False."
         )
@@ -283,9 +282,7 @@ class ClientSerializer:
             ":return: The response of your network call. Does not do error handling on your response."
         )
         http_response = "AsyncHttpResponse" if async_mode else "HttpResponse"
-        retval.append(
-            f":rtype: ~{self.client.init_file_import().import_core_rest}.{http_response}"
-        )
+        retval.append(f":rtype: ~{rest_library}.{http_response}")
         retval.append('"""')
         return retval
 

package/autorest/codegen/serializers/enum_serializer.py

@@ -5,6 +5,7 @@
 # --------------------------------------------------------------------------
 
 from .base_serializer import BaseSerializer
+from ..models import FileImport
 
 
 class EnumSerializer(BaseSerializer):
@@ -12,5 +13,5 @@ class EnumSerializer(BaseSerializer):
         # Generate the enum file
         template = self.env.get_template("enum_container.py.jinja2")
         return template.render(
-            code_model=self.code_model, file_import=self.init_file_import()
+            code_model=self.code_model, file_import=FileImport(self.code_model)
         )

package/autorest/codegen/serializers/general_serializer.py

@@ -6,7 +6,7 @@
 from typing import Any, List
 from jinja2 import Environment
 from .import_serializer import FileImportSerializer, TypingSection
-from ..models.imports import MsrestImportType
+from ..models.imports import MsrestImportType, FileImport
 from ..models import (
     ImportType,
     CodeModel,
@@ -59,7 +59,7 @@ class GeneralSerializer(BaseSerializer):
         }
         params.update(self.code_model.options)
         params.update(kwargs)
-        return template.render(file_import=self.init_file_import(), **params)
+        return template.render(file_import=FileImport(self.code_model), **params)
 
     def serialize_pkgutil_init_file(self) -> str:
         template = self.env.get_template("pkgutil_init.py.jinja2")
@@ -76,7 +76,7 @@ class GeneralSerializer(BaseSerializer):
     def serialize_service_client_file(self, clients: List[Client]) -> str:
         template = self.env.get_template("client_container.py.jinja2")
 
-        imports = self.init_file_import()
+        imports = FileImport(self.code_model)
         for client in clients:
             imports.merge(client.imports(self.async_mode))
 
@@ -92,7 +92,7 @@ class GeneralSerializer(BaseSerializer):
         template = self.env.get_template("vendor.py.jinja2")
 
         # configure imports
-        file_import = self.init_file_import()
+        file_import = FileImport(self.code_model)
         if self.code_model.need_request_converter:
             file_import.add_submodule_import(
                 "azure.core.pipeline.transport",
@@ -107,7 +107,7 @@ class GeneralSerializer(BaseSerializer):
                 ImportType.STDLIB,
             )
             file_import.add_submodule_import(
-                file_import.import_core_pipeline_client,
+                "runtime" if self.code_model.options["unbranded"] else "",
                 f"{'Async' if self.async_mode else ''}PipelineClient",
                 ImportType.SDKCORE,
                 TypingSection.TYPING,
@@ -126,7 +126,7 @@ class GeneralSerializer(BaseSerializer):
         if self.code_model.has_etag:
             file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB)
             file_import.add_submodule_import(
-                file_import.import_core,
+                "",
                 "MatchConditions",
                 ImportType.SDKCORE,
             )
@@ -142,7 +142,7 @@ class GeneralSerializer(BaseSerializer):
 
     def serialize_config_file(self, clients: List[Client]) -> str:
         template = self.env.get_template("config_container.py.jinja2")
-        imports = self.init_file_import()
+        imports = FileImport(self.code_model)
         for client in self.code_model.clients:
             imports.merge(client.config.imports(self.async_mode))
         return template.render(
@@ -160,14 +160,13 @@ class GeneralSerializer(BaseSerializer):
     def serialize_serialization_file(self) -> str:
         template = self.env.get_template("serialization.py.jinja2")
         return template.render(
-            import_core_exceptions=self.init_file_import().import_core_exceptions,
-            import_core_serialization=self.init_file_import().import_core_serialization,
+            code_model=self.code_model,
         )
 
     def serialize_model_base_file(self) -> str:
         template = self.env.get_template("model_base.py.jinja2")
         return template.render(
-            code_model=self.code_model, file_import=self.init_file_import()
+            code_model=self.code_model, file_import=FileImport(self.code_model)
         )
 
     def serialize_validation_file(self) -> str:

package/autorest/codegen/serializers/model_serializer.py

@@ -129,7 +129,7 @@ class _ModelSerializer(BaseSerializer, ABC):
 
 class MsrestModelSerializer(_ModelSerializer):
     def imports(self) -> FileImport:
-        file_import = self.init_file_import()
+        file_import = FileImport(self.code_model)
         file_import.add_msrest_import(
             relative_path="..",
             msrest_import_type=MsrestImportType.Module,
@@ -198,7 +198,7 @@ class MsrestModelSerializer(_ModelSerializer):
 
 class DpgModelSerializer(_ModelSerializer):
     def imports(self) -> FileImport:
-        file_import = self.init_file_import()
+        file_import = FileImport(self.code_model)
         file_import.add_submodule_import(
             "..",
             "_model_base",

package/autorest/codegen/serializers/operation_groups_serializer.py

@@ -13,6 +13,7 @@ from ..models import (
     RequestBuilder,
     OverloadedRequestBuilder,
     Client,
+    FileImport,
 )
 from .import_serializer import FileImportSerializer
 from .builder_serializer import (
@@ -56,7 +57,7 @@ class OperationGroupsSerializer(BaseSerializer):
             if self.operation_group
             else [og for client in self.clients for og in client.operation_groups]
         )
-        imports = self.init_file_import()
+        imports = FileImport(self.code_model)
         for operation_group in operation_groups:
             imports.merge(
                 operation_group.imports(

package/autorest/codegen/serializers/patch_serializer.py

@@ -4,14 +4,14 @@
 # license information.
 # --------------------------------------------------------------------------
 from .import_serializer import FileImportSerializer
-from ..models import ImportType
+from ..models import ImportType, FileImport
 from .base_serializer import BaseSerializer
 
 
 class PatchSerializer(BaseSerializer):
     def serialize(self) -> str:
         template = self.env.get_template("patch.py.jinja2")
-        imports = self.init_file_import()
+        imports = FileImport(self.code_model)
         imports.add_submodule_import("typing", "List", ImportType.STDLIB)
         return template.render(
             code_model=self.code_model,

package/autorest/codegen/serializers/request_builders_serializer.py

@@ -26,7 +26,7 @@ class RequestBuildersSerializer(BaseSerializer):
 
     @property
     def imports(self) -> FileImport:
-        file_import = self.init_file_import()
+        file_import = FileImport(self.code_model)
         for request_builder in self.request_builders:
             if request_builder.group_name == self.group_name:
                 file_import.merge(request_builder.imports())

package/autorest/codegen/serializers/sample_serializer.py

@@ -8,15 +8,19 @@ import logging
 from typing import Dict, Any, Union, Tuple
 from jinja2 import Environment
 
-from autorest.codegen.models.credential_types import KeyCredentialType
-from autorest.codegen.models.credential_types import TokenCredentialType
-from autorest.codegen.models.imports import ImportType
 from autorest.codegen.models.operation import OperationBase
-from autorest.codegen.models.operation_group import OperationGroup
-from autorest.codegen.models.parameter import Parameter, BodyParameter
-from autorest.codegen.serializers.import_serializer import FileImportSerializer
-from autorest.codegen.serializers.base_serializer import BaseSerializer
-from ..models import CodeModel
+from .import_serializer import FileImportSerializer
+from .base_serializer import BaseSerializer
+from ..models import (
+    CodeModel,
+    KeyCredentialType,
+    TokenCredentialType,
+    ImportType,
+    OperationGroup,
+    Parameter,
+    BodyParameter,
+    FileImport,
+)
 from .utils import get_namespace_config, get_namespace_from_package_name
 from ..._utils import to_snake_case
 
@@ -43,7 +47,7 @@ class SampleSerializer(BaseSerializer):
         }
 
     def _imports(self) -> FileImportSerializer:
-        imports = self.init_file_import()
+        imports = FileImport(self.code_model)
         namespace_from_package_name = get_namespace_from_package_name(
             self.code_model.options["package_name"]
         )
@@ -57,18 +61,18 @@ class SampleSerializer(BaseSerializer):
         ) > namespace_from_package_name.count("."):
             namespace = namespace_config
         client = self.code_model.clients[0]
-        imports.add_submodule_import(namespace, client.name, ImportType.THIRDPARTY)
+        imports.add_submodule_import(namespace, client.name, ImportType.LOCAL)
         credential_type = getattr(client.credential, "type", None)
         if isinstance(credential_type, TokenCredentialType):
             imports.add_submodule_import(
-                "azure.identity", "DefaultAzureCredential", ImportType.THIRDPARTY
+                "azure.identity", "DefaultAzureCredential", ImportType.SDKCORE
             )
         elif isinstance(credential_type, KeyCredentialType):
             imports.add_import("os", ImportType.STDLIB)
             imports.add_submodule_import(
-                f"{imports.import_core}.credentials",
+                "credentials",
                 "AzureKeyCredential",
-                ImportType.THIRDPARTY,
+                ImportType.SDKCORE,
             )
         for param in self.operation.parameters.positional:
             if (

package/autorest/codegen/serializers/types_serializer.py

@@ -10,7 +10,7 @@ from .base_serializer import BaseSerializer
 
 class TypesSerializer(BaseSerializer):
     def imports(self) -> FileImport:
-        file_import = self.init_file_import()
+        file_import = FileImport(self.code_model)
         if self.code_model.named_unions:
             file_import.add_submodule_import(
                 "typing",

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

@@ -24,7 +24,7 @@
         {% else %}
         request_copy.url = self._client.format_url(request_copy.url)
         {% endif %}
-        return self._client.send_request(request_copy, **kwargs)  # type: ignore
+        return self._client.send_request(request_copy, stream=stream, **kwargs)  # type: ignore
 
     {{ keywords.def }} close(self) -> None:
         {{ keywords.await }}self._client.close()

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

@@ -2,7 +2,7 @@
 {{ code_model.options['license_header'] }}
 
 from enum import Enum
-from {{ file_import.import_core_case_insensitive_enum }} import CaseInsensitiveEnumMeta
+from {{ code_model.core_library }}{{ ".utils" if code_model.options["unbranded"] else "" }} import CaseInsensitiveEnumMeta
 
 {% for enum in code_model.enums | sort %}
 {% include "enum.py.jinja2" %}

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

@@ -1,6 +1,6 @@
 # coding=utf-8
 # --------------------------------------------------------------------------
-# Copyright (c) Microsoft Corporation. All rights reserved.
+# Copyright (c) {{ code_model.options["company_name"] }} Corporation. All rights reserved.
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
@@ -19,10 +19,10 @@ import email
 from datetime import datetime, date, time, timedelta, timezone
 from json import JSONEncoder
 import isodate
-from {{ file_import.import_core_exceptions }} import DeserializationError
-from {{ file_import.import_core_case_insensitive_enum }} import CaseInsensitiveEnumMeta
-from {{ file_import.import_core_pipeline }} import PipelineResponse
-from {{ file_import.import_core_serialization }} import _Null
+from {{ code_model.core_library }}.exceptions import DeserializationError
+from {{ code_model.core_library }}{{ ".utils" if code_model.options["unbranded"] else "" }} import CaseInsensitiveEnumMeta
+from {{ code_model.core_library }}.{{ "runtime." if code_model.options["unbranded"] else "" }}pipeline import PipelineResponse
+from {{ code_model.core_library }}.serialization import _Null
 
 if sys.version_info >= (3, 9):
     from collections.abc import MutableMapping
@@ -31,7 +31,7 @@ else:
 
 _LOGGER = logging.getLogger(__name__)
 
-__all__ = ["AzureJSONEncoder", "Model", "rest_field", "rest_discriminator"]
+__all__ = ["SdkJSONEncoder", "Model", "rest_field", "rest_discriminator"]
 
 TZ_UTC = timezone.utc
 
@@ -125,7 +125,7 @@ def _is_readonly(p):
         return False
 
 
-class AzureJSONEncoder(JSONEncoder):
+class SdkJSONEncoder(JSONEncoder):
     """A JSON encoder that's capable of serializing datetime objects and bytes."""
 
     def __init__(self, *args, exclude_readonly: bool = False, format: typing.Optional[str] = None, **kwargs):
@@ -140,7 +140,7 @@ class AzureJSONEncoder(JSONEncoder):
                 return {k: v for k, v in o.items() if k not in readonly_props}
             return dict(o.items())
         try:
-            return super(AzureJSONEncoder, self).default(o)
+            return super(SdkJSONEncoder, self).default(o)
         except TypeError:
             if isinstance(o, _Null):
                 return None
@@ -157,7 +157,7 @@ class AzureJSONEncoder(JSONEncoder):
             except AttributeError:
                 # This will be raised when it hits value.total_seconds in the method above
                 pass
-            return super(AzureJSONEncoder, self).default(o)
+            return super(SdkJSONEncoder, self).default(o)
 
 
 _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}]?")
@@ -754,9 +754,12 @@ def _deserialize(
     value: typing.Any,
     module: typing.Optional[str] = None,
     rf: typing.Optional["_RestField"] = None,
+    format: typing.Optional[str] = None,
 ) -> typing.Any:
     if isinstance(value, PipelineResponse):
         value = value.http_response.json()
+    if rf is None and format:
+        rf = _RestField(format=format)
     deserializer = _get_deserialize_callable_from_annotation(deserializer, module, rf)
     return _deserialize_with_callable(deserializer, value)
 

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

@@ -14,7 +14,7 @@
     {% endif %}
     {% if (model.properties | selectattr('optional', "equalto", false) | first) is defined %}
 
-    All required parameters must be populated in order to send to Azure.
+    All required parameters must be populated in order to send to server.
     {% endif %}
 
     {% if model.properties != None %}

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

@@ -15,7 +15,7 @@
     {% endif %}
     {% if (model.properties | selectattr('optional', "equalto", false) | first) is defined %}
 
-    All required parameters must be populated in order to send to Azure.
+    All required parameters must be populated in order to send to server.
     {% endif %}
 
     {% if model.properties != None %}

package/autorest/codegen/templates/packaging_templates/LICENSE.jinja2

@@ -1,4 +1,4 @@
-Copyright (c) {{ company_name }} Corporation.
+Copyright (c) {{ code_model.options["company_name"] }} Corporation.
 
 MIT License
 

package/autorest/codegen/templates/packaging_templates/README.md.jinja2

@@ -67,7 +67,7 @@ Use the returned token credential to authenticate the client:
 ```python
 >>> from {{ namespace }} import {{ client_name }}
 >>> from azure.identity import DefaultAzureCredential
->>> from {{ file_import.import_core_exceptions }} import HttpResponseError
+>>> from {{ code_model.core_library }}.exceptions import HttpResponseError
 
 >>> client = {{ client_name }}(endpoint='<endpoint>', credential=DefaultAzureCredential())
 >>> try: