@autorest/python 5.16.0 → 5.19.0

package/autorest/codegen/models/enum_schema.py

@@ -1,225 +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, TYPE_CHECKING
-from .base_schema import BaseSchema
-from .primitive_schemas import PrimitiveSchema, get_primitive_schema, StringSchema
-from .imports import FileImport, ImportType, TypingSection
-
-if TYPE_CHECKING:
-    from .code_model import CodeModel
-
-
-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,
-        yaml_data: Dict[str, Any],
-        code_model: "CodeModel",
-        description: str,
-        name: str,
-        values: List["EnumValue"],
-        enum_type: PrimitiveSchema,
-    ) -> None:
-        super().__init__(yaml_data=yaml_data, code_model=code_model)
-        self.description = description
-        self.name = name
-        self.values = values
-        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
-
-    def type_annotation(self, *, is_operation_file: bool = False) -> 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(is_operation_file=is_operation_file)}, "_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.code_model.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)
-        )
-
-    @classmethod
-    def from_yaml(
-        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
-    ) -> "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(yaml_data["choiceType"], code_model)
-        else:
-            enum_type = StringSchema({"type": "str"}, code_model)
-        values = EnumSchema._get_enum_values(yaml_data["choices"])
-        return cls(
-            yaml_data=yaml_data,
-            code_model=code_model,
-            description=yaml_data["language"]["python"]["description"],
-            name=name,
-            values=values,
-            enum_type=enum_type,
-        )
-
-    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
-
-
-class HiddenModelEnumSchema(EnumSchema):
-    def imports(self) -> FileImport:
-        file_import = FileImport()
-        file_import.merge(self.enum_type.imports())
-        return file_import
-
-    def type_annotation(self, *, is_operation_file: bool = False) -> str:
-        """The python type used for type annotation
-
-        :return: The type annotation for this schema
-        :rtype: str
-        """
-        return self.enum_type.type_annotation(is_operation_file=is_operation_file)
-
-    @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 "Known 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,135 +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, TYPE_CHECKING
-from .base_schema import BaseSchema
-from .imports import FileImport, ImportType, TypingSection
-
-if TYPE_CHECKING:
-    from .code_model import CodeModel
-
-
-class ListSchema(BaseSchema):
-    def __init__(
-        self,
-        yaml_data: Dict[str, Any],
-        code_model: "CodeModel",
-        element_type: BaseSchema,
-        *,
-        max_items: Optional[int] = None,
-        min_items: Optional[int] = None,
-        unique_items: Optional[int] = None,
-    ) -> None:
-        super().__init__(yaml_data=yaml_data, code_model=code_model)
-        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}]"
-
-    def type_annotation(self, *, is_operation_file: bool = False) -> str:
-        if self.element_type.type_annotation() == "ET.Element":
-            # this means we're version tolerant XML, we just return the XML element
-            return self.element_type.type_annotation(
-                is_operation_file=is_operation_file
-            )
-        return f"List[{self.element_type.type_annotation(is_operation_file=is_operation_file)}]"
-
-    @property
-    def docstring_type(self) -> str:
-        if self.element_type.docstring_type == "ET.Element":
-            # this means we're version tolerant XML, we just return the XML element
-            return self.element_type.docstring_type
-        return f"list[{self.element_type.docstring_type}]"
-
-    @property
-    def docstring_text(self) -> str:
-        if self.element_type.docstring_text == "XML Element":
-            # this means we're version tolerant XML, we just return the XML element
-            return self.element_type.docstring_text
-        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 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, yaml_data: Dict[str, Any], code_model: "CodeModel"
-    ) -> "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, code_model=code_model)
-
-        return cls(
-            yaml_data=yaml_data,
-            code_model=code_model,
-            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()
-        if (
-            not self.element_type.type_annotation(is_operation_file=True)
-            == "ET.Element"
-        ):
-            file_import.add_submodule_import(
-                "typing", "List", ImportType.STDLIB, TypingSection.CONDITIONAL
-            )
-        file_import.merge(self.element_type.imports())
-        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

package/autorest/codegen/models/object_schema.py

@@ -1,303 +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, Union, Type, TYPE_CHECKING
-from .base_schema import BaseSchema
-from .dictionary_schema import DictionarySchema
-from .property import Property
-from .imports import FileImport, ImportModel, ImportType, TypingSection
-
-if TYPE_CHECKING:
-    from .code_model import CodeModel
-
-
-class ObjectSchema(BaseSchema):  # pylint: disable=too-many-instance-attributes
-    """Represents a class ready to be serialized in Python.
-
-    :param str name: The name of the class.
-    :param str description: The description of the class.
-    :param properties: the optional properties of the class.
-    :type properties: dict(str, str)
-    """
-
-    def __init__(
-        self,
-        yaml_data: Dict[str, Any],
-        code_model: "CodeModel",
-        name: str,
-        description: str = "",
-        **kwargs,
-    ) -> None:
-        super().__init__(yaml_data=yaml_data, code_model=code_model)
-        self.name = name
-        self.description = description
-        self.max_properties: Optional[int] = kwargs.pop("max_properties", None)
-        self.min_properties: Optional[int] = kwargs.pop("min_properties", None)
-        self.properties: List[Property] = kwargs.pop("properties", [])
-        self.is_exception: bool = kwargs.pop("is_exception", False)
-        self.base_models: Union[List[int], List["ObjectSchema"]] = kwargs.pop(
-            "base_models", []
-        )
-        self.subtype_map: Optional[Dict[str, str]] = kwargs.pop("subtype_map", None)
-        self.discriminator_name: Optional[str] = kwargs.pop("discriminator_name", None)
-        self.discriminator_value: Optional[str] = kwargs.pop(
-            "discriminator_value", None
-        )
-        self._created_json_template_representation = False
-
-    @property
-    def serialization_type(self) -> str:
-        return self.name
-
-    def type_annotation(self, *, is_operation_file: bool = False) -> str:
-        retval = f"_models.{self.name}"
-        return retval if is_operation_file else f'"{retval}"'
-
-    @property
-    def docstring_type(self) -> str:
-        return f"~{self.code_model.namespace}.models.{self.name}"
-
-    @property
-    def docstring_text(self) -> str:
-        return self.name
-
-    def get_declaration(self, value: Any) -> str:
-        return f"{self.name}()"
-
-    def __repr__(self) -> str:
-        return f"<{self.__class__.__name__} {self.name}>"
-
-    @property
-    def has_xml_serialization_ctxt(self) -> bool:
-        return False
-
-    def xml_serialization_ctxt(self) -> Optional[str]:
-        # object schema contains _xml_map, they don't need serialization context
-        return ""
-
-    def xml_map_content(self) -> Optional[str]:
-        if not self.xml_metadata:
-            raise ValueError("This object does not contain XML metadata")
-        # This is NOT an error on the super call, we use the serialization context for "xml_map",
-        # but we don't want to write a serialization context for an object.
-        return super().xml_serialization_ctxt()
-
-    def get_json_template_representation(self, **kwargs: Any) -> Any:
-        if self._created_json_template_representation:
-            return "..."  # do this to avoid loop
-        self._created_json_template_representation = True
-        # don't add additional properties, because there's not really a concept of
-        # additional properties in the template
-        representation = {
-            f'"{prop.original_swagger_name}"': prop.get_json_template_representation(
-                **kwargs
-            )
-            for prop in [
-                p
-                for p in self.properties
-                if not (p.is_discriminator or p.name == "additional_properties")
-            ]
-        }
-        try:
-            # add discriminator prop if there is one
-            discriminator = next(p for p in self.properties if p.is_discriminator)
-            representation[discriminator.original_swagger_name] = (
-                self.discriminator_value or discriminator.original_swagger_name
-            )
-        except StopIteration:
-            pass
-
-        # once we've finished, we want to reset created_json_template_representation to false
-        # so we can call it again
-        self._created_json_template_representation = False
-        return representation
-
-    @classmethod
-    def from_yaml(
-        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
-    ) -> "ObjectSchema":
-        """Returns a ClassType from the dict object constructed from a yaml file.
-
-        WARNING: This guy might create an infinite loop.
-
-        :param str name: The name of the class type.
-        :param yaml_data: A representation of the schema of a class type from a yaml file.
-        :type yaml_data: dict(str, str)
-        :returns: A ClassType.
-        :rtype: ~autorest.models.schema.ClassType
-        """
-        obj = cls(yaml_data, code_model, "", description="")
-        obj.fill_instance_from_yaml(yaml_data, code_model)
-        return obj
-
-    def fill_instance_from_yaml(
-        self, yaml_data: Dict[str, Any], code_model: "CodeModel"
-    ) -> None:
-        properties = []
-        base_models = []
-
-        name = yaml_data["language"]["python"]["name"]
-
-        # checking to see if there is a parent class and / or additional properties
-        if yaml_data.get("parents"):
-            immediate_parents = yaml_data["parents"]["immediate"]
-            # checking if object has a parent
-            if immediate_parents:
-                for immediate_parent in immediate_parents:
-                    if immediate_parent["type"] == "dictionary":
-                        additional_properties_schema = DictionarySchema.from_yaml(
-                            yaml_data=immediate_parent, code_model=code_model
-                        )
-                        properties.append(
-                            Property(
-                                yaml_data={},
-                                code_model=code_model,
-                                name="additional_properties",
-                                schema=additional_properties_schema,
-                                original_swagger_name="",
-                                description=(
-                                    "Unmatched properties from the message are "
-                                    "deserialized to this collection."
-                                ),
-                            )
-                        )
-                    elif (
-                        immediate_parent["language"]["default"]["name"] != name
-                        and immediate_parent["type"] == "object"
-                    ):
-                        base_models.append(id(immediate_parent))
-
-        # checking to see if this is a polymorphic class
-        subtype_map = None
-        if yaml_data.get("discriminator"):
-            subtype_map = {}
-            # map of discriminator value to child's name
-            for children_yaml in yaml_data["discriminator"]["immediate"].values():
-                subtype_map[children_yaml["discriminatorValue"]] = children_yaml[
-                    "language"
-                ]["python"]["name"]
-        if yaml_data.get("properties"):
-            properties += [
-                Property.from_yaml(
-                    p, code_model, has_additional_properties=len(properties) > 0
-                )
-                for p in yaml_data["properties"]
-            ]
-        # this is to ensure that the attribute map type and property type are generated correctly
-
-        description = yaml_data["language"]["python"]["description"]
-        is_exception = False
-        if code_model.exception_ids:
-            if id(yaml_data) in code_model.exception_ids:
-                is_exception = True
-
-        self.yaml_data = yaml_data
-        self.name = name
-        self.description = description
-        self.properties = properties
-        self.base_models = base_models
-        self.is_exception = is_exception
-        self.subtype_map = subtype_map
-        self.discriminator_name = (
-            yaml_data["discriminator"]["property"]["language"]["python"]["name"]
-            if yaml_data.get("discriminator")
-            else None
-        )
-        self.discriminator_value = yaml_data.get("discriminatorValue", None)
-
-    @property
-    def has_readonly_or_constant_property(self) -> bool:
-        return any(x.readonly or x.constant for x in self.properties)
-
-    @property
-    def property_with_discriminator(self) -> Any:
-        try:
-            return next(
-                p
-                for p in self.properties
-                if getattr(p.schema, "discriminator_name", None)
-            )
-        except StopIteration:
-            return None
-
-    def imports(self) -> FileImport:
-        file_import = FileImport()
-        if self.is_exception:
-            file_import.add_submodule_import(
-                "azure.core.exceptions", "HttpResponseError", ImportType.AZURECORE
-            )
-        return file_import
-
-    def model_file_imports(self) -> FileImport:
-        file_import = self.imports()
-        file_import.add_import(
-            "__init__",
-            ImportType.LOCAL,
-            typing_section=TypingSection.TYPING,
-            alias="_models",
-        )
-        return file_import
-
-
-class HiddenModelObjectSchema(ObjectSchema):
-    @property
-    def serialization_type(self) -> str:
-        return "object"
-
-    def type_annotation(
-        self, *, is_operation_file: bool = False  # pylint: disable=unused-argument
-    ) -> str:
-        if self.xml_metadata:
-            return "ET.Element"
-        return "JSON"
-
-    @property
-    def docstring_type(self) -> str:
-        if self.xml_metadata:
-            return "ET.Element"
-        return "JSON"
-
-    @property
-    def docstring_text(self) -> str:
-        if self.xml_metadata:
-            return "XML Element"
-        return "JSON object"
-
-    def imports(self) -> FileImport:
-        file_import = FileImport()
-        file_import.add_submodule_import(
-            "typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL
-        )
-        if self.xml_metadata:
-            file_import.add_submodule_import(
-                "xml.etree", "ElementTree", ImportType.STDLIB, alias="ET"
-            )
-        file_import.add_import("sys", ImportType.STDLIB)
-        file_import.define_mypy_type(
-            "JSON",
-            "MutableMapping[str, Any] # pylint: disable=unsubscriptable-object",
-            None,
-            {
-                (3, 9): ImportModel(
-                    TypingSection.CONDITIONAL,
-                    ImportType.STDLIB,
-                    "collections.abc",
-                    submodule_name="MutableMapping",
-                ),
-                None: ImportModel(
-                    TypingSection.CONDITIONAL,
-                    ImportType.STDLIB,
-                    "typing",
-                    submodule_name="MutableMapping",
-                ),
-            },
-        )
-        return file_import
-
-
-def get_object_schema(code_model) -> Type[ObjectSchema]:
-    if code_model.options["models_mode"]:
-        return ObjectSchema
-    return HiddenModelObjectSchema