@autorest/python 5.13.0 → 5.16.0

package/autorest/codegen/models/code_model.py

@@ -3,14 +3,10 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from itertools import chain
 import logging
-from typing import cast, List, Dict, Optional, Any, Set, Type
+from typing import cast, List, Dict, Optional, Any, Set
 
 from .base_schema import BaseSchema
-from .credential_schema_policy import (
-    ARMChallengeAuthenticationPolicy, BearerTokenCredentialPolicy, CredentialSchemaPolicy
-)
 from .enum_schema import EnumSchema
 from .object_schema import ObjectSchema
 from .operation_group import OperationGroup
@@ -20,15 +16,13 @@ from .paging_operation import PagingOperation
 from .parameter import Parameter
 from .client import Client
 from .parameter_list import GlobalParameterList
-from .schema_response import SchemaResponse
 from .property import Property
-from .primitive_schemas import IOSchema
 from .request_builder import RequestBuilder
-from .rest import Rest
-
+from .credential_model import CredentialModel
 
 _LOGGER = logging.getLogger(__name__)
 
+
 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.
@@ -51,14 +45,24 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
     :type primitives: Dict[int, ~autorest.models.BaseSchema]
     :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]
+    :param credential_model: The class contains all the credential info
+    :type credential_model: CredentialMode
     """
 
     def __init__(
         self,
+        yaml_data: Dict[str, Any],
         options: Dict[str, Any],
     ) -> None:
-        self.send_request_name = "send_request" if options['show_send_request'] else "_send_request"
-        self.rest_layer_name = "rest" if options["builders_visibility"] == "public" else "_rest"
+        self.yaml_data = yaml_data
+        self.send_request_name = (
+            "send_request" if options["show_send_request"] else "_send_request"
+        )
+        self.rest_layer_name = (
+            "rest" if options["builders_visibility"] == "public" else "_rest"
+        )
         self.options = options
         self.module_name: str = ""
         self.class_name: str = ""
@@ -73,9 +77,9 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
         params = GlobalParameterList(self)
         params.code_model = self
         self.service_client: Client = Client(self, params)
-        self._rest: Optional[Rest] = None
-        self.request_builder_ids: Dict[int, RequestBuilder] = {}
-        self._credential_schema_policy: Optional[CredentialSchemaPolicy] = None
+        self.request_builders: List[RequestBuilder] = []
+        self.package_dependency: Dict[str, str] = {}
+        self._credential_model: Optional[CredentialModel] = None
 
     @property
     def global_parameters(self) -> GlobalParameterList:
@@ -85,16 +89,6 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
     def global_parameters(self, val: GlobalParameterList) -> None:
         self.service_client.parameters = val
 
-    @property
-    def rest(self) -> Rest:
-        if not self._rest:
-            raise ValueError("rest is None. Can not call it, you first have to set it.")
-        return self._rest
-
-    @rest.setter
-    def rest(self, p: Rest) -> None:
-        self._rest = p
-
     def lookup_schema(self, schema_id: int) -> BaseSchema:
         """Looks to see if the schema has already been created.
 
@@ -109,6 +103,30 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
                     return elt_value
         raise KeyError("Didn't find it!!!!!")
 
+    def lookup_request_builder(self, request_builder_id: int) -> RequestBuilder:
+        """Find the request builder based off of id"""
+        try:
+            return next(
+                rb
+                for rb in self.request_builders
+                if id(rb.yaml_data) == request_builder_id
+            )
+        except StopIteration:
+            raise KeyError(f"No request builder with id {request_builder_id} found.")
+
+    @property
+    def exception_ids(self) -> Set[int]:
+        exceptions_set = set()
+        for group in self.yaml_data["operationGroups"]:
+            for operation in group["operations"]:
+                if not operation.get("exceptions"):
+                    continue
+                for exception in operation["exceptions"]:
+                    if not exception.get("schema"):
+                        continue
+                    exceptions_set.add(id(exception["schema"]))
+        return exceptions_set
+
     @staticmethod
     def _sort_schemas_helper(current, seen_schema_names, seen_schema_yaml_ids):
         if current.id in seen_schema_yaml_ids:
@@ -125,12 +143,16 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
                     continue
                 seen_schema_names.add(current.name)
                 seen_schema_yaml_ids.add(current.id)
-                ancestors = CodeModel._sort_schemas_helper(parent, seen_schema_names, seen_schema_yaml_ids) + ancestors
+                ancestors = (
+                    CodeModel._sort_schemas_helper(
+                        parent, seen_schema_names, seen_schema_yaml_ids
+                    )
+                    + ancestors
+                )
         seen_schema_names.add(current.name)
         seen_schema_yaml_ids.add(current.id)
         return ancestors
 
-
     def sort_schemas(self) -> None:
         """Sorts the final object schemas by inheritance and by alphabetical order.
 
@@ -141,12 +163,17 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
         seen_schema_yaml_ids: Set[int] = set()
         sorted_schemas: List[ObjectSchema] = []
         for schema in sorted(self.schemas.values(), key=lambda x: x.name.lower()):
-            sorted_schemas.extend(CodeModel._sort_schemas_helper(schema, seen_schema_names, seen_schema_yaml_ids))
+            sorted_schemas.extend(
+                CodeModel._sort_schemas_helper(
+                    schema, seen_schema_names, seen_schema_yaml_ids
+                )
+            )
         self.sorted_schemas = sorted_schemas
 
     def setup_client_input_parameters(self, yaml_data: Dict[str, Any]):
         dollar_host = [
-            parameter for parameter in self.global_parameters
+            parameter
+            for parameter in self.global_parameters
             if parameter.rest_api_name == "$host"
         ]
         if not dollar_host:
@@ -154,14 +181,18 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
             # So far now, let's get the first one in the first operation
             # UGLY as hell.....
             if yaml_data.get("operationGroups"):
-                first_req_of_first_op_of_first_grp = yaml_data["operationGroups"][0]["operations"][0]["requests"][0]
+                first_req_of_first_op_of_first_grp = yaml_data["operationGroups"][0][
+                    "operations"
+                ][0]["requests"][0]
                 self.service_client.parameterized_host_template = (
                     first_req_of_first_op_of_first_grp["protocol"]["http"]["uri"]
                 )
         else:
             for host in dollar_host:
                 self.global_parameters.remove(host)
-            self.service_client.parameters.add_host(dollar_host[0].yaml_data["clientDefaultValue"])
+            self.service_client.parameters.add_host(
+                dollar_host[0].yaml_data["clientDefaultValue"]
+            )
 
     def format_lro_operations(self) -> None:
         """Adds operations and attributes needed for LROs.
@@ -178,8 +209,8 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
                 i += 1
 
     def remove_next_operation(self) -> None:
-        """Linking paging operations together.
-        """
+        """Linking paging operations together."""
+
         def _lookup_operation(yaml_id: int) -> Operation:
             for operation_group in self.operation_groups:
                 for operation in operation_group.operations:
@@ -192,15 +223,21 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
             for operation in operation_group.operations:
                 # when we add in "LRO" functions we don't include yaml_data, so yaml_data can be empty in these cases
                 next_link_yaml = None
-                if operation.yaml_data and operation.yaml_data['language']['python'].get('paging'):
-                    next_link_yaml = operation.yaml_data['language']['python']['paging'].get('nextLinkOperation')
+                if operation.yaml_data and operation.yaml_data["language"][
+                    "python"
+                ].get("paging"):
+                    next_link_yaml = operation.yaml_data["language"]["python"][
+                        "paging"
+                    ].get("nextLinkOperation")
                 if isinstance(operation, PagingOperation) and next_link_yaml:
                     next_operation = _lookup_operation(id(next_link_yaml))
                     operation.next_operation = next_operation
                     next_operations.append(next_operation)
 
             operation_group.operations = [
-                operation for operation in operation_group.operations if operation not in next_operations
+                operation
+                for operation in operation_group.operations
+                if operation not in next_operations
             ]
 
     @property
@@ -208,18 +245,16 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
         return self.schemas or self.enums
 
     @property
-    def default_authentication_policy(self) -> Type[CredentialSchemaPolicy]:
-        return ARMChallengeAuthenticationPolicy if self.options['azure_arm'] else BearerTokenCredentialPolicy
-
-    @property
-    def credential_schema_policy(self) -> CredentialSchemaPolicy:
-        if not self._credential_schema_policy:
-            raise ValueError("You want to find the Credential Schema Policy, but have not given a value")
-        return self._credential_schema_policy
+    def credential_model(self) -> CredentialModel:
+        if not self._credential_model:
+            raise ValueError(
+                "You want to find the Credential Model, but have not given a value"
+            )
+        return self._credential_model
 
-    @credential_schema_policy.setter
-    def credential_schema_policy(self, val: CredentialSchemaPolicy) -> None:
-        self._credential_schema_policy = val
+    @credential_model.setter
+    def credential_model(self, val: CredentialModel) -> None:
+        self._credential_model = val
 
     @staticmethod
     def _add_properties_from_inheritance_helper(schema, properties) -> List[Property]:
@@ -230,14 +265,17 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
                 parent = cast(ObjectSchema, base_model)
                 # need to make sure that the properties we choose from our parent also don't contain
                 # any of our own properties
-                schema_property_names = set([p.name for p in properties] + [p.name for p in schema.properties])
+                schema_property_names = set(
+                    [p.name for p in properties] + [p.name for p in schema.properties]
+                )
                 chosen_parent_properties = [
-                    p for p in parent.properties
-                    if p.name not in schema_property_names
+                    p for p in parent.properties if p.name not in schema_property_names
                 ]
                 properties = (
-                    CodeModel._add_properties_from_inheritance_helper(parent, chosen_parent_properties) +
-                    properties
+                    CodeModel._add_properties_from_inheritance_helper(
+                        parent, chosen_parent_properties
+                    )
+                    + properties
                 )
 
         return properties
@@ -258,7 +296,9 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
         :rtype: None
         """
         for schema in self.schemas.values():
-            schema.properties = CodeModel._add_properties_from_inheritance_helper(schema, schema.properties)
+            schema.properties = CodeModel._add_properties_from_inheritance_helper(
+                schema, schema.properties
+            )
 
     @staticmethod
     def _add_exceptions_from_inheritance_helper(schema) -> bool:
@@ -267,7 +307,9 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
         parent_is_exception: List[bool] = []
         for base_model in schema.base_models:
             parent = cast(ObjectSchema, base_model)
-            parent_is_exception.append(CodeModel._add_exceptions_from_inheritance_helper(parent))
+            parent_is_exception.append(
+                CodeModel._add_exceptions_from_inheritance_helper(parent)
+            )
         return any(parent_is_exception)
 
     def _add_exceptions_from_inheritance(self) -> None:
@@ -277,7 +319,9 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
         :rtype: None
         """
         for schema in self.schemas.values():
-            schema.is_exception = CodeModel._add_exceptions_from_inheritance_helper(schema)
+            schema.is_exception = CodeModel._add_exceptions_from_inheritance_helper(
+                schema
+            )
 
     def add_inheritance_to_models(self) -> None:
         """Adds base classes and properties from base classes to schemas with parents.
@@ -288,7 +332,9 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
         for schema in self.schemas.values():
             if schema.base_models:
                 # right now, the base model property just holds the name of the parent class
-                schema.base_models = [b for b in self.schemas.values() if b.id in schema.base_models]
+                schema.base_models = [
+                    b for b in self.schemas.values() if b.id in schema.base_models
+                ]
         self._add_properties_from_inheritance()
         self._add_exceptions_from_inheritance()
 
@@ -300,100 +346,69 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
                     return
         raise KeyError("Didn't find the target property")
 
-    def _populate_schema(self, obj: Any) -> None:
-        schema_obj = obj.schema
-        if schema_obj and not isinstance(schema_obj, dict):
-            return
-
-        if schema_obj:
-            schema_obj_id = id(obj.schema)
-            _LOGGER.debug("Looking for id %s for member %s", schema_obj_id, obj)
-            try:
-                obj.schema = self.lookup_schema(schema_obj_id)
-            except KeyError:
-                _LOGGER.critical("Unable to ref the object")
-                raise
-        if isinstance(obj, Parameter) and obj.target_property_name:
-            self._populate_target_property(obj)
-        if isinstance(obj, SchemaResponse) and obj.is_stream_response:
-            obj.schema = IOSchema(namespace=None, yaml_data={})
-
-    def add_schema_link_to_operation(self) -> None:
-        """Puts created schemas into operation classes `schema` property
-
-        :return: None
-        :rtype: None
-        """
-        # Index schemas
-        for operation_group in self.operation_groups:
-            for operation in operation_group.operations:
-                for obj in chain(
-                    operation.parameters,
-                    operation.multiple_content_type_parameters or [],
-                    operation.responses,
-                    operation.exceptions,
-                    chain.from_iterable(response.headers for response in operation.responses),
-                ):
-                    self._populate_schema(obj)
-
-    def add_schema_link_to_request_builder(self) -> None:
-        for request_builder in self.rest.request_builders:
-            for obj in chain(
-                request_builder.parameters,
-                chain.from_iterable(request.parameters for request in request_builder.schema_requests),
-                request_builder.responses,
-            ):
-                self._populate_schema(obj)
-
-
-    def add_schema_link_to_global_parameters(self) -> None:
-        for parameter in self.global_parameters:
-            self._populate_schema(parameter)
-
     def generate_single_parameter_from_multiple_content_types_operation(self) -> None:
         for operation_group in self.operation_groups:
             for operation in operation_group.operations:
                 if operation.multiple_content_type_parameters:
                     operation.convert_multiple_content_type_parameters()
 
-    @property
-    def need_vendored_code(self) -> bool:
-        return self.need_request_converter or self.need_format_url
+    def need_vendored_code(self, async_mode: bool) -> bool:
+        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 self.options["show_operations"] and not self.options["version_tolerant"]
+        return (
+            self.options["show_operations"]
+            and bool(self.request_builders)
+            and not self.options["version_tolerant"]
+        )
 
     @property
     def need_format_url(self) -> bool:
-        return any(rq for rq in self.rest.request_builders if rq.parameters.path)
+        return any(rq for rq in self.request_builders if rq.parameters.path)
 
     @property
-    def has_lro_operations(self) -> bool:
-        return any([
-            isinstance(operation, LROOperation)
-            for operation_group in self.operation_groups
-            for operation in operation_group.operations
-        ])
-
-    def _lookup_request_builder(self, schema_id: int) -> RequestBuilder:
-        """Looks to see if the schema has already been created.
+    def need_mixin_abc(self) -> bool:
+        return any(
+            o
+            for o in self.operation_groups
+            if o.is_empty_operation_group and self.options["python3_only"]
+        )
 
-        :param int schema_id: The yaml id of the schema
-        :return: If created, we return the created schema, otherwise, we throw.
-        :rtype: ~autorest.models.RequestBuilder
-        :raises: KeyError if schema is not found
-        """
-        for elt_key, elt_value in self.request_builder_ids.items():  # type: ignore
-            if schema_id == elt_key:
-                return elt_value
-        raise KeyError("Didn't find it!!!!!")
+    @property
+    def has_lro_operations(self) -> bool:
+        return any(
+            [
+                isinstance(operation, LROOperation)
+                for operation_group in self.operation_groups
+                for operation in operation_group.operations
+            ]
+        )
 
     def link_operation_to_request_builder(self) -> None:
         for operation_group in self.operation_groups:
             for operation in operation_group.operations:
-                request_builder = self._lookup_request_builder(id(operation.yaml_data))
+                request_builder = operation.request_builder
                 if isinstance(operation, LROOperation):
                     request_builder.name = request_builder.name + "_initial"
                 operation.request_builder = request_builder
                 operation.link_body_kwargs_to_body_params()
+
+    def get_models_filename(self, is_python3_file: bool) -> str:
+        if (
+            self.options["version_tolerant"] or self.options["low_level_client"]
+        ) and self.options["python3_only"]:
+            return "_models"
+        if is_python3_file:
+            return "_models_py3"
+        return "_models"
+
+    @property
+    def enums_filename(self) -> str:
+        if self.options["version_tolerant"] or self.options["low_level_client"]:
+            return "_enums"
+        return f"_{self.module_name}_enums"

package/autorest/codegen/models/constant_schema.py

@@ -4,11 +4,14 @@
 # license information.
 # --------------------------------------------------------------------------
 import logging
-from typing import Dict, Any, Optional
+from typing import Dict, Any, Optional, TYPE_CHECKING
 from .base_schema import BaseSchema
 from .primitive_schemas import get_primitive_schema, PrimitiveSchema
 from .imports import FileImport
 
+if TYPE_CHECKING:
+    from .code_model import CodeModel
+
 _LOGGER = logging.getLogger(__name__)
 
 
@@ -23,9 +26,13 @@ class ConstantSchema(BaseSchema):
     """
 
     def __init__(
-        self, namespace: str, yaml_data: Dict[str, Any], schema: PrimitiveSchema, value: Optional[str],
+        self,
+        yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+        schema: PrimitiveSchema,
+        value: Optional[str],
     ) -> None:
-        super(ConstantSchema, self).__init__(namespace=namespace, yaml_data=yaml_data)
+        super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.value = value
         self.schema = schema
 
@@ -33,7 +40,8 @@ class ConstantSchema(BaseSchema):
         if value != self.value:
             _LOGGER.warning(
                 "Passed in value of %s differs from constant value of %s. Choosing constant value",
-                str(value), str(self.value)
+                str(value),
+                str(self.value),
             )
         if self.value is None:
             return "None"
@@ -60,12 +68,13 @@ class ConstantSchema(BaseSchema):
         """
         return self.schema.docstring_type
 
-    @property
-    def type_annotation(self) -> str:
-        return self.schema.type_annotation
+    def type_annotation(self, *, is_operation_file: bool = False) -> str:
+        return self.schema.type_annotation(is_operation_file=is_operation_file)
 
     @classmethod
-    def from_yaml(cls, namespace: str, yaml_data: Dict[str, Any], **kwargs) -> "ConstantSchema":
+    def from_yaml(
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+    ) -> "ConstantSchema":
         """Constructs a ConstantSchema from yaml data.
 
         :param yaml_data: the yaml data from which we will construct this schema
@@ -74,24 +83,31 @@ class ConstantSchema(BaseSchema):
         :return: A created ConstantSchema
         :rtype: ~autorest.models.ConstantSchema
         """
-        name = yaml_data["language"]["python"]["name"] if yaml_data["language"]["python"].get("name") else ""
+        name = (
+            yaml_data["language"]["python"]["name"]
+            if yaml_data["language"]["python"].get("name")
+            else ""
+        )
         _LOGGER.debug("Parsing %s constant", name)
         return cls(
-            namespace=namespace,
             yaml_data=yaml_data,
-            schema=get_primitive_schema(namespace=namespace, yaml_data=yaml_data["valueType"]),
+            code_model=code_model,
+            schema=get_primitive_schema(
+                yaml_data=yaml_data["valueType"], code_model=code_model
+            ),
             value=yaml_data.get("value", {}).get("value", None),
         )
 
     def get_json_template_representation(self, **kwargs: Any) -> Any:
-        kwargs['default_value_declaration'] = self.schema.get_declaration(self.value)
+        kwargs["default_value_declaration"] = self.schema.get_declaration(self.value)
         return self.schema.get_json_template_representation(**kwargs)
 
-    def get_files_and_data_template_representation(self, **kwargs: Any) -> Any:
-        kwargs['default_value_declaration'] = self.schema.get_declaration(self.value)
-        return self.schema.get_files_and_data_template_representation(**kwargs)
-
     def imports(self) -> FileImport:
         file_import = FileImport()
         file_import.merge(self.schema.imports())
         return file_import
+
+    def model_file_imports(self) -> FileImport:
+        file_import = self.imports()
+        file_import.merge(self.schema.model_file_imports())
+        return file_import

package/autorest/codegen/models/credential_model.py

@@ -0,0 +1,55 @@
+# -------------------------------------------------------------------------
+# 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 Set, Optional, Type
+from .credential_schema_policy import (
+    CredentialSchemaPolicy,
+    BearerTokenCredentialPolicy,
+)
+from .credential_schema_policy import ARMChallengeAuthenticationPolicy
+from .credential_schema import TokenCredentialSchema, AzureKeyCredentialSchema
+
+
+class CredentialModel:
+    """Store info about credential."""
+
+    def __init__(self, azure_arm: bool) -> None:
+        self.azure_arm: bool = azure_arm
+        self.credential_scopes: Set[str] = set()
+        self.key_header_name: str = ""
+        self.policy_type: Optional[Type[CredentialSchemaPolicy]] = None
+        self._credential_schema_policy: Optional[CredentialSchemaPolicy] = None
+
+    @property
+    def default_authentication_policy(self) -> Type[CredentialSchemaPolicy]:
+        return (
+            ARMChallengeAuthenticationPolicy
+            if self.azure_arm
+            else BearerTokenCredentialPolicy
+        )
+
+    @property
+    def credential_schema_policy(self) -> CredentialSchemaPolicy:
+        if not self._credential_schema_policy:
+            raise ValueError(
+                "You want to find the Credential Schema Policy, but have not given a value"
+            )
+        return self._credential_schema_policy
+
+    def build_authentication_policy(self):
+        if hasattr(self.policy_type, "credential_scopes"):
+            self._credential_schema_policy = (
+                self.policy_type(  # pylint: disable=not-callable
+                    credential=TokenCredentialSchema(async_mode=False),
+                    credential_scopes=list(self.credential_scopes),
+                )
+            )
+        elif hasattr(self.policy_type, "credential_key_header_name"):
+            self._credential_schema_policy = (
+                self.policy_type(  # pylint: disable=not-callable
+                    credential=AzureKeyCredentialSchema(),
+                    credential_key_header_name=self.key_header_name,
+                )
+            )