@autorest/python 6.1.11 → 6.2.1

package/autorest/codegen/models/code_model.py

@@ -3,20 +3,22 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import List, Dict, Optional, Any, Set, Union
+from typing import List, Dict, Any, Set, Union
 
-from .base_type import BaseType
+from .base import BaseType
 from .enum_type import EnumType
 from .model_type import ModelType
-from .operation_group import OperationGroup
-from .client import Client, Config
-from .request_builder import OverloadedRequestBuilder, RequestBuilder
-from .parameter import Parameter
+from .client import Client
+from .request_builder import RequestBuilder, OverloadedRequestBuilder
+from .constant_type import ConstantType
 
 
-class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-public-methods
-    """Holds all of the information we have parsed out of the yaml file. The CodeModel is what gets
-    serialized by the serializers.
+def _is_legacy(options) -> bool:
+    return not (options["version_tolerant"] or options["low_level_client"])
+
+
+class CodeModel:  # pylint: disable=too-many-public-methods
+    """Top level code model
 
     :param options: Options of the code model. I.e., whether this is for management generation
     :type options: dict[str, bool]
@@ -34,8 +36,6 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
     :param primitives: List of schemas we've created that are not EnumSchemas or ObjectSchemas. Maps their
      yaml id to our created schemas.
     :type primitives: Dict[int, ~autorest.models.BaseType]
-    :param operation_groups: The operation groups we are going to serialize
-    :type operation_groups: list[~autorest.models.OperationGroup]
     :param package_dependency: All the dependencies needed in setup.py
     :type package_dependency: Dict[str, str]
     """
@@ -44,71 +44,136 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
         self,
         yaml_data: Dict[str, Any],
         options: Dict[str, Any],
+        *,
+        is_subnamespace: bool = False,
     ) -> None:
         self.yaml_data = yaml_data
         self.options = options
+        self.namespace = self.yaml_data["namespace"]
         self.types_map: Dict[int, BaseType] = {}  # map yaml id to schema
-        self.operation_groups: List[OperationGroup] = []
         self._model_types: List[ModelType] = []
-        self._client: Optional[Client] = None
-        self._config: Optional[Config] = None
-        self.request_builders: List[
-            Union[RequestBuilder, OverloadedRequestBuilder]
-        ] = []
-        self.package_dependency: Dict[str, str] = {}
-        self.namespace: str = yaml_data["client"]["namespace"].lower()
-        self.module_name: str = self.yaml_data["client"]["moduleName"]
+        from . import build_type
+
+        for type_yaml in yaml_data.get("types", []):
+            build_type(yaml_data=type_yaml, code_model=self)
+        self.clients: List[Client] = [
+            Client.from_yaml(client_yaml_data, self)
+            for client_yaml_data in yaml_data["clients"]
+        ]
+        self.subnamespace_to_clients: Dict[str, List[Client]] = {
+            subnamespace: [
+                Client.from_yaml(client_yaml, self, is_subclient=True)
+                for client_yaml in client_yamls
+            ]
+            for subnamespace, client_yamls in yaml_data.get(
+                "subnamespaceToClients", {}
+            ).items()
+        }
+        if self.options["models_mode"] and self.model_types:
+            self.sort_model_types()
+        self.is_subnamespace = is_subnamespace
 
-    def lookup_type(self, schema_id: int) -> BaseType:
-        """Looks to see if the schema has already been created.
+    @property
+    def has_operations(self) -> bool:
+        if any(c for c in self.clients if c.has_operations):
+            return True
+        return any(
+            c
+            for clients in self.subnamespace_to_clients.values()
+            for c in clients
+            if c.has_operations
+        )
 
-        :param int schema_id: The yaml id of the schema
-        :return: If created, we return the created schema, otherwise, we throw.
-        :rtype: ~autorest.models.BaseType
-        :raises: KeyError if schema is not found
-        """
-        try:
-            return next(type for id, type in self.types_map.items() if id == schema_id)
-        except StopIteration:
-            raise KeyError(f"Couldn't find schema with id {schema_id}")
+    @property
+    def has_non_abstract_operations(self) -> bool:
+        for client in self.clients:
+            for operation_group in client.operation_groups:
+                for operation in operation_group.operations:
+                    if not operation.abstract:
+                        return True
+        for clients in self.subnamespace_to_clients.values():
+            for client in clients:
+                for operation_group in client.operation_groups:
+                    for operation in operation_group.operations:
+                        if not operation.abstract:
+                            return True
+        return False
+
+    def lookup_request_builder(
+        self, request_builder_id: int
+    ) -> Union[RequestBuilder, OverloadedRequestBuilder]:
+        """Find the request builder based off of id"""
+        for client in self.clients:
+            try:
+                return client.lookup_request_builder(request_builder_id)
+            except KeyError:
+                pass
+        raise KeyError(f"No request builder with id {request_builder_id} found.")
+
+    @property
+    def rest_layer_name(self) -> str:
+        """If we have a separate rest layer, what is its name?"""
+        return "rest" if self.options["builders_visibility"] == "public" else "_rest"
+
+    @property
+    def client_filename(self) -> str:
+        return self.clients[0].filename
+
+    def need_vendored_code(self, async_mode: bool) -> bool:
+        """Whether we need to vendor code in the _vendor.py file for this SDK"""
+        if self.has_abstract_operations:
+            return True
+        if async_mode:
+            return self.need_mixin_abc
+        return (
+            self.need_request_converter or self.need_format_url or self.need_mixin_abc
+        )
 
     @property
-    def credential(self) -> Optional[Parameter]:
-        """The credential param, if one exists"""
-        return self.client.parameters.credential
+    def need_request_converter(self) -> bool:
+        return any(c for c in self.clients if c.need_request_converter)
 
     @property
-    def client(self) -> Client:
-        if not self._client:
-            raise ValueError("You haven't linked the client yet")
-        return self._client
+    def need_format_url(self) -> bool:
+        return any(c for c in self.clients if c.need_format_url)
 
-    @client.setter
-    def client(self, val: Client) -> None:
-        self._client = val
+    @property
+    def need_mixin_abc(self) -> bool:
+        return any(c for c in self.clients if c.has_mixin)
 
     @property
-    def config(self) -> Config:
-        if not self._config:
-            raise ValueError("You haven't linked the config yet")
-        return self._config
+    def has_abstract_operations(self) -> bool:
+        return any(c for c in self.clients if c.has_abstract_operations)
 
-    @config.setter
-    def config(self, val: Config) -> None:
-        self._config = val
+    @property
+    def operations_folder_name(self) -> str:
+        """Get the name of the operations folder that holds operations."""
+        name = "operations"
+        if self.options["version_tolerant"] and not any(
+            og
+            for client in self.clients
+            for og in client.operation_groups
+            if not og.is_mixin
+        ):
+            name = f"_{name}"
+        return name
 
-    def lookup_request_builder(
-        self, request_builder_id: int
-    ) -> Union[RequestBuilder, OverloadedRequestBuilder]:
-        """Find the request builder based off of id"""
+    @property
+    def description(self) -> str:
+        return self.clients[0].description
+
+    def lookup_type(self, schema_id: int) -> BaseType:
+        """Looks to see if the schema has already been created.
+
+        :param int schema_id: The yaml id of the schema
+        :return: If created, we return the created schema, otherwise, we throw.
+        :rtype: ~autorest.models.BaseType
+        :raises: KeyError if schema is not found
+        """
         try:
-            return next(
-                rb
-                for rb in self.request_builders
-                if id(rb.yaml_data) == request_builder_id
-            )
+            return next(type for id, type in self.types_map.items() if id == schema_id)
         except StopIteration:
-            raise KeyError(f"No request builder with id {request_builder_id} found.")
+            raise KeyError(f"Couldn't find schema with id {schema_id}")
 
     @property
     def model_types(self) -> List[ModelType]:
@@ -132,9 +197,11 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
         """All of the enums"""
         return [t for t in self.types_map.values() if isinstance(t, EnumType)]
 
-    @staticmethod
     def _sort_model_types_helper(
-        current: ModelType, seen_schema_names: Set[str], seen_schema_yaml_ids: Set[int]
+        self,
+        current: ModelType,
+        seen_schema_names: Set[str],
+        seen_schema_yaml_ids: Set[int],
     ):
         if current.id in seen_schema_yaml_ids:
             return []
@@ -150,7 +217,7 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
                 seen_schema_names.add(current.name)
                 seen_schema_yaml_ids.add(current.id)
                 ancestors = (
-                    CodeModel._sort_model_types_helper(
+                    self._sort_model_types_helper(
                         parent, seen_schema_names, seen_schema_yaml_ids
                     )
                     + ancestors
@@ -170,84 +237,12 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
         sorted_object_schemas: List[ModelType] = []
         for schema in sorted(self.model_types, key=lambda x: x.name.lower()):
             sorted_object_schemas.extend(
-                CodeModel._sort_model_types_helper(
+                self._sort_model_types_helper(
                     schema, seen_schema_names, seen_schema_yaml_ids
                 )
             )
         self.model_types = sorted_object_schemas
 
-    def format_lro_operations(self) -> None:
-        """Adds operations and attributes needed for LROs.
-        If there are LRO functions in here, will add initial LRO function. Will also set the return
-        type of the LRO operation
-        """
-        for operation_group in self.operation_groups:
-            i = 0
-            while i < len(operation_group.operations):
-                operation = operation_group.operations[i]
-                if operation.operation_type in ("lro", "lropaging"):
-                    operation_group.operations.insert(i, operation.initial_operation)  # type: ignore
-                    i += 1
-                i += 1
-
-    @property
-    def operations_folder_name(self) -> str:
-        """Get the name of the operations folder that holds operations."""
-        name = "operations"
-        if self.options["version_tolerant"] and not any(
-            og for og in self.operation_groups if not og.is_mixin
-        ):
-            name = f"_{name}"
-        return name
-
-    @property
-    def has_abstract_operations(self) -> bool:
-        """Whether there is abstract operation in any operation group."""
-        return any(og.has_abstract_operations for og in self.operation_groups)
-
-    def need_vendored_code(self, async_mode: bool) -> bool:
-        """Whether we need to vendor code in the _vendor.py file for this SDK"""
-        if self.has_abstract_operations:
-            return True
-        if async_mode:
-            return self.need_mixin_abc
-        return (
-            self.need_request_converter or self.need_format_url or self.need_mixin_abc
-        )
-
-    @property
-    def need_request_converter(self) -> bool:
-        """
-        Whether we need to convert our created azure.core.rest.HttpRequests to
-        azure.core.pipeline.transport.HttpRequests
-        """
-        return (
-            self.options["show_operations"]
-            and bool(self.request_builders)
-            and not self.options["version_tolerant"]
-        )
-
-    @property
-    def need_format_url(self) -> bool:
-        """Whether we need to format urls. If so, we need to vendor core."""
-        return any(rq for rq in self.request_builders if rq.parameters.path)
-
-    @property
-    def need_mixin_abc(self) -> bool:
-        """Do we want a mixin ABC class for typing purposes?"""
-        return any(o for o in self.operation_groups if o.is_mixin)
-
-    @property
-    def has_lro_operations(self) -> bool:
-        """Are there any LRO operations in this SDK?"""
-        return any(
-            [
-                operation.operation_type in ("lro", "lropaging")
-                for operation_group in self.operation_groups
-                for operation in operation_group.operations
-            ]
-        )
-
     @property
     def models_filename(self) -> str:
         """Get the names of the model file(s)"""
@@ -259,16 +254,34 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
     def enums_filename(self) -> str:
         """The name of the enums file"""
         if self.is_legacy:
-            return f"_{self.module_name}_enums"
+            return f"_{self.clients[0].legacy_filename}_enums"
         return "_enums"
 
     @property
     def is_legacy(self) -> bool:
-        return not (
-            self.options["version_tolerant"] or self.options["low_level_client"]
-        )
+        return _is_legacy(self.options)
 
     @property
-    def rest_layer_name(self) -> str:
-        """If we have a separate rest layer, what is its name?"""
-        return "rest" if self.options["builders_visibility"] == "public" else "_rest"
+    def need_typing_extensions(self) -> bool:
+        if self.options["models_mode"] and any(
+            isinstance(p.type, ConstantType)
+            and (p.optional or self.options["models_mode"] == "dpg")
+            for model in self.model_types
+            for p in model.properties
+        ):
+            return True
+        if any(
+            isinstance(parameter.type, ConstantType)
+            for client in self.clients
+            for og in client.operation_groups
+            for op in og.operations
+            for parameter in op.parameters.method
+        ):
+            return True
+        if any(
+            isinstance(parameter.type, ConstantType)
+            for client in self.clients
+            for parameter in client.config.parameters.kwargs_to_pop
+        ):
+            return True
+        return False

package/autorest/codegen/models/combined_type.py

@@ -6,7 +6,7 @@
 from typing import Any, Dict, List, Optional, TYPE_CHECKING
 import re
 from autorest.codegen.models.imports import FileImport, ImportType
-from .base_type import BaseType
+from .base import BaseType
 
 if TYPE_CHECKING:
     from .code_model import CodeModel
@@ -21,7 +21,10 @@ class CombinedType(BaseType):
     """
 
     def __init__(
-        self, yaml_data: Dict[str, Any], code_model: "CodeModel", types: List[BaseType]
+        self,
+        yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+        types: List[BaseType],
     ) -> None:
         super().__init__(yaml_data, code_model)
         self.types = types  # the types that this type is combining

package/autorest/codegen/models/constant_type.py

@@ -5,8 +5,9 @@
 # --------------------------------------------------------------------------
 import logging
 from typing import Dict, Any, Optional, TYPE_CHECKING
-from .base_type import BaseType
-from .imports import FileImport
+from .base import BaseType
+from .imports import FileImport, ImportType, TypingSection
+from .primitive_types import IntegerType, BinaryType, StringType, BooleanType
 from .utils import add_to_description
 
 if TYPE_CHECKING:
@@ -75,7 +76,17 @@ class ConstantType(BaseType):
         return self.value_type.docstring_type(**kwargs)
 
     def type_annotation(self, **kwargs: Any) -> str:
-        return self.value_type.type_annotation(**kwargs)
+        return (
+            f"Literal[{self.get_declaration()}]"
+            if self._is_literal
+            else self.value_type.type_annotation(**kwargs)
+        )
+
+    @property
+    def _is_literal(self) -> bool:
+        return isinstance(
+            self.value_type, (IntegerType, BinaryType, StringType, BooleanType)
+        )
 
     @classmethod
     def from_yaml(
@@ -112,11 +123,34 @@ class ConstantType(BaseType):
             description=description,
         )
 
-    def imports(self, **kwargs: Any) -> FileImport:
+    def _imports_shared(self, **kwargs: Any):
         file_import = FileImport()
         file_import.merge(self.value_type.imports(**kwargs))
         return file_import
 
+    def imports_for_multiapi(self, **kwargs: Any) -> FileImport:
+        return self._imports_shared(**kwargs)
+
+    def imports(self, **kwargs: Any) -> FileImport:
+        file_import = self._imports_shared(**kwargs)
+        if self._is_literal:
+            file_import.add_import("sys", ImportType.STDLIB)
+            file_import.add_submodule_import(
+                "typing_extensions",
+                "Literal",
+                ImportType.BYVERSION,
+                TypingSection.REGULAR,
+                None,
+                (
+                    (
+                        (3, 8),
+                        "typing",
+                        "pylint: disable=no-name-in-module, ungrouped-imports",
+                    ),
+                ),
+            )
+        return file_import
+
     @property
     def instance_check_template(self) -> str:
         return self.value_type.instance_check_template

package/autorest/codegen/models/credential_types.py

@@ -17,7 +17,7 @@ from typing import (
 )
 
 from .imports import FileImport, ImportType, TypingSection
-from .base_type import BaseType
+from .base import BaseType
 
 if TYPE_CHECKING:
     from .code_model import CodeModel

package/autorest/codegen/models/dictionary_type.py

@@ -4,7 +4,7 @@
 # license information.
 # --------------------------------------------------------------------------
 from typing import Any, Dict, Optional, TYPE_CHECKING, List
-from .base_type import BaseType
+from .base import BaseType
 from .imports import FileImport, ImportType, TypingSection
 
 if TYPE_CHECKING:

package/autorest/codegen/models/enum_type.py

@@ -5,9 +5,9 @@
 # --------------------------------------------------------------------------
 from typing import Any, Dict, List, TYPE_CHECKING, Optional
 
-from .base_type import BaseType
+from .base import BaseType
 from .imports import FileImport, ImportType, TypingSection
-from .base_model import BaseModel
+from .base import BaseModel
 
 if TYPE_CHECKING:
     from .code_model import CodeModel
@@ -126,7 +126,9 @@ class EnumType(BaseType):
     def docstring_type(self, **kwargs: Any) -> str:
         """The python type used for RST syntax input and type annotation."""
         if self.code_model.options["models_mode"]:
-            return f"{self.value_type.type_annotation(**kwargs)} or ~{self.code_model.namespace}.models.{self.name}"
+            type_annotation = self.value_type.type_annotation(**kwargs)
+            enum_type_annotation = f"{self.code_model.namespace}.models.{self.name}"
+            return f"{type_annotation} or ~{enum_type_annotation}"
         return self.value_type.type_annotation(**kwargs)
 
     def get_json_template_representation(