@autorest/python 5.14.0 → 5.17.0

package/autorest/codegen/models/credential_schema_policy.py

@@ -1,77 +0,0 @@
-# -------------------------------------------------------------------------
-# 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 List
-from .credential_schema import CredentialSchema
-
-class CredentialSchemaPolicy:
-
-    def __init__(self, credential: CredentialSchema, *args, **kwargs) -> None:  # pylint: disable=unused-argument
-        self.credential = credential
-
-    @abstractmethod
-    def call(self, async_mode: bool) -> str:
-        ...
-
-    @classmethod
-    def name(cls):
-        return cls.__name__
-
-
-class BearerTokenCredentialPolicy(CredentialSchemaPolicy):
-
-    def __init__(
-        self,
-        credential: CredentialSchema,
-        credential_scopes: List[str]
-    ) -> None:
-        super().__init__(credential)
-        self._credential_scopes = credential_scopes
-
-    @property
-    def credential_scopes(self):
-        return self._credential_scopes
-
-    def call(self, async_mode: bool) -> str:
-        policy_name = f"Async{self.name()}" if async_mode else self.name()
-        return f"policies.{policy_name}(self.credential, *self.credential_scopes, **kwargs)"
-
-
-class ARMChallengeAuthenticationPolicy(BearerTokenCredentialPolicy):
-
-    def call(self, async_mode: bool) -> str:
-        policy_name = f"Async{self.name()}" if async_mode else self.name()
-        return f"{policy_name}(self.credential, *self.credential_scopes, **kwargs)"
-
-
-class AzureKeyCredentialPolicy(CredentialSchemaPolicy):
-
-    def __init__(
-        self,
-        credential: CredentialSchema,
-        credential_key_header_name: str
-    ) -> None:
-        super().__init__(credential)
-        self._credential_key_header_name = credential_key_header_name
-
-    @property
-    def credential_key_header_name(self):
-        return self._credential_key_header_name
-
-    def call(self, async_mode: bool) -> str:
-        return f'policies.AzureKeyCredentialPolicy(self.credential, "{self.credential_key_header_name}", **kwargs)'
-
-def get_credential_schema_policy_type(name):
-    policies = [ARMChallengeAuthenticationPolicy, BearerTokenCredentialPolicy, AzureKeyCredentialPolicy]
-    try:
-        return next(p for p in policies if p.name().lower() == name.lower())
-    except StopIteration:
-        raise ValueError(
-            "The credential policy you pass in with --credential-default-policy-type must be either "
-            "{}".format(
-                " or ".join([p.name() for p in policies])
-            )
-        )

package/autorest/codegen/models/dictionary_schema.py

@@ -1,103 +0,0 @@
-# -------------------------------------------------------------------------
-# 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
-from .base_schema import BaseSchema
-from .imports import FileImport, ImportType, TypingSection
-
-class DictionarySchema(BaseSchema):
-    """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
-    """
-
-    def __init__(
-        self,
-        namespace: str,
-        yaml_data: Dict[str, Any],
-        element_type: "BaseSchema"
-    ) -> None:
-        super(DictionarySchema, self).__init__(namespace=namespace, yaml_data=yaml_data)
-        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}}}"
-
-    @property
-    def type_annotation(self) -> 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}]"
-
-    @property
-    def operation_type_annotation(self) -> str:
-        return f"Dict[str, {self.element_type.operation_type_annotation}]"
-
-    @property
-    def docstring_text(self) -> str:
-        return f"dict mapping str to {self.element_type.docstring_text}"
-
-    @property
-    def docstring_type(self) -> 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.")
-
-    def get_json_template_representation(self, **kwargs: Any) -> Any:
-        return {
-            f'"{"str"}"' : self.element_type.get_json_template_representation(**kwargs)
-        }
-
-    def get_files_and_data_template_representation(self, **kwargs: Any) -> Any:
-        return {
-            f'"{"str"}"' : self.element_type.get_files_and_data_template_representation(**kwargs)
-        }
-
-    @classmethod
-    def from_yaml(cls, namespace: str, yaml_data: Dict[str, Any], **kwargs: Any) -> "DictionarySchema":
-        """Constructs a DictionarySchema 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
-        """
-        element_schema = yaml_data["elementType"]
-
-        from . import build_schema  # pylint: disable=import-outside-toplevel
-
-        element_type = build_schema(
-            yaml_data=element_schema, **kwargs
-        )
-
-        return cls(
-            namespace=namespace,
-            yaml_data=yaml_data,
-            element_type=element_type,
-        )
-
-    def imports(self) -> FileImport:
-        file_import = FileImport()
-        file_import.add_submodule_import("typing", "Dict", ImportType.STDLIB, TypingSection.CONDITIONAL)
-        file_import.merge(self.element_type.imports())
-        return file_import

package/autorest/codegen/models/enum_schema.py

@@ -1,246 +0,0 @@
-# -------------------------------------------------------------------------
-# 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, Optional, Set, Type
-from .base_schema import BaseSchema
-from .primitive_schemas import PrimitiveSchema, get_primitive_schema, StringSchema
-from .imports import FileImport, ImportType, TypingSection
-
-
-class EnumValue:
-    """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, name: str, value: str, description: Optional[str] = None) -> None:
-        self.name = name
-        self.value = value
-        self.description = description
-
-    @classmethod
-    def from_yaml(cls, yaml_data: Dict[str, Any]) -> "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(
-            name=yaml_data["language"]["python"]["name"],
-            value=yaml_data["value"],
-            description=yaml_data["language"]["python"].get("description"),
-        )
-
-
-class EnumSchema(BaseSchema):
-    """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.PrimitiveSchema
-    :param values: List of the values for this enum
-    :type values: list[~autorest.models.EnumValue]
-    """
-
-    def __init__(
-        self,
-        namespace: str,
-        yaml_data: Dict[str, Any],
-        description: str,
-        name: str,
-        values: List["EnumValue"],
-        enum_type: PrimitiveSchema,
-        enum_file_name: str
-    ) -> None:
-        super(EnumSchema, self).__init__(namespace=namespace, yaml_data=yaml_data)
-        self.description = description
-        self.name = name
-        self.values = values
-        self.enum_file_name = enum_file_name
-        self.enum_type = enum_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.enum_type.serialization_type
-
-    @property
-    def type_annotation(self) -> str:
-        """The python type used for type annotation
-
-        :return: The type annotation for this schema
-        :rtype: str
-        """
-        return f'Union[{self.enum_type.type_annotation}, "{self.name}"]'
-
-    @property
-    def operation_type_annotation(self) -> str:
-        """The python type used for type annotation
-
-        :return: The type annotation for this schema
-        :rtype: str
-        """
-        return f'Union[{self.enum_type.type_annotation}, "_models.{self.name}"]'
-
-    def get_declaration(self, value: Any) -> str:
-        return self.enum_type.get_declaration(value)
-
-    @property
-    def docstring_text(self) -> str:
-        return self.name
-
-    @property
-    def docstring_type(self) -> str:
-        """The python type used for RST syntax input and type annotation.
-        """
-        return f"{self.enum_type.type_annotation} or ~{self.namespace}.models.{self.name}"
-
-    @staticmethod
-    def _get_enum_values(yaml_data: List[Dict[str, Any]]) -> List["EnumValue"]:
-        """Creates the list of values for this enum.
-
-        :param yaml_data: yaml data about the enum's values
-        :type yaml_data: dict[str, Any]
-        :return: The list of values for this enum
-        :rtype: list[~autorest.models.EnumValue]
-        """
-        values = []
-        seen_enums: Set[str] = set()
-
-        for enum in yaml_data:
-            enum_name = enum["language"]["python"]["name"]
-            if enum_name in seen_enums:
-                continue
-            values.append(EnumValue.from_yaml(enum))
-            seen_enums.add(enum_name)
-        return values
-
-    def _template_kwargs(self, **kwargs: Any) -> Any:
-        if len(self.values) == 1 and not kwargs.get("default_value_declaration"):
-            kwargs['default_value_declaration'] = self.enum_type.get_declaration(self.values[0].value)
-        description = kwargs.pop("description", "")
-        kwargs["description"] = description
-        return kwargs
-
-
-    def get_json_template_representation(self, **kwargs: Any) -> Any:
-        # for better display effect, use the only value instead of var type
-        return self.enum_type.get_json_template_representation(**self._template_kwargs(**kwargs))
-
-    def get_files_and_data_template_representation(self, **kwargs: Any) -> Any:
-        return self.enum_type.get_files_and_data_template_representation(**self._template_kwargs(**kwargs))
-
-    @classmethod
-    def from_yaml(cls, namespace: str, yaml_data: Dict[str, Any], **kwargs: Any) -> "EnumSchema":
-        """Constructs an EnumSchema 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 EnumSchema
-        :rtype: ~autorest.models.EnumSchema
-        """
-        name = yaml_data["language"]["python"]["name"]
-
-        # choice type doesn't always exist. if there is no choiceType, we default to string
-        if yaml_data.get("choiceType"):
-            enum_type = get_primitive_schema(namespace, yaml_data["choiceType"])
-        else:
-            enum_type = StringSchema(namespace, {"type": "str"})
-        values = EnumSchema._get_enum_values(yaml_data["choices"])
-        code_model = kwargs.pop("code_model")
-
-        return cls(
-            namespace=namespace,
-            yaml_data=yaml_data,
-            description=yaml_data["language"]["python"]["description"],
-            name=name,
-            values=values,
-            enum_type=enum_type,
-            enum_file_name=f"_{code_model.module_name}_enums"
-        )
-
-    def imports(self) -> FileImport:
-        file_import = FileImport()
-        file_import.add_submodule_import("typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL)
-        file_import.merge(self.enum_type.imports())
-        return file_import
-
-    def model_file_imports(self) -> FileImport:
-        imports = self.imports()
-        # we import every enum since we can get extremely long imports
-        # if we import my name
-        imports.add_submodule_import("." + self.enum_file_name, "*", ImportType.LOCAL)
-        return imports
-
-class HiddenModelEnumSchema(EnumSchema):
-
-    def imports(self) -> FileImport:
-        file_import = FileImport()
-        file_import.merge(self.enum_type.imports())
-        return file_import
-
-    @property
-    def type_annotation(self) -> str:
-        """The python type used for type annotation
-
-        :return: The type annotation for this schema
-        :rtype: str
-        """
-        return self.enum_type.type_annotation
-
-    @property
-    def operation_type_annotation(self) -> str:
-        """The python type used for type annotation
-
-        :return: The type annotation for this schema
-        :rtype: str
-        """
-        return self.enum_type.type_annotation
-
-    @property
-    def docstring_text(self) -> str:
-        return f"{self.enum_type.type_annotation}. {self.extra_description_information}"
-
-    @property
-    def extra_description_information(self):
-        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 = " or ".join(possible_values)
-        else:
-            possible_values_str = ", ".join(
-                possible_values[: len(possible_values) - 1]
-            ) + f", and {possible_values[-1]}"
-
-        return "Possible values are: {}.".format(possible_values_str)
-
-    @property
-    def docstring_type(self) -> str:
-        """The python type used for RST syntax input and type annotation.
-        """
-        return self.enum_type.type_annotation
-
-def get_enum_schema(code_model) -> Type[EnumSchema]:
-    if code_model.options["models_mode"]:
-        return EnumSchema
-    return HiddenModelEnumSchema

package/autorest/codegen/models/list_schema.py

@@ -1,113 +0,0 @@
-# -------------------------------------------------------------------------
-# 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, Union
-from .base_schema import BaseSchema
-from .imports import FileImport, ImportType, TypingSection
-
-
-class ListSchema(BaseSchema):
-    def __init__(
-        self,
-        namespace: str,
-        yaml_data: Dict[str, Any],
-        element_type: BaseSchema,
-        *,
-        max_items: Optional[int] = None,
-        min_items: Optional[int] = None,
-        unique_items: Optional[int] = None,
-    ) -> None:
-        super(ListSchema, self).__init__(namespace=namespace, yaml_data=yaml_data)
-        self.element_type = element_type
-        self.max_items = max_items
-        self.min_items = min_items
-        self.unique_items = unique_items
-
-    @property
-    def serialization_type(self) -> str:
-        return f"[{self.element_type.serialization_type}]"
-
-    @property
-    def type_annotation(self) -> str:
-        return f"List[{self.element_type.type_annotation}]"
-
-    @property
-    def operation_type_annotation(self) -> str:
-        return f"List[{self.element_type.operation_type_annotation}]"
-
-    @property
-    def docstring_type(self) -> str:
-        return f"list[{self.element_type.docstring_type}]"
-
-    @property
-    def docstring_text(self) -> str:
-        return f"list of {self.element_type.docstring_text}"
-
-    @property
-    def validation_map(self) -> Optional[Dict[str, Union[bool, int, str]]]:
-        validation_map: Dict[str, Union[bool, int, str]] = {}
-        if self.max_items:
-            validation_map["max_items"] = self.max_items
-            validation_map["min_items"] = self.min_items or 0
-        if self.min_items:
-            validation_map["min_items"] = self.min_items
-        if self.unique_items:
-            validation_map["unique"] = True
-        return validation_map or None
-
-    @property
-    def has_xml_serialization_ctxt(self) -> bool:
-        return super().has_xml_serialization_ctxt or self.element_type.has_xml_serialization_ctxt
-
-    def get_json_template_representation(self, **kwargs: Any) -> Any:
-        return [self.element_type.get_json_template_representation(**kwargs)]
-
-    def get_files_and_data_template_representation(self, **kwargs: Any) -> Any:
-        return [self.element_type.get_files_and_data_template_representation(**kwargs)]
-
-    def xml_serialization_ctxt(self) -> Optional[str]:
-        attrs_list = []
-        base_xml_map = super().xml_serialization_ctxt()
-        if base_xml_map:
-            attrs_list.append(base_xml_map)
-
-        # Attribute at the list level
-        if self.xml_metadata.get("wrapped", False):
-            attrs_list.append("'wrapped': True")
-
-        # Attributes of the items
-        item_xml_metadata = self.element_type.xml_metadata
-        if item_xml_metadata.get("name"):
-            attrs_list.append(f"'itemsName': '{item_xml_metadata['name']}'")
-        if item_xml_metadata.get("prefix", False):
-            attrs_list.append(f"'itemsPrefix': '{item_xml_metadata['prefix']}'")
-        if item_xml_metadata.get("namespace", False):
-            attrs_list.append(f"'itemsNs': '{item_xml_metadata['namespace']}'")
-
-        return ", ".join(attrs_list)
-
-    @classmethod
-    def from_yaml(cls, namespace: str, yaml_data: Dict[str, Any], **kwargs) -> "ListSchema":
-        # TODO: for items, if the type is a primitive is it listed in type instead of $ref?
-        element_schema = yaml_data["elementType"]
-
-        from . import build_schema  # pylint: disable=import-outside-toplevel
-
-        element_type = build_schema(yaml_data=element_schema, **kwargs)
-
-        return cls(
-            namespace=namespace,
-            yaml_data=yaml_data,
-            element_type=element_type,
-            max_items=yaml_data.get("maxItems"),
-            min_items=yaml_data.get("minItems"),
-            unique_items=yaml_data.get("uniqueItems"),
-        )
-
-    def imports(self) -> FileImport:
-        file_import = FileImport()
-        file_import.add_submodule_import("typing", "List", ImportType.STDLIB, TypingSection.CONDITIONAL)
-        file_import.merge(self.element_type.imports())
-        return file_import