@autorest/python 5.16.0 → 5.17.0

package/autorest/codegen/models/{constant_schema.py → constant_type.py}

@@ -5,9 +5,9 @@
 # --------------------------------------------------------------------------
 import logging
 from typing import Dict, Any, Optional, TYPE_CHECKING
-from .base_schema import BaseSchema
-from .primitive_schemas import get_primitive_schema, PrimitiveSchema
+from .base_type import BaseType
 from .imports import FileImport
+from .utils import add_to_description
 
 if TYPE_CHECKING:
     from .code_model import CodeModel
@@ -15,29 +15,29 @@ if TYPE_CHECKING:
 _LOGGER = logging.getLogger(__name__)
 
 
-class ConstantSchema(BaseSchema):
+class ConstantType(BaseType):
     """Schema for constants that will be serialized.
 
     :param yaml_data: the yaml data for this schema
     :type yaml_data: dict[str, Any]
     :param str value: The actual value of this constant.
     :param schema: The schema for the value of this constant.
-    :type schema: ~autorest.models.PrimitiveSchema
+    :type schema: ~autorest.models.PrimitiveType
     """
 
     def __init__(
         self,
         yaml_data: Dict[str, Any],
         code_model: "CodeModel",
-        schema: PrimitiveSchema,
+        value_type: BaseType,
         value: Optional[str],
     ) -> None:
         super().__init__(yaml_data=yaml_data, code_model=code_model)
+        self.value_type = value_type
         self.value = value
-        self.schema = schema
 
-    def get_declaration(self, value: Any):
-        if value != self.value:
+    def get_declaration(self, value=None):
+        if value and value != self.value:
             _LOGGER.warning(
                 "Passed in value of %s differs from constant value of %s. Choosing constant value",
                 str(value),
@@ -45,7 +45,15 @@ class ConstantSchema(BaseSchema):
             )
         if self.value is None:
             return "None"
-        return self.schema.get_declaration(self.value)
+        return self.value_type.get_declaration(self.value)
+
+    def description(self, *, is_operation_file: bool) -> str:
+        if is_operation_file:
+            return ""
+        return add_to_description(
+            self.yaml_data.get("description", ""),
+            f"Default value is {self.get_declaration()}.",
+        )
 
     @property
     def serialization_type(self) -> str:
@@ -54,60 +62,61 @@ class ConstantSchema(BaseSchema):
         :return: The serialization value for msrest
         :rtype: str
         """
-        return self.schema.serialization_type
+        return self.value_type.serialization_type
 
-    @property
-    def docstring_text(self) -> str:
+    def docstring_text(self, **kwargs: Any) -> str:
         return "constant"
 
-    @property
-    def docstring_type(self) -> str:
+    def docstring_type(self, **kwargs: Any) -> str:
         """The python type used for RST syntax input and type annotation.
 
         :param str namespace: Optional. The namespace for the models.
         """
-        return self.schema.docstring_type
+        return self.value_type.docstring_type(**kwargs)
 
-    def type_annotation(self, *, is_operation_file: bool = False) -> str:
-        return self.schema.type_annotation(is_operation_file=is_operation_file)
+    def type_annotation(self, **kwargs: Any) -> str:
+        return self.value_type.type_annotation(**kwargs)
 
     @classmethod
     def from_yaml(
         cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
-    ) -> "ConstantSchema":
-        """Constructs a ConstantSchema from yaml data.
+    ) -> "ConstantType":
+        """Constructs a ConstantType from yaml data.
 
         :param yaml_data: the yaml data from which we will construct this schema
         :type yaml_data: dict[str, Any]
 
-        :return: A created ConstantSchema
-        :rtype: ~autorest.models.ConstantSchema
+        :return: A created ConstantType
+        :rtype: ~autorest.models.ConstantType
         """
-        name = (
-            yaml_data["language"]["python"]["name"]
-            if yaml_data["language"]["python"].get("name")
-            else ""
-        )
-        _LOGGER.debug("Parsing %s constant", name)
+        from . import build_type
+
         return cls(
             yaml_data=yaml_data,
             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),
+            value_type=build_type(yaml_data["valueType"], code_model),
+            value=yaml_data["value"],
         )
 
-    def get_json_template_representation(self, **kwargs: Any) -> Any:
-        kwargs["default_value_declaration"] = self.schema.get_declaration(self.value)
-        return self.schema.get_json_template_representation(**kwargs)
+    def get_json_template_representation(
+        self,
+        *,
+        optional: bool = True,
+        # pylint: disable=unused-argument
+        client_default_value_declaration: Optional[str] = None,
+        description: Optional[str] = None,
+    ) -> Any:
+        return self.value_type.get_json_template_representation(
+            optional=optional,
+            client_default_value_declaration=self.get_declaration(),
+            description=description,
+        )
 
-    def imports(self) -> FileImport:
+    def imports(self, **kwargs: Any) -> FileImport:
         file_import = FileImport()
-        file_import.merge(self.schema.imports())
+        file_import.merge(self.value_type.imports(**kwargs))
         return file_import
 
-    def model_file_imports(self) -> FileImport:
-        file_import = self.imports()
-        file_import.merge(self.schema.model_file_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

@@ -0,0 +1,224 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+from abc import abstractmethod
+from typing import (
+    Optional,
+    Any,
+    Dict,
+    TYPE_CHECKING,
+    List,
+    Generic,
+    TypeVar,
+    Union,
+    cast,
+)
+
+from .imports import FileImport, ImportType, TypingSection
+from .base_type import BaseType
+
+if TYPE_CHECKING:
+    from .code_model import CodeModel
+
+
+class _CredentialPolicyBaseType:
+    """Base class for our different credential policy types.
+
+    Inherited by our BearerTokenCredentialPolicy and AzureKeyCredentialPolicy types.
+    """
+
+    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+        self.yaml_data = yaml_data
+        self.code_model = code_model
+
+    @abstractmethod
+    def call(self, async_mode: bool) -> str:
+        """
+        How to call this credential policy. Used to initialize the credential policy in the config file.
+        """
+        ...
+
+
+class BearerTokenCredentialPolicyType(_CredentialPolicyBaseType):
+    """Credential policy type representing BearerTokenCredentialPolicy"""
+
+    def __init__(
+        self,
+        yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+        credential_scopes: List[str],
+    ) -> None:
+        super().__init__(yaml_data, code_model)
+        self.credential_scopes = credential_scopes
+
+    def call(self, async_mode: bool) -> str:
+        policy_name = f"{'Async' if async_mode else ''}BearerTokenCredentialPolicy"
+        return f"policies.{policy_name}(self.credential, *self.credential_scopes, **kwargs)"
+
+    @classmethod
+    def from_yaml(
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+    ) -> "BearerTokenCredentialPolicyType":
+        return cls(yaml_data, code_model, yaml_data["credentialScopes"])
+
+
+class ARMChallengeAuthenticationPolicyType(BearerTokenCredentialPolicyType):
+    """Credential policy type representing ARMChallengeAuthenticationPolicy"""
+
+    def call(self, async_mode: bool) -> str:
+        policy_name = f"{'Async' if async_mode else ''}ARMChallengeAuthenticationPolicy"
+        return f"{policy_name}(self.credential, *self.credential_scopes, **kwargs)"
+
+
+class AzureKeyCredentialPolicyType(_CredentialPolicyBaseType):
+    def __init__(
+        self, yaml_data: Dict[str, Any], code_model: "CodeModel", key: str
+    ) -> None:
+        super().__init__(yaml_data, code_model)
+        self.key = key
+
+    def call(self, async_mode: bool) -> str:
+        return f'policies.AzureKeyCredentialPolicy(self.credential, "{self.key}", **kwargs)'
+
+    @classmethod
+    def from_yaml(
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+    ) -> "AzureKeyCredentialPolicyType":
+        return cls(yaml_data, code_model, yaml_data["key"])
+
+
+CredentialPolicyType = TypeVar(
+    "CredentialPolicyType",
+    bound=Union[
+        BearerTokenCredentialPolicyType,
+        ARMChallengeAuthenticationPolicyType,
+        AzureKeyCredentialPolicyType,
+    ],
+)
+
+
+class CredentialType(
+    Generic[CredentialPolicyType], BaseType
+):  # pylint:disable=abstract-method
+    """Store info about the type of the credential. Can be either an AzureKeyCredential or a TokenCredential"""
+
+    def __init__(
+        self,
+        yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+        policy: CredentialPolicyType,
+    ) -> None:
+        super().__init__(yaml_data, code_model)
+        self.policy = policy
+
+    def description(
+        self, *, is_operation_file: bool  # pylint: disable=unused-argument
+    ) -> str:
+        return ""
+
+    def get_json_template_representation(
+        self,
+        *,
+        optional: bool = True,
+        client_default_value_declaration: Optional[str] = None,
+        description: Optional[str] = None,
+    ) -> Any:
+        raise TypeError(
+            "You should not try to get a JSON template representation of a CredentialSchema"
+        )
+
+    def docstring_text(self, **kwargs: Any) -> str:
+        return "credential"
+
+    @property
+    def serialization_type(self) -> str:
+        return self.docstring_type()
+
+    @classmethod
+    def from_yaml(
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+    ) -> "CredentialType":
+        from . import build_type
+
+        return cls(
+            yaml_data,
+            code_model,
+            policy=cast(
+                CredentialPolicyType, build_type(yaml_data["policy"], code_model)
+            ),
+        )
+
+
+class TokenCredentialType(
+    CredentialType[  # pylint: disable=unsubscriptable-object
+        Union[BearerTokenCredentialPolicyType, ARMChallengeAuthenticationPolicyType]
+    ]
+):
+    """Type of a token credential. Used by BearerAuth and ARMChallenge policies"""
+
+    def type_annotation(self, **kwargs: Any) -> str:  # pylint: disable=no-self-use
+        if kwargs.pop("async_mode"):
+            return '"AsyncTokenCredential"'
+        return '"TokenCredential"'
+
+    def docstring_type(self, **kwargs: Any) -> str:  # pylint: disable=no-self-use
+        if kwargs.pop("async_mode"):
+            return "~azure.core.credentials_async.AsyncTokenCredential"
+        return "~azure.core.credentials.TokenCredential"
+
+    def imports(self, **kwargs: Any) -> FileImport:  # pylint: disable=no-self-use
+        file_import = FileImport()
+        if kwargs.pop("async_mode"):
+            file_import.add_submodule_import(
+                "azure.core.credentials_async",
+                "AsyncTokenCredential",
+                ImportType.AZURECORE,
+                typing_section=TypingSection.TYPING,
+            )
+        else:
+            file_import.add_submodule_import(
+                "azure.core.credentials",
+                "TokenCredential",
+                ImportType.AZURECORE,
+                typing_section=TypingSection.TYPING,
+            )
+        return file_import
+
+    @property
+    def instance_check_template(self) -> str:
+        return "hasattr({}, get_token)"
+
+
+class AzureKeyCredentialType(
+    # pylint: disable=unsubscriptable-object
+    CredentialType[AzureKeyCredentialPolicyType]
+):
+    """Type for an AzureKeyCredential"""
+
+    def docstring_type(  # pylint: disable=no-self-use
+        self, **kwargs: Any  # pylint: disable=unused-argument
+    ) -> str:
+        return "~azure.core.credentials.AzureKeyCredential"
+
+    def type_annotation(  # pylint: disable=no-self-use
+        self, **kwargs: Any  # pylint: disable=unused-argument
+    ) -> str:
+        return "AzureKeyCredential"
+
+    @property
+    def instance_check_template(self) -> str:
+        return "isinstance({}, AzureKeyCredential)"
+
+    def imports(  # pylint: disable=no-self-use
+        self, **kwargs: Any  # pylint: disable=unused-argument
+    ) -> FileImport:
+        file_import = FileImport()
+        file_import.add_submodule_import(
+            "azure.core.credentials",
+            "AzureKeyCredential",
+            ImportType.AZURECORE,
+            typing_section=TypingSection.CONDITIONAL,
+        )
+        return file_import

package/autorest/codegen/models/{dictionary_schema.py → dictionary_type.py}

@@ -4,27 +4,27 @@
 # license information.
 # --------------------------------------------------------------------------
 from typing import Any, Dict, Optional, TYPE_CHECKING
-from .base_schema import BaseSchema
+from .base_type import BaseType
 from .imports import FileImport, ImportType, TypingSection
 
 if TYPE_CHECKING:
     from .code_model import CodeModel
 
 
-class DictionarySchema(BaseSchema):
+class DictionaryType(BaseType):
     """Schema for dictionaries that will be serialized.
 
     :param yaml_data: the yaml data for this schema
     :type yaml_data: dict[str, Any]
     :param element_type: The type of the value for the dictionary
-    :type element_type: ~autorest.models.BaseSchema
+    :type element_type: ~autorest.models.BaseType
     """
 
     def __init__(
         self,
         yaml_data: Dict[str, Any],
         code_model: "CodeModel",
-        element_type: "BaseSchema",
+        element_type: BaseType,
     ) -> None:
         super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.element_type = element_type
@@ -38,53 +38,64 @@ class DictionarySchema(BaseSchema):
         """
         return f"{{{self.element_type.serialization_type}}}"
 
-    def type_annotation(self, *, is_operation_file: bool = False) -> str:
+    def type_annotation(self, **kwargs: Any) -> str:
         """The python type used for type annotation
 
         :return: The type annotation for this schema
         :rtype: str
         """
-        return f"Dict[str, {self.element_type.type_annotation(is_operation_file=is_operation_file)}]"
+        return f"Dict[str, {self.element_type.type_annotation(**kwargs)}]"
 
-    @property
-    def docstring_text(self) -> str:
-        return f"dict mapping str to {self.element_type.docstring_text}"
+    def description(self, *, is_operation_file: bool) -> str:
+        return "" if is_operation_file else self.yaml_data.get("description", "")
+
+    def docstring_text(self, **kwargs: Any) -> str:
+        return f"dict mapping str to {self.element_type.docstring_text(**kwargs)}"
 
     @property
-    def docstring_type(self) -> str:
+    def xml_serialization_ctxt(self) -> Optional[str]:
+        """No serialization ctxt for dictionaries"""
+        return None
+
+    def docstring_type(self, **kwargs: Any) -> str:
         """The python type used for RST syntax input and type annotation.
 
         :param str namespace: Optional. The namespace for the models.
         """
-        return f"dict[str, {self.element_type.docstring_type}]"
-
-    def xml_serialization_ctxt(self) -> Optional[str]:
-        raise NotImplementedError(
-            "Dictionary schema does not support XML serialization."
-        )
+        return f"dict[str, {self.element_type.docstring_type(**kwargs)}]"
 
-    def get_json_template_representation(self, **kwargs: Any) -> Any:
+    def get_json_template_representation(
+        self,
+        *,
+        optional: bool = True,
+        client_default_value_declaration: Optional[str] = None,
+        description: Optional[str] = None,
+    ) -> Any:
         return {
-            f'"{"str"}"': self.element_type.get_json_template_representation(**kwargs)
+            f'"str"': self.element_type.get_json_template_representation(
+                optional=optional,
+                client_default_value_declaration=client_default_value_declaration,
+                description=description,
+            )
         }
 
     @classmethod
     def from_yaml(
         cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
-    ) -> "DictionarySchema":
-        """Constructs a DictionarySchema from yaml data.
+    ) -> "DictionaryType":
+        """Constructs a DictionaryType from yaml data.
 
         :param yaml_data: the yaml data from which we will construct this schema
         :type yaml_data: dict[str, Any]
 
-        :return: A created DictionarySchema
-        :rtype: ~autorest.models.DictionarySchema
+        :return: A created DictionaryType
+        :rtype: ~autorest.models.DictionaryType
         """
-        element_schema = yaml_data["elementType"]
+        element_schema: Dict[str, Any] = yaml_data["elementType"]
 
-        from . import build_schema  # pylint: disable=import-outside-toplevel
+        from . import build_type  # pylint: disable=import-outside-toplevel
 
-        element_type = build_schema(yaml_data=element_schema, code_model=code_model)
+        element_type = build_type(yaml_data=element_schema, code_model=code_model)
 
         return cls(
             yaml_data=yaml_data,
@@ -92,15 +103,14 @@ class DictionarySchema(BaseSchema):
             element_type=element_type,
         )
 
-    def imports(self) -> FileImport:
+    def imports(self, **kwargs: Any) -> FileImport:
         file_import = FileImport()
         file_import.add_submodule_import(
             "typing", "Dict", ImportType.STDLIB, TypingSection.CONDITIONAL
         )
-        file_import.merge(self.element_type.imports())
+        file_import.merge(self.element_type.imports(**kwargs))
         return file_import
 
-    def model_file_imports(self) -> FileImport:
-        file_import = self.imports()
-        file_import.merge(self.element_type.model_file_imports())
-        return file_import
+    @property
+    def instance_check_template(self) -> str:
+        return "isinstance({}, dict)"