@autorest/python 6.2.0 → 6.2.2

package/autorest/multiapi/models/imports.py

@@ -5,6 +5,7 @@
 # --------------------------------------------------------------------------
 from enum import Enum
 from typing import Dict, Optional, Set, Union, Tuple
+from ..utils import convert_list_to_tuple
 
 
 class ImportType(str, Enum):
@@ -12,6 +13,7 @@ class ImportType(str, Enum):
     THIRDPARTY = "thirdparty"
     AZURECORE = "azurecore"
     LOCAL = "local"
+    BYVERSION = "by_version"
 
 
 class TypingSection(str, Enum):
@@ -25,7 +27,28 @@ class FileImport:
         self,
         imports: Dict[
             TypingSection,
-            Dict[ImportType, Dict[str, Set[Optional[Union[str, Tuple[str, str]]]]]],
+            Dict[
+                ImportType,
+                Dict[
+                    str,
+                    Set[
+                        Optional[
+                            Union[
+                                str,
+                                Tuple[
+                                    str,
+                                    str,
+                                ],
+                                Tuple[
+                                    str,
+                                    str,
+                                    Tuple[Tuple[Tuple[int, int], str, Optional[str]]],
+                                ],
+                            ]
+                        ]
+                    ],
+                ],
+            ],
         ] = None,
     ) -> None:
         # Basic implementation
@@ -35,7 +58,28 @@ class FileImport:
         # Fourth level set: None if this import is a "import", the name to import if it's a "from"
         self._imports: Dict[
             TypingSection,
-            Dict[ImportType, Dict[str, Set[Optional[Union[str, Tuple[str, str]]]]]],
+            Dict[
+                ImportType,
+                Dict[
+                    str,
+                    Set[
+                        Optional[
+                            Union[
+                                str,
+                                Tuple[
+                                    str,
+                                    str,
+                                ],
+                                Tuple[
+                                    str,
+                                    str,
+                                    Tuple[Tuple[Tuple[int, int], str, Optional[str]]],
+                                ],
+                            ]
+                        ]
+                    ],
+                ],
+            ],
         ] = (
             imports or dict()
         )
@@ -44,14 +88,29 @@ class FileImport:
         self,
         from_section: str,
         import_type: ImportType,
-        name_import: Optional[Union[str, Tuple[str, str]]] = None,
+        name_import: Optional[
+            Union[
+                str,
+                Tuple[
+                    str,
+                    str,
+                ],
+                Tuple[str, str, Tuple[Tuple[Tuple[int, int], str, Optional[str]]]],
+            ]
+        ] = None,
         typing_section: TypingSection = TypingSection.REGULAR,
     ) -> None:
-        name_input: Optional[Union[str, Tuple[str, str]]] = None
-        if isinstance(name_import, list):
-            name_input = tuple(name_import)
-        else:
-            name_input = name_import
+        name_input: Optional[
+            Union[
+                str,
+                Tuple[
+                    str,
+                    str,
+                ],
+                Tuple[str, str, Tuple[Tuple[Tuple[int, int], str, Optional[str]]]],
+            ]
+        ] = None
+        name_input = convert_list_to_tuple(name_import)
         self._imports.setdefault(typing_section, dict()).setdefault(
             import_type, dict()
         ).setdefault(from_section, set()).add(name_input)
@@ -66,21 +125,33 @@ class FileImport:
         """Add an import to this import block."""
         self._add_import(from_section, import_type, name_import, typing_section)
 
-    def add_import(
-        self,
-        name_import: str,
-        import_type: ImportType,
-        typing_section: TypingSection = TypingSection.REGULAR,
-    ) -> None:
-        # Implementation detail: a regular import is just a "from" with no from
-        self._add_import(name_import, import_type, None, typing_section)
-
     @property
     def imports(
         self,
     ) -> Dict[
         TypingSection,
-        Dict[ImportType, Dict[str, Set[Optional[Union[str, Tuple[str, str]]]]]],
+        Dict[
+            ImportType,
+            Dict[
+                str,
+                Set[
+                    Optional[
+                        Union[
+                            str,
+                            Tuple[
+                                str,
+                                str,
+                            ],
+                            Tuple[
+                                str,
+                                str,
+                                Tuple[Tuple[Tuple[int, int], str, Optional[str]]],
+                            ],
+                        ]
+                    ]
+                ],
+            ],
+        ],
     ]:
         return self._imports
 

package/autorest/multiapi/serializers/import_serializer.py

@@ -4,17 +4,43 @@
 # license information.
 # --------------------------------------------------------------------------
 from copy import deepcopy
-from typing import Dict, Set, Optional, List
+from typing import Dict, Set, Optional, List, Tuple, Union
 from ..models import ImportType, FileImport, TypingSection
+from ..utils import convert_list_to_tuple
 
 
 def _serialize_package(
-    package_name: str, module_list: Set[Optional[str]], delimiter: str
+    package_name: str,
+    module_list: Set[
+        Optional[
+            Union[
+                str,
+                Tuple[
+                    str,
+                    str,
+                ],
+                Tuple[
+                    str,
+                    Optional[str],
+                    Tuple[Tuple[Tuple[int, int], str, Optional[str]]],
+                ],
+            ]
+        ]
+    ],
+    delimiter: str,
 ) -> str:
     buffer = []
-    if None in module_list:
+
+    versioned_modules = set()
+    normal_modules = set()
+    for m in module_list:
+        if m and isinstance(m, (tuple, list)) and len(m) > 2:
+            versioned_modules.add(convert_list_to_tuple(m))
+        else:
+            normal_modules.add(m)
+    if None in normal_modules:
         buffer.append(f"import {package_name}")
-    if module_list != {None}:
+    if normal_modules != {None} and len(normal_modules) > 0:
         buffer.append(
             "from {} import {}".format(
                 package_name,
@@ -22,18 +48,51 @@ def _serialize_package(
                     sorted(
                         [
                             mod if isinstance(mod, str) else f"{mod[0]} as {mod[1]}"
-                            for mod in module_list
+                            for mod in normal_modules
                             if mod is not None
                         ]
                     )
                 ),
             )
         )
+    for submodule_name, alias, version_modules in versioned_modules:  # type: ignore
+        for n, (version, module_name, comment) in enumerate(version_modules):
+            buffer.append(
+                "{} sys.version_info >= {}:".format("if" if n == 0 else "elif", version)
+            )
+            buffer.append(
+                f"    from {module_name} import {submodule_name}{f' as {alias}' if alias else ''}"
+                f"{f' # {comment}' if comment else ''}"
+            )
+        buffer.append("else:")
+        buffer.append(
+            f"    from {package_name} import {submodule_name}{f' as {alias}' if alias else ''}"
+            "  # type: ignore  # pylint: disable=ungrouped-imports"
+        )
     return delimiter.join(buffer)
 
 
 def _serialize_type(
-    import_type_dict: Dict[str, Set[Optional[str]]], delimiter: str
+    import_type_dict: Dict[
+        str,
+        Set[
+            Optional[
+                Union[
+                    str,
+                    Tuple[
+                        str,
+                        str,
+                    ],
+                    Tuple[
+                        str,
+                        Optional[str],
+                        Tuple[Tuple[Tuple[int, int], str, Optional[str]]],
+                    ],
+                ]
+            ]
+        ],
+    ],
+    delimiter: str,
 ) -> str:
     """Serialize a given import type."""
     import_list = []
@@ -44,7 +103,29 @@ def _serialize_type(
 
 
 def _get_import_clauses(
-    imports: Dict[ImportType, Dict[str, Set[Optional[str]]]], delimiter: str
+    imports: Dict[
+        ImportType,
+        Dict[
+            str,
+            Set[
+                Optional[
+                    Union[
+                        str,
+                        Tuple[
+                            str,
+                            str,
+                        ],
+                        Tuple[
+                            str,
+                            Optional[str],
+                            Tuple[Tuple[Tuple[int, int], str, Optional[str]]],
+                        ],
+                    ]
+                ]
+            ],
+        ],
+    ],
+    delimiter: str,
 ) -> List[str]:
     import_clause = []
     for import_type in ImportType:

package/autorest/multiapi/utils.py

@@ -47,3 +47,9 @@ def _get_default_api_version_from_list(
 
     # If not preview mode, and there is preview, take the latest known stable
     return sorted(not_preview_versions)[-1]
+
+
+def convert_list_to_tuple(l):
+    if not isinstance(l, list):
+        return l
+    return tuple(convert_list_to_tuple(x) for x in l) if isinstance(l, list) else l

package/autorest/preprocess/__init__.py

@@ -16,9 +16,7 @@ from .. import YamlUpdatePlugin, YamlUpdatePluginAutorest
 from .._utils import parse_args, get_body_type_for_description, JSON_REGEXP, KNOWN_TYPES
 
 
-def add_body_param_type(
-    namespace_model: Dict[str, Any], body_parameter: Dict[str, Any]
-):
+def add_body_param_type(code_model: Dict[str, Any], body_parameter: Dict[str, Any]):
     if (
         body_parameter
         and body_parameter["type"]["type"] in ("model", "dict", "list")
@@ -32,7 +30,7 @@ def add_body_param_type(
             "type": "combined",
             "types": [body_parameter["type"], KNOWN_TYPES["binary"]],
         }
-        namespace_model["types"].append(body_parameter["type"])
+        code_model["types"].append(body_parameter["type"])
 
 
 def update_overload_section(
@@ -214,7 +212,7 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
 
     def update_operation(
         self,
-        namespace_model: Dict[str, Any],
+        code_model: Dict[str, Any],
         yaml_data: Dict[str, Any],
         *,
         is_overload: bool = False,
@@ -237,12 +235,12 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
             for entry in yaml_data["bodyParameter"].get("entries", []):
                 update_parameter(entry)
         for overload in yaml_data.get("overloads", []):
-            self.update_operation(namespace_model, overload, is_overload=True)
+            self.update_operation(code_model, overload, is_overload=True)
         for response in yaml_data.get("responses", []):
             response["discriminator"] = "operation"
         if body_parameter and not is_overload:
             # if we have a JSON body, we add a binary overload
-            add_body_param_type(namespace_model, body_parameter)
+            add_body_param_type(code_model, body_parameter)
             add_overloads_for_body_param(yaml_data)
 
     def _update_lro_operation_helper(self, yaml_data: Dict[str, Any]) -> None:
@@ -270,40 +268,36 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
 
     def update_lro_paging_operation(
         self,
-        namespace_model: Dict[str, Any],
+        code_model: Dict[str, Any],
         yaml_data: Dict[str, Any],
         is_overload: bool = False,
     ) -> None:
-        self.update_lro_operation(namespace_model, yaml_data, is_overload=is_overload)
-        self.update_paging_operation(
-            namespace_model, yaml_data, is_overload=is_overload
-        )
+        self.update_lro_operation(code_model, yaml_data, is_overload=is_overload)
+        self.update_paging_operation(code_model, yaml_data, is_overload=is_overload)
         yaml_data["discriminator"] = "lropaging"
         for response in yaml_data.get("responses", []):
             response["discriminator"] = "lropaging"
         for overload in yaml_data.get("overloads", []):
-            self.update_lro_paging_operation(
-                namespace_model, overload, is_overload=True
-            )
+            self.update_lro_paging_operation(code_model, overload, is_overload=True)
 
     def update_lro_operation(
         self,
-        namespace_model: Dict[str, Any],
+        code_model: Dict[str, Any],
         yaml_data: Dict[str, Any],
         is_overload: bool = False,
     ) -> None:
-        self.update_operation(namespace_model, yaml_data, is_overload=is_overload)
+        self.update_operation(code_model, yaml_data, is_overload=is_overload)
         self._update_lro_operation_helper(yaml_data)
         for overload in yaml_data.get("overloads", []):
             self._update_lro_operation_helper(overload)
 
     def update_paging_operation(
         self,
-        namespace_model: Dict[str, Any],
+        code_model: Dict[str, Any],
         yaml_data: Dict[str, Any],
         is_overload: bool = False,
     ) -> None:
-        self.update_operation(namespace_model, yaml_data, is_overload=is_overload)
+        self.update_operation(code_model, yaml_data, is_overload=is_overload)
         if not yaml_data.get("pagerSync"):
             yaml_data["pagerSync"] = "azure.core.paging.ItemPaged"
         if not yaml_data.get("pagerAsync"):
@@ -338,10 +332,10 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
             update_paging_response(response)
             response["itemType"] = item_type
         for overload in yaml_data.get("overloads", []):
-            self.update_paging_operation(namespace_model, overload, is_overload=True)
+            self.update_paging_operation(code_model, overload, is_overload=True)
 
     def update_operation_groups(
-        self, namespace: Dict[str, Any], client: Dict[str, Any]
+        self, code_model: Dict[str, Any], client: Dict[str, Any]
     ) -> None:
         operation_groups_yaml_data = client["operationGroups"]
         for operation_group in operation_groups_yaml_data:
@@ -356,15 +350,18 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
                 client, operation_group["className"]
             )
             for operation in operation_group["operations"]:
-                self.get_operation_updater(operation)(namespace, operation)
+                self.get_operation_updater(operation)(code_model, operation)
 
     def update_yaml(self, yaml_data: Dict[str, Any]) -> None:
         """Convert in place the YAML str."""
-        for namespace in yaml_data.values():
-            update_types(namespace["types"])
-            for client in namespace["clients"]:
+        update_types(yaml_data["types"])
+        for client in yaml_data["clients"]:
+            update_client(client)
+            self.update_operation_groups(yaml_data, client)
+        for clients in yaml_data["subnamespaceToClients"].values():
+            for client in clients:
                 update_client(client)
-                self.update_operation_groups(namespace, client)
+                self.update_operation_groups(yaml_data, client)
 
 
 class PreProcessPluginAutorest(YamlUpdatePluginAutorest, PreProcessPlugin):

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autorest/python",
-  "version": "6.2.0",
+  "version": "6.2.2",
   "description": "The Python extension for generators in AutoRest.",
   "repository": {
     "type": "git",

package/run_cadl.py

@@ -38,6 +38,5 @@ if __name__ == "__main__":
     # run m2r
     python_run(venv_context, "autorest.m2r.__init__", command=sys.argv[1:])
     python_run(venv_context, "autorest.preprocess.__init__", command=sys.argv[1:])
-    python_run(venv_context, "autorest.cadlflags.__init__", command=sys.argv[1:])
     python_run(venv_context, "autorest.codegen.__init__", command=sys.argv[1:])
     python_run(venv_context, "autorest.black.__init__", command=sys.argv[1:])

package/autorest/cadlflags/__init__.py

@@ -1,130 +0,0 @@
-# -------------------------------------------------------------------------
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License. See License.txt in the project root for
-# license information.
-# --------------------------------------------------------------------------
-import logging
-from typing import Any, Dict, List
-from .. import YamlUpdatePlugin
-from .._utils import parse_args
-
-_LOGGER = logging.getLogger(__name__)
-
-OAUTH_TYPE = "OAuth2"
-KEY_TYPE = "Key"
-
-
-def get_azure_key_credential(key: str) -> Dict[str, Any]:
-    return {
-        "type": KEY_TYPE,
-        "policy": {"type": "AzureKeyCredentialPolicy", "key": key},
-    }
-
-
-class CadlFlags(YamlUpdatePlugin):  # pylint: disable=abstract-method
-    """A plugin to apply flags from backdoor python.json into cadl yaml file"""
-
-    def update_yaml(self, yaml_data: Dict[str, Any]) -> None:
-        """Convert in place the YAML str."""
-        if self.options.get("add-credential"):
-            self.update_credential(yaml_data)
-        if self.options.get("namespace"):
-            yaml_data["client"]["namespace"] = self.options["namespace"]
-        if self.options.get("title"):
-            yaml_data["client"]["name"] = self.options["title"]
-
-    def get_credential_scopes_from_flags(self, auth_policy: str) -> List[str]:
-        if self.options.get("azure-arm"):
-            return ["https://management.azure.com/.default"]
-        credential_scopes_temp = self.options.get("credential-scopes")
-        credential_scopes = (
-            credential_scopes_temp.split(",") if credential_scopes_temp else None
-        )
-        if self.options.get("credential-scopes", False) and not credential_scopes:
-            raise ValueError(
-                "--credential-scopes takes a list of scopes in comma separated format. "
-                "For example: --credential-scopes=https://cognitiveservices.azure.com/.default"
-            )
-        if not credential_scopes:
-            _LOGGER.warning(
-                "You have default credential policy %s "
-                "but not the --credential-scopes flag set while generating non-management plane code. "
-                "This is not recommend because it forces the customer to pass credential scopes "
-                "through kwargs if they want to authenticate.",
-                auth_policy,
-            )
-            credential_scopes = []
-        return credential_scopes
-
-    def get_token_credential(self, credential_scopes: List[str]) -> Dict[str, Any]:
-        return {
-            "type": OAUTH_TYPE,
-            "policy": {
-                "type": "ARMChallengeAuthenticationPolicy"
-                if self.options.get("azure-arm")
-                else "BearerTokenCredentialPolicy",
-                "credentialScopes": credential_scopes,
-            },
-        }
-
-    def update_credential_from_flags(self) -> Dict[str, Any]:
-        default_auth_policy = (
-            "ARMChallengeAuthenticationPolicy"
-            if self.options.get("azure-arm")
-            else "BearerTokenCredentialPolicy"
-        )
-        auth_policy = (
-            self.options.get("credential-default-policy-type") or default_auth_policy
-        )
-        credential_scopes = self.get_credential_scopes_from_flags(auth_policy)
-        key = self.options.get("credential-key-header-name")
-        if auth_policy.lower() in (
-            "armchallengeauthenticationpolicy",
-            "bearertokencredentialpolicy",
-        ):
-            if key:
-                raise ValueError(
-                    "You have passed in a credential key header name with default credential policy type "
-                    f"{auth_policy}. This is not allowed, since credential key header "
-                    "name is tied with AzureKeyCredentialPolicy. Instead, with this policy it is recommend you "
-                    "pass in --credential-scopes."
-                )
-            return self.get_token_credential(credential_scopes)
-        # Otherwise you have AzureKeyCredentialPolicy
-        if self.options.get("credential-scopes"):
-            raise ValueError(
-                "You have passed in credential scopes with default credential policy type "
-                "AzureKeyCredentialPolicy. This is not allowed, since credential scopes is tied with "
-                f"{default_auth_policy}. Instead, with this policy "
-                "you must pass in --credential-key-header-name."
-            )
-        if not key:
-            key = "api-key"
-            _LOGGER.info(
-                "Defaulting the AzureKeyCredentialPolicy header's name to 'api-key'"
-            )
-        return get_azure_key_credential(key)
-
-    def update_credential(self, yaml_data: Dict[str, Any]) -> None:
-        credential_type = self.update_credential_from_flags()
-        yaml_data["types"].append(credential_type)
-        credential = {
-            "type": credential_type,
-            "optional": False,
-            "description": "Credential needed for the client to connect to Azure.",
-            "clientName": "credential",
-            "location": "other",
-            "restApiName": "credential",
-            "implementation": "Client",
-            "skipUrlEncoding": True,
-            "inOverload": False,
-        }
-        yaml_data["client"]["parameters"].append(credential)
-
-
-if __name__ == "__main__":
-    # CADL pipeline will call this
-    args, unknown_args = parse_args()
-    CadlFlags(
-        output_folder=args.output_folder, cadl_file=args.cadl_file, **unknown_args
-    ).process()

package/autorest/codegen/models/base_model.py

@@ -1,30 +0,0 @@
-# -------------------------------------------------------------------------
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License. See License.txt in the project root for
-# license information.
-# --------------------------------------------------------------------------
-from typing import Any, Dict, TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from .code_model import NamespaceModel
-
-
-class BaseModel:
-    """This is the base class for model representations that are based on some YAML data.
-
-    :param yaml_data: the yaml data for this schema
-    :type yaml_data: dict[str, Any]
-    """
-
-    def __init__(
-        self, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
-    ) -> None:
-        self.yaml_data = yaml_data
-        self.namespace_model = namespace_model
-
-    @property
-    def id(self) -> int:
-        return id(self.yaml_data)
-
-    def __repr__(self):
-        return f"<{self.__class__.__name__}>"