@autorest/python 5.13.0 → 5.16.0

package/autorest/codegen/models/primitive_schemas.py

@@ -6,21 +6,24 @@
 import logging
 import datetime
 from enum import Enum
-from typing import cast, Any, Dict, List, Optional, Union
+from typing import cast, Any, Dict, List, Optional, Union, TYPE_CHECKING
 
 from .base_schema import BaseSchema
 from .imports import FileImport, ImportType, TypingSection
 
+if TYPE_CHECKING:
+    from .code_model import CodeModel
+
 
 _LOGGER = logging.getLogger(__name__)
 
+
 class RawString(object):
     def __init__(self, string: str) -> None:
         self.string = string
 
     def __repr__(self) -> str:
-        return "r'{}'".format(self.string.replace('\'', '\\\''))
-
+        return "r'{}'".format(self.string.replace("'", "\\'"))
 
 
 class PrimitiveSchema(BaseSchema):
@@ -39,8 +42,9 @@ class PrimitiveSchema(BaseSchema):
     def docstring_type(self) -> str:
         return self._to_python_type()
 
-    @property
-    def type_annotation(self) -> str:
+    def type_annotation(
+        self, *, is_operation_file: bool = False  # pylint: disable=unused-argument
+    ) -> str:
         return self.docstring_type
 
     @property
@@ -70,28 +74,18 @@ class PrimitiveSchema(BaseSchema):
     def get_json_template_representation(self, **kwargs: Any) -> Any:
         if self.default_value:
             kwargs["default_value_declaration"] = kwargs.get(
-                "default_value_declaration",
-                self.get_declaration(self.default_value)
+                "default_value_declaration", self.get_declaration(self.default_value)
             )
-        return self._add_optional_and_default_value_template_representation(
-            **kwargs
-        )
+        return self._add_optional_and_default_value_template_representation(**kwargs)
 
     @property
     def default_template_representation_declaration(self) -> str:
         return self.get_declaration(self.docstring_type)
 
-    def get_files_and_data_template_representation(self, **kwargs: Any) -> Any:
-        """Template of what the files input should look like
-        """
-        return self._add_optional_and_default_value_template_representation(
-            **kwargs
-        )
 
 class IOSchema(PrimitiveSchema):
-
-    def __init__(self, namespace, yaml_data) -> None:
-        super(IOSchema, self).__init__(namespace=namespace, yaml_data=yaml_data)
+    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+        super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.type = "IO"
 
     @property
@@ -102,8 +96,9 @@ class IOSchema(PrimitiveSchema):
     def docstring_type(self) -> str:
         return self.type
 
-    @property
-    def type_annotation(self) -> str:
+    def type_annotation(
+        self, *, is_operation_file: bool = False  # pylint: disable=unused-argument
+    ) -> str:
         return self.docstring_type
 
     @property
@@ -116,9 +111,12 @@ class IOSchema(PrimitiveSchema):
 
     def imports(self) -> FileImport:
         file_import = FileImport()
-        file_import.add_submodule_import("typing", "IO", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        file_import.add_submodule_import(
+            "typing", "IO", ImportType.STDLIB, TypingSection.CONDITIONAL
+        )
         return file_import
 
+
 class AnySchema(PrimitiveSchema):
     @property
     def serialization_type(self) -> str:
@@ -128,8 +126,9 @@ class AnySchema(PrimitiveSchema):
     def docstring_type(self) -> str:
         return "any"
 
-    @property
-    def type_annotation(self) -> str:
+    def type_annotation(
+        self, *, is_operation_file: bool = False  # pylint: disable=unused-argument
+    ) -> str:
         return "Any"
 
     @property
@@ -138,23 +137,15 @@ class AnySchema(PrimitiveSchema):
 
     def imports(self) -> FileImport:
         file_import = FileImport()
-        file_import.add_submodule_import("typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        file_import.add_submodule_import(
+            "typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL
+        )
         return file_import
 
-class JSONSchema(AnySchema):
-
-    @property
-    def docstring_type(self) -> str:
-        return "JSONType"
-
-    @property
-    def type_annotation(self) -> str:
-        return "JSONType"
-
 
 class NumberSchema(PrimitiveSchema):
-    def __init__(self, namespace: str, yaml_data: Dict[str, Any]) -> None:
-        super(NumberSchema, self).__init__(namespace=namespace, yaml_data=yaml_data)
+    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+        super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.precision = cast(int, yaml_data["precision"])
         self.multiple = cast(int, yaml_data.get("multipleOf"))
         self.maximum = cast(int, yaml_data.get("maximum"))
@@ -165,10 +156,18 @@ class NumberSchema(PrimitiveSchema):
     @property
     def serialization_constraints(self) -> List[str]:
         validation_constraints = [
-            f"maximum_ex={self.maximum}" if self.maximum is not None and self.exclusive_maximum else None,
-            f"maximum={self.maximum}" if self.maximum is not None and not self.exclusive_maximum else None,
-            f"minimum_ex={self.minimum}" if self.minimum is not None and self.exclusive_minimum else None,
-            f"minimum={self.minimum}" if self.minimum is not None and not self.exclusive_minimum else None,
+            f"maximum_ex={self.maximum}"
+            if self.maximum is not None and self.exclusive_maximum
+            else None,
+            f"maximum={self.maximum}"
+            if self.maximum is not None and not self.exclusive_maximum
+            else None,
+            f"minimum_ex={self.minimum}"
+            if self.minimum is not None and self.exclusive_minimum
+            else None,
+            f"minimum={self.minimum}"
+            if self.minimum is not None and not self.exclusive_minimum
+            else None,
             f"multiple={self.multiple}" if self.multiple else None,
         ]
         return [x for x in validation_constraints if x is not None]
@@ -206,8 +205,9 @@ class NumberSchema(PrimitiveSchema):
             return "int"
         return "float"
 
-    @property
-    def type_annotation(self) -> str:
+    def type_annotation(
+        self, *, is_operation_file: bool = False  # pylint: disable=unused-argument
+    ) -> str:
         python_type = self.docstring_type
         if python_type == "long":
             return "int"
@@ -218,13 +218,18 @@ class NumberSchema(PrimitiveSchema):
         default_value = 0 if self.docstring_type == "int" else 0.0
         return self.get_declaration(default_value)
 
-class StringSchema(PrimitiveSchema):
 
-    def __init__(self, namespace: str, yaml_data: Dict[str, Any]) -> None:
-        super(StringSchema, self).__init__(namespace=namespace, yaml_data=yaml_data)
+class StringSchema(PrimitiveSchema):
+    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+        super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.max_length = cast(int, yaml_data.get("maxLength"))
         self.min_length = cast(
-            int, (yaml_data.get("minLength", 0) if yaml_data.get("maxLength") else yaml_data.get("minLength"))
+            int,
+            (
+                yaml_data.get("minLength", 0)
+                if yaml_data.get("maxLength")
+                else yaml_data.get("minLength")
+            ),
         )
         self.pattern = cast(str, yaml_data.get("pattern"))
 
@@ -254,8 +259,8 @@ class StringSchema(PrimitiveSchema):
 
 
 class DatetimeSchema(PrimitiveSchema):
-    def __init__(self, namespace: str, yaml_data: Dict[str, Any]) -> None:
-        super(DatetimeSchema, self).__init__(namespace=namespace, yaml_data=yaml_data)
+    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+        super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.format = self.Formats(yaml_data["format"])
 
     class Formats(str, Enum):
@@ -264,15 +269,19 @@ class DatetimeSchema(PrimitiveSchema):
 
     @property
     def serialization_type(self) -> str:
-        formats_to_attribute_type = {self.Formats.datetime: "iso-8601", self.Formats.rfc1123: "rfc-1123"}
+        formats_to_attribute_type = {
+            self.Formats.datetime: "iso-8601",
+            self.Formats.rfc1123: "rfc-1123",
+        }
         return formats_to_attribute_type[self.format]
 
     @property
     def docstring_type(self) -> str:
-        return "~" + self.type_annotation
+        return "~" + self.type_annotation()
 
-    @property
-    def type_annotation(self) -> str:
+    def type_annotation(
+        self, *, is_operation_file: bool = False  # pylint: disable=unused-argument
+    ) -> str:
         return "datetime.datetime"
 
     @property
@@ -294,6 +303,7 @@ class DatetimeSchema(PrimitiveSchema):
     def default_template_representation_declaration(self):
         return self.get_declaration(datetime.datetime(2020, 2, 20))
 
+
 class TimeSchema(PrimitiveSchema):
     @property
     def serialization_type(self) -> str:
@@ -301,10 +311,11 @@ class TimeSchema(PrimitiveSchema):
 
     @property
     def docstring_type(self) -> str:
-        return "~" + self.type_annotation
+        return "~" + self.type_annotation()
 
-    @property
-    def type_annotation(self) -> str:
+    def type_annotation(
+        self, *, is_operation_file: bool = False  # pylint: disable=unused-argument
+    ) -> str:
         return "datetime.time"
 
     @property
@@ -334,10 +345,11 @@ class UnixTimeSchema(PrimitiveSchema):
 
     @property
     def docstring_type(self) -> str:
-        return "~" + self.type_annotation
+        return "~" + self.type_annotation()
 
-    @property
-    def type_annotation(self) -> str:
+    def type_annotation(
+        self, *, is_operation_file: bool = False  # pylint: disable=unused-argument
+    ) -> str:
         return "datetime.datetime"
 
     @property
@@ -367,10 +379,11 @@ class DateSchema(PrimitiveSchema):
 
     @property
     def docstring_type(self) -> str:
-        return "~" + self.type_annotation
+        return "~" + self.type_annotation()
 
-    @property
-    def type_annotation(self) -> str:
+    def type_annotation(
+        self, *, is_operation_file: bool = False  # pylint: disable=unused-argument
+    ) -> str:
         return "datetime.date"
 
     @property
@@ -400,10 +413,11 @@ class DurationSchema(PrimitiveSchema):
 
     @property
     def docstring_type(self) -> str:
-        return "~" + self.type_annotation
+        return "~" + self.type_annotation()
 
-    @property
-    def type_annotation(self) -> str:
+    def type_annotation(
+        self, *, is_operation_file: bool = False  # pylint: disable=unused-argument
+    ) -> str:
         return "datetime.timedelta"
 
     @property
@@ -427,8 +441,8 @@ class DurationSchema(PrimitiveSchema):
 
 
 class ByteArraySchema(PrimitiveSchema):
-    def __init__(self, namespace: str, yaml_data: Dict[str, Any]) -> None:
-        super(ByteArraySchema, self).__init__(namespace=namespace, yaml_data=yaml_data)
+    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+        super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.format = self.Formats(yaml_data["format"])
 
     class Formats(str, Enum):
@@ -453,7 +467,9 @@ class ByteArraySchema(PrimitiveSchema):
         return f'bytearray("{value}", encoding="utf-8")'
 
 
-def get_primitive_schema(namespace: str, yaml_data: Dict[str, Any]) -> "PrimitiveSchema":
+def get_primitive_schema(
+    yaml_data: Dict[str, Any], code_model: "CodeModel"
+) -> "PrimitiveSchema":
     mapping = {
         "integer": NumberSchema,
         "number": NumberSchema,
@@ -467,10 +483,13 @@ def get_primitive_schema(namespace: str, yaml_data: Dict[str, Any]) -> "Primitiv
         "byte-array": ByteArraySchema,
         "any": AnySchema,
         "any-object": AnySchema,
-        "binary": IOSchema
+        "binary": IOSchema,
     }
     schema_type = yaml_data["type"]
     primitive_schema = cast(
-        PrimitiveSchema, mapping.get(schema_type, PrimitiveSchema).from_yaml(namespace=namespace, yaml_data=yaml_data)
+        PrimitiveSchema,
+        mapping.get(schema_type, PrimitiveSchema).from_yaml(
+            yaml_data=yaml_data, code_model=code_model
+        ),
     )
     return primitive_schema

package/autorest/codegen/models/property.py

@@ -3,7 +3,7 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import cast, Any, Dict, Union, List, Optional
+from typing import cast, Any, Dict, Union, List, Optional, TYPE_CHECKING
 
 from .base_model import BaseModel
 from .constant_schema import ConstantSchema
@@ -11,19 +11,24 @@ from .imports import FileImport, ImportType, TypingSection
 from .base_schema import BaseSchema
 from .enum_schema import EnumSchema
 
+if TYPE_CHECKING:
+    from .code_model import CodeModel
+
+
 class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
     def __init__(
         self,
         yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
         name: str,
         schema: BaseSchema,
         original_swagger_name: str,
         *,
         flattened_names: Optional[List[str]] = None,
         description: Optional[str] = None,
-        client_default_value: Optional[Any] = None
+        client_default_value: Optional[Any] = None,
     ) -> None:
-        super().__init__(yaml_data)
+        super().__init__(yaml_data, code_model)
         self.name = name
         self.schema = schema
         self.original_swagger_name = original_swagger_name
@@ -35,15 +40,18 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
         self.client_default_value = client_default_value
         self.description = self._create_description(description, yaml_data)
 
-
-    def _create_description(self, description_input: Optional[str], yaml_data: Dict[str, Any]) -> str:
-        description: str = description_input or yaml_data["language"]["python"]["description"]
+    def _create_description(
+        self, description_input: Optional[str], yaml_data: Dict[str, Any]
+    ) -> str:
+        description: str = (
+            description_input or yaml_data["language"]["python"]["description"]
+        )
         if description and description[-1] != ".":
             description += "."
         if self.name == "tags":
             description = "A set of tags. " + description
         if self.constant:
-            description += f' Has constant value: {self.constant_declaration}.'
+            description += f" Has constant value: {self.constant_declaration}."
         elif self.required:
             if description:
                 description = "Required. " + description
@@ -51,16 +59,19 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
                 description = "Required. "
         elif isinstance(self.schema, ConstantSchema):
             description += (
-                f" The only acceptable values to pass in are None and {self.constant_declaration}. " +
-                f"The default value is {self.default_value_declaration}."
+                f" The only acceptable values to pass in are None and {self.constant_declaration}. "
+                + f"The default value is {self.default_value_declaration}."
             )
         if self.is_discriminator:
             description += "Constant filled by server. "
         if isinstance(self.schema, EnumSchema):
-            values = [self.schema.enum_type.get_declaration(v.value) for v in self.schema.values]
+            values = [
+                self.schema.enum_type.get_declaration(v.value)
+                for v in self.schema.values
+            ]
             if description and description[-1] != " ":
                 description += " "
-            description += "Possible values include: {}.".format(", ".join(values))
+            description += "Known values are: {}.".format(", ".join(values))
             if self.schema.default_value:
                 description += f' Default value: "{self.schema.default_value}".'
         return description
@@ -70,9 +81,9 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
         # this bool doesn't consider you to be constant if you are a discriminator
         # you also have to be required to be considered a constant
         return (
-            isinstance(self.schema, ConstantSchema) and
-            self.required and
-            not self.is_discriminator
+            isinstance(self.schema, ConstantSchema)
+            and self.required
+            and not self.is_discriminator
         )
 
     @property
@@ -85,29 +96,36 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
         if self.constant:
             retval["constant"] = True
         if self.schema.validation_map:
-            validation_map_from_schema = cast(Dict[str, Union[bool, int, str]], self.schema.validation_map)
+            validation_map_from_schema = cast(
+                Dict[str, Union[bool, int, str]], self.schema.validation_map
+            )
             retval.update(validation_map_from_schema)
         return retval or None
 
     @property
     def escaped_swagger_name(self) -> str:
-        """Return the RestAPI name correctly escaped for serialization.
-        """
+        """Return the RestAPI name correctly escaped for serialization."""
         if self.flattened_names:
             return ".".join(n.replace(".", "\\\\.") for n in self.flattened_names)
         return self.original_swagger_name.replace(".", "\\\\.")
 
     @classmethod
-    def from_yaml(cls, yaml_data: Dict[str, Any], **kwargs) -> "Property":
+    def from_yaml(
+        cls,
+        yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+        *,
+        has_additional_properties: Optional[bool] = None,
+    ) -> "Property":
         from . import build_schema  # pylint: disable=import-outside-toplevel
 
         name = yaml_data["language"]["python"]["name"]
-        has_additional_properties = kwargs.pop("has_additional_properties", None)
         if name == "additional_properties" and has_additional_properties:
             name = "additional_properties1"
-        schema = build_schema(yaml_data=yaml_data["schema"], **kwargs)
+        schema = build_schema(yaml_data=yaml_data["schema"], code_model=code_model)
         return cls(
             yaml_data=yaml_data,
+            code_model=code_model,
             name=name,
             schema=schema,
             original_swagger_name=yaml_data["serializedName"],
@@ -126,7 +144,7 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
                 return self.schema.get_declaration(self.schema.value)
             raise ValueError(
                 "Trying to get constant declaration for a schema that is not ConstantSchema"
-                )
+            )
         raise ValueError("Trying to get a declaration for a schema that doesn't exist")
 
     @property
@@ -149,26 +167,26 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
             return self.schema.get_declaration(self.client_default_value)
         return self.schema.default_value_declaration
 
-    @property
-    def type_annotation(self) -> str:
+    def type_annotation(self, *, is_operation_file: bool = False) -> str:
         if self.required:
-            return self.schema.type_annotation
-        return f"Optional[{self.schema.type_annotation}]"
+            return self.schema.type_annotation(is_operation_file=is_operation_file)
+        return f"Optional[{self.schema.type_annotation(is_operation_file=is_operation_file)}]"
 
     def get_json_template_representation(self, **kwargs: Any) -> Any:
         kwargs["optional"] = not self.required
         if self.default_value:
-            kwargs["default_value_declaration"] = self.schema.get_declaration(self.default_value)
+            kwargs["default_value_declaration"] = self.schema.get_declaration(
+                self.default_value
+            )
         if self.description:
             kwargs["description"] = self.description
         return self.schema.get_json_template_representation(**kwargs)
 
-    def get_files_and_data_template_representation(self, **kwargs: Any) -> Any:
-        kwargs["optional"] = not self.required
-        return self.schema.get_files_and_data_template_representation(**kwargs)
-
     def model_file_imports(self) -> FileImport:
         file_import = self.schema.model_file_imports()
         if not self.required:
-            file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL)
+            file_import.add_submodule_import(
+                "typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL
+            )
+        file_import.merge(self.schema.model_file_imports())
         return file_import