@autorest/python 5.14.0 → 5.17.0

package/autorest/codegen/models/constant_type.py

@@ -0,0 +1,122 @@
+# -------------------------------------------------------------------------
+# 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 Dict, Any, Optional, TYPE_CHECKING
+from .base_type import BaseType
+from .imports import FileImport
+from .utils import add_to_description
+
+if TYPE_CHECKING:
+    from .code_model import CodeModel
+
+_LOGGER = logging.getLogger(__name__)
+
+
+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.PrimitiveType
+    """
+
+    def __init__(
+        self,
+        yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+        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
+
+    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),
+                str(self.value),
+            )
+        if self.value is None:
+            return "None"
+        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:
+        """Returns the serialization value for msrest.
+
+        :return: The serialization value for msrest
+        :rtype: str
+        """
+        return self.value_type.serialization_type
+
+    def docstring_text(self, **kwargs: Any) -> str:
+        return "constant"
+
+    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.value_type.docstring_type(**kwargs)
+
+    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"
+    ) -> "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 ConstantType
+        :rtype: ~autorest.models.ConstantType
+        """
+        from . import build_type
+
+        return cls(
+            yaml_data=yaml_data,
+            code_model=code_model,
+            value_type=build_type(yaml_data["valueType"], code_model),
+            value=yaml_data["value"],
+        )
+
+    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, **kwargs: Any) -> FileImport:
+        file_import = FileImport()
+        file_import.merge(self.value_type.imports(**kwargs))
+        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_type.py

@@ -0,0 +1,116 @@
+# -------------------------------------------------------------------------
+# 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, Optional, TYPE_CHECKING
+from .base_type import BaseType
+from .imports import FileImport, ImportType, TypingSection
+
+if TYPE_CHECKING:
+    from .code_model import CodeModel
+
+
+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.BaseType
+    """
+
+    def __init__(
+        self,
+        yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+        element_type: BaseType,
+    ) -> None:
+        super().__init__(yaml_data=yaml_data, code_model=code_model)
+        self.element_type = element_type
+
+    @property
+    def serialization_type(self) -> str:
+        """Returns the serialization value for msrest.
+
+        :return: The serialization value for msrest
+        :rtype: str
+        """
+        return f"{{{self.element_type.serialization_type}}}"
+
+    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(**kwargs)}]"
+
+    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 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(**kwargs)}]"
+
+    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(
+                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"
+    ) -> "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 DictionaryType
+        :rtype: ~autorest.models.DictionaryType
+        """
+        element_schema: Dict[str, Any] = yaml_data["elementType"]
+
+        from . import build_type  # pylint: disable=import-outside-toplevel
+
+        element_type = build_type(yaml_data=element_schema, code_model=code_model)
+
+        return cls(
+            yaml_data=yaml_data,
+            code_model=code_model,
+            element_type=element_type,
+        )
+
+    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(**kwargs))
+        return file_import
+
+    @property
+    def instance_check_template(self) -> str:
+        return "isinstance({}, dict)"

package/autorest/codegen/models/enum_type.py

@@ -0,0 +1,195 @@
+# -------------------------------------------------------------------------
+# 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, List, TYPE_CHECKING, Optional
+
+from .base_type import BaseType
+from .imports import FileImport, ImportType, TypingSection
+from .base_model import BaseModel
+
+if TYPE_CHECKING:
+    from .code_model import CodeModel
+
+
+class EnumValue(BaseModel):
+    """Model containing necessary information for a single value of an enum.
+
+    :param str name: The name of this enum value
+    :param str value: The value of this enum value
+    :param str description: Optional. The description for this enum value
+    """
+
+    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+        super().__init__(yaml_data=yaml_data, code_model=code_model)
+        self.name: str = self.yaml_data["name"]
+        self.value: str = self.yaml_data["value"]
+        self.description: Optional[str] = self.yaml_data.get("description")
+
+    @classmethod
+    def from_yaml(
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+    ) -> "EnumValue":
+        """Constructs an EnumValue from yaml data.
+
+        :param yaml_data: the yaml data from which we will construct this object
+        :type yaml_data: dict[str, Any]
+
+        :return: A created EnumValue
+        :rtype: ~autorest.models.EnumValue
+        """
+        return cls(
+            yaml_data=yaml_data,
+            code_model=code_model,
+        )
+
+
+class EnumType(BaseType):
+    """Schema for enums that will be serialized.
+
+    :param yaml_data: the yaml data for this schema
+    :type yaml_data: dict[str, Any]
+    :param str description: The description of this enum
+    :param str name: The name of the enum.
+    :type element_type: ~autorest.models.PrimitiveType
+    :param values: List of the values for this enum
+    :type values: list[~autorest.models.EnumValue]
+    """
+
+    def __init__(
+        self,
+        yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+        values: List["EnumValue"],
+        value_type: BaseType,
+    ) -> None:
+        super().__init__(yaml_data=yaml_data, code_model=code_model)
+        self.name: str = yaml_data["name"]
+        self.values = values
+        self.value_type = value_type
+
+    def __lt__(self, other):
+        return self.name.lower() < other.name.lower()
+
+    @property
+    def serialization_type(self) -> str:
+        """Returns the serialization value for msrest.
+
+        :return: The serialization value for msrest
+        :rtype: str
+        """
+        return self.value_type.serialization_type
+
+    def description(
+        self, *, is_operation_file: bool  # pylint: disable=unused-argument
+    ) -> str:
+        possible_values = [self.get_declaration(v.value) for v in self.values]
+        if not possible_values:
+            return ""
+        if len(possible_values) == 1:
+            return possible_values[0]
+        if len(possible_values) == 2:
+            possible_values_str = " and ".join(possible_values)
+        else:
+            possible_values_str = (
+                ", ".join(possible_values[: len(possible_values) - 1])
+                + f", and {possible_values[-1]}"
+            )
+
+        enum_description = f"Known values are: {possible_values_str}."
+        return enum_description
+
+    def type_annotation(self, **kwargs: Any) -> str:
+        """The python type used for type annotation
+
+        :return: The type annotation for this schema
+        :rtype: str
+        """
+        if self.code_model.options["models_mode"]:
+            return (
+                f"Union[{self.value_type.type_annotation(**kwargs)},"
+                f' "_models.{self.name}"]'
+            )
+        return self.value_type.type_annotation(**kwargs)
+
+    def get_declaration(self, value: Any) -> str:
+        return self.value_type.get_declaration(value)
+
+    def docstring_text(self, **kwargs: Any) -> str:
+        if self.code_model.options["models_mode"]:
+            return self.name
+        return self.value_type.type_annotation(**kwargs)
+
+    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}"
+        return self.value_type.type_annotation(**kwargs)
+
+    def get_json_template_representation(
+        self,
+        *,
+        optional: bool = True,
+        client_default_value_declaration: Optional[str] = None,
+        description: Optional[str] = None,
+    ) -> Any:
+        # for better display effect, use the only value instead of var type
+        return self.value_type.get_json_template_representation(
+            optional=optional,
+            client_default_value_declaration=client_default_value_declaration,
+            description=description,
+        )
+
+    @property
+    def instance_check_template(self) -> str:
+        return self.value_type.instance_check_template
+
+    @classmethod
+    def from_yaml(
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+    ) -> "EnumType":
+        """Constructs an EnumType 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 EnumType
+        :rtype: ~autorest.models.EnumType
+        """
+        from . import build_type
+
+        return cls(
+            yaml_data=yaml_data,
+            code_model=code_model,
+            value_type=build_type(yaml_data["valueType"], code_model),
+            values=[
+                EnumValue.from_yaml(value, code_model) for value in yaml_data["values"]
+            ],
+        )
+
+    def imports(self, **kwargs: Any) -> FileImport:
+        is_operation_file = kwargs.pop("is_operation_file", False)
+        file_import = FileImport()
+        if self.code_model.options["models_mode"]:
+            file_import.add_submodule_import(
+                "typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL
+            )
+            if not is_operation_file:
+                file_import.add_submodule_import(
+                    "..",
+                    "models",
+                    ImportType.LOCAL,
+                    TypingSection.TYPING,
+                    alias="_models",
+                )
+        file_import.merge(
+            self.value_type.imports(is_operation_file=is_operation_file, **kwargs)
+        )
+        relative_path = kwargs.pop("relative_path", None)
+        if self.code_model.options["models_mode"] and relative_path:
+            # add import for enums in operations file
+            file_import.add_submodule_import(
+                relative_path, "models", ImportType.LOCAL, alias="_models"
+            )
+        return file_import