@autorest/python 6.9.6 → 6.9.8

package/autorest/codegen/__init__.py

@@ -4,7 +4,7 @@
 # license information.
 # --------------------------------------------------------------------------
 import logging
-from typing import Dict, Any, Union
+from typing import Dict, Any, Union, Optional
 from pathlib import Path
 import yaml
 
@@ -48,10 +48,8 @@ class OptionsRetriever:
         return self.options.get(key, self.OPTIONS_TO_DEFAULT.get(key))
 
     @property
-    def company_name(self) -> bool:
-        return self.options.get(
-            "company-name", "Microsoft" if not self.unbranded else ""
-        )
+    def company_name(self) -> str:
+        return self.options.get("company-name", "" if self.unbranded else "Microsoft")
 
     @property
     def license_header(self) -> str:
@@ -152,6 +150,28 @@ class OptionsRetriever:
         # 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
+
 
 class CodeGenerator(Plugin):
     def __init__(self, *args, **kwargs: Any) -> None:
@@ -275,7 +295,6 @@ class CodeGenerator(Plugin):
                     break
 
     def _build_code_model_options(self) -> Dict[str, Any]:
-        """Build en options dict from the user input while running autorest."""
         flags = [
             "azure_arm",
             "head_as_boolean",
@@ -300,7 +319,7 @@ class CodeGenerator(Plugin):
             "combine_operation_files",
             "package_mode",
             "package_pprint_name",
-            "package_configuration",
+            "packaging_files_config",
             "default_optional_constants_to_none",
             "generate_sample",
             "default_api_version",
@@ -399,7 +418,7 @@ class CodeGeneratorAutorest(CodeGenerator, PluginAutorest):
             ),
             "package-mode": self._autorestapi.get_value("package-mode"),
             "package-pprint-name": self._autorestapi.get_value("package-pprint-name"),
-            "package-configuration": self._autorestapi.get_value(
+            "packaging-files-config": self._autorestapi.get_value(
                 "package-configuration"
             ),
             "default-optional-constants-to-none": self._autorestapi.get_boolean_value(

package/autorest/codegen/models/base.py

@@ -31,9 +31,6 @@ class BaseModel:
     def __repr__(self):
         return f"<{self.__class__.__name__}>"
 
-    def init_file_import(self) -> FileImport:
-        return FileImport(self.code_model)
-
 
 class BaseType(BaseModel, ABC):  # pylint: disable=too-many-public-methods
     """This is the base class for all types.
@@ -56,13 +53,13 @@ class BaseType(BaseModel, ABC):  # pylint: disable=too-many-public-methods
         return cls(yaml_data=yaml_data, code_model=code_model)
 
     def imports(self, **kwargs) -> FileImport:  # pylint: disable=unused-argument
-        return self.init_file_import()
+        return FileImport(self.code_model)
 
     def imports_for_multiapi(self, **kwargs: Any) -> FileImport:
         return self.imports(**kwargs)
 
     def imports_for_sample(self) -> FileImport:
-        return self.init_file_import()
+        return self.imports()
 
     @staticmethod
     def serialize_sample_value(value: Any) -> str:

package/autorest/codegen/models/client.py

@@ -195,7 +195,7 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
             raise KeyError(f"No operation with id {operation_id} found.") from exc
 
     def _imports_shared(self, async_mode: bool) -> FileImport:
-        file_import = self.init_file_import()
+        file_import = FileImport(self.code_model)
         file_import.add_submodule_import(
             "typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL
         )
@@ -205,7 +205,7 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
             )
         else:
             file_import.add_submodule_import(
-                file_import.import_core_pipeline_client,
+                "runtime" if self.code_model.options["unbranded"] else "",
                 self.pipeline_class(async_mode),
                 ImportType.SDKCORE,
             )
@@ -231,7 +231,9 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
             typing_section=TypingSection.REGULAR,
         )
         file_import.add_submodule_import(
-            file_import.import_core_policies, "policies", ImportType.SDKCORE
+            "runtime" if self.code_model.options["unbranded"] else "pipeline",
+            "policies",
+            ImportType.SDKCORE,
         )
         if self.code_model.options["azure_arm"]:
             async_prefix = "Async" if async_mode else ""
@@ -300,20 +302,20 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
         if async_mode:
             file_import.add_submodule_import("typing", "Awaitable", ImportType.STDLIB)
             file_import.add_submodule_import(
-                file_import.import_core_rest,
+                "rest",
                 "AsyncHttpResponse",
                 ImportType.SDKCORE,
                 TypingSection.CONDITIONAL,
             )
         else:
             file_import.add_submodule_import(
-                file_import.import_core_rest,
+                "rest",
                 "HttpResponse",
                 ImportType.SDKCORE,
                 TypingSection.CONDITIONAL,
             )
         file_import.add_submodule_import(
-            file_import.import_core_rest,
+            "rest",
             "HttpRequest",
             ImportType.SDKCORE,
             TypingSection.CONDITIONAL,
@@ -412,9 +414,11 @@ class Config(_ClientConfigBase[ConfigGlobalParameterList]):
         return f"{super().name}Configuration"
 
     def _imports_shared(self, async_mode: bool) -> FileImport:
-        file_import = self.init_file_import()
+        file_import = FileImport(self.code_model)
         file_import.add_submodule_import(
-            file_import.import_core_policies, "policies", ImportType.SDKCORE
+            "runtime" if self.code_model.options["unbranded"] else "pipeline",
+            "policies",
+            ImportType.SDKCORE,
         )
         file_import.add_submodule_import(
             "typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL

package/autorest/codegen/models/code_model.py

@@ -3,7 +3,7 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import List, Dict, Any, Set, Union
+from typing import List, Dict, Any, Set, Union, Literal
 
 from .base import BaseType
 from .enum_type import EnumType
@@ -202,6 +202,10 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
         """All of the enums"""
         return [t for t in self.types_map.values() if isinstance(t, EnumType)]
 
+    @property
+    def core_library(self) -> Literal["azure.core", "corehttp"]:
+        return "azure.core" if not self.options["unbranded"] else "corehttp"
+
     def _sort_model_types_helper(
         self,
         current: ModelType,

package/autorest/codegen/models/combined_type.py

@@ -103,7 +103,7 @@ class CombinedType(BaseType):
         raise ValueError("You shouldn't do instance checks on a multiple type")
 
     def imports(self, **kwargs: Any) -> FileImport:
-        file_import = self.init_file_import()
+        file_import = FileImport(self.code_model)
         if self.name and not kwargs.get("is_types_file"):
             file_import.add_submodule_import(
                 kwargs.pop("relative_path"),

package/autorest/codegen/models/constant_type.py

@@ -124,7 +124,7 @@ class ConstantType(BaseType):
         )
 
     def _imports_shared(self, **kwargs: Any):
-        file_import = self.init_file_import()
+        file_import = super().imports(**kwargs)
         file_import.merge(self.value_type.imports(**kwargs))
         return file_import
 

package/autorest/codegen/models/credential_types.py

@@ -86,9 +86,9 @@ class KeyCredentialPolicyType(_CredentialPolicyBaseType):
     @property
     def credential_name(self) -> str:
         return (
-            "AzureKeyCredential"
-            if not self.code_model.options["unbranded"]
-            else "ServiceKeyCredential"
+            "ServiceKeyCredential"
+            if self.code_model.options["unbranded"]
+            else "AzureKeyCredential"
         )
 
     def call(self, async_mode: bool) -> str:
@@ -186,23 +186,31 @@ class TokenCredentialType(
     def type_description(self) -> str:
         return "TokenCredential"
 
+    @property
+    def credentials_subfolder(self) -> str:
+        return (
+            "credentials"
+            if self.code_model.options["unbranded"]
+            else "credentials_async"
+        )
+
     def docstring_type(self, **kwargs: Any) -> str:
         if kwargs.get("async_mode"):
-            return f"~{self.init_file_import().import_core_credentials_async}.AsyncTokenCredential"
-        return f"~{self.init_file_import().import_core_credentials}.TokenCredential"
+            return f"~{self.code_model.core_library}.{self.credentials_subfolder}.AsyncTokenCredential"
+        return f"~{self.code_model.core_library}.credentials.TokenCredential"
 
     def imports(self, **kwargs: Any) -> FileImport:
-        file_import = self.init_file_import()
+        file_import = super().imports(**kwargs)
         if kwargs.get("async_mode"):
             file_import.add_submodule_import(
-                file_import.import_core_credentials_async,
+                self.credentials_subfolder,
                 "AsyncTokenCredential",
                 ImportType.SDKCORE,
                 typing_section=TypingSection.TYPING,
             )
         else:
             file_import.add_submodule_import(
-                file_import.import_core_credentials,
+                "credentials",
                 "TokenCredential",
                 ImportType.SDKCORE,
                 typing_section=TypingSection.TYPING,
@@ -221,7 +229,9 @@ class KeyCredentialType(
     """Type for an KeyCredential"""
 
     def docstring_type(self, **kwargs: Any) -> str:  # pylint: disable=unused-argument
-        return f"~{self.init_file_import().import_core}.credentials.{self.policy.credential_name}"
+        return (
+            f"~{self.code_model.core_library}.credentials.{self.policy.credential_name}"
+        )
 
     def type_annotation(self, **kwargs: Any) -> str:  # pylint: disable=unused-argument
         return self.policy.credential_name
@@ -231,9 +241,9 @@ class KeyCredentialType(
         return "isinstance({}, " + f"{self.policy.credential_name})"
 
     def imports(self, **kwargs: Any) -> FileImport:  # pylint: disable=unused-argument
-        file_import = self.init_file_import()
+        file_import = super().imports(**kwargs)
         file_import.add_submodule_import(
-            f"{file_import.import_core}.credentials",
+            "credentials",
             self.policy.credential_name,
             ImportType.SDKCORE,
             typing_section=TypingSection.CONDITIONAL,

package/autorest/codegen/models/dictionary_type.py

@@ -123,7 +123,7 @@ class DictionaryType(BaseType):
         )
 
     def imports(self, **kwargs: Any) -> FileImport:
-        file_import = self.init_file_import()
+        file_import = FileImport(self.code_model)
         file_import.add_submodule_import(
             "typing", "Dict", ImportType.STDLIB, TypingSection.CONDITIONAL
         )

package/autorest/codegen/models/enum_type.py

@@ -76,7 +76,7 @@ class EnumValue(BaseType):
         return self.value_type.instance_check_template
 
     def imports(self, **kwargs: Any) -> FileImport:
-        file_import = self.init_file_import()
+        file_import = FileImport(self.code_model)
         file_import.merge(self.value_type.imports(**kwargs))
         file_import.add_literal_import()
         file_import.add_submodule_import(
@@ -230,7 +230,7 @@ class EnumType(BaseType):
 
     def imports(self, **kwargs: Any) -> FileImport:
         operation = kwargs.pop("operation", False)
-        file_import = self.init_file_import()
+        file_import = FileImport(self.code_model)
         if self.code_model.options["models_mode"]:
             file_import.add_submodule_import(
                 "typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL

package/autorest/codegen/models/imports.py

@@ -11,6 +11,10 @@ if TYPE_CHECKING:
 
 
 class ImportType(str, Enum):
+    """
+    Ordering of these enum matters. We order import groupings in a file based off of this ordering.
+    """
+
     STDLIB = "stdlib"
     THIRDPARTY = "thirdparty"
     SDKCORE = "sdkcore"
@@ -87,14 +91,27 @@ class TypeDefinition:
         self.async_definition = async_definition
 
 
-class FileImport:  # pylint: disable=too-many-public-methods
+class FileImport:
     def __init__(self, code_model: "CodeModel") -> None:
         self.imports: List[ImportModel] = []
         self.code_model = code_model
         # has sync and async type definitions
         self.type_definitions: Dict[str, TypeDefinition] = {}
+        self.core_library = self.code_model.core_library
 
     def _append_import(self, import_model: ImportModel) -> None:
+        if import_model.import_type == ImportType.SDKCORE:
+            mod_name = import_model.module_name
+            core_libraries = [
+                self.code_model.core_library,
+                "azure",
+                "msrest",
+            ]
+            if all(l not in mod_name for l in core_libraries):
+                # this is to make sure we don't tack on core libraries when we don't need to
+                import_model.module_name = (
+                    f"{self.code_model.core_library}{'.' if mod_name else ''}{mod_name}"
+                )
         if not any(
             i
             for i in self.imports
@@ -312,71 +329,3 @@ class FileImport:  # pylint: disable=too-many-public-methods
                         ImportType.LOCAL,
                         typing_section,
                     )
-
-    @property
-    def import_core(self) -> str:
-        return "azure.core" if not self.code_model.options["unbranded"] else "corehttp"
-
-    @property
-    def import_core_exceptions(self) -> str:
-        return f"{self.import_core}.exceptions"
-
-    @property
-    def import_core_rest(self) -> str:
-        return f"{self.import_core}.rest"
-
-    @property
-    def import_core_credentials(self) -> str:
-        return f"{self.import_core}.credentials"
-
-    @property
-    def import_core_credentials_async(self) -> str:
-        return self.import_core + (
-            ".credentials_async"
-            if not self.code_model.options["unbranded"]
-            else ".credentials"
-        )
-
-    @property
-    def import_core_paging(self) -> str:
-        return f"{self.import_core}.paging"
-
-    @property
-    def import_core_paging_async(self) -> str:
-        return self.import_core + (
-            ".async_paging" if not self.code_model.options["unbranded"] else ".paging"
-        )
-
-    @property
-    def import_core_utils(self) -> str:
-        return f"{self.import_core}.utils"
-
-    @property
-    def import_core_case_insensitive_enum(self) -> str:
-        return self.import_core + (
-            "" if not self.code_model.options["unbranded"] else ".utils"
-        )
-
-    @property
-    def import_core_pipeline(self) -> str:
-        return self.import_core + (
-            ".pipeline"
-            if not self.code_model.options["unbranded"]
-            else ".runtime.pipeline"
-        )
-
-    @property
-    def import_core_policies(self) -> str:
-        return self.import_core + (
-            ".pipeline" if not self.code_model.options["unbranded"] else ".runtime"
-        )
-
-    @property
-    def import_core_serialization(self) -> str:
-        return f"{self.import_core}.serialization"
-
-    @property
-    def import_core_pipeline_client(self) -> str:
-        return self.import_core + (
-            "" if not self.code_model.options["unbranded"] else ".runtime"
-        )

package/autorest/codegen/models/list_type.py

@@ -146,7 +146,7 @@ class ListType(BaseType):
         )
 
     def imports(self, **kwargs: Any) -> FileImport:
-        file_import = self.init_file_import()
+        file_import = FileImport(self.code_model)
         if not (
             self.code_model.options["version_tolerant"]
             and self.element_type.is_xml

package/autorest/codegen/models/model_type.py

@@ -268,7 +268,7 @@ class JSONModelType(ModelType):
         return "isinstance({}, MutableMapping)"
 
     def imports(self, **kwargs: Any) -> FileImport:
-        file_import = self.init_file_import()
+        file_import = FileImport(self.code_model)
         file_import.add_submodule_import(
             "typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL
         )

package/autorest/codegen/models/operation.py

@@ -230,7 +230,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods
     def _imports_shared(
         self, async_mode: bool, **kwargs: Any  # pylint: disable=unused-argument
     ) -> FileImport:
-        file_import = self.init_file_import()
+        file_import = FileImport(self.code_model)
         file_import.add_submodule_import(
             "typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL
         )
@@ -308,7 +308,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods
         async_mode: bool,
     ) -> FileImport:
         """Helper method to get a request builder import."""
-        file_import = self.init_file_import()
+        file_import = FileImport(self.code_model)
         if self.code_model.options["builders_visibility"] != "embedded":
             group_name = request_builder.group_name
             rest_import_path = "..." if async_mode else ".."
@@ -338,7 +338,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods
         self, async_mode: bool, **kwargs: Any
     ) -> FileImport:
         if self.abstract:
-            return self.init_file_import()
+            return FileImport(self.code_model)
         file_import = self._imports_shared(async_mode, **kwargs)
 
         for param in self.parameters.method:
@@ -378,9 +378,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods
             "ResourceNotModifiedError",
         ]
         for error in errors:
-            file_import.add_submodule_import(
-                file_import.import_core_exceptions, error, ImportType.SDKCORE
-            )
+            file_import.add_submodule_import("exceptions", error, ImportType.SDKCORE)
         if self.code_model.options["azure_arm"]:
             file_import.add_submodule_import(
                 "azure.mgmt.core.exceptions", "ARMErrorFormat", ImportType.SDKCORE
@@ -392,7 +390,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods
             self.parameters.kwargs_to_pop, ParameterLocation.QUERY  # type: ignore
         ):
             file_import.add_submodule_import(
-                file_import.import_core_utils,
+                "utils",
                 "case_insensitive_dict",
                 ImportType.SDKCORE,
             )
@@ -406,7 +404,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods
             )
         if self.has_etag:
             file_import.add_submodule_import(
-                file_import.import_core_exceptions,
+                "exceptions",
                 "ResourceModifiedError",
                 ImportType.SDKCORE,
             )
@@ -433,13 +431,13 @@ class OperationBase(  # pylint: disable=too-many-public-methods
         else:
             if async_mode:
                 file_import.add_submodule_import(
-                    file_import.import_core_rest,
+                    "rest",
                     "AsyncHttpResponse",
                     ImportType.SDKCORE,
                 )
             else:
                 file_import.add_submodule_import(
-                    file_import.import_core_rest,
+                    "rest",
                     "HttpResponse",
                     ImportType.SDKCORE,
                 )
@@ -449,13 +447,11 @@ class OperationBase(  # pylint: disable=too-many-public-methods
         ):
             file_import.merge(self.request_builder.imports())
         file_import.add_submodule_import(
-            file_import.import_core_pipeline,
+            f"{'runtime.' if self.code_model.options['unbranded'] else ''}pipeline",
             "PipelineResponse",
             ImportType.SDKCORE,
         )
-        file_import.add_submodule_import(
-            file_import.import_core_rest, "HttpRequest", ImportType.SDKCORE
-        )
+        file_import.add_submodule_import("rest", "HttpRequest", ImportType.SDKCORE)
         file_import.add_submodule_import(
             "typing", "Callable", ImportType.STDLIB, TypingSection.CONDITIONAL
         )
@@ -576,7 +572,7 @@ class Operation(OperationBase[Response]):
             relative_path = "..." if async_mode else ".."
             if self.parameters.has_body:
                 file_import.add_submodule_import(
-                    f"{relative_path}_model_base", "AzureJSONEncoder", ImportType.LOCAL
+                    f"{relative_path}_model_base", "SdkJSONEncoder", ImportType.LOCAL
                 )
                 file_import.add_import("json", ImportType.STDLIB)
             if self.default_error_deserialization or any(

package/autorest/codegen/models/operation_group.py

@@ -48,7 +48,7 @@ class OperationGroup(BaseModel):
         return ", ".join(base_classes)
 
     def imports_for_multiapi(self, async_mode: bool) -> FileImport:
-        file_import = self.init_file_import()
+        file_import = FileImport(self.code_model)
         relative_path = ".." if async_mode else "."
         for operation in self.operations:
             file_import.merge(
@@ -79,7 +79,7 @@ class OperationGroup(BaseModel):
         return any(o for o in self.operations if o.need_validation)
 
     def imports(self, async_mode: bool) -> FileImport:
-        file_import = self.init_file_import()
+        file_import = FileImport(self.code_model)
 
         relative_path = ("..." if async_mode else "..") + (
             "." if self.client.is_subclient else ""

package/autorest/codegen/models/paging_operation.py

@@ -62,11 +62,11 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
         self.override_success_response_to_200 = override_success_response_to_200
         self.pager_sync: str = (
             yaml_data.get("pagerSync")
-            or f"{self.init_file_import().import_core_paging}.ItemPaged"
+            or f"{self.code_model.core_library}.paging.ItemPaged"
         )
         self.pager_async: str = (
             yaml_data.get("pagerAsync")
-            or f"{self.init_file_import().import_core_paging_async}.AsyncItemPaged"
+            or f"{self.code_model.core_library}.paging.AsyncItemPaged"
         )
 
     def _get_attr_name(self, wire_name: str) -> str:
@@ -150,7 +150,7 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
 
     def imports(self, async_mode: bool, **kwargs: Any) -> FileImport:
         if self.abstract:
-            return self.init_file_import()
+            return FileImport(self.code_model)
         file_import = self._imports_shared(async_mode, **kwargs)
         file_import.merge(super().imports(async_mode, **kwargs))
         if self.code_model.options["tracing"] and self.want_tracing:
@@ -166,7 +166,7 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
         elif any(p.is_api_version for p in self.client.parameters):
             file_import.add_import("urllib.parse", ImportType.STDLIB)
             file_import.add_submodule_import(
-                file_import.import_core_utils,
+                "utils",
                 "case_insensitive_dict",
                 ImportType.SDKCORE,
             )

package/autorest/codegen/models/parameter.py

@@ -168,7 +168,7 @@ class _ParameterBase(
         return self.type.serialization_type
 
     def _imports_shared(self, async_mode: bool, **_: Any) -> FileImport:
-        file_import = self.init_file_import()
+        file_import = FileImport(self.code_model)
         if self.optional and self.client_default_value is None:
             file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB)
         if self.added_on: