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

package/generator/build/lib/pygen/__init__.py

@@ -3,13 +3,15 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
+from collections.abc import ItemsView, KeysView, MutableMapping, ValuesView
 import logging
 from pathlib import Path
 import json
 from abc import ABC, abstractmethod
-from typing import Any, Dict, Union, List
+from typing import Any, Dict, Iterator, Optional, Union, List
 
 import yaml
+from .utils import TYPESPEC_PACKAGE_MODE, VALID_PACKAGE_MODE
 
 from ._version import VERSION
 
@@ -18,6 +20,177 @@ __version__ = VERSION
 _LOGGER = logging.getLogger(__name__)
 
 
+class OptionsDict(MutableMapping):
+    DEFAULTS = {
+        "azure-arm": False,
+        "basic-setup-py": False,
+        "client-side-validation": False,
+        "emit-cross-language-definition-file": False,
+        "flavor": "azure",  # need to default to azure in shared code so we don't break swagger generation
+        "from-typespec": False,
+        "generate-sample": False,
+        "generate-test": False,
+        "head-as-boolean": True,
+        "keep-version-file": False,
+        "low-level-client": False,
+        "multiapi": False,
+        "no-async": False,
+        "no-namespace-folders": False,
+        "polymorphic-examples": 5,
+        "validate-versioning": True,
+        "version-tolerant": True,
+    }
+
+    def __init__(self, options: Optional[Dict[str, Any]] = None) -> None:
+        self._data = options.copy() if options else {}
+        self._validate_combinations()
+
+    def __getitem__(self, key: str) -> Any:
+        if key == "head-as-boolean" and self.get("azure-arm"):
+            # override to always true if azure-arm is set
+            return True
+        if key in self._data:
+            retval = self._data[key]
+            if key == "package-files-config":
+                try:
+                    return {k.strip(): v.strip() for k, v in [i.split(":") for i in retval.split("|")]}
+                except AttributeError:
+                    return retval
+            return retval
+        if key == "package-mode" and self._data.get("packaging-files-dir"):
+            # if packaging-files-dir is set, use it as package-mode
+            return self._data["packaging-files-dir"]
+        return self._get_default(key)
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        validated_value = self._validate_and_transform(key, value)
+        self._data[key] = validated_value
+
+    def __delitem__(self, key: str) -> None:
+        if key in self._data:
+            del self._data[key]
+        else:
+            raise KeyError(f"Option '{key}' not found")
+
+    def __iter__(self) -> Iterator[str]:
+        # Return both explicitly set keys and all possible default keys
+        return iter(set(self.keys()))
+
+    def __len__(self) -> int:
+        return len(set(self._data.keys()).union(self.DEFAULTS.keys()))
+
+    def __contains__(self, key: str) -> bool:  # type: ignore
+        return key in self._data or key in self.DEFAULTS
+
+    def __repr__(self) -> str:
+        """String representation."""
+        return f"OptionsDict({dict(self.items())})"
+
+    def _get_default(self, key: str) -> Any:  # pylint: disable=too-many-return-statements
+        if key == "show-operations":
+            return not self.get("low-level-client")
+        if key == "tracing":
+            return self.get("show-operations") and self.get("flavor") == "azure"
+        if key in ["show-send-request", "only-path-and-body-params-positional", "default-optional-constants-to-none"]:
+            return self.get("low-level-client") or self.get("version-tolerant")
+        if key == "combine-operation-files":
+            return self.get("version-tolerant")
+        if key == "package-pprint-name":
+            return " ".join([i.capitalize() for i in str(self.get("package-name", "")).split("-")])
+        if key == "builders-visibility":
+            # Default to public if low-level client is not set, otherwise embedded
+            return "embedded" if not self.get("low-level-client") else "public"
+        if key == "models-mode":
+            models_mode_default = False if self.get("low-level-client") or self.get("version-tolerant") else "msrest"
+            if self.get("tsp_file") is not None:
+                models_mode_default = "dpg"
+            # switch to falsy value for easier code writing
+            return models_mode_default
+        return self.DEFAULTS[key]
+
+    def _validate_combinations(self) -> None:
+        if not self.get("show-operations") and self.get("builders-visibility") == "embedded":
+            raise ValueError(
+                "Can not embed builders without operations. "
+                "Either set --show-operations to True, or change the value of --builders-visibility "
+                "to 'public' or 'hidden'."
+            )
+
+        if self.get("basic-setup-py") and not self.get("package-version"):
+            raise ValueError("--basic-setup-py must be used with --package-version")
+
+        if self.get("package-mode") and not self.get("package-version"):
+            raise ValueError("--package-mode must be used with --package-version")
+
+        if not self.get("show-operations") and self.get("combine-operation-files"):
+            raise ValueError(
+                "Can not combine operation files if you are not showing operations. "
+                "If you want operation files, pass in flag --show-operations"
+            )
+
+        if self.get("multiapi") and self.get("version-tolerant"):
+            raise ValueError(
+                "Can not currently generate version tolerant multiapi SDKs. "
+                "We are working on creating a new multiapi SDK for version tolerant and it is not available yet."
+            )
+
+        if self.get("client-side-validation") and self.get("version-tolerant"):
+            raise ValueError("Can not generate version tolerant with --client-side-validation. ")
+
+        if not (self.get("azure-arm") or self.get("version-tolerant")):
+            _LOGGER.warning(
+                "You are generating with options that would not allow the SDK to be shipped as an official Azure SDK. "
+                "Please read https://aka.ms/azsdk/dpcodegen for more details."
+            )
+
+        if self.get("flavor") != "azure" and self.get("tracing"):
+            raise ValueError("Can only have tracing turned on for Azure SDKs.")
+
+    def _validate_and_transform(self, key: str, value: Any) -> Any:
+        if key == "builders-visibility" and value not in ["public", "hidden", "embedded"]:
+            raise ValueError("The value of --builders-visibility must be either 'public', 'hidden', or 'embedded'")
+
+        if key == "models-mode" and value == "none":
+            value = False  # switch to falsy value for easier code writing
+
+        if key == "models-mode" and value not in ["msrest", "dpg", False]:
+            raise ValueError(
+                "--models-mode can only be 'msrest', 'dpg' or 'none'. "
+                "Pass in 'msrest' if you want msrest models, or "
+                "'none' if you don't want any."
+            )
+        if key == "package-mode":
+            if (
+                (value not in TYPESPEC_PACKAGE_MODE and self.get("from-typespec"))
+                or (value not in VALID_PACKAGE_MODE and not self.get("from-typespec"))
+            ) and not Path(value).exists():
+                raise ValueError(
+                    f"--package-mode can only be {' or '.join(TYPESPEC_PACKAGE_MODE)} or directory which contains template files"  # pylint: disable=line-too-long
+                )
+        return value
+
+    def setdefault(self, key: str, default: Any, /) -> Any:  # type: ignore # pylint: disable=arguments-differ
+        """Set a default value for a key if it does not exist."""
+        if key not in self._data:
+            self[key] = default
+        return self[key]
+
+    def keys(self) -> KeysView[str]:
+        """Return all keys, including defaults."""
+        all_keys = set(self._data.keys())
+        for key in self.DEFAULTS:
+            if key not in all_keys:
+                all_keys.add(key)
+        all_keys.update(self.DEFAULTS.keys())
+        return KeysView({key: None for key in all_keys})
+
+    def values(self) -> ValuesView[Any]:
+        return {key: self[key] for key in self.keys()}.values()  # pylint: disable=consider-using-dict-items
+
+    def items(self) -> ItemsView[str, Any]:
+        return {key: self[key] for key in self.keys()}.items()  # pylint: disable=consider-using-dict-items
+
+
 class ReaderAndWriter:
     def __init__(self, *, output_folder: Union[str, Path], **kwargs: Any) -> None:
         self.output_folder = Path(output_folder)
@@ -31,7 +204,8 @@ class ReaderAndWriter:
                 python_json = json.load(fd)
         except Exception:  # pylint: disable=broad-except
             python_json = {}
-        self.options = kwargs
+        kwargs["output-folder"] = str(self.output_folder)
+        self.options = OptionsDict(kwargs)
         if python_json:
             _LOGGER.warning("Loading python.json file. This behavior will be depreacted")
         self.options.update(python_json)

package/generator/build/lib/pygen/black.py

@@ -21,7 +21,7 @@ _BLACK_MODE.line_length = 120
 class BlackScriptPlugin(Plugin):
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
-        output_folder = self.options.get("output_folder", str(self.output_folder))
+        output_folder = self.options.get("output-folder", str(self.output_folder))
         if output_folder.startswith("file:"):
             output_folder = output_folder[5:]
         if os.name == "nt" and output_folder.startswith("///"):

package/generator/build/lib/pygen/codegen/__init__.py

@@ -4,8 +4,7 @@
 # license information.
 # --------------------------------------------------------------------------
 import logging
-from typing import Dict, Any, Union, Optional
-from pathlib import Path
+from typing import Dict, Any
 import yaml
 
 
@@ -13,223 +12,12 @@ from .. import Plugin
 from ..utils import parse_args
 from .models.code_model import CodeModel
 from .serializers import JinjaSerializer
-from ._utils import VALID_PACKAGE_MODE, TYPESPEC_PACKAGE_MODE
-
-
-def _default_pprint(package_name: str) -> str:
-    return " ".join([i.capitalize() for i in package_name.split("-")])
 
 
 _LOGGER = logging.getLogger(__name__)
 
 
-class OptionsRetriever:
-    OPTIONS_TO_DEFAULT = {
-        "azure-arm": False,
-        "flavor": "azure",  # need to default to azure in shared code so we don't break swagger generation
-        "no-async": False,
-        "low-level-client": False,
-        "version-tolerant": True,
-        "keep-version-file": False,
-        "no-namespace-folders": False,
-        "basic-setup-py": False,
-        "client-side-validation": False,
-        "multiapi": False,
-        "polymorphic-examples": 5,
-        "generate-sample": False,
-        "generate-test": False,
-        "from-typespec": False,
-        "emit-cross-language-definition-file": False,
-    }
-
-    @property
-    def is_azure_flavor(self) -> bool:
-        return self.flavor == "azure"
-
-    def __init__(self, options: Dict[str, Any]) -> None:
-        self.options = options
-
-    def __getattr__(self, prop: str) -> Any:
-        key = prop.replace("_", "-")
-        return self.options.get(key, self.OPTIONS_TO_DEFAULT.get(key))
-
-    @property
-    def show_operations(self) -> bool:
-        return self.options.get("show-operations", not self.low_level_client)
-
-    @property
-    def _models_mode_default(self) -> str:
-        models_mode_default = "none" if self.low_level_client or self.version_tolerant else "msrest"
-        if self.options.get("tsp_file") is not None:
-            models_mode_default = "dpg"
-        return models_mode_default
-
-    @property
-    def original_models_mode(self) -> str:
-        return self.options.get("models-mode", self._models_mode_default)
-
-    @property
-    def models_mode(self) -> Union[str, bool]:
-        # switch to falsy value for easier code writing
-        return False if self.original_models_mode == "none" else self.original_models_mode
-
-    @property
-    def tracing(self) -> bool:
-        return self.options.get(
-            "tracing",
-            self.show_operations and self.is_azure_flavor,
-        )
-
-    @property
-    def show_send_request(self) -> bool:
-        return self.options.get(
-            "show-send-request",
-            self._low_level_or_version_tolerant,
-        )
-
-    @property
-    def _low_level_or_version_tolerant(self) -> bool:
-        return self.low_level_client or self.version_tolerant
-
-    @property
-    def only_path_and_body_params_positional(self) -> bool:
-        return self.options.get(
-            "only-path-and-body-params-positional",
-            self._low_level_or_version_tolerant,
-        )
-
-    @property
-    def combine_operation_files(self) -> bool:
-        return self.options.get(
-            "combine-operation-files",
-            self.version_tolerant,
-        )
-
-    @property
-    def package_pprint_name(self) -> str:
-        return self.options.get("package-pprint-name") or _default_pprint(str(self.package_name))
-
-    @property
-    def validate_versioning(self) -> bool:
-        return self.options.get("validate-versioning", True)
-
-    @property
-    def default_optional_constants_to_none(self) -> bool:
-        return self.options.get(
-            "default-optional-constants-to-none",
-            self._low_level_or_version_tolerant,
-        )
-
-    @property
-    def builders_visibility(self) -> str:
-        builders_visibility = self.options.get("builders-visibility")
-        if builders_visibility is None:
-            return "public" if self.low_level_client else "embedded"
-        return builders_visibility.lower()
-
-    @property
-    def head_as_boolean(self) -> bool:
-        head_as_boolean = self.options.get("head-as-boolean", True)
-        # Force some options in ARM MODE
-        return True if self.azure_arm else head_as_boolean
-
-    @property
-    def package_mode(self) -> str:
-        return self.options.get("packaging-files-dir") or self.options.get("package-mode", "")
-
-    @property
-    def packaging_files_config(self) -> Optional[Dict[str, Any]]:
-        packaging_files_config = self.options.get("packaging-files-config")
-        if packaging_files_config is None:
-            return None
-        # packaging-files-config is either a string or a dict
-        # if it's a string, we can split on the comma to get the dict
-        # otherwise we just return
-        try:
-            return {k.strip(): v.strip() for k, v in [i.split(":") for i in packaging_files_config.split("|")]}
-        except AttributeError:
-            return packaging_files_config
-
-    @property
-    def package_version(self) -> Optional[str]:
-        return str(self.options.get("package-version", ""))
-
-    @property
-    def header_text(self) -> Optional[str]:
-        return self.options.get("header-text")
-
-
 class CodeGenerator(Plugin):
-    def __init__(self, *args, **kwargs: Any) -> None:
-        super().__init__(*args, **kwargs)
-        self.options_retriever = OptionsRetriever(self.options)
-
-    def _validate_code_model_options(self) -> None:
-        if self.options_retriever.builders_visibility not in [
-            "public",
-            "hidden",
-            "embedded",
-        ]:
-            raise ValueError("The value of --builders-visibility must be either 'public', 'hidden', or 'embedded'")
-
-        if self.options_retriever.original_models_mode not in ["msrest", "dpg", "none"]:
-            raise ValueError(
-                "--models-mode can only be 'msrest', 'dpg' or 'none'. "
-                "Pass in 'msrest' if you want msrest models, or "
-                "'none' if you don't want any."
-            )
-
-        if not self.options_retriever.show_operations and self.options_retriever.builders_visibility == "embedded":
-            raise ValueError(
-                "Can not embed builders without operations. "
-                "Either set --show-operations to True, or change the value of --builders-visibility "
-                "to 'public' or 'hidden'."
-            )
-
-        if self.options_retriever.basic_setup_py and not self.options_retriever.package_version:
-            raise ValueError("--basic-setup-py must be used with --package-version")
-
-        if self.options_retriever.package_mode and not self.options_retriever.package_version:
-            raise ValueError("--package-mode must be used with --package-version")
-
-        if not self.options_retriever.show_operations and self.options_retriever.combine_operation_files:
-            raise ValueError(
-                "Can not combine operation files if you are not showing operations. "
-                "If you want operation files, pass in flag --show-operations"
-            )
-
-        if self.options_retriever.package_mode:
-            if (
-                (
-                    self.options_retriever.package_mode not in TYPESPEC_PACKAGE_MODE
-                    and self.options_retriever.from_typespec
-                )
-                or (
-                    self.options_retriever.package_mode not in VALID_PACKAGE_MODE
-                    and not self.options_retriever.from_typespec
-                )
-            ) and not Path(self.options_retriever.package_mode).exists():
-                raise ValueError(
-                    f"--package-mode can only be {' or '.join(TYPESPEC_PACKAGE_MODE)} or directory which contains template files"  # pylint: disable=line-too-long
-                )
-
-        if self.options_retriever.multiapi and self.options_retriever.version_tolerant:
-            raise ValueError(
-                "Can not currently generate version tolerant multiapi SDKs. "
-                "We are working on creating a new multiapi SDK for version tolerant and it is not available yet."
-            )
-
-        if self.options_retriever.client_side_validation and self.options_retriever.version_tolerant:
-            raise ValueError("Can not generate version tolerant with --client-side-validation. ")
-
-        if not (self.options_retriever.azure_arm or self.options_retriever.version_tolerant):
-            _LOGGER.warning(
-                "You are generating with options that would not allow the SDK to be shipped as an official Azure SDK. "
-                "Please read https://aka.ms/azsdk/dpcodegen for more details."
-            )
-
-        if not self.options_retriever.is_azure_flavor and self.options_retriever.tracing:
-            raise ValueError("Can only have tracing turned on for Azure SDKs.")
 
     @staticmethod
     def sort_exceptions(yaml_data: Dict[str, Any]) -> None:
@@ -272,43 +60,6 @@ class CodeGenerator(Plugin):
                     del yaml_data["schemas"]["objects"][i]
                     break
 
-    def _build_code_model_options(self) -> Dict[str, Any]:
-        flags = [
-            "azure_arm",
-            "head_as_boolean",
-            "header_text",
-            "keep_version_file",
-            "no_async",
-            "no_namespace_folders",
-            "basic_setup_py",
-            "package_name",
-            "package_version",
-            "client_side_validation",
-            "tracing",
-            "multiapi",
-            "polymorphic_examples",
-            "models_mode",
-            "builders_visibility",
-            "show_operations",
-            "show_send_request",
-            "only_path_and_body_params_positional",
-            "version_tolerant",
-            "low_level_client",
-            "combine_operation_files",
-            "package_mode",
-            "package_pprint_name",
-            "packaging_files_config",
-            "default_optional_constants_to_none",
-            "generate_sample",
-            "generate_test",
-            "default_api_version",
-            "from_typespec",
-            "flavor",
-            "emit_cross_language_definition_file",
-            "validate_versioning",
-        ]
-        return {f: getattr(self.options_retriever, f) for f in flags}
-
     def get_yaml(self) -> Dict[str, Any]:
         # tsp file doesn't have to be relative to output folder
         with open(self.options["tsp_file"], "r", encoding="utf-8-sig") as fd:
@@ -319,21 +70,18 @@ class CodeGenerator(Plugin):
 
     def process(self) -> bool:
         # List the input file, should be only one
-        self._validate_code_model_options()
-        options = self._build_code_model_options()
         yaml_data = self.get_yaml()
 
         self.sort_exceptions(yaml_data)
 
-        if self.options_retriever.azure_arm:
+        if self.options["azure-arm"]:
             self.remove_cloud_errors(yaml_data)
 
-        code_model = CodeModel(yaml_data=yaml_data, options=options)
-        if not self.options_retriever.is_azure_flavor and any(client.lro_operations for client in code_model.clients):
+        code_model = CodeModel(yaml_data=yaml_data, options=self.options)
+        if self.options["flavor"] != "azure" and any(client.lro_operations for client in code_model.clients):
             raise ValueError("Only support LROs for Azure SDKs")
         serializer = self.get_serializer(code_model)
         serializer.serialize()
-
         return True
 
 

package/generator/build/lib/pygen/codegen/_utils.py

@@ -35,9 +35,6 @@ DEFAULT_LICENSE_DESCRIPTION = (
     "SOFTWARE."
 )
 
-SWAGGER_PACKAGE_MODE = ["mgmtplane", "dataplane"]  # for backward compatibility
-TYPESPEC_PACKAGE_MODE = ["azure-mgmt", "azure-dataplane", "generic"]
-VALID_PACKAGE_MODE = SWAGGER_PACKAGE_MODE + TYPESPEC_PACKAGE_MODE
 NAME_LENGTH_LIMIT = 40
 
 

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

@@ -165,7 +165,7 @@ def build_type(yaml_data: Dict[str, Any], code_model: CodeModel) -> BaseType:
     response: Optional[BaseType] = None
     if yaml_data["type"] == "model":
         # need to special case model to avoid recursion
-        if yaml_data["base"] == "json" or not code_model.options["models_mode"]:
+        if yaml_data["base"] == "json" or not code_model.options["models-mode"]:
             model_type = JSONModelType
         elif yaml_data["base"] == "dpg":
             model_type = DPGModelType  # type: ignore

package/generator/build/lib/pygen/codegen/models/base_builder.py

@@ -75,7 +75,7 @@ class BaseBuilder(
         self.external_docs: Optional[Dict[str, Any]] = yaml_data.get("externalDocs")
         self.client_namespace: str = yaml_data.get("clientNamespace", code_model.namespace)
 
-        if code_model.options["version_tolerant"] and yaml_data.get("abstract"):
+        if code_model.options["version-tolerant"] and yaml_data.get("abstract"):
             _LOGGER.warning(
                 'Not going to generate operation "%s" because we are unable to generate this '
                 "type of operation right now. "

package/generator/build/lib/pygen/codegen/models/client.py

@@ -70,7 +70,7 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):  # pylint: disable=t
         self.config = Config.from_yaml(yaml_data, self.code_model)
         self.is_subclient = is_subclient
         self.request_builders = self._build_request_builders()
-        if self.code_model.options["show_operations"]:
+        if self.code_model.options["show-operations"]:
             self.operation_groups = [
                 OperationGroup.from_yaml(op_group, code_model, self)
                 for op_group in self.yaml_data.get("operationGroups", [])
@@ -91,7 +91,7 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):  # pylint: disable=t
     @property
     def need_cloud_setting(self) -> bool:
         return bool(
-            self.code_model.options.get("azure_arm", False)
+            self.code_model.options.get("azure-arm", False)
             and self.credential_scopes is not None
             and self.endpoint_parameter is not None
         )
@@ -144,7 +144,7 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):  # pylint: disable=t
         return request_builders
 
     def pipeline_class(self, async_mode: bool) -> str:
-        if self.code_model.options["azure_arm"]:
+        if self.code_model.options["azure-arm"]:
             if async_mode:
                 return "AsyncARMPipelineClient"
             return "ARMPipelineClient"
@@ -160,7 +160,7 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):  # pylint: disable=t
     @property
     def send_request_name(self) -> str:
         """Name of the send request function"""
-        return "send_request" if self.code_model.options["show_send_request"] else "_send_request"
+        return "send_request" if self.code_model.options["show-send-request"] else "_send_request"
 
     @property
     def has_parameterized_host(self) -> bool:
@@ -186,7 +186,7 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):  # pylint: disable=t
     @property
     def filename(self) -> str:
         """Name of the file for the client"""
-        if self.code_model.options["version_tolerant"] or self.code_model.options["low_level_client"]:
+        if self.code_model.options["version-tolerant"] or self.code_model.options["low-level-client"]:
             return "_client"
         return f"_{self.legacy_filename}"
 
@@ -206,7 +206,7 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):  # pylint: disable=t
     def _imports_shared(self, async_mode: bool, **kwargs) -> FileImport:
         file_import = FileImport(self.code_model)
         file_import.add_submodule_import("typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL)
-        if self.code_model.options["azure_arm"]:
+        if self.code_model.options["azure-arm"]:
             file_import.add_submodule_import("azure.mgmt.core", self.pipeline_class(async_mode), ImportType.SDKCORE)
         else:
             file_import.add_submodule_import(
@@ -241,7 +241,7 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):  # pylint: disable=t
             "policies",
             ImportType.SDKCORE,
         )
-        if self.code_model.options["azure_arm"]:
+        if self.code_model.options["azure-arm"]:
             async_prefix = "Async" if async_mode else ""
             file_import.add_submodule_import(
                 "azure.mgmt.core.policies",
@@ -331,10 +331,10 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):  # pylint: disable=t
                 ImportType.LOCAL,
             )
 
-        if self.code_model.model_types and self.code_model.options["models_mode"] == "msrest":
+        if self.code_model.model_types and self.code_model.options["models-mode"] == "msrest":
             path_to_models = ".." if async_mode else "."
             file_import.add_submodule_import(path_to_models, "models", ImportType.LOCAL, alias="_models")
-        elif self.code_model.options["models_mode"] == "msrest":
+        elif self.code_model.options["models-mode"] == "msrest":
             # in this case, we have client_models = {} in the service client, which needs a type annotation
             # this import will always be commented, so will always add it to the typing section
             file_import.add_submodule_import("typing", "Dict", ImportType.STDLIB)
@@ -404,7 +404,7 @@ class Config(_ClientConfigBase[ConfigGlobalParameterList]):
 
     @property
     def sdk_moniker(self) -> str:
-        package_name = self.code_model.options["package_name"]
+        package_name = self.code_model.options.get("package-name")
         if package_name and package_name.startswith("azure-"):
             package_name = package_name[len("azure-") :]
         return package_name if package_name else self.yaml_data["name"].lower()
@@ -421,14 +421,14 @@ class Config(_ClientConfigBase[ConfigGlobalParameterList]):
             ImportType.SDKCORE,
         )
         file_import.add_submodule_import("typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL)
-        if self.code_model.options["package_version"]:
+        if self.code_model.options.get("package-version"):
             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="_version"),
                 "VERSION",
                 ImportType.LOCAL,
             )
-        if self.code_model.options["azure_arm"]:
+        if self.code_model.options["azure-arm"]:
             policy = "AsyncARMChallengeAuthenticationPolicy" if async_mode else "ARMChallengeAuthenticationPolicy"
             file_import.add_submodule_import("azure.mgmt.core.policies", "ARMHttpLoggingPolicy", ImportType.SDKCORE)
             file_import.add_submodule_import("azure.mgmt.core.policies", policy, ImportType.SDKCORE)