@autorest/python 5.16.0 → 5.17.0

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