@autorest/python 6.18.0 → 6.20.0

package/autorest/m4reformatter/__init__.py

@@ -28,6 +28,20 @@ KEY_TYPE = "Key"
 _LOGGER = logging.getLogger(__name__)
 
 
+def get_item_type(yaml_data: Dict[str, Any], item_name: str, enable_exception: bool = True) -> Optional[Dict[str, Any]]:
+    try:
+        return next(p["type"] for p in yaml_data.get("properties", []) if p["wireName"] == item_name)
+    except StopIteration:
+        pass
+    for parent in yaml_data.get("parents", []):
+        result = get_item_type(parent, item_name, False)
+        if result:
+            return result
+    if enable_exception:
+        raise StopIteration(f"Could not find item type {item_name} from type {yaml_data['name']}")
+    return None
+
+
 def is_body(yaml_data: Dict[str, Any]) -> bool:
     """Return true if passed in parameter is a body param"""
     return yaml_data["protocol"]["http"]["in"] == "body"
@@ -544,9 +558,7 @@ class M4Reformatter(YamlUpdatePluginAutorest):  # pylint: disable=too-many-publi
         if self.version_tolerant:
             # if we're in version tolerant, hide the paging model
             returned_response_object["type"]["internal"] = True
-        operation["itemType"] = next(
-            p["type"] for p in returned_response_object["type"]["properties"] if p["wireName"] == operation["itemName"]
-        )
+        operation["itemType"] = get_item_type(returned_response_object["type"], operation["itemName"])
         if yaml_data["language"]["default"]["paging"].get("nextLinkOperation"):
             operation["nextOperation"] = self.update_operation(
                 group_name=group_name,

package/generator/pygen/black.py

@@ -6,7 +6,6 @@
 import logging
 from pathlib import Path
 import os
-from typing import Any, Dict
 import black
 from black.report import NothingChanged
 
@@ -19,7 +18,7 @@ _BLACK_MODE = black.Mode()  # pyright: ignore [reportPrivateImportUsage]
 _BLACK_MODE.line_length = 120
 
 
-class BlackScriptPlugin(Plugin):  # pylint: disable=abstract-method
+class BlackScriptPlugin(Plugin):
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
         output_folder = self.options.get("output_folder", str(self.output_folder))
@@ -57,7 +56,7 @@ class BlackScriptPlugin(Plugin):  # pylint: disable=abstract-method
             file_content = black.format_file_contents(file_content, fast=True, mode=_BLACK_MODE)
         except NothingChanged:
             pass
-        except:  # pylint: disable=bare-except
+        except:
             _LOGGER.error("Error: failed to format %s", file)
             raise
         else:

package/generator/pygen/codegen/models/__init__.py

@@ -30,6 +30,7 @@ from .primitive_types import (
     UnixTimeType,
     SdkCoreType,
     DecimalType,
+    MultiPartFileType,
 )
 from .enum_type import EnumType, EnumValue
 from .base import BaseType
@@ -149,6 +150,7 @@ TYPE_TO_OBJECT = {
     "unixtime": UnixTimeType,
     "credential": StringType,
     "sdkcore": SdkCoreType,
+    "multipartfile": MultiPartFileType,
 }
 _LOGGER = logging.getLogger(__name__)
 

package/generator/pygen/codegen/models/code_model.py

@@ -7,7 +7,7 @@ from typing import List, Dict, Any, Set, Union, Literal
 
 from .base import BaseType
 from .enum_type import EnumType
-from .model_type import ModelType
+from .model_type import ModelType, UsageFlags
 from .combined_type import CombinedType
 from .client import Client
 from .request_builder import RequestBuilder, OverloadedRequestBuilder
@@ -162,9 +162,7 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
         """All of the model types in this class"""
         if not self._model_types:
             self._model_types = [
-                t
-                for t in self.types_map.values()
-                if isinstance(t, ModelType) and not (self.options["models_mode"] == "dpg" and t.page_result_model)
+                t for t in self.types_map.values() if isinstance(t, ModelType) and t.usage != UsageFlags.Default.value
             ]
         return self._model_types
 

package/generator/pygen/codegen/models/combined_type.py

@@ -51,7 +51,7 @@ class CombinedType(BaseType):
     def client_default_value(self) -> Any:
         return self.yaml_data.get("clientDefaultValue")
 
-    def description(self, *, is_operation_file: bool) -> str:  # pylint: disable=unused-argument
+    def description(self, *, is_operation_file: bool) -> str:
         if len(self.types) == 2:
             return f"Is either a {self.types[0].type_description} type or a {self.types[1].type_description} type."
         return f"Is one of the following types: {', '.join([t.type_description for t in self.types])}"

package/generator/pygen/codegen/models/credential_types.py

@@ -106,7 +106,7 @@ CredentialPolicyType = TypeVar(
 )
 
 
-class CredentialType(Generic[CredentialPolicyType], BaseType):  # pylint:disable=abstract-method
+class CredentialType(Generic[CredentialPolicyType], BaseType):
     """Store info about the type of the credential. Can be either an KeyCredential or a TokenCredential"""
 
     def __init__(
@@ -118,7 +118,7 @@ class CredentialType(Generic[CredentialPolicyType], BaseType):  # pylint:disable
         super().__init__(yaml_data, code_model)
         self.policy = policy
 
-    def description(self, *, is_operation_file: bool) -> str:  # pylint: disable=unused-argument
+    def description(self, *, is_operation_file: bool) -> str:
         return ""
 
     def get_json_template_representation(
@@ -146,11 +146,7 @@ class CredentialType(Generic[CredentialPolicyType], BaseType):  # pylint:disable
         )
 
 
-class TokenCredentialType(
-    CredentialType[  # pylint: disable=unsubscriptable-object
-        Union[BearerTokenCredentialPolicyType, ARMChallengeAuthenticationPolicyType]
-    ]
-):
+class TokenCredentialType(CredentialType[Union[BearerTokenCredentialPolicyType, ARMChallengeAuthenticationPolicyType]]):
     """Type of a token credential. Used by BearerAuth and ARMChallenge policies"""
 
     def type_annotation(self, **kwargs: Any) -> str:
@@ -194,23 +190,20 @@ class TokenCredentialType(
         return "hasattr({}, 'get_token')"
 
 
-class KeyCredentialType(
-    # pylint: disable=unsubscriptable-object
-    CredentialType[KeyCredentialPolicyType]
-):
+class KeyCredentialType(CredentialType[KeyCredentialPolicyType]):
     """Type for an KeyCredential"""
 
-    def docstring_type(self, **kwargs: Any) -> str:  # pylint: disable=unused-argument
+    def docstring_type(self, **kwargs: Any) -> str:
         return f"~{self.code_model.core_library}.credentials.{self.policy.credential_name}"
 
-    def type_annotation(self, **kwargs: Any) -> str:  # pylint: disable=unused-argument
+    def type_annotation(self, **kwargs: Any) -> str:
         return self.policy.credential_name
 
     @property
     def instance_check_template(self) -> str:
         return "isinstance({}, " + f"{self.policy.credential_name})"
 
-    def imports(self, **kwargs: Any) -> FileImport:  # pylint: disable=unused-argument
+    def imports(self, **kwargs: Any) -> FileImport:
         file_import = super().imports(**kwargs)
         file_import.add_submodule_import(
             "credentials",

package/generator/pygen/codegen/models/enum_type.py

@@ -137,7 +137,7 @@ class EnumType(BaseType):
         """
         return self.value_type.serialization_type
 
-    def description(self, *, is_operation_file: bool) -> str:  # pylint: disable=unused-argument
+    def description(self, *, is_operation_file: bool) -> str:
         possible_values = [self.get_declaration(v.value) for v in self.values]
         if not possible_values:
             return ""

package/generator/pygen/codegen/models/lro_operation.py

@@ -1,4 +1,3 @@
-# pylint: disable=multiple-statements
 # -------------------------------------------------------------------------
 # Copyright (c) Microsoft Corporation. All rights reserved.
 # Licensed under the MIT License. See License.txt in the project root for

package/generator/pygen/codegen/models/lro_paging_operation.py

@@ -21,7 +21,7 @@ class LROPagingOperation(LROOperationBase[LROPagingResponse], PagingOperationBas
         return "lropaging"
 
     def cls_type_annotation(self, *, async_mode: bool) -> str:
-        return f"ClsType[{Response.type_annotation(self.responses[0], async_mode=async_mode)}]"  # pylint: disable=no-member
+        return f"ClsType[{Response.type_annotation(self.responses[0], async_mode=async_mode)}]"
 
     def imports(self, async_mode: bool, **kwargs: Any) -> FileImport:
         lro_imports = LROOperationBase.imports(self, async_mode, **kwargs)

package/generator/pygen/codegen/models/model_type.py

@@ -17,9 +17,9 @@ from .property import Property
 from .imports import FileImport, ImportType, TypingSection
 
 if sys.version_info >= (3, 8):
-    from typing import Literal  # pylint: disable=no-name-in-module, ungrouped-imports
+    from typing import Literal
 else:
-    from typing_extensions import Literal  # type: ignore  # pylint: disable=ungrouped-imports
+    from typing_extensions import Literal  # type: ignore
 
 if TYPE_CHECKING:
     from .code_model import CodeModel
@@ -50,9 +50,7 @@ def _get_properties(type: "ModelType", properties: List[Property]) -> List[Prope
     return properties
 
 
-class ModelType(  # pylint: disable=abstract-method
-    BaseType
-):  # pylint: disable=too-many-instance-attributes, too-many-public-methods
+class ModelType(BaseType):  # pylint: disable=too-many-instance-attributes, too-many-public-methods
     """Represents a class ready to be serialized in Python.
 
     :param str name: The name of the class.
@@ -84,13 +82,12 @@ class ModelType(  # pylint: disable=abstract-method
         self._got_polymorphic_subtypes = False
         self.internal: bool = self.yaml_data.get("internal", False)
         self.snake_case_name: str = self.yaml_data["snakeCaseName"]
-        self.page_result_model: bool = self.yaml_data.get("pageResultModel", False)
         self.cross_language_definition_id: Optional[str] = self.yaml_data.get("crossLanguageDefinitionId")
-        self.usage: int = self.yaml_data.get("usage", 0)
+        self.usage: int = self.yaml_data.get("usage", UsageFlags.Input.value | UsageFlags.Output.value)
 
     @property
     def is_usage_output(self) -> bool:
-        return self.usage & UsageFlags.Output.value
+        return bool(self.usage & UsageFlags.Output.value)
 
     @property
     def flattened_property(self) -> Optional[Property]:
@@ -285,7 +282,7 @@ class JSONModelType(ModelType):
         return file_import
 
 
-class GeneratedModelType(ModelType):  # pylint: disable=abstract-method
+class GeneratedModelType(ModelType):
     def type_annotation(self, **kwargs: Any) -> str:
         is_operation_file = kwargs.pop("is_operation_file", False)
         skip_quote = kwargs.get("skip_quote", False)

package/generator/pygen/codegen/models/operation.py

@@ -418,8 +418,19 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
         file_import.merge(self.get_request_builder_import(self.request_builder, async_mode))
         if self.overloads:
             file_import.add_submodule_import("typing", "overload", ImportType.STDLIB)
-        if self.non_default_errors and self.code_model.options["models_mode"] == "dpg":
-            file_import.add_submodule_import(f"{relative_path}_model_base", "_deserialize", ImportType.LOCAL)
+        if self.code_model.options["models_mode"] == "dpg":
+            if self.parameters.has_body:
+                if self.has_form_data_body:
+                    file_import.add_submodule_import(relative_path, "_model_base", ImportType.LOCAL)
+                else:
+                    file_import.add_submodule_import(
+                        f"{relative_path}_model_base",
+                        "SdkJSONEncoder",
+                        ImportType.LOCAL,
+                    )
+                    file_import.add_import("json", ImportType.STDLIB)
+            if (self.default_error_deserialization or any(r.type for r in self.responses)) or self.non_default_errors:
+                file_import.add_submodule_import(f"{relative_path}_model_base", "_deserialize", ImportType.LOCAL)
         return file_import
 
     def get_response_from_status(self, status_code: Optional[Union[str, int]]) -> ResponseType:
@@ -492,20 +503,6 @@ class Operation(OperationBase[Response]):
             )
         if self.has_response_body and not self.has_optional_return_type and not self.code_model.options["models_mode"]:
             file_import.add_submodule_import("typing", "cast", ImportType.STDLIB)
-        relative_path = "..." if async_mode else ".."
-        if self.code_model.options["models_mode"] == "dpg":
-            if self.parameters.has_body:
-                if self.has_form_data_body:
-                    file_import.add_submodule_import(relative_path, "_model_base", ImportType.LOCAL)
-                else:
-                    file_import.add_submodule_import(
-                        f"{relative_path}_model_base",
-                        "SdkJSONEncoder",
-                        ImportType.LOCAL,
-                    )
-                    file_import.add_import("json", ImportType.STDLIB)
-            if self.default_error_deserialization or any(r.type for r in self.responses):
-                file_import.add_submodule_import(f"{relative_path}_model_base", "_deserialize", ImportType.LOCAL)
 
         return file_import
 

package/generator/pygen/codegen/models/paging_operation.py

@@ -1,4 +1,3 @@
-# pylint: disable=multiple-statements
 # -------------------------------------------------------------------------
 # Copyright (c) Microsoft Corporation. All rights reserved.
 # Licensed under the MIT License. See License.txt in the project root for

package/generator/pygen/codegen/models/parameter_list.py

@@ -261,8 +261,7 @@ class _ParameterListBase(
         )
 
 
-class _ParameterList(_ParameterListBase[Parameter, BodyParameter]):  # pylint: disable=unsubscriptable-object
-    """Base Parameter class for the two operation ParameterLists"""
+class _ParameterList(_ParameterListBase[Parameter, BodyParameter]):
 
     @staticmethod
     def parameter_creator() -> Callable[[Dict[str, Any], "CodeModel"], Parameter]:
@@ -285,9 +284,7 @@ class ParameterList(_ParameterList):
     """ParameterList is the parameter list for Operation classes"""
 
 
-class _RequestBuilderParameterList(
-    _ParameterListBase[RequestBuilderParameter, RequestBuilderBodyParameter]  # pylint: disable=unsubscriptable-object
-):
+class _RequestBuilderParameterList(_ParameterListBase[RequestBuilderParameter, RequestBuilderBodyParameter]):
     """_RequestBuilderParameterList is base parameter list for RequestBuilder classes"""
 
     @staticmethod

package/generator/pygen/codegen/models/primitive_types.py

@@ -22,8 +22,8 @@ class RawString(object):
         return "r'{}'".format(self.string.replace("'", "\\'"))
 
 
-class PrimitiveType(BaseType):  # pylint: disable=abstract-method
-    def description(self, *, is_operation_file: bool) -> str:  # pylint: disable=unused-argument
+class PrimitiveType(BaseType):
+    def description(self, *, is_operation_file: bool) -> str:
         return ""
 
     def type_annotation(self, **kwargs: Any) -> str:
@@ -188,7 +188,7 @@ class AnyObjectType(PrimitiveType):
         return "JSON"
 
 
-class NumberType(PrimitiveType):  # pylint: disable=abstract-method
+class NumberType(PrimitiveType):
     def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
         super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.precision: Optional[int] = yaml_data.get("precision")
@@ -233,6 +233,12 @@ class NumberType(PrimitiveType):  # pylint: disable=abstract-method
 
 
 class IntegerType(NumberType):
+
+    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+        super().__init__(yaml_data=yaml_data, code_model=code_model)
+        if yaml_data.get("encode") == "string":
+            self.encode = "str"
+
     @property
     def serialization_type(self) -> str:
         return "int"
@@ -624,3 +630,29 @@ class SdkCoreType(PrimitiveType):
     @property
     def serialization_type(self) -> str:
         return self.name
+
+
+class MultiPartFileType(PrimitiveType):
+    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+        super().__init__(yaml_data=yaml_data, code_model=code_model)
+        self.name = "FileType"
+
+    def type_annotation(self, **kwargs: Any) -> str:
+        return self.name
+
+    def docstring_type(self, **kwargs: Any) -> str:
+        return f"~{self.code_model.namespace}._vendor.{self.name}"
+
+    def imports(self, **kwargs: Any) -> FileImport:
+        file_import = super().imports(**kwargs)
+        relative_path = "..." if kwargs.get("async_mode") else ".."
+        file_import.add_submodule_import(f"{relative_path}_vendor", self.name, ImportType.LOCAL)
+        return file_import
+
+    @property
+    def default_template_representation_declaration(self) -> str:
+        return '"filetype"' if self.code_model.for_test else "filetype"
+
+    @property
+    def instance_check_template(self) -> str:
+        return f"isinstance({{}}, {self.name})"

package/generator/pygen/codegen/models/property.py

@@ -97,12 +97,9 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
         return self.is_discriminator and self.is_polymorphic and cast(ConstantType, self.type).value is None
 
     def type_annotation(self, *, is_operation_file: bool = False) -> str:
-        types_type_annotation = self.type.type_annotation(is_operation_file=is_operation_file)
-        if self.is_multipart_file_input:
-            # we only support FileType or list of FileType
-            types_type_annotation = types_type_annotation.replace("bytes", "FileType")
         if self.is_base_discriminator:
             return "str"
+        types_type_annotation = self.type.type_annotation(is_operation_file=is_operation_file)
         if self.optional and self.client_default_value is None:
             return f"Optional[{types_type_annotation}]"
         return types_type_annotation
@@ -115,9 +112,6 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
         *,
         client_default_value_declaration: Optional[str] = None,
     ) -> Any:
-        if self.is_multipart_file_input:
-            file_type_str = '"filetype"' if self.code_model.for_test else "filetype"
-            return f"[{file_type_str}]" if self.type.type == "list" else file_type_str
         if self.client_default_value:
             client_default_value_declaration = self.get_declaration(self.client_default_value)
         # make sure there is no \n otherwise the json template will be invalid
@@ -156,8 +150,6 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
                 "rest_discriminator" if self.is_discriminator else "rest_field",
                 ImportType.LOCAL,
             )
-        if self.is_multipart_file_input:
-            file_import.add_submodule_import(".._vendor", "FileType", ImportType.LOCAL)
         return file_import
 
     @classmethod

package/generator/pygen/codegen/serializers/__init__.py

@@ -66,7 +66,7 @@ def _sample_output_path(source_file_path: str) -> Path:
     return Path("")
 
 
-class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
+class JinjaSerializer(ReaderAndWriter):
     def __init__(
         self,
         code_model: CodeModel,

package/generator/pygen/codegen/serializers/builder_serializer.py

@@ -1,4 +1,4 @@
-# pylint: disable=too-many-lines,multiple-statements
+# pylint: disable=too-many-lines
 # -------------------------------------------------------------------------
 # Copyright (c) Microsoft Corporation. All rights reserved.
 # Licensed under the MIT License. See License.txt in the project root for
@@ -23,7 +23,6 @@ from ..models import (
     BinaryType,
     BodyParameter,
     ParameterMethodLocation,
-    RequestBuilderBodyParameter,
     OverloadedRequestBuilder,
     Property,
     RequestBuilderType,
@@ -218,7 +217,7 @@ def is_json_model_type(parameters: ParameterListType) -> bool:
     )
 
 
-class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-method
+class _BuilderBaseSerializer(Generic[BuilderType]):
     def __init__(self, code_model: CodeModel, async_mode: bool) -> None:
         self.code_model = code_model
         self.async_mode = async_mode
@@ -391,7 +390,7 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
 ############################## REQUEST BUILDERS ##############################
 
 
-class RequestBuilderSerializer(_BuilderBaseSerializer[RequestBuilderType]):  # pylint: disable=abstract-method
+class RequestBuilderSerializer(_BuilderBaseSerializer[RequestBuilderType]):
     def description_and_summary(self, builder: RequestBuilderType) -> List[str]:
         retval = super().description_and_summary(builder)
         retval += [
@@ -517,7 +516,7 @@ class RequestBuilderSerializer(_BuilderBaseSerializer[RequestBuilderType]):  # p
 ############################## NORMAL OPERATIONS ##############################
 
 
-class _OperationSerializer(_BuilderBaseSerializer[OperationType]):  # pylint: disable=abstract-method
+class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
     def description_and_summary(self, builder: OperationType) -> List[str]:
         retval = super().description_and_summary(builder)
         if builder.deprecated:
@@ -535,9 +534,9 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):  # pylint: di
         return "response"
 
     def example_template(self, builder: OperationType) -> List[str]:
+        if self.code_model.options["models_mode"] in ("msrest", "dpg"):
+            return []
         retval = super().example_template(builder)
-        if self.code_model.options["models_mode"] == "msrest":
-            return retval
         for response in builder.responses:
             polymorphic_subtypes: List[ModelType] = []
             if not response.type:
@@ -842,14 +841,14 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):  # pylint: di
         elif request_builder.overloads:
             seen_body_params = set()
             for overload in request_builder.overloads:
-                body_param = cast(RequestBuilderBodyParameter, overload.parameters.body_parameter)
+                body_param = overload.parameters.body_parameter
                 if body_param.client_name in seen_body_params:
                     continue
                 seen_body_params.add(body_param.client_name)
 
                 retval.append(f"    {body_param.client_name}={body_param.name_in_high_level_operation},")
         elif request_builder.parameters.has_body:
-            body_param = cast(RequestBuilderBodyParameter, request_builder.parameters.body_parameter)
+            body_param = request_builder.parameters.body_parameter
             retval.append(f"    {body_param.client_name}={body_param.name_in_high_level_operation},")
         retval.append("    headers=_headers,")
         retval.append("    params=_params,")
@@ -871,7 +870,7 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):  # pylint: di
         )
         return retval
 
-    def _call_request_builder_helper(  # pylint: disable=too-many-statements
+    def _call_request_builder_helper(
         self,
         builder: OperationType,
         request_builder: RequestBuilderType,
@@ -1031,7 +1030,7 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):  # pylint: di
             retval.append("deserialized = None")
         if builder.any_response_has_headers:
             retval.append("response_headers = {}")
-        if builder.has_response_body or builder.any_response_has_headers:
+        if builder.has_response_body or builder.any_response_has_headers:  # pylint: disable=too-many-nested-blocks
             if len(builder.responses) > 1:
                 status_codes, res_headers, res_deserialization = [], [], []
                 for status_code in builder.success_status_codes:
@@ -1173,7 +1172,7 @@ class OperationSerializer(_OperationSerializer[Operation]): ...
 PagingOperationType = TypeVar("PagingOperationType", bound=Union[PagingOperation, LROPagingOperation])
 
 
-class _PagingOperationSerializer(_OperationSerializer[PagingOperationType]):  # pylint: disable=abstract-method
+class _PagingOperationSerializer(_OperationSerializer[PagingOperationType]):
     def __init__(self, code_model: CodeModel, async_mode: bool) -> None:
         # for pylint reasons need to redefine init
         # probably because inheritance is going too deep
@@ -1458,7 +1457,7 @@ class LROOperationSerializer(_LROOperationSerializer[LROOperation]): ...
 class LROPagingOperationSerializer(
     _LROOperationSerializer[LROPagingOperation],
     _PagingOperationSerializer[LROPagingOperation],
-):  # pylint: disable=abstract-method
+):
     @property
     def _call_method(self) -> str:
         return "await " if self.async_mode else ""

package/generator/pygen/codegen/serializers/general_serializer.py

@@ -124,7 +124,6 @@ class GeneralSerializer(BaseSerializer):
             file_import.add_submodule_import("typing", "Union", ImportType.STDLIB)
             file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB)
             file_import.add_submodule_import("typing", "Mapping", ImportType.STDLIB)
-            file_import.add_submodule_import("typing", "Sequence", ImportType.STDLIB)
             file_import.add_submodule_import("typing", "Dict", ImportType.STDLIB)
             file_import.add_submodule_import("typing", "Any", ImportType.STDLIB)
             file_import.add_submodule_import("typing", "List", ImportType.STDLIB)
@@ -183,12 +182,13 @@ class GeneralSerializer(BaseSerializer):
     def serialize_cross_language_definition_file(self) -> str:
         cross_langauge_def_dict = {
             f"{self.code_model.namespace}.models.{model.name}": model.cross_language_definition_id
-            for model in self.code_model.model_types
+            for model in self.code_model.public_model_types
         }
         cross_langauge_def_dict.update(
             {
                 f"{self.code_model.namespace}.models.{enum.name}": enum.cross_language_definition_id
                 for enum in self.code_model.enums
+                if not enum.internal
             }
         )
         cross_langauge_def_dict.update(

package/generator/pygen/codegen/serializers/model_serializer.py

@@ -194,6 +194,8 @@ class DpgModelSerializer(_ModelSerializer):
         )
 
         for model in self.code_model.model_types:
+            if model.base == "json":
+                continue
             file_import.merge(model.imports(is_operation_file=False))
             for prop in model.properties:
                 file_import.merge(prop.imports())

package/generator/pygen/codegen/serializers/sample_serializer.py

@@ -1,4 +1,3 @@
-# pylint: disable=too-many-lines
 # -------------------------------------------------------------------------
 # Copyright (c) Microsoft Corporation. All rights reserved.
 # Licensed under the MIT License. See License.txt in the project root for
@@ -22,7 +21,6 @@ from ..models import (
     FileImport,
 )
 from .utils import get_namespace_config, get_namespace_from_package_name
-from ...utils import to_snake_case
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -42,7 +40,7 @@ class SampleSerializer(BaseSerializer):
         self.operation = operation
         self.sample = sample
         self.file_name = file_name
-        self.sample_params = {to_snake_case(k): v for k, v in sample.get("parameters", {}).items()}
+        self.sample_params = sample.get("parameters", {})
 
     def _imports(self) -> FileImportSerializer:
         imports = FileImport(self.code_model)
@@ -66,8 +64,8 @@ class SampleSerializer(BaseSerializer):
                 "AzureKeyCredential",
                 ImportType.SDKCORE,
             )
-        for param in self.operation.parameters.positional:
-            if not param.client_default_value and not param.optional and param.client_name in self.sample_params:
+        for param in self.operation.parameters.positional + self.operation.parameters.keyword_only:
+            if not param.client_default_value and not param.optional and param.wire_name in self.sample_params:
                 imports.merge(param.type.imports_for_sample())
         return FileImportSerializer(imports, True)
 
@@ -80,15 +78,19 @@ class SampleSerializer(BaseSerializer):
         elif isinstance(credential_type, KeyCredentialType):
             special_param.update({"credential": 'AzureKeyCredential(key=os.getenv("AZURE_KEY"))'})
 
-        params_positional = [
-            p for p in self.code_model.clients[0].parameters.positional if not (p.optional or p.client_default_value)
+        params = [
+            p
+            for p in (
+                self.code_model.clients[0].parameters.positional + self.code_model.clients[0].parameters.keyword_only
+            )
+            if not (p.optional or p.client_default_value)
         ]
         client_params = {
             p.client_name: special_param.get(
                 p.client_name,
-                f'"{self.sample_params.get(p.client_name) or p.client_name.upper()}"',
+                f'"{self.sample_params.get(p.wire_name) or p.client_name.upper()}"',
             )
-            for p in params_positional
+            for p in params
         }
 
         return client_params
@@ -103,15 +105,18 @@ class SampleSerializer(BaseSerializer):
 
     # prepare operation parameters
     def _operation_params(self) -> Dict[str, Any]:
-        params_positional = [p for p in self.operation.parameters.positional if not p.client_default_value]
+        params = [
+            p
+            for p in (self.operation.parameters.positional + self.operation.parameters.keyword_only)
+            if not p.client_default_value
+        ]
         failure_info = "fail to find required param named {}"
         operation_params = {}
-        for param in params_positional:
-            name = param.client_name
-            param_value = self.sample_params.get(name)
+        for param in params:
             if not param.optional:
+                param_value = self.sample_params.get(param.wire_name)
                 if not param_value:
-                    raise Exception(failure_info.format(name))  # pylint: disable=broad-exception-raised
+                    raise Exception(failure_info.format(param.client_name))  # pylint: disable=broad-exception-raised
                 operation_params[param.client_name] = self.handle_param(param, param_value)
         return operation_params
 
@@ -145,7 +150,7 @@ class SampleSerializer(BaseSerializer):
         name = self.sample.get("x-ms-original-file", "")
         if "specification" in name:
             return "specification" + name.split("specification")[-1]
-        return ""
+        return name if self.code_model.options["from_typespec"] else ""
 
     def serialize(self) -> str:
         operation_result, return_var = self._operation_result()