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

package/generator/build/lib/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)

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

@@ -326,7 +326,7 @@ class _BuilderBaseSerializer(Generic[BuilderType]):
 
         if (
             isinstance(body_param.type, (ListType, DictionaryType))
-            and self.code_model.options["models_mode"] == "msrest"
+            and self.code_model.options["models-mode"] == "msrest"
         ):
             return template
 
@@ -351,7 +351,7 @@ class _BuilderBaseSerializer(Generic[BuilderType]):
             )
             for idx in range(
                 min(
-                    self.code_model.options["polymorphic_examples"],
+                    self.code_model.options["polymorphic-examples"],
                     len(polymorphic_subtypes),
                 )
             ):
@@ -494,7 +494,7 @@ class RequestBuilderSerializer(_BuilderBaseSerializer[RequestBuilderType]):
         return retval
 
     def construct_url(self, builder: RequestBuilderType) -> str:
-        if any(o for o in ["low_level_client", "version_tolerant"] if self.code_model.options.get(o)):
+        if any(o for o in ["low-level-client", "version-tolerant"] if self.code_model.options.get(o)):
             url_value = _escape_str(builder.url)
         else:
             url_value = f'kwargs.pop("template_url", {_escape_str(builder.url)})'
@@ -522,7 +522,7 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
         return "response"
 
     def example_template(self, builder: OperationType) -> List[str]:
-        if self.code_model.options["models_mode"] in ("msrest", "dpg"):
+        if self.code_model.options["models-mode"] in ("msrest", "dpg"):
             return []
         retval = super().example_template(builder)
         for response in builder.responses:
@@ -540,7 +540,7 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
                 )
                 for idx in range(
                     min(
-                        self.code_model.options["polymorphic_examples"],
+                        self.code_model.options["polymorphic-examples"],
                         len(polymorphic_subtypes),
                     )
                 ):
@@ -559,7 +559,7 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
     def make_pipeline_call(self, builder: OperationType) -> List[str]:
         retval = []
         type_ignore = self.async_mode and builder.group_name == ""  # is in a mixin
-        if builder.stream_value is True and not self.code_model.options["version_tolerant"]:
+        if builder.stream_value is True and not self.code_model.options["version-tolerant"]:
             retval.append("_decompress = kwargs.pop('decompress', True)")
         pylint_disable = " # pylint: disable=protected-access" if self.code_model.is_azure_flavor else ""
         retval.extend(
@@ -688,9 +688,9 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
         send_xml = builder.parameters.body_parameter.type.is_xml
         xml_serialization_ctxt = body_param.type.xml_serialization_ctxt if send_xml else None
         ser_ctxt_name = "serialization_ctxt"
-        if xml_serialization_ctxt and self.code_model.options["models_mode"]:
+        if xml_serialization_ctxt and self.code_model.options["models-mode"]:
             retval.append(f'{ser_ctxt_name} = {{"xml": {{{xml_serialization_ctxt}}}}}')
-        if self.code_model.options["models_mode"] == "msrest":
+        if self.code_model.options["models-mode"] == "msrest":
             is_xml_cmd = _xml_config(send_xml, builder.parameters.body_parameter.content_types)
             serialization_ctxt_cmd = f", {ser_ctxt_name}={ser_ctxt_name}" if xml_serialization_ctxt else ""
             serialization_type = body_param.type.serialization_type(serialize_namespace=self.serialize_namespace)
@@ -698,7 +698,7 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
                 f"_{body_kwarg_name} = self._serialize.body({body_param.client_name}, "
                 f"'{serialization_type}'{is_xml_cmd}{serialization_ctxt_cmd})"
             )
-        elif self.code_model.options["models_mode"] == "dpg":
+        elif self.code_model.options["models-mode"] == "dpg":
             if json_serializable(body_param.default_content_type):
                 if hasattr(body_param.type, "encode") and body_param.type.encode:  # type: ignore
                     create_body_call = (
@@ -812,7 +812,7 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
         is_next_request: bool = False,
     ) -> List[str]:
         retval: List[str] = []
-        if self.code_model.options["builders_visibility"] == "embedded":
+        if self.code_model.options["builders-visibility"] == "embedded":
             request_path_name = request_builder.name
         else:
             group_name = request_builder.group_name
@@ -873,7 +873,7 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
         if builder.parameters.path:
             retval.extend(self.serialize_path(builder))
         url_to_format = "_request.url"
-        if self.code_model.options["version_tolerant"] and template_url:
+        if self.code_model.options["version-tolerant"] and template_url:
             url_to_format = template_url
         retval.append(
             "_request.url = self._client.format_url({}{})".format(
@@ -948,7 +948,7 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
                 deserialized = f"{'await ' if self.async_mode else ''}response.read()"
             else:
                 stream_logic = False
-                if self.code_model.options["version_tolerant"]:
+                if self.code_model.options["version-tolerant"]:
                     deserialized = "response.iter_bytes()"
                 else:
                     deserialized = (
@@ -959,13 +959,13 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
             pylint_disable = ""
             if isinstance(response.type, ModelType) and response.type.internal:
                 pylint_disable = "  # pylint: disable=protected-access"
-            if self.code_model.options["models_mode"] == "msrest":
+            if self.code_model.options["models-mode"] == "msrest":
                 deserialize_code.append("deserialized = self._deserialize(")
                 serialization_type = response.serialization_type(serialize_namespace=self.serialize_namespace)
                 deserialize_code.append(f"    '{serialization_type}',{pylint_disable}")
                 deserialize_code.append(" pipeline_response.http_response")
                 deserialize_code.append(")")
-            elif self.code_model.options["models_mode"] == "dpg":
+            elif self.code_model.options["models-mode"] == "dpg":
                 if builder.has_stream_response:
                     deserialize_code.append("deserialized = response.content")
                 else:
@@ -1019,7 +1019,7 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
             retval.extend([f"    {l}" for l in response_read])
         retval.append("    map_error(status_code=response.status_code, response=response, error_map=error_map)")
         error_model = ""
-        if builder.non_default_errors and self.code_model.options["models_mode"]:
+        if builder.non_default_errors and self.code_model.options["models-mode"]:
             error_model = ", model=error"
             condition = "if"
             retval.append("    error = None")
@@ -1031,7 +1031,7 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
                         type_annotation = e.type.type_annotation(  # type: ignore
                             is_operation_file=True, skip_quote=True, serialize_namespace=self.serialize_namespace
                         )
-                        if self.code_model.options["models_mode"] == "dpg":
+                        if self.code_model.options["models-mode"] == "dpg":
                             retval.append(f"        error = _failsafe_deserialize({type_annotation},  response.json())")
                         else:
                             retval.append(
@@ -1051,7 +1051,7 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
                                 "        raise {}(response=response{}{})".format(
                                     status_code_error_map[cast(int, status_code)],
                                     error_model,
-                                    (", error_format=ARMErrorFormat" if self.code_model.options["azure_arm"] else ""),
+                                    (", error_format=ARMErrorFormat" if self.code_model.options["azure-arm"] else ""),
                                 )
                             )
                             condition = "if"
@@ -1065,7 +1065,7 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
                     type_annotation = e.type.type_annotation(  # type: ignore
                         is_operation_file=True, skip_quote=True, serialize_namespace=self.serialize_namespace
                     )
-                    if self.code_model.options["models_mode"] == "dpg":
+                    if self.code_model.options["models-mode"] == "dpg":
                         if xml_serializable(str(e.default_content_type)):
                             retval.append(
                                 f"        error = _failsafe_deserialize_xml({type_annotation},  response.text())"
@@ -1079,12 +1079,12 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
                         )
                     condition = "elif"
         # default error handling
-        if builder.default_error_deserialization and self.code_model.options["models_mode"]:
+        if builder.default_error_deserialization and self.code_model.options["models-mode"]:
             error_model = ", model=error"
             indent = "        " if builder.non_default_errors else "    "
             if builder.non_default_errors:
                 retval.append("    else:")
-            if self.code_model.options["models_mode"] == "dpg":
+            if self.code_model.options["models-mode"] == "dpg":
                 retval.append(
                     f"{indent}error = _failsafe_deserialize({builder.default_error_deserialization},  response.json())"
                 )
@@ -1096,7 +1096,7 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
         retval.append(
             "    raise HttpResponseError(response=response{}{})".format(
                 error_model,
-                (", error_format=ARMErrorFormat" if self.code_model.options["azure_arm"] else ""),
+                (", error_format=ARMErrorFormat" if self.code_model.options["azure-arm"] else ""),
             )
         )
         return retval
@@ -1144,7 +1144,7 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
             else:
                 retval.extend(self.response_headers_and_deserialization(builder, builder.responses[0]))
                 retval.append("")
-        if builder.has_optional_return_type or self.code_model.options["models_mode"]:
+        if builder.has_optional_return_type or self.code_model.options["models-mode"]:
             deserialized = "deserialized"
         else:
             deserialized = f"cast({builder.response_type_annotation(async_mode=self.async_mode)}, deserialized)"
@@ -1161,7 +1161,7 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
         ):
             retval.append("")
             retval.append(f"return {deserialized}  # type: ignore")
-        if builder.request_builder.method == "HEAD" and self.code_model.options["head_as_boolean"]:
+        if builder.request_builder.method == "HEAD" and self.code_model.options["head-as-boolean"]:
             retval.append("return 200 <= response.status_code <= 299")
         return retval
 
@@ -1180,7 +1180,7 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
 
     def error_map(self, builder: OperationType) -> List[str]:
         retval = ["error_map: MutableMapping = {"]
-        if builder.non_default_errors and self.code_model.options["models_mode"]:
+        if builder.non_default_errors and self.code_model.options["models-mode"]:
             # TODO: we should decide whether to add the build-in error map when there is a customized default error type
             if self._need_specific_error_map(401, builder):
                 retval.append("    401: ClientAuthenticationError,")
@@ -1326,7 +1326,7 @@ class _PagingOperationSerializer(_OperationSerializer[PagingOperationType]):
         retval = [f"{'async ' if self.async_mode else ''}def extract_data(pipeline_response):"]
         response = builder.responses[0]
         deserialized = "pipeline_response.http_response.json()"
-        if self.code_model.options["models_mode"] == "msrest":
+        if self.code_model.options["models-mode"] == "msrest":
             suffix = ".http_response" if hasattr(builder, "initial_operation") else ""
             deserialize_type = response.serialization_type(serialize_namespace=self.serialize_namespace)
             pylint_disable = "  # pylint: disable=protected-access"
@@ -1337,13 +1337,13 @@ class _PagingOperationSerializer(_OperationSerializer[PagingOperationType]):
                 f"self._deserialize(\n    {deserialize_type},{pylint_disable}\n    pipeline_response{suffix}\n)"
             )
             retval.append(f"    deserialized = {deserialized}")
-        elif self.code_model.options["models_mode"] == "dpg":
+        elif self.code_model.options["models-mode"] == "dpg":
             # we don't want to generate paging models for DPG
             retval.append(f"    deserialized = {deserialized}")
         else:
             retval.append(f"    deserialized = {deserialized}")
         item_name = builder.item_name
-        if self.code_model.options["models_mode"] == "msrest":
+        if self.code_model.options["models-mode"] == "msrest":
             access = f".{item_name}"
         else:
             item_name_array = item_name.split(".")
@@ -1351,7 +1351,7 @@ class _PagingOperationSerializer(_OperationSerializer[PagingOperationType]):
                 "".join([f'.get("{i}", {{}})' for i in item_name_array[:-1]]) + f'.get("{item_name_array[-1]}", [])'
             )
         list_of_elem_deserialized = ""
-        if self.code_model.options["models_mode"] == "dpg":
+        if self.code_model.options["models-mode"] == "dpg":
             item_type = builder.item_type.type_annotation(
                 is_operation_file=True, serialize_namespace=self.serialize_namespace
             )
@@ -1377,7 +1377,7 @@ class _PagingOperationSerializer(_OperationSerializer[PagingOperationType]):
             next_link_name = builder.next_link_name
             if not next_link_name:
                 cont_token_property = "None"
-            elif self.code_model.options["models_mode"] == "msrest":
+            elif self.code_model.options["models-mode"] == "msrest":
                 cont_token_property = f"deserialized.{next_link_name} or None"
             else:
                 cont_token_property = f'deserialized.get("{next_link_name}") or None'
@@ -1498,8 +1498,8 @@ class _LROOperationSerializer(_OperationSerializer[LROOperationType]):
             if builder.lro_response.headers:
                 retval.append("    response_headers = {}")
             if (
-                not self.code_model.options["models_mode"]
-                or self.code_model.options["models_mode"] == "dpg"
+                not self.code_model.options["models-mode"]
+                or self.code_model.options["models-mode"] == "dpg"
                 or builder.lro_response.headers
             ):
                 retval.append("    response = pipeline_response.http_response")

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

@@ -137,7 +137,7 @@ class ClientSerializer:
         if not self.client.code_model.is_legacy and self.client.request_id_header_name:
             result.append(f'kwargs["request_id_header_name"] = "{self.client.request_id_header_name}"')
         policies = build_policies(
-            self.client.code_model.options["azure_arm"],
+            self.client.code_model.options["azure-arm"],
             async_mode,
             is_azure_flavor=self.client.code_model.is_azure_flavor,
             tracing=self.client.code_model.options["tracing"],
@@ -161,7 +161,7 @@ class ClientSerializer:
                 return f"{{k: v for k, v in {models_dict_name}.__dict__.items() if isinstance(v, type)}}"
             return "{}"
 
-        is_msrest_model = self.client.code_model.options["models_mode"] == "msrest"
+        is_msrest_model = self.client.code_model.options["models-mode"] == "msrest"
         if is_msrest_model:
             add_private_models = len(self.client.code_model.model_types) != len(
                 self.client.code_model.public_model_types
@@ -177,7 +177,7 @@ class ClientSerializer:
         client_models_str = "client_models" if is_msrest_model else ""
         retval.append(f"self._serialize = Serializer({client_models_str})")
         retval.append(f"self._deserialize = Deserializer({client_models_str})")
-        if not self.client.code_model.options["client_side_validation"]:
+        if not self.client.code_model.options["client-side-validation"]:
             retval.append("self._serialize.client_side_validation = False")
         operation_groups = [og for og in self.client.operation_groups if not og.is_mixin]
         for og in operation_groups:
@@ -252,7 +252,7 @@ class ClientSerializer:
         rest_library = f"{self.client.code_model.core_library}.rest"
         retval = ['"""Runs the network request through the client\'s chained policies.']
         retval.append("")
-        if self.client.code_model.options["builders_visibility"] != "embedded":
+        if self.client.code_model.options["builders-visibility"] != "embedded":
             retval.extend(self._request_builder_example(async_mode))
         else:
             retval.extend(self._rest_request_example(async_mode))

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

@@ -39,7 +39,7 @@ class GeneralSerializer(BaseSerializer):
             "MIN_PYTHON_VERSION": MIN_PYTHON_VERSION,
             "MAX_PYTHON_VERSION": MAX_PYTHON_VERSION,
         }
-        params.update(self.code_model.options)
+        params.update({"options": self.code_model.options})
         return template.render(code_model=self.code_model, **params)
 
     def serialize_package_file(self, template_name: str, **kwargs: Any) -> str:
@@ -47,12 +47,12 @@ class GeneralSerializer(BaseSerializer):
         package_parts = (
             self.code_model.namespace.split(".")[:-1]
             if self.code_model.is_tsp
-            else (self.code_model.options["package_name"] or "").split("-")[:-1]
+            else (self.code_model.options.get("package-name", "")).split("-")[:-1]
         )
         token_credential = any(
             c for c in self.code_model.clients if isinstance(getattr(c.credential, "type", None), TokenCredentialType)
         )
-        version = self.code_model.options["package_version"]
+        version = self.code_model.options.get("package-version", "")
         if any(x in version for x in ["a", "b", "rc"]) or version[0] == "0":
             dev_status = "4 - Beta"
         else:
@@ -68,7 +68,7 @@ class GeneralSerializer(BaseSerializer):
             "MIN_PYTHON_VERSION": MIN_PYTHON_VERSION,
             "MAX_PYTHON_VERSION": MAX_PYTHON_VERSION,
         }
-        params.update(self.code_model.options)
+        params.update({"options": self.code_model.options})
         params.update(kwargs)
         return template.render(file_import=FileImport(self.code_model), **params)
 

package/generator/build/lib/pygen/codegen/serializers/metadata_serializer.py

@@ -158,7 +158,7 @@ class MetadataSerializer(BaseSerializer):
         chosen_version, total_api_version_list = self._choose_api_version()
 
         # setting to true, because for multiapi we always generate with a version file with version 0.1.0
-        self.code_model.options["package_version"] = "0.1.0"
+        self.code_model.options["package-version"] = "0.1.0"
         template = self.env.get_template("metadata.json.jinja2")
 
         client_serialize_namespace = self.code_model.get_serialize_namespace(self.client_namespace, async_mode=False)

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

@@ -164,7 +164,7 @@ class MsrestModelSerializer(_ModelSerializer):
     def declare_model(self, model: ModelType) -> str:
         basename = (
             "msrest.serialization.Model"
-            if self.code_model.options["client_side_validation"]
+            if self.code_model.options["client-side-validation"]
             else "_serialization.Model"
         )
         if model.parents:

package/generator/build/lib/pygen/codegen/serializers/operations_init_serializer.py

@@ -24,7 +24,7 @@ class OperationsInitSerializer:
 
     def operation_group_imports(self) -> List[str]:
         def _get_filename(operation_group: OperationGroup) -> str:
-            return "_operations" if self.code_model.options["combine_operation_files"] else operation_group.filename
+            return "_operations" if self.code_model.options["combine-operation-files"] else operation_group.filename
 
         return [f"from .{_get_filename(og)} import {og.class_name}  # type: ignore" for og in self.operation_groups]
 

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

@@ -147,7 +147,7 @@ class SampleSerializer(BaseSerializer):
         name = self.sample.get("x-ms-original-file", "")
         if "specification" in name:
             return "specification" + name.split("specification")[-1]
-        return name if self.code_model.options["from_typespec"] else ""
+        return name if self.code_model.options["from-typespec"] else ""
 
     def serialize(self) -> str:
         operation_result, return_var = self._operation_result()

package/generator/build/lib/pygen/codegen/serializers/test_serializer.py

@@ -54,13 +54,13 @@ class TestName:
 
     @property
     def preparer_name(self) -> str:
-        if self.code_model.options["azure_arm"]:
+        if self.code_model.options["azure-arm"]:
             return "RandomNameResourceGroupPreparer"
         return self.prefix + "Preparer"
 
     @property
     def base_test_class_name(self) -> str:
-        if self.code_model.options["azure_arm"]:
+        if self.code_model.options["azure-arm"]:
             return "AzureMgmtRecordedTestCase"
         return f"{self.client_name}TestBase{self.async_suffix_capt}"
 
@@ -196,12 +196,12 @@ class TestSerializer(TestGeneralSerializer):
         test_name = TestName(self.code_model, self.client.name, async_mode=self.async_mode)
         async_suffix = "_async" if self.async_mode else ""
         imports.add_submodule_import(
-            "devtools_testutils" if self.code_model.options["azure_arm"] else "testpreparer" + async_suffix,
+            "devtools_testutils" if self.code_model.options["azure-arm"] else "testpreparer" + async_suffix,
             test_name.base_test_class_name,
             ImportType.LOCAL,
         )
         imports.add_submodule_import(
-            "devtools_testutils" if self.code_model.options["azure_arm"] else "testpreparer",
+            "devtools_testutils" if self.code_model.options["azure-arm"] else "testpreparer",
             test_name.preparer_name,
             ImportType.LOCAL,
         )
@@ -210,7 +210,7 @@ class TestSerializer(TestGeneralSerializer):
             "recorded_by_proxy" + async_suffix,
             ImportType.LOCAL,
         )
-        if self.code_model.options["azure_arm"]:
+        if self.code_model.options["azure-arm"]:
             self.add_import_client(imports)
         return FileImportSerializer(imports, self.async_mode)
 

package/generator/build/lib/pygen/codegen/templates/config.py.jinja2

@@ -46,7 +46,7 @@ class {{ client.name }}Configuration:  {{ client.config.pylint_disable() }}
         self.proxy_policy = kwargs.get('proxy_policy') or policies.ProxyPolicy(**kwargs)
         self.logging_policy = kwargs.get('logging_policy') or policies.NetworkTraceLoggingPolicy(**kwargs)
         {% if code_model.is_azure_flavor %}
-        self.http_logging_policy = kwargs.get('http_logging_policy') or {{ "ARM" if client.code_model.options['azure_arm'] else "policies." }}HttpLoggingPolicy(**kwargs)
+        self.http_logging_policy = kwargs.get('http_logging_policy') or {{ "ARM" if client.code_model.options["azure-arm"] else "policies." }}HttpLoggingPolicy(**kwargs)
         self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs)
         self.redirect_policy = kwargs.get('redirect_policy') or policies.{{ keywords.async_class }}RedirectPolicy(**kwargs)
         {% endif %}

package/generator/build/lib/pygen/codegen/templates/config_container.py.jinja2

@@ -8,7 +8,7 @@
 
 {{ imports }}
 
-{% if not code_model.options['package_version'] %}
+{% if not code_model.options.get("package-version") %}
 VERSION = "unknown"
 {% endif %}
 

package/generator/build/lib/pygen/codegen/templates/conftest.py.jinja2

@@ -13,7 +13,7 @@ load_dotenv()
 @pytest.fixture(scope="session", autouse=True)
 def add_sanitizers(test_proxy):
     {% for test_name in test_names %}
-    {% set prefix_upper = "AZURE" if code_model.options["azure_arm"] else test_name.prefix|upper %}
+    {% set prefix_upper = "AZURE" if code_model.options["azure-arm"] else test_name.prefix|upper %}
     {% set prefix_lower = test_name.prefix|lower %}
     {{ prefix_lower }}_subscription_id = os.environ.get("{{ prefix_upper }}_SUBSCRIPTION_ID", "00000000-0000-0000-0000-000000000000")
     {{ prefix_lower }}_tenant_id = os.environ.get("{{ prefix_upper }}_TENANT_ID", "00000000-0000-0000-0000-000000000000")