@autorest/python 6.13.2 → 6.13.4

package/autorest/_utils.py

@@ -121,9 +121,13 @@ JSON_REGEXP = re.compile(r"^(application|text)/(.+\+)?json$")
 
 
 def build_policies(
-    is_arm: bool, async_mode: bool, unbranded: bool = False, tracing: bool = True
+    is_arm: bool,
+    async_mode: bool,
+    *,
+    is_azure_flavor: bool = False,
+    tracing: bool = True,
 ) -> List[str]:
-    if not unbranded:
+    if is_azure_flavor:
         # for Azure
         async_prefix = "Async" if async_mode else ""
         policies = [

package/autorest/codegen/__init__.py

@@ -26,7 +26,7 @@ _LOGGER = logging.getLogger(__name__)
 class OptionsRetriever:
     OPTIONS_TO_DEFAULT = {
         "azure-arm": False,
-        "unbranded": 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,
@@ -40,6 +40,10 @@ class OptionsRetriever:
         "from-typespec": False,
     }
 
+    @property
+    def is_azure_flavor(self) -> bool:
+        return self.flavor == "azure"
+
     def __init__(self, options: Dict[str, Any]) -> None:
         self.options = options
 
@@ -49,15 +53,17 @@ class OptionsRetriever:
 
     @property
     def company_name(self) -> str:
-        return self.options.get("company-name", "" if self.unbranded else "Microsoft")
+        return self.options.get(
+            "company-name", "Microsoft" if self.is_azure_flavor else ""
+        )
 
     @property
     def license_header(self) -> str:
         license_header = self.options.get(
             "header-text",
-            ""
-            if self.unbranded and not self.company_name
-            else DEFAULT_HEADER_TEXT.format(company_name=self.company_name),
+            DEFAULT_HEADER_TEXT.format(company_name=self.company_name)
+            if self.company_name
+            else "",
         )
         if license_header:
             license_header = license_header.replace("\n", "\n# ")
@@ -96,7 +102,7 @@ class OptionsRetriever:
     def tracing(self) -> bool:
         return self.options.get(
             "tracing",
-            self.show_operations and not self.unbranded,
+            self.show_operations and self.is_azure_flavor,
         )
 
     @property
@@ -264,10 +270,11 @@ class CodeGenerator(Plugin):
                 "Please read https://aka.ms/azsdk/dpcodegen for more details."
             )
 
-        if self.options_retriever.unbranded and self.options_retriever.tracing:
-            raise ValueError(
-                "Can not set --unbranded=true and --tracing=true at the same time."
-            )
+        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 remove_cloud_errors(yaml_data: Dict[str, Any]) -> None:
@@ -324,7 +331,7 @@ class CodeGenerator(Plugin):
             "generate_sample",
             "default_api_version",
             "from_typespec",
-            "unbranded",
+            "flavor",
             "company_name",
         ]
         return {f: getattr(self.options_retriever, f) for f in flags}
@@ -347,10 +354,10 @@ class CodeGenerator(Plugin):
             self.remove_cloud_errors(yaml_data)
 
         code_model = CodeModel(yaml_data=yaml_data, options=options)
-        if self.options_retriever.unbranded and any(
+        if not self.options_retriever.is_azure_flavor and any(
             client.lro_operations for client in code_model.clients
         ):
-            raise ValueError("Do not support LRO when --unbranded=true")
+            raise ValueError("Only support LROs for Azure SDKs")
         serializer = self.get_serializer(code_model)
         serializer.serialize()
 

package/autorest/codegen/models/client.py

@@ -214,7 +214,7 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
             )
         else:
             file_import.add_submodule_import(
-                "runtime" if self.code_model.options["unbranded"] else "",
+                "" if self.code_model.is_azure_flavor else "runtime",
                 self.pipeline_class(async_mode),
                 ImportType.SDKCORE,
             )
@@ -240,7 +240,7 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
             typing_section=TypingSection.REGULAR,
         )
         file_import.add_submodule_import(
-            "runtime" if self.code_model.options["unbranded"] else "pipeline",
+            "pipeline" if self.code_model.is_azure_flavor else "runtime",
             "policies",
             ImportType.SDKCORE,
         )
@@ -428,7 +428,7 @@ class Config(_ClientConfigBase[ConfigGlobalParameterList]):
     def _imports_shared(self, async_mode: bool) -> FileImport:
         file_import = FileImport(self.code_model)
         file_import.add_submodule_import(
-            "runtime" if self.code_model.options["unbranded"] else "pipeline",
+            "pipeline" if self.code_model.is_azure_flavor else "runtime",
             "policies",
             ImportType.SDKCORE,
         )

package/autorest/codegen/models/code_model.py

@@ -119,6 +119,10 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
                 pass
         raise KeyError(f"No request builder with id {request_builder_id} found.")
 
+    @property
+    def is_azure_flavor(self) -> bool:
+        return self.options["flavor"] == "azure"
+
     @property
     def rest_layer_name(self) -> str:
         """If we have a separate rest layer, what is its name?"""
@@ -210,7 +214,7 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
 
     @property
     def core_library(self) -> Literal["azure.core", "corehttp"]:
-        return "azure.core" if not self.options["unbranded"] else "corehttp"
+        return "azure.core" if self.is_azure_flavor else "corehttp"
 
     def _sort_model_types_helper(
         self,

package/autorest/codegen/models/credential_types.py

@@ -86,9 +86,9 @@ class KeyCredentialPolicyType(_CredentialPolicyBaseType):
     @property
     def credential_name(self) -> str:
         return (
-            "ServiceKeyCredential"
-            if self.code_model.options["unbranded"]
-            else "AzureKeyCredential"
+            "AzureKeyCredential"
+            if self.code_model.is_azure_flavor
+            else "ServiceKeyCredential"
         )
 
     def call(self, async_mode: bool) -> str:
@@ -188,11 +188,7 @@ class TokenCredentialType(
 
     @property
     def credentials_subfolder(self) -> str:
-        return (
-            "credentials"
-            if self.code_model.options["unbranded"]
-            else "credentials_async"
-        )
+        return "credentials_async" if self.code_model.is_azure_flavor else "credentials"
 
     def docstring_type(self, **kwargs: Any) -> str:
         if kwargs.get("async_mode"):

package/autorest/codegen/models/operation.py

@@ -450,7 +450,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods
         ):
             file_import.merge(self.request_builder.imports())
         file_import.add_submodule_import(
-            f"{'runtime.' if self.code_model.options['unbranded'] else ''}pipeline",
+            f"{'' if self.code_model.is_azure_flavor else 'runtime.'}pipeline",
             "PipelineResponse",
             ImportType.SDKCORE,
         )

package/autorest/codegen/models/response.py

@@ -180,7 +180,7 @@ class PagingResponse(Response):
             or f"{self.code_model.core_library}.paging.ItemPaged"
         )
         default_paging_submodule = (
-            f"{'' if self.code_model.options['unbranded'] else 'async_'}paging"
+            f"{'async_' if self.code_model.is_azure_flavor else ''}paging"
         )
         self.pager_async: str = (
             self.yaml_data.get("pagerAsync")
@@ -231,7 +231,7 @@ class PagingResponse(Response):
         async_mode = kwargs.get("async_mode")
         if async_mode:
             file_import.add_submodule_import(
-                f"{'' if self.code_model.options['unbranded'] else 'async_'}paging",
+                f"{'async_' if self.code_model.is_azure_flavor else ''}paging",
                 "AsyncList",
                 ImportType.SDKCORE,
             )

package/autorest/codegen/serializers/__init__.py

@@ -242,7 +242,7 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
         params = self.code_model.options["packaging_files_config"] or {}
         for template_name in package_files:
             if (
-                self.code_model.options["unbranded"]
+                not self.code_model.is_azure_flavor
                 and template_name == "dev_requirements.txt.jinja2"
             ):
                 continue

package/autorest/codegen/serializers/builder_serializer.py

@@ -451,7 +451,7 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
 
     @property
     def pipeline_name(self) -> str:
-        return f"{'' if self.code_model.options['unbranded'] else '_'}pipeline"
+        return f"{'_' if self.code_model.is_azure_flavor else ''}pipeline"
 
 
 ############################## REQUEST BUILDERS ##############################

package/autorest/codegen/serializers/client_serializer.py

@@ -111,7 +111,7 @@ class ClientSerializer:
         result = []
         pipeline_client_name = self.client.pipeline_class(async_mode)
         endpoint_name = (
-            "endpoint" if self.client.code_model.options["unbranded"] else "base_url"
+            "base_url" if self.client.code_model.is_azure_flavor else "endpoint"
         )
         params = {
             endpoint_name: self.host_variable_name,
@@ -124,8 +124,8 @@ class ClientSerializer:
         policies = build_policies(
             self.client.code_model.options["azure_arm"],
             async_mode,
-            self.client.code_model.options["unbranded"],
-            self.client.code_model.options["tracing"],
+            is_azure_flavor=self.client.code_model.is_azure_flavor,
+            tracing=self.client.code_model.options["tracing"],
         )
         result.extend(
             [

package/autorest/codegen/serializers/general_serializer.py

@@ -107,7 +107,7 @@ class GeneralSerializer(BaseSerializer):
                 ImportType.STDLIB,
             )
             file_import.add_submodule_import(
-                "runtime" if self.code_model.options["unbranded"] else "",
+                "" if self.code_model.is_azure_flavor else "runtime",
                 f"{'Async' if self.async_mode else ''}PipelineClient",
                 ImportType.SDKCORE,
                 TypingSection.TYPING,

package/autorest/codegen/templates/config.py.jinja2

@@ -51,7 +51,7 @@ class {{ client.name }}Configuration:  {{ client.config.pylint_disable }}
         self.headers_policy = kwargs.get('headers_policy') or policies.HeadersPolicy(**kwargs)
         self.proxy_policy = kwargs.get('proxy_policy') or policies.ProxyPolicy(**kwargs)
         self.logging_policy = kwargs.get('logging_policy') or policies.NetworkTraceLoggingPolicy(**kwargs)
-        {% if not code_model.options["unbranded"] %}
+        {% 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.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)

package/autorest/codegen/templates/enum_container.py.jinja2

@@ -2,7 +2,7 @@
 {{ code_model.options['license_header'] }}
 
 from enum import Enum
-from {{ code_model.core_library }}{{ ".utils" if code_model.options["unbranded"] else "" }} import CaseInsensitiveEnumMeta
+from {{ code_model.core_library }}{{ "" if code_model.is_azure_flavor else ".utils" }} import CaseInsensitiveEnumMeta
 
 {% for enum in code_model.enums | sort %}
 {% include "enum.py.jinja2" %}

package/autorest/codegen/templates/model_base.py.jinja2

@@ -22,8 +22,8 @@ from json import JSONEncoder
 from typing_extensions import Self
 import isodate
 from {{ code_model.core_library }}.exceptions import DeserializationError
-from {{ code_model.core_library }}{{ ".utils" if code_model.options["unbranded"] else "" }} import CaseInsensitiveEnumMeta
-from {{ code_model.core_library }}.{{ "runtime." if code_model.options["unbranded"] else "" }}pipeline import PipelineResponse
+from {{ code_model.core_library }}{{ "" if code_model.is_azure_flavor else ".utils" }} import CaseInsensitiveEnumMeta
+from {{ code_model.core_library }}.{{ "" if code_model.is_azure_flavor else "runtime." }}pipeline import PipelineResponse
 from {{ code_model.core_library }}.serialization import _Null
 
 if sys.version_info >= (3, 9):

package/autorest/codegen/templates/packaging_templates/README.md.jinja2

@@ -1,4 +1,4 @@
-{% if not code_model.options["unbranded"] %}
+{% if code_model.is_azure_flavor %}
 {% if package_mode == "mgmtplane" -%}
 # Microsoft Azure SDK for Python
 

package/autorest/codegen/templates/packaging_templates/setup.py.jinja2

@@ -45,7 +45,7 @@ setup(
     license="MIT License",
     author="{{ code_model.options["company_name"] }} Corporation",
     {% endif %}
-    {% if not unbranded %}
+    {% if code_model.is_azure_flavor %}
     author_email="{{ author_email }}",
     url="{{ url }}",
     keywords="azure, azure sdk",
@@ -89,12 +89,12 @@ setup(
         {% else %}
         "isodate<1.0.0,>=0.6.1",
         {% endif %}
-        {% if unbranded %}
-        "corehttp[requests]",
-        {% elif azure_arm %}
+        {% if azure_arm %}
         "azure-mgmt-core<2.0.0,>=1.3.2",
-        {% else %}
+        {% elif code_model.is_azure_flavor %}
         "azure-core<2.0.0,>=1.30.0",
+        {% else %}
+        "corehttp[requests]",
         {% endif %}
         {% if code_model.need_typing_extensions %}
         "typing-extensions>=4.6.0",

package/autorest/codegen/templates/vendor.py.jinja2

@@ -65,7 +65,7 @@ def prep_if_none_match(etag: Optional[str], match_condition: Optional[MatchCondi
         return "*"
     return None
 {% endif %}
-{% if code_model.has_form_data and code_model.options["models_mode"] == "dpg" %}
+{% if code_model.has_form_data and code_model.options["models_mode"] == "dpg" and not async_mode  %}
 # file-like tuple could be `(filename, IO (or bytes))` or `(filename, IO (or bytes), content_type)`
 FileContent = Union[str, bytes, IO[str], IO[bytes]]
 
@@ -103,4 +103,4 @@ def prepare_multipart_form_data(
             data[data_field] = serialize_multipart_data_entry(data_entry)
 
     return files, data
-{% endif %}
+{% endif %}

package/autorest/multiapi/models/code_model.py

@@ -45,7 +45,7 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes
             default_version_metadata["global_parameters"]
         )
         self.user_specified_default_api = user_specified_default_api
-        self.options: Dict[str, Any] = {"unbranded": False, "company_name": "Microsoft"}
+        self.options: Dict[str, Any] = {"flavor": "azure", "company_name": "Microsoft"}
         self.core_library = "azure.core"
 
     @property

package/autorest/multiapi/serializers/__init__.py

@@ -87,7 +87,9 @@ class MultiAPISerializer(ReaderAndWriter):  # pylint: disable=abstract-method
 
         # serialize service client file
         imports = FileImportSerializer(code_model.client.imports(async_mode))
-        config_policies = build_policies(code_model.azure_arm, async_mode)
+        config_policies = build_policies(
+            code_model.azure_arm, async_mode, is_azure_flavor=True
+        )
         self.write_file(
             _get_file_path(code_model.client.filename, async_mode),
             _render_template(

package/autorest/preprocess/__init__.py

@@ -8,7 +8,7 @@
 import copy
 from typing import Callable, Dict, Any, List, Optional
 
-from .._utils import to_snake_case, update_enum_value
+from .._utils import to_snake_case
 from .helpers import (
     add_redefined_builtin_info,
     pad_builtin_namespaces,
@@ -267,23 +267,15 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
                     type.get("description", ""), type["name"]
                 )
                 type["snakeCaseName"] = to_snake_case(type["name"])
-            if type.get("values") and not self.version_tolerant:
+            if type.get("values"):
                 # we're enums
-                values_to_add = []
                 for value in type["values"]:
                     padded_name = self.pad_reserved_words(
                         value["name"].lower(), PadType.ENUM
                     ).upper()
-                    if value["name"] != padded_name:
-                        values_to_add.append(
-                            update_enum_value(
-                                name=padded_name,
-                                value=value["value"],
-                                description=value["description"],
-                                enum_type=value["enumType"],
-                            )
-                        )
-                type["values"].extend(values_to_add)
+                    if padded_name[0] in "0123456789":
+                        padded_name = "ENUM_" + padded_name
+                    value["name"] = padded_name
 
         # add type for reference
         for v in HEADERS_CONVERT_IN_METHOD.values():

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autorest/python",
-  "version": "6.13.2",
+  "version": "6.13.4",
   "description": "The Python extension for generators in AutoRest.",
   "main": "index.js",
   "repository": {