@typespec/http-client-python 0.13.0-dev.1 → 0.13.0-dev.3

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

@@ -124,7 +124,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
         return successful_response_with_body and successful_response_without_body
 
     def response_type_annotation(self, **kwargs) -> str:
-        if self.code_model.options["head_as_boolean"] and self.request_builder.method.lower() == "head":
+        if self.code_model.options["head-as-boolean"] and self.request_builder.method.lower() == "head":
             return "bool"
         response_type_annotations: OrderedSet[str] = {
             response.type_annotation(**kwargs): None for response in self.responses if response.type
@@ -148,13 +148,13 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
         return retval
 
     def cls_type_annotation(self, *, async_mode: bool, **kwargs: Any) -> str:
-        if self.request_builder.method.lower() == "head" and self.code_model.options["head_as_boolean"]:
+        if self.request_builder.method.lower() == "head" and self.code_model.options["head-as-boolean"]:
             return "ClsType[None]"
         return f"ClsType[{self.response_type_annotation(async_mode=async_mode, **kwargs)}]"
 
     def _response_docstring_helper(self, attr_name: str, **kwargs: Any) -> str:
         responses_with_body = [r for r in self.responses if r.type]
-        if self.request_builder.method.lower() == "head" and self.code_model.options["head_as_boolean"]:
+        if self.request_builder.method.lower() == "head" and self.code_model.options["head-as-boolean"]:
             return "bool"
         if responses_with_body:
             response_docstring_values: OrderedSet[str] = {
@@ -170,9 +170,9 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
 
     def response_docstring_text(self, **kwargs) -> str:
         retval = self._response_docstring_helper("docstring_text", **kwargs)
-        if not self.code_model.options["version_tolerant"]:
+        if not self.code_model.options["version-tolerant"]:
             retval += " or the result of cls(response)"
-        if self.code_model.options["models_mode"] == "dpg" and any(
+        if self.code_model.options["models-mode"] == "dpg" and any(
             isinstance(r.type, ModelType) for r in self.responses
         ):
             r = next(r for r in self.responses if isinstance(r.type, ModelType))
@@ -202,7 +202,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
         exception_schema = default_exceptions[0].type
         if isinstance(exception_schema, ModelType):
             return exception_schema.type_annotation(skip_quote=True)
-        return None if self.code_model.options["models_mode"] == "dpg" else "'object'"
+        return None if self.code_model.options["models-mode"] == "dpg" else "'object'"
 
     @property
     def non_default_errors(self) -> List[Response]:
@@ -248,7 +248,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
                     async_mode=async_mode, need_import_iobase=self.need_import_iobase, **kwargs
                 )
             )
-        if self.code_model.options["models_mode"]:
+        if self.code_model.options["models-mode"]:
             for exception in self.exceptions:
                 file_import.merge(
                     exception.imports_for_multiapi(
@@ -275,7 +275,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
     @property
     def need_validation(self) -> bool:
         """Whether we need parameter / operation validation. For API version."""
-        return self.code_model.options["validate_versioning"] and (
+        return self.code_model.options["validate-versioning"] and (
             bool(self.added_on) or any(p for p in self.parameters if p.added_on)
         )
 
@@ -287,7 +287,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
     ) -> FileImport:
         """Helper method to get a request builder import."""
         file_import = FileImport(self.code_model)
-        if self.code_model.options["builders_visibility"] != "embedded":
+        if self.code_model.options["builders-visibility"] != "embedded":
             group_name = request_builder.group_name
             rest_import_path = "..." if async_mode else ".."
             if group_name:
@@ -304,7 +304,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
                     import_type=ImportType.LOCAL,
                     alias="rest",
                 )
-        if self.code_model.options["builders_visibility"] == "embedded" and async_mode:
+        if self.code_model.options["builders-visibility"] == "embedded" and async_mode:
             file_import.add_submodule_import(
                 self.code_model.get_relative_import_path(
                     serialize_namespace,
@@ -341,7 +341,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
             file_import.merge(
                 response.imports(async_mode=async_mode, need_import_iobase=self.need_import_iobase, **kwargs)
             )
-        if self.code_model.options["models_mode"]:
+        if self.code_model.options["models-mode"]:
             for exception in self.exceptions:
                 file_import.merge(exception.imports(async_mode=async_mode, **kwargs))
 
@@ -369,7 +369,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
             errors.extend(["StreamConsumedError", "StreamClosedError"])
         for error in errors:
             file_import.add_submodule_import("exceptions", error, ImportType.SDKCORE)
-        if self.code_model.options["azure_arm"]:
+        if self.code_model.options["azure-arm"]:
             file_import.add_submodule_import("azure.mgmt.core.exceptions", "ARMErrorFormat", ImportType.SDKCORE)
         file_import.add_mutable_mapping_import()
 
@@ -418,7 +418,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
                 "HttpResponse",
                 ImportType.SDKCORE,
             )
-        if self.code_model.options["builders_visibility"] == "embedded" and not async_mode:
+        if self.code_model.options["builders-visibility"] == "embedded" and not async_mode:
             file_import.merge(self.request_builder.imports(**kwargs))
         file_import.add_submodule_import(
             f"{'' if self.code_model.is_azure_flavor else 'runtime.'}pipeline",
@@ -439,7 +439,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
         file_import.merge(self.get_request_builder_import(self.request_builder, async_mode, serialize_namespace))
         if self.overloads:
             file_import.add_submodule_import("typing", "overload", ImportType.STDLIB)
-        if self.code_model.options["models_mode"] == "dpg":
+        if self.code_model.options["models-mode"] == "dpg":
             relative_path = self.code_model.get_relative_import_path(
                 serialize_namespace, module_name="_utils.model_base"
             )
@@ -491,7 +491,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
             # in a mixin
             basename = self.code_model.clients[0].legacy_filename
 
-        if basename == "operations" or self.code_model.options["combine_operation_files"]:
+        if basename == "operations" or self.code_model.options["combine-operation-files"]:
             return "_operations"
         return f"_{basename}_operations"
 
@@ -543,7 +543,7 @@ class Operation(OperationBase[Response]):
                 "distributed_trace_async",
                 ImportType.SDKCORE,
             )
-        if self.has_response_body and not self.has_optional_return_type and not self.code_model.options["models_mode"]:
+        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)
 
         return file_import

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

@@ -40,7 +40,7 @@ class OperationGroup(BaseModel):
         self.operations = operations
         self.api_versions = api_versions
         self.operation_groups: List[OperationGroup] = []
-        if self.code_model.options["show_operations"]:
+        if self.code_model.options["show-operations"]:
             self.operation_groups = [
                 OperationGroup.from_yaml(op_group, code_model, client)
                 for op_group in self.yaml_data.get("operationGroups", [])
@@ -78,7 +78,7 @@ class OperationGroup(BaseModel):
         for operation in self.operations:
             file_import.merge(operation.imports_for_multiapi(async_mode, **kwargs))
         if (self.code_model.model_types or self.code_model.enums) and self.code_model.options[
-            "models_mode"
+            "models-mode"
         ] == "msrest":
             file_import.add_submodule_import(relative_path, "models", ImportType.LOCAL, alias="_models")
         return file_import
@@ -110,7 +110,7 @@ class OperationGroup(BaseModel):
 
         for operation in self.operations:
             file_import.merge(operation.imports(async_mode, **kwargs))
-        if not self.code_model.options["combine_operation_files"]:
+        if not self.code_model.options["combine-operation-files"]:
             for og in self.operation_groups:
                 file_import.add_submodule_import(
                     self.code_model.get_relative_import_path(
@@ -138,7 +138,7 @@ class OperationGroup(BaseModel):
         # for multiapi
         if (
             (self.code_model.public_model_types)
-            and self.code_model.options["models_mode"] == "msrest"
+            and self.code_model.options["models-mode"] == "msrest"
             and not self.is_mixin
         ):
             file_import.add_submodule_import(

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

@@ -92,14 +92,14 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
         if not wire_name:
             # That's an ok scenario, it just means no next page possible
             return None
-        if self.code_model.options["models_mode"] == "msrest":
+        if self.code_model.options["models-mode"] == "msrest":
             return self._get_attr_name(wire_name)
         return wire_name
 
     @property
     def item_name(self) -> str:
         wire_name = self.yaml_data["itemName"]
-        if self.code_model.options["models_mode"] == "msrest":
+        if self.code_model.options["models-mode"] == "msrest":
             # we don't use the paging model for dpg
             return self._get_attr_name(wire_name)
         return wire_name
@@ -135,7 +135,7 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
             )
         if (
             self.next_request_builder
-            and self.code_model.options["builders_visibility"] == "embedded"
+            and self.code_model.options["builders-visibility"] == "embedded"
             and not async_mode
         ):
             file_import.merge(self.next_request_builder.imports(**kwargs))
@@ -168,7 +168,7 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
                 "case_insensitive_dict",
                 ImportType.SDKCORE,
             )
-        if self.code_model.options["models_mode"] == "dpg":
+        if self.code_model.options["models-mode"] == "dpg":
             relative_path = self.code_model.get_relative_import_path(
                 serialize_namespace, module_name="_utils.model_base"
             )

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

@@ -237,7 +237,7 @@ class BodyParameter(_ParameterBase):
         return (
             self.type.is_form_data
             or bool(self.entries)
-            or ("multipart/form-data" in self.content_types and self.code_model.options["from_typespec"])
+            or ("multipart/form-data" in self.content_types and self.code_model.options["from-typespec"])
         )
 
     @property
@@ -314,7 +314,7 @@ class Parameter(_ParameterBase):
 
     @property
     def hide_in_operation_signature(self) -> bool:
-        if self.code_model.options["version_tolerant"] and self.client_name == "maxpagesize":
+        if self.code_model.options["version-tolerant"] and self.client_name == "maxpagesize":
             return True
         return self.is_continuation_token
 
@@ -342,7 +342,7 @@ class Parameter(_ParameterBase):
     ) -> ParameterMethodLocation:
         if not self.in_method_signature:
             raise ValueError(f"Parameter '{self.client_name}' is not in the method.")
-        if self.code_model.options["models_mode"] == "dpg" and self.in_flattened_body:
+        if self.code_model.options["models-mode"] == "dpg" and self.in_flattened_body:
             return ParameterMethodLocation.KEYWORD_ONLY
         if self.grouper:
             return ParameterMethodLocation.POSITIONAL
@@ -356,7 +356,7 @@ class Parameter(_ParameterBase):
             ParameterLocation.HEADER,
             ParameterLocation.QUERY,
         )
-        if self.code_model.options["only_path_and_body_params_positional"] and query_or_header:
+        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:
@@ -385,15 +385,15 @@ class ClientParameter(Parameter):
             return ParameterMethodLocation.KWARG
         if (
             self.is_host
-            and (self.code_model.options["version_tolerant"] or self.code_model.options["low_level_client"])
-            and not self.code_model.options["azure_arm"]
+            and (self.code_model.options["version-tolerant"] or self.code_model.options["low-level-client"])
+            and not self.code_model.options["azure-arm"]
         ):
             # this means i am the base url
             return ParameterMethodLocation.KEYWORD_ONLY
         if (
             self.client_default_value is not None
-            and self.code_model.options["from_typespec"]
-            and not self.code_model.options["azure_arm"]
+            and self.code_model.options["from-typespec"]
+            and not self.code_model.options["azure-arm"]
         ):
             return ParameterMethodLocation.KEYWORD_ONLY
         return ParameterMethodLocation.POSITIONAL

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

@@ -87,11 +87,17 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
     def is_enum_discriminator(self) -> bool:
         return self.is_discriminator and self.type.type == "enum"
 
+    @property
+    def is_combined_discriminator(self) -> bool:
+        return self.is_discriminator and self.type.type == "combined"
+
     @property
     def is_base_discriminator(self) -> bool:
         """If this discriminator is on the base model for polymorphic inheritance"""
         if self.is_enum_discriminator:
             return self.is_polymorphic and self.client_default_value is None
+        if self.is_combined_discriminator:
+            return True
         return self.is_discriminator and self.is_polymorphic and cast(ConstantType, self.type).value is None
 
     @property
@@ -146,7 +152,7 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
         file_import.merge(self.type.imports(**kwargs))
         if (self.optional and self.client_default_value is None) or self.readonly:
             file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB)
-        if self.code_model.options["models_mode"] == "dpg":
+        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="_utils.model_base"),

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

@@ -110,7 +110,7 @@ class RequestBuilderBase(BaseBuilder[ParameterListType, Sequence["RequestBuilder
             msrest_import_type=MsrestImportType.Serializer,
             typing_section=TypingSection.REGULAR,
         )
-        if self.overloads and self.code_model.options["builders_visibility"] != "embedded":
+        if self.overloads and self.code_model.options["builders-visibility"] != "embedded":
             file_import.add_submodule_import("typing", "overload", ImportType.STDLIB)
         return file_import
 
@@ -127,7 +127,7 @@ class RequestBuilderBase(BaseBuilder[ParameterListType, Sequence["RequestBuilder
         client: "Client",
     ) -> str:
         additional_mark = ""
-        if code_model.options["combine_operation_files"] and code_model.options["builders_visibility"] == "embedded":
+        if code_model.options["combine-operation-files"] and code_model.options["builders-visibility"] == "embedded":
             additional_mark = yaml_data["groupName"] or client.yaml_data["builderPadName"]
         names = [
             "build",

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

@@ -26,7 +26,7 @@ class RequestBuilderBodyParameter(BodyParameter):
         if (
             isinstance(self.type, (BinaryType, StringType))
             or any("xml" in ct for ct in self.content_types)
-            or self.code_model.options["models_mode"] == "dpg"
+            or self.code_model.options["models-mode"] == "dpg"
         ):
             self.client_name = "content"
         else:
@@ -40,7 +40,7 @@ class RequestBuilderBodyParameter(BodyParameter):
     @property
     def in_method_signature(self) -> bool:
         return (
-            super().in_method_signature and not self.is_partial_body and self.code_model.options["models_mode"] != "dpg"
+            super().in_method_signature and not self.is_partial_body and self.code_model.options["models-mode"] != "dpg"
         )
 
     @property

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

@@ -191,7 +191,7 @@ class PagingResponse(Response):
 
     def docstring_text(self, **kwargs: Any) -> str:
         base_description = "An iterator like instance of "
-        if not self.code_model.options["version_tolerant"]:
+        if not self.code_model.options["version-tolerant"]:
             base_description += "either "
         return base_description + self.item_type.docstring_text(**kwargs)
 
@@ -266,7 +266,7 @@ class LROResponse(Response):
     def docstring_text(self, **kwargs) -> str:
         super_text = super().docstring_text(**kwargs)
         base_description = f"An instance of {self.get_poller(kwargs.get('async_mode', False))} that returns "
-        if not self.code_model.options["version_tolerant"]:
+        if not self.code_model.options["version-tolerant"]:
             base_description += "either "
         return base_description + super_text
 
@@ -321,7 +321,7 @@ class LROPagingResponse(LROResponse, PagingResponse):
 
     def docstring_text(self, **kwargs) -> str:
         base_description = "An instance of LROPoller that returns an iterator like instance of "
-        if not self.code_model.options["version_tolerant"]:
+        if not self.code_model.options["version-tolerant"]:
             base_description += "either "
         return base_description + Response.docstring_text(self)
 

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

@@ -33,8 +33,7 @@ from .patch_serializer import PatchSerializer
 from .sample_serializer import SampleSerializer
 from .test_serializer import TestSerializer, TestGeneralSerializer
 from .types_serializer import TypesSerializer
-from ...utils import to_snake_case
-from .._utils import VALID_PACKAGE_MODE
+from ...utils import to_snake_case, VALID_PACKAGE_MODE
 from .utils import (
     extract_sample_name,
     get_namespace_from_package_name,
@@ -84,11 +83,11 @@ class JinjaSerializer(ReaderAndWriter):
 
     @property
     def has_aio_folder(self) -> bool:
-        return not self.code_model.options["no_async"] and bool(self.code_model.has_operations)
+        return not self.code_model.options["no-async"] and bool(self.code_model.has_operations)
 
     @property
     def has_operations_folder(self) -> bool:
-        return self.code_model.options["show_operations"] and bool(self.code_model.has_operations)
+        return self.code_model.options["show-operations"] and bool(self.code_model.has_operations)
 
     @property
     def serialize_loop(self) -> List[AsyncInfo]:
@@ -98,7 +97,7 @@ class JinjaSerializer(ReaderAndWriter):
 
     @property
     def keep_version_file(self) -> bool:
-        if self.options.get("keep_version_file"):
+        if self.options.get("keep-version-file"):
             return True
         # If the version file is already there and the version is greater than the current version, keep it.
         try:
@@ -107,7 +106,7 @@ class JinjaSerializer(ReaderAndWriter):
             serialized_version = match.group(1) if match else ""
         except (FileNotFoundError, IndexError):
             serialized_version = ""
-        return serialized_version > self.code_model.options["package_version"]
+        return serialized_version > self.code_model.options.get("package-version", "")
 
     def serialize(self) -> None:
         env = Environment(
@@ -124,25 +123,25 @@ class JinjaSerializer(ReaderAndWriter):
             exec_path = self.exec_path(client_namespace)
             if client_namespace == "":
                 # Write the setup file
-                if self.code_model.options["basic_setup_py"]:
+                if self.code_model.options["basic-setup-py"]:
                     self.write_file(exec_path / Path("setup.py"), general_serializer.serialize_setup_file())
 
                 # add packaging files in root namespace (e.g. setup.py, README.md, etc.)
-                if self.code_model.options["package_mode"]:
+                if self.code_model.options.get("package-mode"):
                     self._serialize_and_write_package_files(client_namespace)
 
                 # write apiview-properties.json
-                if self.code_model.options.get("emit_cross_language_definition_file"):
+                if self.code_model.options.get("emit-cross-language-definition-file"):
                     self.write_file(
                         exec_path / Path("apiview-properties.json"),
                         general_serializer.serialize_cross_language_definition_file(),
                     )
 
                 # add generated samples and generated tests
-                if self.code_model.options["show_operations"] and self.code_model.has_operations:
-                    if self.code_model.options["generate_sample"]:
+                if self.code_model.options["show-operations"] and self.code_model.has_operations:
+                    if self.code_model.options["generate-sample"]:
                         self._serialize_and_write_sample(env, namespace=client_namespace)
-                    if self.code_model.options["generate_test"]:
+                    if self.code_model.options["generate-test"]:
                         self._serialize_and_write_test(env, namespace=client_namespace)
 
                 # add _metadata.json
@@ -169,7 +168,7 @@ class JinjaSerializer(ReaderAndWriter):
             # add models folder if there are models in this namespace
             if (
                 self.code_model.has_non_json_models(client_namespace_type.models) or client_namespace_type.enums
-            ) and self.code_model.options["models_mode"]:
+            ) and self.code_model.options["models-mode"]:
                 self._serialize_and_write_models_folder(
                     env=env,
                     namespace=client_namespace,
@@ -177,7 +176,7 @@ class JinjaSerializer(ReaderAndWriter):
                     enums=client_namespace_type.enums,
                 )
 
-            if not self.code_model.options["models_mode"]:
+            if not self.code_model.options["models-mode"]:
                 # keep models file if users ended up just writing a models file
                 model_path = exec_path / Path("models.py")
                 if self.read_file(model_path):
@@ -201,7 +200,7 @@ class JinjaSerializer(ReaderAndWriter):
 
     def _serialize_and_write_package_files(self, client_namespace: str) -> None:
         root_of_sdk = self.exec_path(client_namespace)
-        if self.code_model.options["package_mode"] in VALID_PACKAGE_MODE:
+        if self.code_model.options["package-mode"] in VALID_PACKAGE_MODE:
             env = Environment(
                 loader=PackageLoader("pygen.codegen", "templates/packaging_templates"),
                 undefined=StrictUndefined,
@@ -212,9 +211,9 @@ class JinjaSerializer(ReaderAndWriter):
             package_files = _PACKAGE_FILES
             if not self.code_model.license_description:
                 package_files.remove("LICENSE.jinja2")
-        elif Path(self.code_model.options["package_mode"]).exists():
+        elif Path(self.code_model.options["package-mode"]).exists():
             env = Environment(
-                loader=FileSystemLoader(str(Path(self.code_model.options["package_mode"]))),
+                loader=FileSystemLoader(str(Path(self.code_model.options["package-mode"]))),
                 keep_trailing_newline=True,
                 undefined=StrictUndefined,
             )
@@ -222,7 +221,7 @@ class JinjaSerializer(ReaderAndWriter):
         else:
             return
         serializer = GeneralSerializer(self.code_model, env, async_mode=False)
-        params = self.code_model.options["packaging_files_config"] or {}
+        params = self.code_model.options.get("packaging-files-config", {})
         for template_name in package_files:
             if not self.code_model.is_azure_flavor and template_name == "dev_requirements.txt.jinja2":
                 continue
@@ -251,7 +250,7 @@ class JinjaSerializer(ReaderAndWriter):
     ) -> None:
         # Write the models folder
         models_path = self.exec_path(namespace) / "models"
-        serializer = DpgModelSerializer if self.code_model.options["models_mode"] == "dpg" else MsrestModelSerializer
+        serializer = DpgModelSerializer if self.code_model.options["models-mode"] == "dpg" else MsrestModelSerializer
         if self.code_model.has_non_json_models(models):
             self.write_file(
                 models_path / Path(f"{self.code_model.models_filename}.py"),
@@ -332,7 +331,7 @@ class JinjaSerializer(ReaderAndWriter):
 
             # write operations file
             OgLoop = namedtuple("OgLoop", ["operation_groups", "filename"])
-            if self.code_model.options["combine_operation_files"]:
+            if self.code_model.options["combine-operation-files"]:
                 loops = [OgLoop(operation_groups, "_operations")]
             else:
                 loops = [OgLoop([og], og.filename) for og in operation_groups]
@@ -372,7 +371,7 @@ class JinjaSerializer(ReaderAndWriter):
             _write_version_file(original_version_file_name="_version.py")
         elif self.keep_version_file and _read_version_file("version.py"):
             _write_version_file(original_version_file_name="version.py")
-        elif self.code_model.options["package_version"]:
+        elif self.code_model.options.get("package-version"):
             self.write_file(
                 exec_path / Path("_version.py"),
                 general_serializer.serialize_version_file(),
@@ -437,7 +436,7 @@ class JinjaSerializer(ReaderAndWriter):
             )
 
         # write _model_base.py
-        if self.code_model.options["models_mode"] == "dpg":
+        if self.code_model.options["models-mode"] == "dpg":
             self.write_file(
                 utils_folder_path / Path("model_base.py"),
                 general_serializer.serialize_model_base_file(),
@@ -479,7 +478,7 @@ class JinjaSerializer(ReaderAndWriter):
         """Assume the process is running in the root folder of the package. If not, we need the path compensation."""
         return (
             Path("../" * (self.code_model.namespace.count(".") + 1))
-            if self.code_model.options["no_namespace_folders"]
+            if self.code_model.options["no-namespace-folders"]
             else Path(".")
         )
 
@@ -488,7 +487,7 @@ class JinjaSerializer(ReaderAndWriter):
 
     # pylint: disable=line-too-long
     def exec_path(self, namespace: str) -> Path:
-        if self.code_model.options["no_namespace_folders"] and not self.code_model.options["multiapi"]:
+        if self.code_model.options["no-namespace-folders"] and not self.code_model.options["multiapi"]:
             # when output folder contains parts different from the namespace, we fall back to current folder directly.
             # (e.g. https://github.com/Azure/azure-sdk-for-python/blob/main/sdk/communication/azure-communication-callautomation/swagger/SWAGGER.md)
             return Path(".")
@@ -506,7 +505,7 @@ class JinjaSerializer(ReaderAndWriter):
         namespace_config = get_namespace_config(self.code_model.namespace, self.code_model.options["multiapi"])
         num_of_namespace = namespace_config.count(".") + 1
         num_of_package_namespace = (
-            get_namespace_from_package_name(self.code_model.options["package_name"]).count(".") + 1
+            get_namespace_from_package_name(self.code_model.options.get("namespace", "")).count(".") + 1
         )
         if num_of_namespace > num_of_package_namespace:
             return Path("/".join(namespace_config.split(".")[num_of_package_namespace:]))
@@ -519,7 +518,7 @@ class JinjaSerializer(ReaderAndWriter):
                 for operation in op_group.operations:
                     if (
                         self.code_model.options["multiapi"]
-                        and operation.api_versions[0] != self.code_model.options["default_api_version"]
+                        and operation.api_versions[0] != self.code_model.options["default-api-version"]
                     ):
                         continue
                     samples = operation.yaml_data.get("samples")
@@ -550,7 +549,7 @@ class JinjaSerializer(ReaderAndWriter):
         out_path = self.exec_path_for_test_sample(namespace) / Path("generated_tests")
         general_serializer = TestGeneralSerializer(code_model=self.code_model, env=env)
         self.write_file(out_path / "conftest.py", general_serializer.serialize_conftest())
-        if not self.code_model.options["azure_arm"]:
+        if not self.code_model.options["azure-arm"]:
             for async_mode in (True, False):
                 async_suffix = "_async" if async_mode else ""
                 general_serializer.async_mode = async_mode
@@ -562,7 +561,7 @@ class JinjaSerializer(ReaderAndWriter):
         for client in self.code_model.clients:
             for og in client.operation_groups:
                 if self.code_model.options["multiapi"] and any(
-                    o.api_versions[0] != self.code_model.options["default_api_version"] for o in og.operations
+                    o.api_versions[0] != self.code_model.options["default-api-version"] for o in og.operations
                 ):
                     continue
                 test_serializer = TestSerializer(self.code_model, env, client=client, operation_group=og)