@autorest/python 6.32.3 → 6.34.0

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

@@ -30,9 +30,11 @@ class TypingSection(str, Enum):
 
 
 class MsrestImportType(Enum):
-    Module = auto()  # import _serialization.py or msrest.serialization as Module
-    Serializer = auto()  # from _serialization.py or msrest.serialization import Serializer
-    SerializerDeserializer = auto()  # from _serialization.py or msrest.serialization import Serializer and Deserializer
+    Module = auto()  # import _utils/serialization.py or msrest.serialization as Module
+    Serializer = auto()  # from _utils/serialization.py or msrest.serialization import Serializer
+    SerializerDeserializer = (
+        auto()
+    )  # from _utils/serialization.py or msrest.serialization import Serializer and Deserializer
 
 
 class ImportModel:
@@ -261,21 +263,23 @@ class FileImport:
                 if msrest_import_type == MsrestImportType.SerializerDeserializer:
                     self.add_submodule_import("msrest", "Deserializer", ImportType.THIRDPARTY, typing_section)
         else:
-            # _serialization.py is always in root namespace
-            imported_namespace = self.code_model.namespace
+            # _utils/serialization.py is always in root namespace
+            imported_namespace = f"{self.code_model.namespace}._utils"
             if self.code_model.options["multiapi"]:
-                # for multiapi, the namespace is azure.mgmt.xxx.v20XX_XX_XX while _serialization.py is in azure.mgmt.xxx
-                imported_namespace = get_parent_namespace(imported_namespace)
+                # for multiapi, the namespace is azure.mgmt.xxx.v20XX_XX_XX
+                # while _utils/serialization.py is in azure.mgmt.xxx
+                imported_namespace = f"{get_parent_namespace(imported_namespace)}._utils"
             if msrest_import_type == MsrestImportType.Module:
                 self.add_submodule_import(
                     self.code_model.get_relative_import_path(serialize_namespace, imported_namespace),
-                    "_serialization",
+                    "serialization",
                     ImportType.LOCAL,
                     typing_section,
+                    alias="_serialization",
                 )
             else:
                 relative_path = self.code_model.get_relative_import_path(
-                    serialize_namespace, imported_namespace, module_name="_serialization"
+                    serialize_namespace, f"{self.code_model.namespace}._utils.serialization"
                 )
                 self.add_submodule_import(relative_path, "Serializer", ImportType.LOCAL, typing_section)
                 if msrest_import_type == MsrestImportType.SerializerDeserializer:

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

@@ -134,7 +134,7 @@ class LROOperationBase(OperationBase[LROResponseType]):
             # but final call returns a model
             serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
             file_import.add_submodule_import(
-                self.code_model.get_relative_import_path(serialize_namespace, module_name="_model_base"),
+                self.code_model.get_relative_import_path(serialize_namespace, module_name="_utils.model_base"),
                 "_deserialize",
                 ImportType.LOCAL,
             )

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

@@ -292,7 +292,7 @@ class GeneratedModelType(ModelType):
 
     def docstring_type(self, **kwargs: Any) -> str:
         type_annotation = self.type_annotation(need_model_alias=False, skip_quote=True, **kwargs)
-        return f"~{self.code_model.namespace}.models.{type_annotation}"
+        return f"~{self.client_namespace}.models.{type_annotation}"
 
     def docstring_text(self, **kwargs: Any) -> str:
         return self.name
@@ -318,9 +318,10 @@ class GeneratedModelType(ModelType):
             )
             if self.is_form_data:
                 file_import.add_submodule_import(
-                    self.code_model.get_relative_import_path(serialize_namespace),
-                    "_model_base",
+                    self.code_model.get_relative_import_path(serialize_namespace, module_name="_utils.model_base"),
+                    "Model",
                     ImportType.LOCAL,
+                    alias="_Model",
                 )
         elif serialize_namespace_type == NamespaceType.TYPES_FILE or (
             serialize_namespace_type == NamespaceType.MODEL and called_by_property

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

@@ -391,7 +391,9 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
                 ImportType.SDKCORE,
             )
             if not async_mode:
-                relative_path = self.code_model.get_relative_import_path(serialize_namespace, module_name="_vendor")
+                relative_path = self.code_model.get_relative_import_path(
+                    serialize_namespace, module_name="_utils.utils"
+                )
                 file_import.add_submodule_import(
                     relative_path,
                     "prep_if_match",
@@ -436,12 +438,17 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
         if self.overloads:
             file_import.add_submodule_import("typing", "overload", ImportType.STDLIB)
         if self.code_model.options["models_mode"] == "dpg":
-            relative_path = self.code_model.get_relative_import_path(serialize_namespace, module_name="_model_base")
+            relative_path = self.code_model.get_relative_import_path(
+                serialize_namespace, module_name="_utils.model_base"
+            )
             body_param = self.parameters.body_parameter if self.parameters.has_body else None
             if body_param and not isinstance(body_param.type, BinaryType):
                 if self.has_form_data_body:
                     file_import.add_submodule_import(
-                        self.code_model.get_relative_import_path(serialize_namespace), "_model_base", ImportType.LOCAL
+                        relative_path,
+                        "Model",
+                        ImportType.LOCAL,
+                        alias="_Model",
                     )
                 elif xml_serializable(self.parameters.body_parameter.default_content_type):
                     file_import.add_submodule_import(

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

@@ -63,11 +63,11 @@ class OperationGroup(BaseModel):
             operation_group.has_non_abstract_operations for operation_group in self.operation_groups
         )
 
-    @property
-    def base_class(self) -> str:
+    def base_class(self, async_mode: bool) -> str:
+        pipeline_client = f"{'Async' if async_mode else ''}PipelineClient"
         base_classes: List[str] = []
         if self.is_mixin:
-            base_classes.append(f"{self.client.name}MixinABC")
+            base_classes.append(f"ClientMixinABC[{pipeline_client}, {self.client.name}Configuration]")
         return ", ".join(base_classes)
 
     def imports_for_multiapi(self, async_mode: bool, **kwargs) -> FileImport:
@@ -100,8 +100,12 @@ class OperationGroup(BaseModel):
 
     def imports(self, async_mode: bool, **kwargs: Any) -> FileImport:
         file_import = FileImport(self.code_model)
-
         serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
+        utils_path = self.code_model.get_relative_import_path(
+            serialize_namespace,
+            f"{self.code_model.namespace}._utils.utils",
+        )
+
         for operation in self.operations:
             file_import.merge(operation.imports(async_mode, **kwargs))
         if not self.code_model.options["combine_operation_files"]:
@@ -141,32 +145,28 @@ class OperationGroup(BaseModel):
                 ImportType.LOCAL,
                 alias="_models",
             )
+        file_import.add_submodule_import(
+            self.code_model.get_relative_import_path(
+                serialize_namespace,
+                self.code_model.get_imported_namespace_for_client(self.client.client_namespace, async_mode),
+                module_name="_configuration",
+            ),
+            f"{self.client.name}Configuration",
+            ImportType.LOCAL,
+        )
+        file_import.add_submodule_import(
+            "" if self.code_model.is_azure_flavor else "runtime",
+            f"{'Async' if async_mode else ''}PipelineClient",
+            ImportType.SDKCORE,
+        )
         if self.is_mixin:
             file_import.add_submodule_import(
-                # XxxMixinABC is always defined in _vendor of client namespace
-                self.code_model.get_relative_import_path(
-                    serialize_namespace,
-                    self.code_model.get_imported_namespace_for_client(self.client.client_namespace, async_mode),
-                    module_name="_vendor",
-                ),
-                f"{self.client.name}MixinABC",
+                # XxxMixinABC is always defined in _utils of client namespace
+                utils_path,
+                "ClientMixinABC",
                 ImportType.LOCAL,
             )
         else:
-            file_import.add_submodule_import(
-                "" if self.code_model.is_azure_flavor else "runtime",
-                f"{'Async' if async_mode else ''}PipelineClient",
-                ImportType.SDKCORE,
-            )
-            file_import.add_submodule_import(
-                self.code_model.get_relative_import_path(
-                    serialize_namespace,
-                    self.code_model.get_imported_namespace_for_client(self.client.client_namespace, async_mode),
-                    module_name="_configuration",
-                ),
-                f"{self.client.name}Configuration",
-                ImportType.LOCAL,
-            )
             file_import.add_msrest_import(
                 serialize_namespace=kwargs.get("serialize_namespace", self.code_model.namespace),
                 msrest_import_type=MsrestImportType.Serializer,
@@ -179,12 +179,8 @@ class OperationGroup(BaseModel):
             )
         if self.has_abstract_operations:
             file_import.add_submodule_import(
-                # raise_if_not_implemented is always defined in _vendor of top namespace
-                self.code_model.get_relative_import_path(
-                    serialize_namespace,
-                    self.code_model.get_imported_namespace_for_client(self.code_model.namespace, async_mode),
-                    module_name="_vendor",
-                ),
+                # raise_if_not_implemented is always defined in _utils of top namespace
+                utils_path,
                 "raise_if_not_implemented",
                 ImportType.LOCAL,
             )

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

@@ -157,7 +157,9 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
                 ImportType.SDKCORE,
             )
         if self.code_model.options["models_mode"] == "dpg":
-            relative_path = self.code_model.get_relative_import_path(serialize_namespace, module_name="_model_base")
+            relative_path = self.code_model.get_relative_import_path(
+                serialize_namespace, module_name="_utils.model_base"
+            )
             file_import.merge(self.item_type.imports(**kwargs))
             if self.default_error_deserialization or self.need_deserialize:
                 file_import.add_submodule_import(relative_path, "_deserialize", ImportType.LOCAL)

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

@@ -275,7 +275,7 @@ class BodyParameter(_ParameterBase):
         if self.is_form_data:
             serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
             file_import.add_submodule_import(
-                self.code_model.get_relative_import_path(serialize_namespace, module_name="_vendor"),
+                self.code_model.get_relative_import_path(serialize_namespace, module_name="_utils.utils"),
                 "prepare_multipart_form_data",
                 ImportType.LOCAL,
             )
@@ -357,6 +357,9 @@ class Parameter(_ParameterBase):
         )
         if self.code_model.options["only_path_and_body_params_positional"] and query_or_header:
             return ParameterMethodLocation.KEYWORD_ONLY
+        # for optional path parameter, we need to use keyword only
+        if self.location == ParameterLocation.PATH and self.optional:
+            return ParameterMethodLocation.KEYWORD_ONLY
         return ParameterMethodLocation.POSITIONAL
 
     @classmethod

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

@@ -618,13 +618,13 @@ class MultiPartFileType(PrimitiveType):
         return self.name
 
     def docstring_type(self, **kwargs: Any) -> str:
-        return f"~{self.code_model.namespace}._vendor.{self.name}"
+        return f"~{self.code_model.namespace}._utils.utils.{self.name}"
 
     def imports(self, **kwargs: Any) -> FileImport:
         file_import = super().imports(**kwargs)
         serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
         file_import.add_submodule_import(
-            self.code_model.get_relative_import_path(serialize_namespace, module_name="_vendor"),
+            self.code_model.get_relative_import_path(serialize_namespace, module_name="_utils.utils"),
             self.name,
             ImportType.LOCAL,
         )

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

@@ -149,7 +149,7 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
         if self.code_model.options["models_mode"] == "dpg":
             serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
             file_import.add_submodule_import(
-                self.code_model.get_relative_import_path(serialize_namespace, module_name="_model_base"),
+                self.code_model.get_relative_import_path(serialize_namespace, module_name="_utils.model_base"),
                 "rest_discriminator" if self.is_discriminator else "rest_field",
                 ImportType.LOCAL,
             )

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

@@ -153,7 +153,7 @@ class JinjaSerializer(ReaderAndWriter):
                     general_serializer.serialize_pkgutil_init_file(),
                 )
 
-            # _model_base.py/_serialization.py/_vendor.py/py.typed/_types.py/_validation.py
+            # _utils/py.typed/_types.py/_validation.py
             # is always put in top level namespace
             if self.code_model.is_top_namespace(client_namespace):
                 self._serialize_and_write_top_level_folder(env=env, namespace=client_namespace)
@@ -404,25 +404,41 @@ class JinjaSerializer(ReaderAndWriter):
                     general_serializer.serialize_config_file(clients),
                 )
 
-                # sometimes we need define additional Mixin class for client in _vendor.py
-                self._serialize_and_write_vendor_file(env, namespace)
+                # sometimes we need define additional Mixin class for client in _utils.py
+                self._serialize_and_write_utils_folder(env, namespace)
 
-    def _serialize_and_write_vendor_file(self, env: Environment, namespace: str) -> None:
+    def _serialize_and_write_utils_folder(self, env: Environment, namespace: str) -> None:
         exec_path = self.exec_path(namespace)
-        # write _vendor.py
-        for async_mode, async_path in self.serialize_loop:
-            if self.code_model.need_vendored_code(async_mode=async_mode, client_namespace=namespace):
-                self.write_file(
-                    exec_path / Path(f"{async_path}_vendor.py"),
-                    GeneralSerializer(
-                        code_model=self.code_model, env=env, async_mode=async_mode, client_namespace=namespace
-                    ).serialize_vendor_file(),
-                )
+        general_serializer = GeneralSerializer(code_model=self.code_model, env=env, async_mode=False)
+        utils_folder_path = exec_path / Path("_utils")
+        if self.code_model.need_utils_folder(async_mode=False, client_namespace=namespace):
+            self.write_file(
+                utils_folder_path / Path("__init__.py"),
+                self.code_model.license_header,
+            )
+        if self.code_model.need_utils_utils(async_mode=False, client_namespace=namespace):
+            self.write_file(
+                utils_folder_path / Path("utils.py"),
+                general_serializer.need_utils_utils_file(),
+            )
+        # write _utils/serialization.py
+        if self.code_model.need_utils_serialization:
+            self.write_file(
+                utils_folder_path / Path("serialization.py"),
+                general_serializer.serialize_serialization_file(),
+            )
+
+        # write _model_base.py
+        if self.code_model.options["models_mode"] == "dpg":
+            self.write_file(
+                utils_folder_path / Path("model_base.py"),
+                general_serializer.serialize_model_base_file(),
+            )
 
     def _serialize_and_write_top_level_folder(self, env: Environment, namespace: str) -> None:
         exec_path = self.exec_path(namespace)
-        # write _vendor.py
-        self._serialize_and_write_vendor_file(env, namespace)
+        # write _utils folder
+        self._serialize_and_write_utils_folder(env, namespace)
 
         general_serializer = GeneralSerializer(code_model=self.code_model, env=env, async_mode=False)
 
@@ -432,20 +448,6 @@ class JinjaSerializer(ReaderAndWriter):
         # write the empty py.typed file
         self.write_file(exec_path / Path("py.typed"), "# Marker file for PEP 561.")
 
-        # write _serialization.py
-        if not self.code_model.options["client_side_validation"] and not self.code_model.options["multiapi"]:
-            self.write_file(
-                exec_path / Path("_serialization.py"),
-                general_serializer.serialize_serialization_file(),
-            )
-
-        # write _model_base.py
-        if self.code_model.options["models_mode"] == "dpg":
-            self.write_file(
-                exec_path / Path("_model_base.py"),
-                general_serializer.serialize_model_base_file(),
-            )
-
         # write _validation.py
         if any(og for client in self.code_model.clients for og in client.operation_groups if og.need_validation):
             self.write_file(

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

@@ -672,7 +672,7 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
                 [
                     "_body = (",
                     f"    {body_param.client_name}.as_dict()",
-                    f"    if isinstance({body_param.client_name}, _model_base.Model) else",
+                    f"    if isinstance({body_param.client_name}, _Model) else",
                     f"    {body_param.client_name}",
                     ")",
                     f"_file_fields: List[str] = {file_fields}",

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

@@ -3,10 +3,10 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import List
+from typing import List, cast
 
 from . import utils
-from ..models import Client, ParameterMethodLocation
+from ..models import Client, ParameterMethodLocation, Parameter, ParameterLocation
 from .parameter_serializer import ParameterSerializer, PopKwargType
 from ...utils import build_policies
 
@@ -77,17 +77,40 @@ class ClientSerializer:
         retval.append('"""')
         return retval
 
-    def initialize_config(self) -> str:
+    def initialize_config(self) -> List[str]:
+        retval = []
+        additional_signatures = []
+        if self.client.need_cloud_setting:
+            additional_signatures.append("credential_scopes=credential_scopes")
+            endpoint_parameter = cast(Parameter, self.client.endpoint_parameter)
+            retval.extend(
+                [
+                    '_cloud = kwargs.pop("cloud_setting", None) or settings.current.azure_cloud  # type: ignore',
+                    "_endpoints = get_arm_endpoints(_cloud)",
+                    f"if not {endpoint_parameter.client_name}:",
+                    f'    {endpoint_parameter.client_name} = _endpoints["resource_manager"]',
+                    'credential_scopes = kwargs.pop("credential_scopes", _endpoints["credential_scopes"])',
+                ]
+            )
         config_name = f"{self.client.name}Configuration"
         config_call = ", ".join(
             [
-                f"{p.client_name}={p.client_name}"
+                (
+                    f"{p.client_name}="
+                    + (
+                        f"cast(str, {p.client_name})"
+                        if self.client.need_cloud_setting and p.location == ParameterLocation.ENDPOINT_PATH
+                        else p.client_name
+                    )
+                )
                 for p in self.client.config.parameters.method
                 if p.method_location != ParameterMethodLocation.KWARG
             ]
+            + additional_signatures
             + ["**kwargs"]
         )
-        return f"self._config = {config_name}({config_call})"
+        retval.append(f"self._config = {config_name}({config_call})")
+        return retval
 
     @property
     def host_variable_name(self) -> str:
@@ -104,8 +127,11 @@ class ClientSerializer:
         result = []
         pipeline_client_name = self.client.pipeline_class(async_mode)
         endpoint_name = "base_url" if self.client.code_model.is_azure_flavor else "endpoint"
+        host_variable_name = (
+            f"cast(str, {self.host_variable_name})" if self.client.need_cloud_setting else self.host_variable_name
+        )
         params = {
-            endpoint_name: self.host_variable_name,
+            endpoint_name: host_variable_name,
             "policies": "_policies",
         }
         if not self.client.code_model.is_legacy and self.client.request_id_header_name:

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

@@ -16,13 +16,29 @@ from ..models.utils import NamespaceType
 from .client_serializer import ClientSerializer, ConfigSerializer
 from .base_serializer import BaseSerializer
 
+VERSION_MAP = {
+    "msrest": "0.7.1",
+    "isodate": "0.6.1",
+    "azure-mgmt-core": "1.5.0",
+    "azure-core": "1.30.0",
+    "typing-extensions": "4.6.0",
+    "corehttp": "1.0.0b6",
+}
+
+MIN_PYTHON_VERSION = "3.9"
+MAX_PYTHON_VERSION = "3.12"
+
 
 class GeneralSerializer(BaseSerializer):
     """General serializer for SDK root level files"""
 
     def serialize_setup_file(self) -> str:
         template = self.env.get_template("packaging_templates/setup.py.jinja2")
-        params = {}
+        params = {
+            "VERSION_MAP": VERSION_MAP,
+            "MIN_PYTHON_VERSION": MIN_PYTHON_VERSION,
+            "MAX_PYTHON_VERSION": MAX_PYTHON_VERSION,
+        }
         params.update(self.code_model.options)
         return template.render(code_model=self.code_model, **params)
 
@@ -48,6 +64,9 @@ class GeneralSerializer(BaseSerializer):
             "pkgutil_names": [".".join(package_parts[: i + 1]) for i in range(len(package_parts))],
             "init_names": ["/".join(package_parts[: i + 1]) + "/__init__.py" for i in range(len(package_parts))],
             "client_name": self.code_model.clients[0].name,
+            "VERSION_MAP": VERSION_MAP,
+            "MIN_PYTHON_VERSION": MIN_PYTHON_VERSION,
+            "MAX_PYTHON_VERSION": MAX_PYTHON_VERSION,
         }
         params.update(self.code_model.options)
         params.update(kwargs)
@@ -88,44 +107,33 @@ class GeneralSerializer(BaseSerializer):
             serialize_namespace=self.serialize_namespace,
         )
 
-    def serialize_vendor_file(self) -> str:
-        template = self.env.get_template("vendor.py.jinja2")
+    def need_utils_utils_file(self) -> str:
+        template = self.env.get_template("utils.py.jinja2")
         clients = self.code_model.get_clients(self.client_namespace)
 
         # configure imports
         file_import = FileImport(self.code_model)
-        if self.code_model.need_vendored_mixin(self.client_namespace):
+        if self.code_model.need_utils_mixin:
             file_import.add_submodule_import(
                 "abc",
                 "ABC",
                 ImportType.STDLIB,
             )
-            file_import.add_submodule_import(
-                "" if self.code_model.is_azure_flavor else "runtime",
-                f"{'Async' if self.async_mode else ''}PipelineClient",
-                ImportType.SDKCORE,
-                TypingSection.TYPING,
-            )
             file_import.add_msrest_import(
-                serialize_namespace=self.serialize_namespace,
+                serialize_namespace=f"{self.serialize_namespace}._utils",
                 msrest_import_type=MsrestImportType.SerializerDeserializer,
                 typing_section=TypingSection.TYPING,
             )
-            for client in clients:
-                if client.has_mixin:
-                    file_import.add_submodule_import(
-                        "._configuration",
-                        f"{client.name}Configuration",
-                        ImportType.LOCAL,
-                    )
-        if self.code_model.need_vendored_etag(self.client_namespace):
+            file_import.add_submodule_import("typing", "TypeVar", ImportType.STDLIB)
+            file_import.add_submodule_import("typing", "Generic", ImportType.STDLIB)
+        if self.code_model.need_utils_etag(self.client_namespace):
             file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB)
             file_import.add_submodule_import(
                 "",
                 "MatchConditions",
                 ImportType.SDKCORE,
             )
-        if self.code_model.need_vendored_form_data(self.async_mode, self.client_namespace):
+        if self.code_model.need_utils_form_data(self.async_mode, self.client_namespace):
             file_import.add_submodule_import("typing", "IO", ImportType.STDLIB)
             file_import.add_submodule_import("typing", "Tuple", ImportType.STDLIB)
             file_import.add_submodule_import("typing", "Union", ImportType.STDLIB)
@@ -135,12 +143,12 @@ class GeneralSerializer(BaseSerializer):
             file_import.add_submodule_import("typing", "Any", ImportType.STDLIB)
             file_import.add_submodule_import("typing", "List", ImportType.STDLIB)
             file_import.add_submodule_import(
-                "._model_base",
+                ".._utils.model_base",
                 "SdkJSONEncoder",
                 ImportType.LOCAL,
             )
             file_import.add_submodule_import(
-                "._model_base",
+                ".._utils.model_base",
                 "Model",
                 ImportType.LOCAL,
             )
@@ -206,19 +214,33 @@ class GeneralSerializer(BaseSerializer):
                 if not enum.internal
             }
         )
-        cross_langauge_def_dict.update(
-            {
-                (
-                    f"{self.code_model.namespace}.{client.name}."
-                    + ("" if operation_group.is_mixin else f"{operation_group.property_name}.")
-                    + f"{operation.name}"
-                ): operation.cross_language_definition_id
-                for client in self.code_model.clients
-                for operation_group in client.operation_groups
-                for operation in operation_group.operations
-                if not operation.name.startswith("_")
-            }
-        )
+        for client in self.code_model.clients:
+            for operation_group in client.operation_groups:
+                for operation in operation_group.operations:
+                    if operation.name.startswith("_"):
+                        continue
+                    cross_langauge_def_dict.update(
+                        {
+                            f"{self.code_model.namespace}."
+                            + (
+                                f"{client.name}."
+                                if operation_group.is_mixin
+                                else f"operations.{operation_group.class_name}."
+                            )
+                            + f"{operation.name}": operation.cross_language_definition_id
+                        }
+                    )
+                    cross_langauge_def_dict.update(
+                        {
+                            f"{self.code_model.namespace}.aio."
+                            + (
+                                f"{client.name}."
+                                if operation_group.is_mixin
+                                else f"operations.{operation_group.class_name}."
+                            )
+                            + f"{operation.name}": operation.cross_language_definition_id
+                        }
+                    )
         return json.dumps(
             {
                 "CrossLanguagePackageId": self.code_model.cross_language_package_id,

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

@@ -230,10 +230,11 @@ class DpgModelSerializer(_ModelSerializer):
         file_import = FileImport(self.code_model)
         if any(not m.parents for m in self.models):
             file_import.add_submodule_import(
-                self.code_model.get_relative_import_path(self.serialize_namespace),
-                "_model_base",
+                self.code_model.get_relative_import_path(self.serialize_namespace, module_name="_utils.model_base"),
+                "Model",
                 ImportType.LOCAL,
                 TypingSection.REGULAR,
+                alias="_Model",
             )
         for model in self.models:
             if model.base == "json":
@@ -272,7 +273,7 @@ class DpgModelSerializer(_ModelSerializer):
         return file_import
 
     def declare_model(self, model: ModelType) -> str:
-        basename = "_model_base.Model"
+        basename = "_Model"
         if model.parents:
             basename = ", ".join([m.name for m in model.parents])
         if model.discriminator_value:

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

@@ -109,6 +109,7 @@ class ParameterSerializer:
             return f"[{serialize_line} if q is not None else '' for q in {origin_name}]"
         return serialize_line
 
+    # pylint: disable=line-too-long
     def serialize_path(
         self,
         parameters: Union[
@@ -124,7 +125,11 @@ class ParameterSerializer:
             [
                 '    "{}": {},'.format(
                     path_parameter.wire_name,
-                    self.serialize_parameter(path_parameter, serializer_name),
+                    (
+                        f'"" if {path_parameter.full_client_name} is None else "/" + {self.serialize_parameter(path_parameter, serializer_name)}'
+                        if path_parameter.optional and isinstance(path_parameter, RequestBuilderParameter)
+                        else self.serialize_parameter(path_parameter, serializer_name)
+                    ),
                 )
                 for path_parameter in parameters
             ]

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

@@ -62,7 +62,7 @@ class SampleSerializer(BaseSerializer):
                 ImportType.SDKCORE,
             )
         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:
+            if param.client_default_value is None and not param.optional and param.wire_name in self.sample_params:
                 imports.merge(param.type.imports_for_sample())
         return FileImportSerializer(imports, True)
 
@@ -80,7 +80,7 @@ class SampleSerializer(BaseSerializer):
             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)
+            if not p.optional and p.client_default_value is None
         ]
         client_params = {
             p.client_name: special_param.get(