@autorest/python 6.2.0 → 6.2.1

package/autorest/codegen/models/code_model.py

@@ -5,21 +5,20 @@
 # --------------------------------------------------------------------------
 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 .client import Client
 from .request_builder import RequestBuilder, OverloadedRequestBuilder
-from .operation_group import OperationGroup
+from .constant_type import ConstantType
 
 
 def _is_legacy(options) -> bool:
     return not (options["version_tolerant"] or options["low_level_client"])
 
 
-class CodeModel:
-    """Holds all of the information we have parsed out of the yaml file. The CodeModel is what gets
-    serialized by the serializers.
+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]
@@ -37,8 +36,6 @@ class CodeModel:
     :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]
     """
@@ -47,50 +44,60 @@ class CodeModel:
         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_models: List["NamespaceModel"] = [
-            NamespaceModel(namespace_yaml_data, self.options, namespace)
-            for namespace, namespace_yaml_data in yaml_data.items()
-        ]
-
-    @property
-    def is_legacy(self) -> bool:
-        return _is_legacy(self.options)
-
-    @property
-    def description(self) -> str:
-        return self.namespace_models[0].clients[0].description
-
-
-class NamespaceModel:
-    def __init__(
-        self, yaml_data: Dict[str, Any], options: Dict[str, Any], namespace: str
-    ):
-        self.yaml_data = yaml_data
+        self.namespace = self.yaml_data["namespace"]
         self.types_map: Dict[int, BaseType] = {}  # map yaml id to schema
         self._model_types: List[ModelType] = []
-        self.options = options
         from . import build_type
 
         for type_yaml in yaml_data.get("types", []):
-            build_type(yaml_data=type_yaml, namespace_model=self)
-        self.clients: List[Client] = []
-        self.namespace = namespace
+            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
@@ -104,12 +111,69 @@ class NamespaceModel:
         raise KeyError(f"No request builder with id {request_builder_id} found.")
 
     @property
-    def operation_groups(self) -> List[OperationGroup]:
-        return [og for client in self.clients for og in client.operation_groups]
+    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 request_builders(self) -> List[Union[RequestBuilder, OverloadedRequestBuilder]]:
-        return [rb for client in self.clients for rb in client.request_builders]
+    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 need_request_converter(self) -> bool:
+        return any(c for c in self.clients if c.need_request_converter)
+
+    @property
+    def need_format_url(self) -> bool:
+        return any(c for c in self.clients if c.need_format_url)
+
+    @property
+    def need_mixin_abc(self) -> bool:
+        return any(c for c in self.clients if c.has_mixin)
+
+    @property
+    def has_abstract_operations(self) -> bool:
+        return any(c for c in self.clients if c.has_abstract_operations)
+
+    @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
+
+    @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(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 model_types(self) -> List[ModelType]:
@@ -179,15 +243,6 @@ class NamespaceModel:
             )
         self.model_types = sorted_object_schemas
 
-    @property
-    def is_legacy(self) -> bool:
-        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"
-
     @property
     def models_filename(self) -> str:
         """Get the names of the model file(s)"""
@@ -195,10 +250,6 @@ class NamespaceModel:
             return "_models_py3"
         return "_models"
 
-    @property
-    def client_filename(self) -> str:
-        return self.clients[0].filename
-
     @property
     def enums_filename(self) -> str:
         """The name of the enums file"""
@@ -206,41 +257,31 @@ class NamespaceModel:
             return f"_{self.clients[0].legacy_filename}_enums"
         return "_enums"
 
-    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:
-        return any(c for c in self.clients if c.need_request_converter)
-
-    @property
-    def need_format_url(self) -> bool:
-        return any(c for c in self.clients if c.need_format_url)
-
-    @property
-    def need_mixin_abc(self) -> bool:
-        return any(c for c in self.clients if c.has_mixin)
-
     @property
-    def has_abstract_operations(self) -> bool:
-        return any(c for c in self.clients if c.has_abstract_operations)
+    def is_legacy(self) -> bool:
+        return _is_legacy(self.options)
 
     @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
+    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
-            if not og.is_mixin
+            for op in og.operations
+            for parameter in op.parameters.method
         ):
-            name = f"_{name}"
-        return name
+            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,10 +6,10 @@
 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 NamespaceModel
+    from .code_model import CodeModel
     from .model_type import ModelType
 
 
@@ -23,10 +23,10 @@ class CombinedType(BaseType):
     def __init__(
         self,
         yaml_data: Dict[str, Any],
-        namespace_model: "NamespaceModel",
+        code_model: "CodeModel",
         types: List[BaseType],
     ) -> None:
-        super().__init__(yaml_data, namespace_model)
+        super().__init__(yaml_data, code_model)
         self.types = types  # the types that this type is combining
 
     @property
@@ -105,12 +105,12 @@ class CombinedType(BaseType):
 
     @classmethod
     def from_yaml(
-        cls, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
     ) -> "BaseType":
         from . import build_type
 
         return cls(
             yaml_data,
-            namespace_model,
-            [build_type(t, namespace_model) for t in yaml_data["types"]],
+            code_model,
+            [build_type(t, code_model) for t in yaml_data["types"]],
         )

package/autorest/codegen/models/constant_type.py

@@ -5,12 +5,13 @@
 # --------------------------------------------------------------------------
 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:
-    from .code_model import NamespaceModel
+    from .code_model import CodeModel
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -28,11 +29,11 @@ class ConstantType(BaseType):
     def __init__(
         self,
         yaml_data: Dict[str, Any],
-        namespace_model: "NamespaceModel",
+        code_model: "CodeModel",
         value_type: BaseType,
         value: Optional[str],
     ) -> None:
-        super().__init__(yaml_data=yaml_data, namespace_model=namespace_model)
+        super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.value_type = value_type
         self.value = value
 
@@ -75,11 +76,21 @@ 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(
-        cls, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
     ) -> "ConstantType":
         """Constructs a ConstantType from yaml data.
 
@@ -93,8 +104,8 @@ class ConstantType(BaseType):
 
         return cls(
             yaml_data=yaml_data,
-            namespace_model=namespace_model,
-            value_type=build_type(yaml_data["valueType"], namespace_model),
+            code_model=code_model,
+            value_type=build_type(yaml_data["valueType"], code_model),
             value=yaml_data["value"],
         )
 
@@ -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,10 +17,10 @@ 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 NamespaceModel
+    from .code_model import CodeModel
 
 
 class _CredentialPolicyBaseType:
@@ -29,11 +29,9 @@ class _CredentialPolicyBaseType:
     Inherited by our BearerTokenCredentialPolicy and AzureKeyCredentialPolicy types.
     """
 
-    def __init__(
-        self, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
-    ) -> None:
+    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
         self.yaml_data = yaml_data
-        self.namespace_model = namespace_model
+        self.code_model = code_model
 
     @abstractmethod
     def call(self, async_mode: bool) -> str:
@@ -49,10 +47,10 @@ class BearerTokenCredentialPolicyType(_CredentialPolicyBaseType):
     def __init__(
         self,
         yaml_data: Dict[str, Any],
-        namespace_model: "NamespaceModel",
+        code_model: "CodeModel",
         credential_scopes: List[str],
     ) -> None:
-        super().__init__(yaml_data, namespace_model)
+        super().__init__(yaml_data, code_model)
         self.credential_scopes = credential_scopes
 
     def call(self, async_mode: bool) -> str:
@@ -61,9 +59,9 @@ class BearerTokenCredentialPolicyType(_CredentialPolicyBaseType):
 
     @classmethod
     def from_yaml(
-        cls, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
     ) -> "BearerTokenCredentialPolicyType":
-        return cls(yaml_data, namespace_model, yaml_data["credentialScopes"])
+        return cls(yaml_data, code_model, yaml_data["credentialScopes"])
 
 
 class ARMChallengeAuthenticationPolicyType(BearerTokenCredentialPolicyType):
@@ -76,9 +74,9 @@ class ARMChallengeAuthenticationPolicyType(BearerTokenCredentialPolicyType):
 
 class AzureKeyCredentialPolicyType(_CredentialPolicyBaseType):
     def __init__(
-        self, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel", key: str
+        self, yaml_data: Dict[str, Any], code_model: "CodeModel", key: str
     ) -> None:
-        super().__init__(yaml_data, namespace_model)
+        super().__init__(yaml_data, code_model)
         self.key = key
 
     def call(self, async_mode: bool) -> str:
@@ -86,9 +84,9 @@ class AzureKeyCredentialPolicyType(_CredentialPolicyBaseType):
 
     @classmethod
     def from_yaml(
-        cls, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
     ) -> "AzureKeyCredentialPolicyType":
-        return cls(yaml_data, namespace_model, yaml_data["key"])
+        return cls(yaml_data, code_model, yaml_data["key"])
 
 
 CredentialPolicyType = TypeVar(
@@ -109,10 +107,10 @@ class CredentialType(
     def __init__(
         self,
         yaml_data: Dict[str, Any],
-        namespace_model: "NamespaceModel",
+        code_model: "CodeModel",
         policy: CredentialPolicyType,
     ) -> None:
-        super().__init__(yaml_data, namespace_model)
+        super().__init__(yaml_data, code_model)
         self.policy = policy
 
     def description(
@@ -140,15 +138,15 @@ class CredentialType(
 
     @classmethod
     def from_yaml(
-        cls, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
     ) -> "CredentialType":
         from . import build_type
 
         return cls(
             yaml_data,
-            namespace_model,
+            code_model,
             policy=cast(
-                CredentialPolicyType, build_type(yaml_data["policy"], namespace_model)
+                CredentialPolicyType, build_type(yaml_data["policy"], code_model)
             ),
         )
 

package/autorest/codegen/models/dictionary_type.py

@@ -4,11 +4,11 @@
 # 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:
-    from .code_model import NamespaceModel
+    from .code_model import CodeModel
     from .model_type import ModelType
 
 
@@ -24,10 +24,10 @@ class DictionaryType(BaseType):
     def __init__(
         self,
         yaml_data: Dict[str, Any],
-        namespace_model: "NamespaceModel",
+        code_model: "CodeModel",
         element_type: BaseType,
     ) -> None:
-        super().__init__(yaml_data=yaml_data, namespace_model=namespace_model)
+        super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.element_type = element_type
 
     @property
@@ -96,7 +96,7 @@ class DictionaryType(BaseType):
 
     @classmethod
     def from_yaml(
-        cls, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
     ) -> "DictionaryType":
         """Constructs a DictionaryType from yaml data.
 
@@ -110,13 +110,11 @@ class DictionaryType(BaseType):
 
         from . import build_type  # pylint: disable=import-outside-toplevel
 
-        element_type = build_type(
-            yaml_data=element_schema, namespace_model=namespace_model
-        )
+        element_type = build_type(yaml_data=element_schema, code_model=code_model)
 
         return cls(
             yaml_data=yaml_data,
-            namespace_model=namespace_model,
+            code_model=code_model,
             element_type=element_type,
         )